2 * This file is a part of hildon
4 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
7 * Copyright (C) 1998 Cesar Miquel, Shawn T. Amundson and Mattias Groenlund
10 * Copyright (C) 1995, 1996, 1997, 1998 by Steffen Beyer
12 * HldonCalendar modifications
13 * Copyright (C) 2005, 2006 Nokia Corporation, all rights reserved.
15 * Contact: Michael Dominic Kostrzewa <michael.kostrzewa@nokia.com>
17 * This library is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU Lesser General Public
19 * License as published by the Free Software Foundation; either
20 * version 2 of the License, or (at your option) any later version. or (at your option) any later version.
22 * This library is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * Lesser General Public License for more details.
27 * You should have received a copy of the GNU Lesser General Public
28 * License along with this library; if not, write to the Free
29 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
34 * file for a list of people on the GTK+ Team. See the ChangeLog
35 * files for a list of changes. These files are distributed with
36 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
40 * SECTION:hildon-calendar
41 * @short_description: A calendar widget
43 * HildonCalendar is a slightly modified #GtkCalendar. It has an almost same API
44 * but a slightly different look and behaviour. Use this widget instead of
45 * standard #GtkCalendar or use #HildonDateEditor for more higher-level date setting
54 #define _GNU_SOURCE /* needed for GNU nl_langinfo_l */
58 #ifdef HAVE_SYS_TIME_H
67 #include <glib/gprintf.h>
68 #include <gdk/gdkkeysyms.h>
69 #include <gtk/gtkprivate.h>
71 #include "hildon-calendar.h"
72 #include "hildon-marshalers.h"
73 #include "hildon-calendar-private.h"
75 /***************************************************************************/
76 /* The following date routines are taken from the lib_date package. Keep
77 * them separate in case we want to update them if a newer lib_date comes
80 typedef unsigned int N_int;
82 typedef unsigned long N_long;
84 typedef signed long Z_long;
86 typedef enum { false = FALSE , true = TRUE } boolean;
88 #define and && /* logical (boolean) operators: lower case */
92 static const N_int month_length [2][13] =
94 { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
95 { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
98 static const N_int days_in_months[2][14] =
100 { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
101 { 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
104 static Z_long calc_days (N_int year, N_int mm, N_int dd);
106 static N_int day_of_week (N_int year, N_int mm, N_int dd);
108 static Z_long dates_difference (N_int year1, N_int mm1, N_int dd1,
109 N_int year2, N_int mm2, N_int dd2);
111 static N_int weeks_in_year (N_int year);
116 return ((((year % 4) == 0) and ((year % 100) != 0)) or ((year % 400) == 0));
120 day_of_week (N_int year,
126 days = calc_days (year, mm, dd);
133 return( (N_int) days );
137 weeks_in_year (N_int year)
139 return (52 + ((day_of_week(year,1,1)==4) or (day_of_week(year,12,31)==4)));
143 check_date (N_int year,
147 if (year < 1) return(false);
148 if ((mm < 1) or (mm > 12)) return(false);
149 if ((dd < 1) or (dd > month_length[leap(year)][mm])) return(false);
154 week_number (N_int year,
160 first = day_of_week (year,1,1) - 1;
161 return( (N_int) ( (dates_difference(year,1,1, year,mm,dd) + first) / 7L ) +
166 year_to_days (N_int year)
168 return ( year * 365L + (year / 4) - (year / 100) + (year / 400) );
172 calc_days (N_int year,
178 if (year < 1) return(0L);
179 if ((mm < 1) or (mm > 12)) return(0L);
180 if ((dd < 1) or (dd > month_length[(lp = leap(year))][mm])) return(0L);
181 return( year_to_days(--year) + days_in_months[lp][mm] + dd );
185 week_of_year (N_int *week,
190 if (check_date(*year,mm,dd))
192 *week = week_number(*year,mm,dd);
194 *week = weeks_in_year(--(*year));
195 else if (*week > weeks_in_year(*year))
206 dates_difference (N_int year1,
213 return (calc_days (year2, mm2, dd2) - calc_days (year1, mm1, dd1));
216 /*** END OF lib_date routines ********************************************/
218 /* HILDON: Spacings modified */
219 #define HILDON_ARROW_SEP 5 /* Space between arrows and data */
221 #define HILDON_DAY_WIDTH 26
223 #define HILDON_DAY_HEIGHT 25
225 /* additional widths given to week number and day windows */
227 #define HILDON_WEEKS_EXTRA_WIDTH 8
229 #define HILDON_DAYS_EXTRA_WIDTH 8
231 /* Spacing around day/week headers and main area, inside those windows */
233 #define CALENDAR_MARGIN 0
235 /* Spacing around day/week headers and main area, outside those windows */
237 #define INNER_BORDER 0 /* 4 */
239 /* Separation between day headers and main area */
241 #define CALENDAR_YSEP 3 /* 4 */
243 /* Separation between week headers and main area */
245 #define CALENDAR_XSEP 6 /* 4 */
247 #define DAY_XSEP 0 /* not really good for small calendar */
249 #define DAY_YSEP 0 /* not really good for small calendar */
252 #define HEADER_FG_COLOR(widget) \
253 (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
255 #define HEADER_BG_COLOR(widget) \
256 (& (widget)->style->bg[GTK_WIDGET_STATE (widget)])
258 #define SELECTED_BG_COLOR(widget) \
259 (& (widget)->style->base[GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE])
261 #define SELECTED_FG_COLOR(widget) \
262 (& (widget)->style->text[GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE])
264 #define NORMAL_DAY_COLOR(widget) \
265 (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
267 #define PREV_MONTH_COLOR(widget) \
268 (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
270 #define NEXT_MONTH_COLOR(widget) \
271 (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
273 #define MARKED_COLOR(widget) \
274 (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
276 #define BACKGROUND_COLOR(widget) \
277 (& (widget)->style->base[GTK_WIDGET_STATE (widget)])
279 #define HIGHLIGHT_BACK_COLOR(widget) \
280 (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
282 #define CALENDAR_INITIAL_TIMER_DELAY 200
284 #define CALENDAR_TIMER_DELAY 20
300 MONTH_CHANGED_SIGNAL,
302 DAY_SELECTED_DOUBLE_CLICK_SIGNAL,
307 ERRONEOUS_DATE_SIGNAL,
308 SELECTED_DATE_SIGNAL,
320 PROP_NO_MONTH_CHANGE,
321 PROP_SHOW_WEEK_NUMBERS,
328 static gint hildon_calendar_signals [LAST_SIGNAL] = { 0 };
330 static GtkWidgetClass* parent_class = NULL;
332 typedef void (*HildonCalendarSignalDate) (GtkObject *object, guint arg1, guint arg2, guint arg3, gpointer data);
335 hildon_calendar_class_init (HildonCalendarClass *class);
338 hildon_calendar_init (HildonCalendar *calendar);
341 hildon_calendar_finalize (GObject *calendar);
344 hildon_calendar_destroy (GtkObject *calendar);
347 hildon_calendar_set_property (GObject *object,
353 hildon_calendar_get_property (GObject *object,
359 hildon_calendar_realize (GtkWidget *widget);
362 hildon_calendar_unrealize (GtkWidget *widget);
365 hildon_calendar_size_request (GtkWidget *widget,
366 GtkRequisition *requisition);
369 hildon_calendar_size_allocate (GtkWidget *widget,
370 GtkAllocation *allocation);
373 hildon_calendar_expose (GtkWidget *widget,
374 GdkEventExpose *event);
377 hildon_calendar_button_press (GtkWidget *widget,
378 GdkEventButton *event);
381 hildon_calendar_button_release (GtkWidget *widget,
382 GdkEventButton *event);
385 hildon_calendar_main_button (GtkWidget *widget,
386 GdkEventButton *event);
389 hildon_calendar_motion_notify (GtkWidget *widget,
390 GdkEventMotion *event);
393 hildon_calendar_enter_notify (GtkWidget *widget,
394 GdkEventCrossing *event);
397 hildon_calendar_leave_notify (GtkWidget *widget,
398 GdkEventCrossing *event);
401 hildon_calendar_key_press (GtkWidget *widget,
405 hildon_calendar_scroll (GtkWidget *widget,
406 GdkEventScroll *event);
409 hildon_calendar_grab_notify (GtkWidget *widget,
410 gboolean was_grabbed);
413 hildon_calendar_focus_out (GtkWidget *widget,
414 GdkEventFocus *event);
417 hildon_calendar_state_changed (GtkWidget *widget,
418 GtkStateType previous_state);
421 hildon_calendar_style_set (GtkWidget *widget,
422 GtkStyle *previous_style);
425 hildon_calendar_paint_header (GtkWidget *widget);
428 hildon_calendar_paint_footer (GtkWidget *widget);
431 hildon_calendar_paint_day_names (GtkWidget *widget);
434 hildon_calendar_paint_week_numbers (GtkWidget *widget);
437 hildon_calendar_paint_main (GtkWidget *widget);
440 hildon_calendar_select_and_focus_day (HildonCalendar *calendar,
444 hildon_calendar_paint_arrow (GtkWidget *widget,
448 hildon_calendar_paint_day_num (GtkWidget *widget,
452 hildon_calendar_paint_day (GtkWidget *widget,
457 hildon_calendar_compute_days (HildonCalendar *calendar);
460 left_x_for_column (HildonCalendar *calendar,
464 top_y_for_row (HildonCalendar *calendar,
468 hildon_calendar_drag_data_get (GtkWidget *widget,
469 GdkDragContext *context,
470 GtkSelectionData *selection_data,
475 hildon_calendar_drag_data_received (GtkWidget *widget,
476 GdkDragContext *context,
479 GtkSelectionData *selection_data,
484 hildon_calendar_drag_motion (GtkWidget *widget,
485 GdkDragContext *context,
491 hildon_calendar_drag_leave (GtkWidget *widget,
492 GdkDragContext *context,
496 hildon_calendar_drag_drop (GtkWidget *widget,
497 GdkDragContext *context,
502 /* This function was added because we need to mark current day according to
507 hildon_calendar_check_current_date (HildonCalendar *calendar,
512 hildon_calendar_get_type (void)
514 static GType calendar_type = 0;
518 static const GTypeInfo calendar_info =
520 sizeof (HildonCalendarClass),
521 NULL, /* base_init */
522 NULL, /* base_finalize */
523 (GClassInitFunc) hildon_calendar_class_init,
524 NULL, /* class_finalize */
525 NULL, /* class_data */
526 sizeof (HildonCalendar),
528 (GInstanceInitFunc) hildon_calendar_init,
531 calendar_type = g_type_register_static (GTK_TYPE_WIDGET, "HildonCalendar",
535 return calendar_type;
539 locales_init (HildonCalendarPrivate *priv)
541 /* Hildon: This is not exactly portable, see
542 * http://bugzilla.gnome.org/show_bug.cgi?id=343415
543 * The labels need to be instance variables as the startup wizard changes
548 l = newlocale (LC_TIME_MASK, setlocale (LC_MESSAGES, NULL), NULL);
550 priv->abbreviated_dayname[0] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_1, l),
551 -1, NULL, NULL, NULL);
552 priv->abbreviated_dayname[1] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_2, l),
553 -1, NULL, NULL, NULL);
554 priv->abbreviated_dayname[2] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_3, l),
555 -1, NULL, NULL, NULL) ;
556 priv->abbreviated_dayname[3] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_4, l),
557 -1, NULL, NULL, NULL);
558 priv->abbreviated_dayname[4] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_5, l),
559 -1, NULL, NULL, NULL);
560 priv->abbreviated_dayname[5] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_6, l),
561 -1, NULL, NULL, NULL);
562 priv->abbreviated_dayname[6] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_7, l),
563 -1, NULL, NULL, NULL);
564 priv->monthname[0] = g_locale_to_utf8 (nl_langinfo_l(MON_1, l),
565 -1, NULL, NULL, NULL);
566 priv->monthname[1] = g_locale_to_utf8 (nl_langinfo_l(MON_2, l),
567 -1, NULL, NULL, NULL);
568 priv->monthname[2] = g_locale_to_utf8 (nl_langinfo_l(MON_3, l),
569 -1, NULL, NULL, NULL);
570 priv->monthname[3] = g_locale_to_utf8 (nl_langinfo_l(MON_4, l),
571 -1, NULL, NULL, NULL);
572 priv->monthname[4] = g_locale_to_utf8 (nl_langinfo_l(MON_5, l),
573 -1, NULL, NULL, NULL);
574 priv->monthname[5] = g_locale_to_utf8 (nl_langinfo_l(MON_6, l),
575 -1, NULL, NULL, NULL);
576 priv->monthname[6] = g_locale_to_utf8 (nl_langinfo_l(MON_7, l),
577 -1, NULL, NULL, NULL);
578 priv->monthname[7] = g_locale_to_utf8 (nl_langinfo_l(MON_8, l),
579 -1, NULL, NULL, NULL);
580 priv->monthname[8] = g_locale_to_utf8 (nl_langinfo_l(MON_9, l),
581 -1, NULL, NULL, NULL);
582 priv->monthname[9] = g_locale_to_utf8 (nl_langinfo_l(MON_10, l),
583 -1, NULL, NULL, NULL);
584 priv->monthname[10] = g_locale_to_utf8 (nl_langinfo_l(MON_11, l),
585 -1, NULL, NULL, NULL);
586 priv->monthname[11] = g_locale_to_utf8 (nl_langinfo_l(MON_12, l),
587 -1, NULL, NULL, NULL);
593 hildon_calendar_class_init (HildonCalendarClass *class)
595 GObjectClass *gobject_class;
596 GtkObjectClass *object_class;
597 GtkWidgetClass *widget_class;
599 gobject_class = (GObjectClass*) class;
600 object_class = (GtkObjectClass*) class;
601 widget_class = (GtkWidgetClass*) class;
603 parent_class = g_type_class_peek_parent (class);
605 gobject_class->set_property = hildon_calendar_set_property;
606 gobject_class->get_property = hildon_calendar_get_property;
607 gobject_class->finalize = hildon_calendar_finalize;
609 object_class->destroy = hildon_calendar_destroy;
611 widget_class->realize = hildon_calendar_realize;
612 widget_class->unrealize = hildon_calendar_unrealize;
613 widget_class->expose_event = hildon_calendar_expose;
614 widget_class->size_request = hildon_calendar_size_request;
615 widget_class->size_allocate = hildon_calendar_size_allocate;
616 widget_class->button_press_event = hildon_calendar_button_press;
617 widget_class->button_release_event = hildon_calendar_button_release;
618 widget_class->motion_notify_event = hildon_calendar_motion_notify;
619 widget_class->enter_notify_event = hildon_calendar_enter_notify;
620 widget_class->leave_notify_event = hildon_calendar_leave_notify;
621 widget_class->key_press_event = hildon_calendar_key_press;
622 widget_class->scroll_event = hildon_calendar_scroll;
623 widget_class->style_set = hildon_calendar_style_set;
624 widget_class->state_changed = hildon_calendar_state_changed;
625 widget_class->grab_notify = hildon_calendar_grab_notify;
626 widget_class->focus_out_event = hildon_calendar_focus_out;
628 widget_class->drag_data_get = hildon_calendar_drag_data_get;
629 widget_class->drag_motion = hildon_calendar_drag_motion;
630 widget_class->drag_leave = hildon_calendar_drag_leave;
631 widget_class->drag_drop = hildon_calendar_drag_drop;
632 widget_class->drag_data_received = hildon_calendar_drag_data_received;
634 class->month_changed = NULL;
635 class->day_selected = NULL;
636 class->day_selected_double_click = NULL;
637 class->prev_month = NULL;
638 class->next_month = NULL;
639 class->prev_year = NULL;
640 class->next_year = NULL;
643 * HildonCalendar:year:
647 g_object_class_install_property (gobject_class,
649 g_param_spec_int ("year",
653 GTK_PARAM_READWRITE));
656 * HildonCalendar:month:
658 * The selected month as number between 0 and 11.
660 g_object_class_install_property (gobject_class,
662 g_param_spec_int ("month",
664 "The selected month (as a number between 0 and 11)",
666 GTK_PARAM_READWRITE));
669 * HildonCalendar:day:
671 * The selected day as number between 1 and 31 or 0 to unselect the currently selected day.
673 g_object_class_install_property (gobject_class,
675 g_param_spec_int ("day",
677 "The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day)",
679 GTK_PARAM_READWRITE));
682 * HildonCalendar:show-heading:
684 * Determines whether a heading is displayed.
687 g_object_class_install_property (gobject_class,
689 g_param_spec_boolean ("show-heading",
691 "If TRUE, a heading is displayed",
693 GTK_PARAM_READWRITE));
696 * HildonCalendar:show-day-names:
698 * Determines whether day names are displayed.
701 g_object_class_install_property (gobject_class,
703 g_param_spec_boolean ("show-day-names",
705 "If TRUE, day names are displayed",
707 GTK_PARAM_READWRITE));
709 * HildonCalendar:no-month-change:
711 * Determines whether the selected month can be changed.
714 g_object_class_install_property (gobject_class,
715 PROP_NO_MONTH_CHANGE,
716 g_param_spec_boolean ("no-month-change",
718 "If TRUE, the selected month cannot be changed",
720 GTK_PARAM_READWRITE));
723 * HildonCalendar:show-week-numbers:
725 * Determines whether week numbers are displayed.
728 g_object_class_install_property (gobject_class,
729 PROP_SHOW_WEEK_NUMBERS,
730 g_param_spec_boolean ("show-week-numbers",
732 "If TRUE, week numbers are displayed",
734 GTK_PARAM_READWRITE));
737 * HildonCalendar:week-start:
739 * Determines the start day of the week (0 for Sunday, 1 for Monday etc.)
742 g_object_class_install_property (gobject_class,
744 g_param_spec_int ("week-start",
746 "First day of the week; 0 for Sunday, 1 for Monday etc.",
748 GTK_PARAM_READWRITE));
751 * HildonCalendar:min-year:
753 * Minimum valid year (0 if no limit).
756 g_object_class_install_property (gobject_class,
758 g_param_spec_int ("min-year",
759 "Minimum valid year",
760 "Minimum valid year (0 if no limit)",
762 GTK_PARAM_READWRITE));
765 * HildonCalendar:max-year:
767 * Maximum valid year (0 if no limit).
770 g_object_class_install_property (gobject_class,
772 g_param_spec_int ("max-year",
773 "Maximum valid year",
774 "Maximum valid year (0 if no limit)",
776 GTK_PARAM_READWRITE));
778 hildon_calendar_signals[MONTH_CHANGED_SIGNAL] =
779 g_signal_new ("month_changed",
780 G_OBJECT_CLASS_TYPE (gobject_class),
782 G_STRUCT_OFFSET (HildonCalendarClass, month_changed),
784 _hildon_marshal_VOID__VOID,
787 hildon_calendar_signals[DAY_SELECTED_SIGNAL] =
788 g_signal_new ("day_selected",
789 G_OBJECT_CLASS_TYPE (gobject_class),
791 G_STRUCT_OFFSET (HildonCalendarClass, day_selected),
793 _hildon_marshal_VOID__VOID,
796 hildon_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
797 g_signal_new ("day_selected_double_click",
798 G_OBJECT_CLASS_TYPE (gobject_class),
800 G_STRUCT_OFFSET (HildonCalendarClass, day_selected_double_click),
802 _hildon_marshal_VOID__VOID,
805 hildon_calendar_signals[PREV_MONTH_SIGNAL] =
806 g_signal_new ("prev_month",
807 G_OBJECT_CLASS_TYPE (gobject_class),
809 G_STRUCT_OFFSET (HildonCalendarClass, prev_month),
811 _hildon_marshal_VOID__VOID,
814 hildon_calendar_signals[NEXT_MONTH_SIGNAL] =
815 g_signal_new ("next_month",
816 G_OBJECT_CLASS_TYPE (gobject_class),
818 G_STRUCT_OFFSET (HildonCalendarClass, next_month),
820 _hildon_marshal_VOID__VOID,
823 hildon_calendar_signals[PREV_YEAR_SIGNAL] =
824 g_signal_new ("prev_year",
825 G_OBJECT_CLASS_TYPE (gobject_class),
827 G_STRUCT_OFFSET (HildonCalendarClass, prev_year),
829 _hildon_marshal_VOID__VOID,
832 hildon_calendar_signals[NEXT_YEAR_SIGNAL] =
833 g_signal_new ("next_year",
834 G_OBJECT_CLASS_TYPE (gobject_class),
836 G_STRUCT_OFFSET (HildonCalendarClass, next_year),
838 _hildon_marshal_VOID__VOID,
842 * HildonCalendar::erroneous-date:
844 * Emitted when the user tries to set a date which is outside the boundaries
845 * set by min-year and max-year properties.
848 hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL] =
849 g_signal_new ("erroneous_date",
850 G_OBJECT_CLASS_TYPE (gobject_class),
854 _hildon_marshal_VOID__VOID,
857 * HildonCalendar::selected-date:
859 * Emitted on button-release when the user has selected a date.
862 hildon_calendar_signals[SELECTED_DATE_SIGNAL] =
863 g_signal_new ("selected_date",
864 G_OBJECT_CLASS_TYPE(gobject_class),
868 _hildon_marshal_VOID__VOID,
873 hildon_calendar_init (HildonCalendar *calendar)
878 /* char buffer[255];*/
879 /* time_t tmp_time;*/
881 HildonCalendarPrivate *private_data;
882 /* gchar *year_before;*/
886 GDateWeekday week_1stday;
890 widget = GTK_WIDGET (calendar);
891 GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
893 calendar->private_data = g_malloc (sizeof (HildonCalendarPrivate));
894 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
898 tm = localtime (&secs);
899 calendar->month = tm->tm_mon;
900 calendar->year = 1900 + tm->tm_year;
903 calendar->marked_date[i] = FALSE;
904 calendar->num_marked_dates = 0;
905 calendar->selected_day = tm->tm_mday;
907 calendar->display_flags = ( HILDON_CALENDAR_SHOW_HEADING |
908 HILDON_CALENDAR_SHOW_DAY_NAMES );
910 /* Hildon: we should mark current day and we need to store current date */
911 private_data->current_day = tm->tm_mday;
912 private_data->current_month = tm->tm_mon;
913 private_data->current_year = tm->tm_year + 1900;
915 /* Hildon: following lines are for stylus sliding */
916 private_data->slide_stylus = FALSE;
917 private_data->prev_row = -1;
918 private_data->prev_col = -1;
920 /* Hildon: is_bad_day indicate if day was selected out of legal range */
921 private_data->is_bad_day = FALSE;
923 calendar->highlight_row = -1;
924 calendar->highlight_col = -1;
926 calendar->focus_row = -1;
927 calendar->focus_col = -1;
928 calendar->xor_gc = NULL;
930 private_data->max_year_width = 0;
931 private_data->max_month_width = 0;
932 private_data->max_day_char_width = 0;
933 private_data->max_week_char_width = 0;
935 private_data->max_day_char_ascent = 0;
936 private_data->max_day_char_descent = 0;
937 private_data->max_label_char_ascent = 0;
938 private_data->max_label_char_descent = 0;
940 /* private_data->arrow_width = 10;*/
942 private_data->freeze_count = 0;
944 private_data->dirty_header = 0;
945 private_data->dirty_day_names = 0;
946 private_data->dirty_week = 0;
947 private_data->dirty_main = 0;
949 private_data->need_timer = 0;
950 private_data->timer = 0;
951 private_data->click_child = -1;
953 private_data->in_drag = 0;
954 private_data->drag_highlight = 0;
956 private_data->min_year = 0;
957 private_data->max_year = 0;
959 gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_COPY);
960 gtk_drag_dest_add_text_targets (widget);
963 private_data->year_before = 0;
965 /* Translate to calendar:YM if you want years to be displayed
966 * before months; otherwise translate to calendar:MY.
967 * Do *not* translate it to anything else, if it
968 * it isn't calendar:YM or calendar:MY it will not work.
970 * Note that this flipping is in top the text direction flipping,
971 * so if you have a default text direction of RTL and YM, then
972 * the year will appear on the right.
974 year_before = _("calendar:MY");
975 if (strcmp (year_before, "calendar:YM") == 0)
976 private_data->year_before = 1;
977 else if (strcmp (year_before, "calendar:MY") != 0)
978 g_warning ("Whoever translated calendar:MY did so wrongly.\n");
980 langinfo = nl_langinfo (_NL_TIME_FIRST_WEEKDAY);
981 first_weekday = langinfo[0];
982 langinfo = nl_langinfo (_NL_TIME_WEEK_1STDAY);
983 week_origin = GPOINTER_TO_UINT (langinfo);
984 if (week_origin == 19971130)
985 week_1stday = G_DATE_SUNDAY;
986 else if (week_origin == 19971201)
987 week_1stday = G_DATE_MONDAY;
988 else if (g_date_valid_dmy ((week_origin % 100),
989 (week_origin / 100) % 100,
990 (week_origin / 10000)))
993 date = g_date_new_dmy ((week_origin % 100),
994 (week_origin / 100) % 100,
995 (week_origin / 10000));
996 week_1stday = g_date_get_weekday (date);
1001 g_warning ("Invalid value set for _NL_TIME_WEEK_1STDAY");
1002 week_1stday = G_DATE_SUNDAY;
1005 private_data->week_start = (week_1stday + first_weekday - 1) % 7;
1007 locales_init (private_data);
1011 hildon_calendar_new (void)
1013 return g_object_new (HILDON_TYPE_CALENDAR, NULL);
1016 /* column_from_x: returns the column 0-6 that the
1017 * x pixel of the xwindow is in */
1019 column_from_x (HildonCalendar *calendar,
1023 gint x_left, x_right;
1027 for (c = 0; c < 7; c++)
1029 x_left = left_x_for_column (calendar, c);
1030 x_right = x_left + HILDON_CALENDAR_GET_PRIVATE (calendar)->day_width;
1032 if (event_x >= x_left && event_x < x_right)
1043 row_height (HildonCalendar *calendar)
1045 return (HILDON_CALENDAR_GET_PRIVATE (calendar)->main_h - CALENDAR_MARGIN
1046 - ((calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1047 ? CALENDAR_YSEP : CALENDAR_MARGIN)) / 6;
1051 /* row_from_y: returns the row 0-5 that the
1052 * y pixel of the xwindow is in */
1054 row_from_y (HildonCalendar *calendar,
1059 gint y_top, y_bottom;
1063 for (r = 0; r < 6; r++)
1065 y_top = top_y_for_row (calendar, r);
1066 y_bottom = y_top + HILDON_DAY_HEIGHT /*height*/;
1068 if (event_y >= y_top && event_y < y_bottom)
1078 /* left_x_for_column: returns the x coordinate
1079 * for the left of the column */
1081 left_x_for_column (HildonCalendar *calendar,
1087 if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
1088 column = 6 - column;
1090 width = HILDON_CALENDAR_GET_PRIVATE (calendar)->day_width;
1091 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1092 x_left = CALENDAR_XSEP + (width + DAY_XSEP) * column;
1094 x_left = CALENDAR_MARGIN + (width + DAY_XSEP) * column;
1099 /* top_y_for_row: returns the y coordinate
1100 * for the top of the row */
1102 top_y_for_row (HildonCalendar *calendar,
1105 return (HILDON_CALENDAR_GET_PRIVATE (calendar)->main_h
1106 - (CALENDAR_MARGIN + (6 - row)
1107 * HILDON_DAY_HEIGHT));
1111 hildon_calendar_set_month_prev (HildonCalendar *calendar)
1113 HildonCalendarPrivate *priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1116 if (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1119 if (calendar->month == 0)
1121 if (!priv->min_year || calendar->year > priv->min_year)
1123 calendar->month = 11;
1130 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1132 hildon_calendar_freeze (calendar);
1133 hildon_calendar_compute_days (calendar);
1135 g_signal_emit (calendar,
1136 hildon_calendar_signals[PREV_MONTH_SIGNAL],
1138 g_signal_emit (calendar,
1139 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1142 if (month_len < calendar->selected_day)
1144 calendar->selected_day = 0;
1145 hildon_calendar_select_day (calendar, month_len);
1149 if (calendar->selected_day < 0)
1150 calendar->selected_day = calendar->selected_day + 1 + month_length[leap (calendar->year)][calendar->month + 1];
1151 hildon_calendar_select_day (calendar, calendar->selected_day);
1154 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1155 hildon_calendar_thaw (calendar);
1159 hildon_calendar_set_month_next (HildonCalendar *calendar)
1161 HildonCalendarPrivate *priv;
1164 g_return_if_fail (GTK_IS_WIDGET (calendar));
1166 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1168 if (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1171 if (calendar->month == 11)
1173 if (!priv->max_year || calendar->year < priv->max_year)
1175 calendar->month = 0;
1182 hildon_calendar_freeze (calendar);
1183 hildon_calendar_compute_days (calendar);
1184 g_signal_emit (calendar,
1185 hildon_calendar_signals[NEXT_MONTH_SIGNAL],
1187 g_signal_emit (calendar,
1188 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1191 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1193 if (month_len < calendar->selected_day)
1195 calendar->selected_day = 0;
1196 hildon_calendar_select_day (calendar, month_len);
1199 hildon_calendar_select_day (calendar, calendar->selected_day);
1201 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1202 hildon_calendar_thaw (calendar);
1206 hildon_calendar_set_year_prev (HildonCalendar *calendar)
1208 HildonCalendarPrivate *priv;
1211 g_return_if_fail (GTK_IS_WIDGET (calendar));
1213 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1215 if (!priv->min_year || priv->min_year < calendar->year)
1218 hildon_calendar_freeze (calendar);
1219 hildon_calendar_compute_days (calendar);
1220 g_signal_emit (calendar,
1221 hildon_calendar_signals[PREV_YEAR_SIGNAL],
1223 g_signal_emit (calendar,
1224 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1227 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1229 if (month_len < calendar->selected_day)
1231 calendar->selected_day = 0;
1232 hildon_calendar_select_day (calendar, month_len);
1235 hildon_calendar_select_day (calendar, calendar->selected_day);
1237 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1238 hildon_calendar_thaw (calendar);
1242 hildon_calendar_set_year_next (HildonCalendar *calendar)
1244 HildonCalendarPrivate *priv;
1247 g_return_if_fail (GTK_IS_WIDGET (calendar));
1248 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1250 hildon_calendar_freeze (calendar);
1252 if (!priv->max_year || priv->max_year > calendar->year)
1255 hildon_calendar_compute_days (calendar);
1256 g_signal_emit (calendar,
1257 hildon_calendar_signals[NEXT_YEAR_SIGNAL],
1259 g_signal_emit (calendar,
1260 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1263 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1265 if (month_len < calendar->selected_day)
1267 calendar->selected_day = 0;
1268 hildon_calendar_select_day (calendar, month_len);
1271 hildon_calendar_select_day (calendar, calendar->selected_day);
1272 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1273 hildon_calendar_thaw (calendar);
1277 hildon_calendar_main_button (GtkWidget *widget,
1278 GdkEventButton *event)
1280 HildonCalendar *calendar;
1281 HildonCalendarPrivate *private_data;
1287 calendar = HILDON_CALENDAR (widget);
1288 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1290 x = (gint) (event->x);
1291 y = (gint) (event->y);
1293 row = row_from_y (calendar, y);
1294 col = column_from_x (calendar, x);
1296 /* If row or column isn't found, just return. */
1297 if (row == -1 || col == -1)
1300 day_month = calendar->day_month[row][col];
1302 if ((calendar->year == private_data->min_year &&
1303 calendar->month == 0 && day_month == MONTH_PREV) ||
1304 (calendar->year == private_data->max_year &&
1305 calendar->month == 11 && day_month == MONTH_NEXT))
1307 private_data->is_bad_day = TRUE;
1308 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
1312 if (event->type == GDK_BUTTON_RELEASE)
1314 day = calendar->day[row][col];
1316 if (day_month == MONTH_PREV)
1318 hildon_calendar_set_month_prev (calendar);
1320 else if (day_month == MONTH_NEXT)
1322 hildon_calendar_set_month_next (calendar);
1325 if (!GTK_WIDGET_HAS_FOCUS (widget))
1326 gtk_widget_grab_focus (widget);
1328 if (event->button == 1)
1330 private_data->in_drag = 1;
1331 private_data->drag_start_x = x;
1332 private_data->drag_start_y = y;
1335 hildon_calendar_select_and_focus_day (calendar, day);
1337 else if (event->type == GDK_2BUTTON_PRESS)
1339 private_data->in_drag = 0;
1340 private_data->slide_stylus = FALSE;
1341 if (day_month == MONTH_CURRENT)
1342 g_signal_emit (calendar,
1343 hildon_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL], 0);
1348 hildon_calendar_realize_arrows (GtkWidget *widget)
1350 HildonCalendar *calendar;
1351 HildonCalendarPrivate *private_data;
1352 GdkWindowAttr attributes;
1353 gint attributes_mask;
1355 guint arrow_vlength, arrow_hlength;
1356 /*gboolean year_left;*/
1358 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1360 calendar = HILDON_CALENDAR (widget);
1361 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1363 gtk_widget_style_get (widget,
1364 "scroll-arrow-hlength", &arrow_hlength,
1365 "scroll-arrow-vlength", &arrow_vlength,
1368 if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1369 year_left = private_data->year_before;
1371 year_left = !private_data->year_before;
1373 /* Arrow windows ------------------------------------- */
1374 if (! (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1375 && (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING))
1377 attributes.wclass = GDK_INPUT_OUTPUT;
1378 attributes.window_type = GDK_WINDOW_CHILD;
1379 attributes.visual = gtk_widget_get_visual (widget);
1380 attributes.colormap = gtk_widget_get_colormap (widget);
1381 attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
1382 | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1383 | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
1384 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1386 attributes.width = arrow_vlength;
1387 attributes.height = arrow_hlength;
1389 attributes.x = (widget->allocation.width - private_data->max_year_width) / 2 - arrow_vlength - HILDON_ARROW_SEP;
1390 private_data->arrow_win[ARROW_YEAR_LEFT] = gdk_window_new (private_data->header_win,
1391 &attributes, attributes_mask);
1393 attributes.x = (widget->allocation.width + private_data->max_year_width) / 2 + HILDON_ARROW_SEP;
1394 private_data->arrow_win[ARROW_YEAR_RIGHT] = gdk_window_new (private_data->header_win,
1395 &attributes, attributes_mask);
1396 attributes.x = (widget->allocation.width - private_data->max_month_width) / 2 - arrow_vlength - HILDON_ARROW_SEP;
1397 private_data->arrow_win[ARROW_MONTH_LEFT] = gdk_window_new (private_data->footer_win,
1398 &attributes, attributes_mask);
1399 attributes.x = (widget->allocation.width + private_data->max_month_width) / 2 + HILDON_ARROW_SEP;
1400 private_data->arrow_win[ARROW_MONTH_RIGHT] = gdk_window_new (private_data->footer_win,
1401 &attributes, attributes_mask);
1404 for (i = 0; i < 4; i++)
1408 case ARROW_MONTH_LEFT:
1410 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1411 - (3 + 2*private_data->arrow_width
1412 + private_data->max_month_width));
1416 case ARROW_MONTH_RIGHT:
1418 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1419 - 3 - private_data->arrow_width);
1421 attributes.x = (private_data->arrow_width
1422 + private_data->max_month_width);
1424 case ARROW_YEAR_LEFT:
1428 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1429 - (3 + 2*private_data->arrow_width
1430 + private_data->max_year_width));
1432 case ARROW_YEAR_RIGHT:
1434 attributes.x = (private_data->arrow_width
1435 + private_data->max_year_width);
1437 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1438 - 3 - private_data->arrow_width);
1441 private_data->arrow_win[i] = gdk_window_new (private_data->header_win,
1445 for (i = 0; i < 4; i++)
1447 if (GTK_WIDGET_IS_SENSITIVE (widget))
1448 private_data->arrow_state[i] = GTK_STATE_NORMAL;
1450 private_data->arrow_state[i] = GTK_STATE_INSENSITIVE;
1451 gdk_window_set_background (private_data->arrow_win[i],
1452 HEADER_BG_COLOR (GTK_WIDGET (calendar)));
1453 gdk_window_show (private_data->arrow_win[i]);
1454 gdk_window_set_user_data (private_data->arrow_win[i], widget);
1459 for (i = 0; i < 4; i++)
1460 private_data->arrow_win[i] = NULL;
1465 hildon_calendar_realize_header (GtkWidget *widget)
1467 HildonCalendar *calendar;
1468 HildonCalendarPrivate *private_data;
1469 GdkWindowAttr attributes;
1470 gint attributes_mask;
1471 guint arrow_hlength;
1473 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1475 calendar = HILDON_CALENDAR (widget);
1476 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1478 gtk_widget_style_get (widget,
1479 "scroll-arrow-hlength", &arrow_hlength,
1481 /* Header window ------------------------------------- */
1482 if (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING)
1484 attributes.wclass = GDK_INPUT_OUTPUT;
1485 attributes.window_type = GDK_WINDOW_CHILD;
1486 attributes.visual = gtk_widget_get_visual (widget);
1487 attributes.colormap = gtk_widget_get_colormap (widget);
1488 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
1489 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1490 attributes.x = 0 /*widget->style->xthickness*/;
1491 attributes.y = 0 /*widget->style->ythickness*/;
1492 attributes.width = widget->allocation.width; /* - 2 * attributes.x */;
1493 attributes.height = arrow_hlength /*private_data->header_h - 2 * attributes.y*/;
1494 private_data->header_win = gdk_window_new (widget->window,
1495 &attributes, attributes_mask);
1497 attributes.y = arrow_hlength + 2 * CALENDAR_YSEP + private_data->main_h + private_data->day_name_h;
1499 private_data->footer_win = gdk_window_new(widget->window,
1500 &attributes, attributes_mask);
1502 gdk_window_set_background (private_data->header_win,
1503 HEADER_BG_COLOR (widget));
1504 gdk_window_set_background (private_data->footer_win,
1505 HEADER_BG_COLOR (widget));
1507 gdk_window_show (private_data->header_win);
1508 gdk_window_show (private_data->footer_win);
1509 gdk_window_set_user_data (private_data->header_win, widget);
1510 gdk_window_set_user_data (private_data->footer_win, widget);
1514 private_data->header_win = NULL;
1515 private_data->footer_win = NULL;
1517 hildon_calendar_realize_arrows (widget);
1521 hildon_calendar_realize_day_names (GtkWidget *widget)
1523 HildonCalendar *calendar;
1524 HildonCalendarPrivate *private_data;
1525 GdkWindowAttr attributes;
1526 gint attributes_mask;
1528 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1530 calendar = HILDON_CALENDAR (widget);
1531 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1533 /* Day names window --------------------------------- */
1534 if ( calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1536 attributes.wclass = GDK_INPUT_OUTPUT;
1537 attributes.window_type = GDK_WINDOW_CHILD;
1538 attributes.visual = gtk_widget_get_visual (widget);
1539 attributes.colormap = gtk_widget_get_colormap (widget);
1540 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
1541 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1542 attributes.x = HILDON_DAY_WIDTH + HILDON_WEEKS_EXTRA_WIDTH/*(widget->style->xthickness + INNER_BORDER)*/;
1543 attributes.y = private_data->header_h;
1544 attributes.width = widget->allocation.width - attributes.x;
1545 attributes.height = private_data->day_name_h;
1546 private_data->day_name_win = gdk_window_new (widget->window,
1549 gdk_window_set_background (private_data->day_name_win,
1550 BACKGROUND_COLOR ( GTK_WIDGET (calendar)));
1552 gdk_window_show (private_data->day_name_win);
1553 gdk_window_set_user_data (private_data->day_name_win, widget);
1557 private_data->day_name_win = NULL;
1562 hildon_calendar_realize_week_numbers (GtkWidget *widget)
1564 HildonCalendar *calendar;
1565 HildonCalendarPrivate *private_data;
1566 GdkWindowAttr attributes;
1567 gint attributes_mask;
1569 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1571 calendar = HILDON_CALENDAR (widget);
1572 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1574 /* Week number window -------------------------------- */
1575 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1577 attributes.wclass = GDK_INPUT_OUTPUT;
1578 attributes.window_type = GDK_WINDOW_CHILD;
1579 attributes.visual = gtk_widget_get_visual (widget);
1580 attributes.colormap = gtk_widget_get_colormap (widget);
1581 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
1583 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1584 attributes.x = 0 /*widget->style->xthickness + INNER_BORDER*/;
1585 attributes.y = private_data->header_h;
1586 /*+ (widget->style->ythickness + INNER_BORDER))*/;
1587 attributes.width = HILDON_DAY_WIDTH + HILDON_WEEKS_EXTRA_WIDTH;
1588 attributes.height = private_data->main_h + private_data->day_name_h;
1589 private_data->week_win = gdk_window_new (widget->window,
1590 &attributes, attributes_mask);
1591 gdk_window_set_background (private_data->week_win,
1592 BACKGROUND_COLOR (GTK_WIDGET (calendar)));
1593 gdk_window_show (private_data->week_win);
1594 gdk_window_set_user_data (private_data->week_win, widget);
1598 private_data->week_win = NULL;
1603 hildon_calendar_realize (GtkWidget *widget)
1605 HildonCalendar *calendar;
1606 HildonCalendarPrivate *private_data;
1607 GdkWindowAttr attributes;
1608 gint attributes_mask;
1611 calendar = HILDON_CALENDAR (widget);
1612 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1614 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1615 hildon_calendar_compute_days (calendar);
1617 attributes.x = widget->allocation.x;
1618 attributes.y = widget->allocation.y;
1619 attributes.width = widget->allocation.width;
1620 attributes.height = widget->allocation.height;
1621 attributes.wclass = GDK_INPUT_OUTPUT;
1622 attributes.window_type = GDK_WINDOW_CHILD;
1623 attributes.event_mask = (gtk_widget_get_events (widget)
1624 | GDK_EXPOSURE_MASK |GDK_KEY_PRESS_MASK | GDK_SCROLL_MASK);
1625 attributes.visual = gtk_widget_get_visual (widget);
1626 attributes.colormap = gtk_widget_get_colormap (widget);
1628 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1629 widget->window = gdk_window_new (widget->parent->window,
1630 &attributes, attributes_mask);
1632 widget->style = gtk_style_attach (widget->style, widget->window);
1634 /* Header window ------------------------------------- */
1635 hildon_calendar_realize_header (widget);
1636 /* Day names window --------------------------------- */
1637 hildon_calendar_realize_day_names (widget);
1638 /* Week number window -------------------------------- */
1639 hildon_calendar_realize_week_numbers (widget);
1640 /* Main Window -------------------------------------- */
1641 attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
1642 | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1643 | GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
1645 attributes.x = HILDON_DAY_WIDTH + HILDON_WEEKS_EXTRA_WIDTH /*private_data->week_width + (widget->style->ythickness + INNER_BORDER)*/;
1646 attributes.y = (private_data->header_h + private_data->day_name_h
1647 + (widget->style->ythickness + INNER_BORDER));
1648 attributes.width = (widget->allocation.width - attributes.x
1649 /*- (widget->style->xthickness + INNER_BORDER)*/);
1650 attributes.height = private_data->main_h;
1651 private_data->main_win = gdk_window_new (widget->window,
1652 &attributes, attributes_mask);
1653 gdk_window_set_background (private_data->main_win,
1654 BACKGROUND_COLOR ( GTK_WIDGET ( calendar)));
1655 gdk_window_show (private_data->main_win);
1656 gdk_window_set_user_data (private_data->main_win, widget);
1657 gdk_window_set_background (widget->window, BACKGROUND_COLOR (widget));
1658 gdk_window_show (widget->window);
1659 gdk_window_set_user_data (widget->window, widget);
1661 /* Set widgets gc */
1662 calendar->gc = gdk_gc_new (widget->window);
1664 values.foreground = widget->style->white;
1665 values.function = GDK_XOR;
1666 calendar->xor_gc = gdk_gc_new_with_values (widget->window,
1673 hildon_calendar_unrealize (GtkWidget *widget)
1675 HildonCalendar *calendar;
1676 HildonCalendarPrivate *private_data;
1679 calendar = HILDON_CALENDAR (widget);
1680 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1682 if (private_data->header_win)
1684 for (i = 0; i < 4; i++)
1686 if (private_data->arrow_win[i])
1688 gdk_window_set_user_data (private_data->arrow_win[i], NULL);
1689 gdk_window_destroy (private_data->arrow_win[i]);
1690 private_data->arrow_win[i] = NULL;
1693 gdk_window_set_user_data (private_data->header_win, NULL);
1694 gdk_window_destroy (private_data->header_win);
1695 private_data->header_win = NULL;
1696 gdk_window_set_user_data (private_data->footer_win, NULL);
1697 gdk_window_destroy (private_data->footer_win);
1698 private_data->footer_win = NULL;
1701 if (private_data->week_win)
1703 gdk_window_set_user_data (private_data->week_win, NULL);
1704 gdk_window_destroy (private_data->week_win);
1705 private_data->week_win = NULL;
1708 if (private_data->main_win)
1710 gdk_window_set_user_data (private_data->main_win, NULL);
1711 gdk_window_destroy (private_data->main_win);
1712 private_data->main_win = NULL;
1714 if (private_data->day_name_win)
1716 gdk_window_set_user_data (private_data->day_name_win, NULL);
1717 gdk_window_destroy (private_data->day_name_win);
1718 private_data->day_name_win = NULL;
1720 if (calendar->xor_gc)
1721 g_object_unref (calendar->xor_gc);
1723 g_object_unref (calendar->gc);
1725 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
1726 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
1730 hildon_calendar_size_request (GtkWidget *widget,
1731 GtkRequisition *requisition)
1733 HildonCalendar *calendar;
1734 HildonCalendarPrivate *private_data;
1735 PangoLayout *layout;
1736 PangoRectangle logical_rect;
1741 /*gint calendar_margin = CALENDAR_MARGIN;*/
1742 gint header_width, main_width;
1743 gint max_header_height = 0;
1748 calendar = HILDON_CALENDAR (widget);
1749 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1750 gtk_widget_style_get (GTK_WIDGET (widget),
1751 "focus-line-width", &focus_width,
1752 "focus-padding", &focus_padding,
1753 "scroll-arrow-hlength", &arrow_hlength,
1756 layout = gtk_widget_create_pango_layout (widget, NULL);
1759 * Calculate the requisition width for the widget.
1764 if (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING)
1766 private_data->max_month_width = 0;
1767 for (i = 0; i < 12; i++)
1769 pango_layout_set_text (layout, private_data->monthname[i], -1);
1770 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1771 private_data->max_month_width = MAX (private_data->max_month_width,
1772 logical_rect.width + 8);
1773 max_header_height = MAX (max_header_height, logical_rect.height);
1775 private_data->max_year_width = 0;
1776 for (i=0; i<10; i++)
1778 g_snprintf (buffer, sizeof (buffer), "%d%d%d%d", i,i,i,i);
1779 pango_layout_set_text (layout, buffer, -1);
1780 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1781 private_data->max_year_width = MAX (private_data->max_year_width,
1782 logical_rect.width + 8);
1783 max_header_height = MAX (max_header_height, logical_rect.height);
1788 private_data->max_month_width = 0;
1789 private_data->max_year_width = 0;
1792 if (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1793 header_width = (private_data->max_month_width
1794 + private_data->max_year_width
1797 header_width = (private_data->max_month_width
1798 + private_data->max_year_width
1799 + 4 * private_data->arrow_width + 3 * 3);
1801 /* Mainwindow labels width */
1803 private_data->max_day_char_width = 0;
1804 private_data->min_day_width = 0;
1805 private_data->max_label_char_ascent = 0;
1806 private_data->max_label_char_descent = 0;
1808 for (i = 0; i < 9; i++)
1810 g_snprintf (buffer, sizeof (buffer), "%d%d", i, i);
1811 pango_layout_set_text (layout, buffer, -1);
1812 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1813 private_data->min_day_width = MAX (private_data->min_day_width,
1814 logical_rect.width);
1816 private_data->max_day_char_ascent = MAX (private_data->max_label_char_ascent,
1817 PANGO_ASCENT (logical_rect));
1818 private_data->max_day_char_descent = MAX (private_data->max_label_char_descent,
1819 PANGO_DESCENT (logical_rect));
1821 /* We add one to max_day_char_width to be able to make the marked day "bold" */
1822 private_data->max_day_char_width = private_data->min_day_width / 2 + 1;
1824 if (calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1825 for (i = 0; i < 7; i++)
1827 pango_layout_set_text (layout, private_data->abbreviated_dayname[i], -1);
1828 pango_layout_line_get_pixel_extents (pango_layout_get_lines (layout)->data, NULL, &logical_rect);
1830 /* Hildon: add 4 so that passive focus wouldn't overlap day names */
1831 private_data->min_day_width = MAX (private_data->min_day_width, logical_rect.width + 4);
1832 private_data->max_label_char_ascent = MAX (private_data->max_label_char_ascent,
1833 PANGO_ASCENT (logical_rect));
1834 private_data->max_label_char_descent = MAX (private_data->max_label_char_descent,
1835 PANGO_DESCENT (logical_rect));
1838 private_data->max_week_char_width = 0;
1839 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1840 for (i = 0; i < 9; i++)
1842 g_snprintf (buffer, sizeof (buffer), "%d%d", i, i);
1843 pango_layout_set_text (layout, buffer, -1);
1844 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1845 private_data->max_week_char_width = MAX (private_data->max_week_char_width,
1846 logical_rect.width / 2);
1849 main_width = (7 * (private_data->min_day_width + (focus_padding + focus_width) * 2) + (DAY_XSEP * 6) + CALENDAR_MARGIN * 2
1850 + (private_data->max_week_char_width
1851 ? private_data->max_week_char_width * 2 + (focus_padding + focus_width) * 2 + CALENDAR_XSEP * 2
1854 /* requisition->width = MAX (header_width, main_width + INNER_BORDER * 2) + widget->style->xthickness * 2;
1856 * FIXME: header_width is broken, when Calendar is themed !
1857 * Next line is workaround for this bug
1859 requisition->width = (main_width + INNER_BORDER * 2) + widget->style->xthickness * 2 + HILDON_WEEKS_EXTRA_WIDTH + HILDON_DAYS_EXTRA_WIDTH;
1862 * Calculate the requisition height for the widget.
1863 * This is Hildon calculation
1866 if (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING)
1867 private_data->header_h = arrow_hlength + CALENDAR_YSEP;
1869 private_data->header_h = 0;
1871 if (calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1872 private_data->day_name_h = HILDON_DAY_HEIGHT;
1874 private_data->day_name_h = 0;
1876 private_data->main_h = 6 * HILDON_DAY_HEIGHT;
1877 requisition->height = 2 * private_data->header_h + private_data->day_name_h + private_data->main_h;
1879 g_object_unref (layout);
1883 hildon_calendar_size_allocate (GtkWidget *widget,
1884 GtkAllocation *allocation)
1886 HildonCalendar *calendar;
1887 HildonCalendarPrivate *private_data;
1888 gint xthickness = widget->style->xthickness;
1889 /*gint ythickness = widget->style->xthickness;*/
1891 gint arrow_vlength, arrow_hlength;
1893 widget->allocation = *allocation;
1895 calendar = HILDON_CALENDAR (widget);
1896 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1898 if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1899 year_left = private_data->year_before;
1901 year_left = !private_data->year_before;
1903 gtk_widget_style_get (widget,
1904 "scroll-arrow-vlength", &arrow_vlength,
1905 "scroll-arrow-hlength", &arrow_hlength,
1908 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1910 /* this variable is introduced to avoid breaking week_width because
1911 of HILDON_WEEKS_EXTRA_WIDTH and HILDON_DAYS_EXTRA_WIDTH appearing
1912 in calculation of day_width */
1913 int real_day_width = (private_data->min_day_width
1914 * ((allocation->width
1915 - (xthickness + INNER_BORDER) * 2
1916 - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2))
1917 / (7 * private_data->min_day_width + private_data->max_week_char_width * 2));
1919 private_data->day_width = (private_data->min_day_width
1920 * ((allocation->width
1921 - (HILDON_WEEKS_EXTRA_WIDTH + HILDON_DAYS_EXTRA_WIDTH)
1922 - (xthickness + INNER_BORDER) * 2
1923 - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2))
1924 / (7 * private_data->min_day_width + private_data->max_week_char_width * 2));
1925 private_data->week_width = ((allocation->width - (xthickness + INNER_BORDER) * 2
1926 - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2 )
1927 - real_day_width * 7 + CALENDAR_MARGIN + CALENDAR_XSEP);
1931 private_data->day_width = (allocation->width
1932 - (xthickness + INNER_BORDER) * 2
1933 - (CALENDAR_MARGIN * 2)
1934 - (DAY_XSEP * 6))/7;
1935 private_data->week_width = 0;
1938 if (GTK_WIDGET_REALIZED (widget))
1940 gdk_window_move_resize (widget->window,
1941 allocation->x, allocation->y,
1942 allocation->width, allocation->height);
1943 if (private_data->header_win)
1944 gdk_window_move_resize (private_data->header_win,
1945 0, 0, widget->allocation.width, arrow_hlength);
1946 if (private_data->arrow_win[ARROW_YEAR_LEFT])
1949 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_LEFT],
1951 private_data->arrow_width,
1952 private_data->header_h - 7);
1954 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_LEFT],
1955 (allocation->width - 2 * xthickness
1956 - (3 + 2*private_data->arrow_width
1957 + private_data->max_year_width)),
1959 private_data->arrow_width,
1960 private_data->header_h - 7);*/
1962 gdk_window_move (private_data->arrow_win[ARROW_YEAR_LEFT],
1963 (widget->allocation.width - private_data->max_year_width) / 2 - arrow_vlength - HILDON_ARROW_SEP, 0);
1965 if (private_data->arrow_win[ARROW_YEAR_RIGHT])
1968 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_RIGHT],
1969 (private_data->arrow_width
1970 + private_data->max_year_width),
1972 private_data->arrow_width,
1973 private_data->header_h - 7);
1975 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_RIGHT],
1976 (allocation->width - 2 * xthickness
1977 - 3 - private_data->arrow_width),
1979 private_data->arrow_width,
1980 private_data->header_h - 7);*/
1981 gdk_window_move (private_data->arrow_win[ARROW_YEAR_RIGHT],
1982 (widget->allocation.width + private_data->max_year_width) / 2 + HILDON_ARROW_SEP, 0);
1984 if (private_data->footer_win)
1985 gdk_window_move_resize (private_data->footer_win,
1986 0, private_data->header_h + private_data->day_name_h + private_data->main_h + CALENDAR_YSEP,
1987 widget->allocation.width, arrow_hlength);
1989 if (private_data->arrow_win[ARROW_MONTH_LEFT])
1992 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_LEFT],
1993 (allocation->width - 2 * xthickness
1994 - (3 + 2*private_data->arrow_width
1995 + private_data->max_month_width)),
1997 private_data->arrow_width,
1998 private_data->header_h - 7);
2000 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_LEFT],
2002 private_data->arrow_width,
2003 private_data->header_h - 7);
2006 gdk_window_move (private_data->arrow_win[ARROW_MONTH_LEFT],
2007 (widget->allocation.width - private_data->max_month_width) / 2 - arrow_vlength - HILDON_ARROW_SEP, 0);
2009 if (private_data->arrow_win[ARROW_MONTH_RIGHT])
2012 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_RIGHT],
2013 (allocation->width - 2 * xthickness
2014 - 3 - private_data->arrow_width),
2016 private_data->arrow_width,
2017 private_data->header_h - 7);
2019 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_RIGHT],
2020 (private_data->arrow_width
2021 + private_data->max_month_width),
2023 private_data->arrow_width,
2024 private_data->header_h - 7);*/
2025 gdk_window_move (private_data->arrow_win[ARROW_MONTH_RIGHT],
2026 (widget->allocation.width + private_data->max_month_width) / 2 + HILDON_ARROW_SEP, 0);
2030 if (private_data->day_name_win)
2031 gdk_window_move_resize (private_data->day_name_win,
2032 private_data->week_width, /*xthickness + INNER_BORDER*/
2033 private_data->header_h /*+ (widget->style->ythickness + INNER_BORDER)*/,
2034 widget->allocation.width - private_data->week_width /*- (xthickness + INNER_BORDER) * 2*/,
2035 private_data->day_name_h);
2036 if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
2038 if (private_data->week_win)
2039 gdk_window_move_resize (private_data->week_win,
2040 0 /*(xthickness + INNER_BORDER)*/,
2041 private_data->header_h /*+ (widget->style->ythickness + INNER_BORDER)*/,
2043 private_data->main_h + private_data->day_name_h);
2044 gdk_window_move_resize (private_data->main_win,
2045 private_data->week_width /* + (xthickness + INNER_BORDER)*/,
2046 private_data->header_h + private_data->day_name_h
2047 /*+ (widget->style->ythickness + INNER_BORDER)*/,
2048 widget->allocation.width - private_data->week_width
2049 /*- (xthickness + INNER_BORDER) * 2*/,
2050 private_data->main_h);
2054 gdk_window_move_resize (private_data->main_win,
2055 0 /*(xthickness + INNER_BORDER)*/,
2056 private_data->header_h + private_data->day_name_h
2057 /*+ (widget->style->ythickness + INNER_BORDER)*/,
2058 widget->allocation.width
2059 - private_data->week_width
2060 /*- (xthickness + INNER_BORDER) * 2*/,
2061 private_data->main_h);
2062 if (private_data->week_win)
2063 gdk_window_move_resize (private_data->week_win,
2064 widget->allocation.width
2065 - private_data->week_width
2066 /*- (xthickness + INNER_BORDER)*/,
2067 private_data->header_h + private_data->day_name_h
2068 /*+ (widget->style->ythickness + INNER_BORDER)*/,
2069 private_data->week_width,
2070 private_data->main_h);
2076 hildon_calendar_expose (GtkWidget *widget,
2077 GdkEventExpose *event)
2079 HildonCalendar *calendar;
2080 HildonCalendarPrivate *private_data;
2082 calendar = HILDON_CALENDAR (widget);
2083 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2085 if (GTK_WIDGET_DRAWABLE (widget))
2087 if (event->window == private_data->main_win)
2088 hildon_calendar_paint_main (widget);
2090 if (event->window == private_data->header_win)
2091 hildon_calendar_paint_header (widget);
2092 if (event->window == private_data->footer_win)
2093 hildon_calendar_paint_footer(widget);
2095 if (event->window == private_data->day_name_win)
2096 hildon_calendar_paint_day_names (widget);
2098 if (event->window == private_data->week_win)
2099 hildon_calendar_paint_week_numbers (widget);
2102 /* FIXME This appeared after 2.6 -> 2.10 migration. Without this the
2103 * arrows disappear when spinning through the calendar. Apparently, something
2104 * overdraws them somehow or the expose events go into blackhole. This is
2105 * a dirty fix... but kinda works */
2107 hildon_calendar_paint_header (widget);
2108 hildon_calendar_paint_footer (widget);
2114 hildon_calendar_paint_header (GtkWidget *widget)
2116 HildonCalendar *calendar;
2120 gint header_width, cal_height;
2121 HildonCalendarPrivate *private_data;
2122 PangoLayout *layout;
2123 PangoRectangle logical_rect;
2126 calendar = HILDON_CALENDAR (widget);
2127 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2129 if (private_data->freeze_count)
2131 private_data->dirty_header = 1;
2135 private_data->dirty_header = 0;
2139 gdk_window_clear (private_data->header_win);
2141 header_width = widget->allocation.width /*- 2 * widget->style->xthickness*/;
2142 cal_height = widget->allocation.height;
2144 g_snprintf (buffer, sizeof (buffer), "%d", calendar->year);
2145 layout = gtk_widget_create_pango_layout (widget, buffer);
2146 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2148 gtk_widget_style_get (widget, "scroll-arrow-hlength", &arrow_hlength, NULL);
2150 y = (arrow_hlength - logical_rect.height) / 2;
2151 x = (widget->allocation.width - logical_rect.width) / 2;
2153 /* Draw year and its arrows */
2154 gdk_gc_set_foreground (gc, HEADER_FG_COLOR (GTK_WIDGET (calendar)));
2155 gdk_draw_layout (private_data->header_win, gc, x, y, layout);
2157 hildon_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
2158 hildon_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
2160 g_object_unref (layout);
2164 hildon_calendar_paint_footer (GtkWidget *widget)
2166 HildonCalendar *calendar;
2170 gint header_width, cal_height;
2171 HildonCalendarPrivate *private_data;
2172 PangoLayout *layout;
2173 PangoRectangle logical_rect;
2176 calendar = HILDON_CALENDAR (widget);
2177 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2179 if (private_data->freeze_count)
2181 private_data->dirty_header = 1;
2185 private_data->dirty_header = 0;
2189 gdk_window_clear (private_data->footer_win);
2191 header_width = widget->allocation.width - 2 * widget->style->xthickness;
2192 cal_height = widget->allocation.height;
2194 /* Draw month and its arrows */
2195 g_snprintf (buffer, sizeof (buffer), "%s", private_data->monthname[calendar->month]);
2196 layout = gtk_widget_create_pango_layout (widget, buffer);
2197 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2199 gtk_widget_style_get (widget, "scroll-arrow-hlength", &arrow_hlength, NULL);
2201 x = (widget->allocation.width - logical_rect.width) / 2;
2202 y = (arrow_hlength - logical_rect.height) / 2;
2204 gdk_gc_set_foreground (gc, HEADER_FG_COLOR(GTK_WIDGET (calendar)));
2205 gdk_draw_layout (private_data->footer_win, gc, x, y, layout);
2207 hildon_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
2208 hildon_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
2210 g_object_unref(layout);
2214 hildon_calendar_paint_day_names (GtkWidget *widget)
2216 HildonCalendar *calendar;
2220 int day_width, cal_width;
2223 PangoLayout *layout;
2224 PangoRectangle logical_rect;
2225 HildonCalendarPrivate *private_data;
2229 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2230 calendar = HILDON_CALENDAR (widget);
2231 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2234 gtk_widget_style_get (GTK_WIDGET (widget),
2235 "focus-line-width", &focus_width,
2236 "focus-padding", &focus_padding,
2239 * Handle freeze/thaw functionality
2242 if (private_data->freeze_count)
2244 private_data->dirty_day_names = 1;
2247 private_data->dirty_day_names = 0;
2253 gdk_window_clear (private_data->day_name_win);
2255 day_width = private_data->day_width;
2256 cal_width = widget->allocation.width;
2257 cal_height = widget->allocation.height;
2258 day_wid_sep = day_width + DAY_XSEP;
2261 * Draw rectangles as inverted background for the labels.
2268 layout = gtk_widget_create_pango_layout (widget, NULL);
2270 gdk_gc_set_foreground (gc, SELECTED_FG_COLOR (widget));
2271 for (i = 0; i < 7; i++)
2273 guint x = left_x_for_column (calendar, i);
2275 if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
2279 day = (day + private_data->week_start) % 7;
2280 g_snprintf (buffer, sizeof (buffer), "%s", private_data->abbreviated_dayname[day]);
2282 pango_layout_set_text (layout, buffer, -1);
2283 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2285 /* Hildon: draw passive focus for day name */
2286 if (calendar->focus_col == i)
2287 gtk_paint_box(GTK_WIDGET (calendar)->style,
2288 private_data->day_name_win,
2290 GTK_SHADOW_OUT, NULL,
2291 GTK_WIDGET (calendar), "passive-focus",
2294 logical_rect.width + 4,
2297 gdk_draw_layout (private_data->day_name_win, gc,
2299 CALENDAR_MARGIN + focus_width + focus_padding + logical_rect.y,
2302 g_object_unref (layout);
2306 hildon_calendar_paint_week_numbers (GtkWidget *widget)
2308 HildonCalendar *calendar;
2310 guint row, week = 0, year;
2314 HildonCalendarPrivate *private_data;
2315 PangoLayout *layout;
2316 PangoRectangle logical_rect;
2320 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2321 g_return_if_fail (widget->window != NULL);
2322 calendar = HILDON_CALENDAR (widget);
2323 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2327 * Handle freeze/thaw functionality
2330 if (private_data->freeze_count)
2332 private_data->dirty_week = 1;
2335 private_data->dirty_week = 0;
2337 gtk_widget_style_get (GTK_WIDGET (widget),
2338 "focus-line-width", &focus_width,
2339 "focus-padding", &focus_padding,
2346 gdk_window_clear (private_data->week_win);
2349 * Draw a rectangle as inverted background for the labels.
2352 gdk_gc_set_foreground (gc, SELECTED_BG_COLOR (widget));
2354 /* Hildon: don't paint background for weekday window */
2360 layout = gtk_widget_create_pango_layout (widget, NULL);
2362 gdk_gc_set_foreground (gc, SELECTED_FG_COLOR (widget));
2363 gdk_draw_line(private_data->week_win, gc,
2364 HILDON_DAY_WIDTH + 7,
2366 HILDON_DAY_WIDTH + 7,
2367 private_data->main_h + private_data->day_name_h);
2369 for (row = 0; row < 6; row++)
2371 year = calendar->year;
2372 if (calendar->day[row][6] < 15 && row > 3 && calendar->month == 11)
2375 g_return_if_fail (week_of_year (&week, &year,
2376 ((calendar->day[row][6] < 15 && row > 3 ? 1 : 0)
2377 + calendar->month) % 12 + 1, calendar->day[row][6]));
2379 g_snprintf (buffer, sizeof (buffer), "%d", week);
2380 pango_layout_set_text (layout, buffer, -1);
2381 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2383 /* Hildon: draw passive focus for week */
2384 if (calendar->focus_row == row)
2386 guint y = top_y_for_row (calendar, calendar->focus_row + 1);
2388 gtk_paint_box(GTK_WIDGET (calendar)->style,
2389 private_data->week_win,
2391 GTK_SHADOW_OUT, NULL,
2392 GTK_WIDGET (calendar), "passive-focus",
2394 private_data->week_width/* - 4*/,
2398 y_loc = private_data->day_name_h + top_y_for_row (calendar, row) + (HILDON_DAY_HEIGHT - logical_rect.height) / 2;
2399 x_loc = (HILDON_DAY_WIDTH - logical_rect.width) / 2;
2401 gdk_draw_layout (private_data->week_win, gc, x_loc, y_loc, layout);
2404 g_object_unref (layout);
2408 hildon_calendar_paint_day_num (GtkWidget *widget,
2411 HildonCalendar *calendar;
2412 gint r, c, row, col;
2413 HildonCalendarPrivate *private_data;
2414 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2416 calendar = HILDON_CALENDAR (widget);
2418 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2422 for (r = 0; r < 6; r++)
2423 for (c = 0; c < 7; c++)
2424 if (calendar->day_month[r][c] == MONTH_CURRENT &&
2425 calendar->day[r][c] == day)
2431 g_return_if_fail (row != -1);
2432 g_return_if_fail (col != -1);
2434 hildon_calendar_paint_day (widget, row, col);
2438 hildon_calendar_paint_day (GtkWidget *widget,
2442 HildonCalendar *calendar;
2452 HildonCalendarPrivate *private_data;
2453 PangoLayout *layout;
2454 PangoRectangle logical_rect;
2456 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2457 g_return_if_fail (row < 6);
2458 g_return_if_fail (col < 7);
2459 calendar = HILDON_CALENDAR (widget);
2460 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2462 if (private_data->main_win == NULL) return;
2465 * Handle freeze/thaw functionality
2468 if (private_data->freeze_count)
2470 private_data->dirty_main = 1;
2474 gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
2476 day = calendar->day[row][col];
2477 x_left = left_x_for_column (calendar, col);
2478 y_top = top_y_for_row (calendar, row);
2480 gdk_window_clear_area (private_data->main_win, x_left, y_top,
2481 HILDON_DAY_WIDTH, HILDON_DAY_HEIGHT);
2485 if (calendar->day_month[row][col] == MONTH_PREV)
2487 gdk_gc_set_foreground (gc, PREV_MONTH_COLOR (GTK_WIDGET (calendar)));
2489 else if (calendar->day_month[row][col] == MONTH_NEXT)
2491 gdk_gc_set_foreground (gc, NEXT_MONTH_COLOR (GTK_WIDGET (calendar)));
2495 if (calendar->selected_day == day)
2497 /* Hildon: use custom graphics */
2498 gtk_paint_box(GTK_WIDGET (calendar)->style,
2499 private_data->main_win,
2501 GTK_SHADOW_NONE, NULL,
2502 GTK_WIDGET (calendar), "active-day",
2507 if (calendar->marked_date[day-1])
2508 gdk_gc_set_foreground (gc, MARKED_COLOR (GTK_WIDGET (calendar)));
2510 gdk_gc_set_foreground (gc, NORMAL_DAY_COLOR (GTK_WIDGET (calendar)));
2511 if (calendar->selected_day == day)
2512 gdk_gc_set_foreground (gc, SELECTED_FG_COLOR (GTK_WIDGET (calendar)));
2514 gdk_gc_set_foreground (gc, & (GTK_WIDGET (calendar)->style->fg[GTK_WIDGET_STATE (calendar)]));
2517 if (GTK_WIDGET_HAS_FOCUS (calendar) &&
2518 calendar->focus_row == row &&
2519 calendar->focus_col == col)
2523 if (calendar->selected_day == day)
2524 state = GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE;
2526 state = GTK_STATE_NORMAL;
2528 gtk_paint_focus (widget->style,
2529 private_data->main_win,
2530 (calendar->selected_day == day)
2531 ? GTK_STATE_SELECTED : GTK_STATE_NORMAL,
2532 NULL, widget, "calendar-day",
2538 /* Hildon: paint green indicator for current day */
2539 if ((day == private_data->current_day && calendar->selected_day !=
2540 private_data->current_day) && (calendar->day_month[row][col] == MONTH_CURRENT))
2541 hildon_calendar_check_current_date (calendar, x_left, y_top);
2543 g_snprintf (buffer, sizeof (buffer), "%d", day);
2544 layout = gtk_widget_create_pango_layout (widget, buffer);
2545 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2547 x_loc = x_left + (HILDON_DAY_WIDTH - logical_rect.width) / 2;
2548 y_loc = y_top + (HILDON_DAY_HEIGHT - logical_rect.height) / 2;
2550 gdk_draw_layout (private_data->main_win, gc,
2551 x_loc, y_loc, layout);
2552 if (calendar->marked_date[day-1] &&
2553 calendar->day_month[row][col] == MONTH_CURRENT)
2554 gdk_draw_layout (private_data->main_win, gc,
2555 x_loc-1, y_loc, layout);
2557 g_object_unref (layout);
2561 hildon_calendar_paint_main (GtkWidget *widget)
2563 HildonCalendar *calendar;
2564 HildonCalendarPrivate *private_data;
2567 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2568 g_return_if_fail (widget->window != NULL);
2570 calendar = HILDON_CALENDAR (widget);
2571 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2573 if (private_data->freeze_count)
2575 private_data->dirty_main = 1;
2578 private_data->dirty_main = 0;
2579 gdk_window_clear (private_data->main_win);
2581 for (col = 0; col < 7; col++)
2582 for (row = 0; row < 6; row++)
2583 hildon_calendar_paint_day (widget, row, col);
2587 hildon_calendar_compute_days (HildonCalendar *calendar)
2589 HildonCalendarPrivate *private_data;
2592 gint ndays_in_month;
2593 gint ndays_in_prev_month;
2599 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2601 private_data = HILDON_CALENDAR_GET_PRIVATE (GTK_WIDGET (calendar));
2603 year = calendar->year;
2604 month = calendar->month + 1;
2606 ndays_in_month = month_length[leap (year)][month];
2608 first_day = day_of_week (year, month, 1);
2609 first_day = (first_day + 7 - private_data->week_start) % 7;
2611 /* Compute days of previous month */
2613 ndays_in_prev_month = month_length[leap (year)][month-1];
2615 ndays_in_prev_month = month_length[leap (year)][12];
2616 day = ndays_in_prev_month - first_day + 1;
2621 for (col = 0; col < first_day; col++)
2623 calendar->day[row][col] = day;
2624 calendar->day_month[row][col] = MONTH_PREV;
2629 /* Compute days of current month */
2631 for (day = 1; day <= ndays_in_month; day++)
2633 calendar->day[row][col] = day;
2634 calendar->day_month[row][col] = MONTH_CURRENT;
2644 /* Compute days of next month */
2646 for (; row <= 5; row++)
2648 for (; col <= 6; col++)
2650 calendar->day[row][col] = day;
2651 calendar->day_month[row][col] = MONTH_NEXT;
2659 * hildon_calendar_get_display_options:
2660 * @calendar: a #HildonCalendar
2662 * Returns the current display options of @calendar.
2664 * Return value: the display options.
2666 HildonCalendarDisplayOptions
2667 hildon_calendar_get_display_options (HildonCalendar *calendar)
2669 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), 0);
2671 return calendar->display_flags;
2675 * hildon_calendar_set_display_options:
2676 * @calendar: a #HildonCalendar
2677 * @flags: the display options to set
2679 * Sets display options (whether to display the heading and the month
2684 hildon_calendar_set_display_options (HildonCalendar *calendar,
2685 HildonCalendarDisplayOptions flags)
2687 HildonCalendarPrivate *private_data;
2691 HildonCalendarDisplayOptions old_flags;
2693 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2695 widget = GTK_WIDGET (calendar);
2696 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
2697 old_flags = calendar->display_flags;
2699 if (GTK_WIDGET_REALIZED (widget))
2701 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_NO_MONTH_CHANGE)
2704 if (! (flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
2705 && (private_data->header_win))
2707 calendar->display_flags &= ~HILDON_CALENDAR_NO_MONTH_CHANGE;
2708 hildon_calendar_realize_arrows (widget);
2712 for (i = 0; i < 4; i++)
2714 if (private_data->arrow_win[i])
2716 gdk_window_set_user_data (private_data->arrow_win[i],
2718 gdk_window_destroy (private_data->arrow_win[i]);
2719 private_data->arrow_win[i] = NULL;
2725 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_HEADING)
2729 if (flags & HILDON_CALENDAR_SHOW_HEADING)
2731 calendar->display_flags |= HILDON_CALENDAR_SHOW_HEADING;
2732 hildon_calendar_realize_header (widget);
2736 for (i = 0; i < 4; i++)
2738 if (private_data->arrow_win[i])
2740 gdk_window_set_user_data (private_data->arrow_win[i],
2742 gdk_window_destroy (private_data->arrow_win[i]);
2743 private_data->arrow_win[i] = NULL;
2746 gdk_window_set_user_data (private_data->header_win, NULL);
2747 gdk_window_destroy (private_data->header_win);
2748 private_data->header_win = NULL;
2753 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_DAY_NAMES)
2757 if (flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
2759 calendar->display_flags |= HILDON_CALENDAR_SHOW_DAY_NAMES;
2760 hildon_calendar_realize_day_names (widget);
2764 gdk_window_set_user_data (private_data->day_name_win, NULL);
2765 gdk_window_destroy (private_data->day_name_win);
2766 private_data->day_name_win = NULL;
2770 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
2774 if (flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
2776 calendar->display_flags |= HILDON_CALENDAR_SHOW_WEEK_NUMBERS;
2777 hildon_calendar_realize_week_numbers (widget);
2781 gdk_window_set_user_data (private_data->week_win, NULL);
2782 gdk_window_destroy (private_data->week_win);
2783 private_data->week_win = NULL;
2787 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_WEEK_START_MONDAY)
2788 g_warning ("HILDON_CALENDAR_WEEK_START_MONDAY is ignored; the first day of the week is determined from the locale");
2790 calendar->display_flags = flags;
2792 gtk_widget_queue_resize (GTK_WIDGET (calendar));
2796 calendar->display_flags = flags;
2798 g_object_freeze_notify (G_OBJECT (calendar));
2799 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_HEADING)
2800 g_object_notify (G_OBJECT (calendar), "show-heading");
2801 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_DAY_NAMES)
2802 g_object_notify (G_OBJECT (calendar), "show-day-names");
2803 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_NO_MONTH_CHANGE)
2804 g_object_notify (G_OBJECT (calendar), "no-month-change");
2805 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
2806 g_object_notify (G_OBJECT (calendar), "show-week-numbers");
2807 g_object_thaw_notify (G_OBJECT (calendar));
2811 hildon_calendar_select_month (HildonCalendar *calendar,
2815 HildonCalendarPrivate *priv;
2817 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), FALSE);
2818 g_return_val_if_fail (month <= 11, FALSE);
2820 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
2822 if (priv->max_year && year > priv->max_year)
2823 year = priv->max_year;
2824 if (priv->min_year && year < priv->min_year)
2825 year = priv->min_year;
2827 calendar->month = month;
2828 calendar->year = year;
2830 hildon_calendar_compute_days (calendar);
2832 gtk_widget_queue_draw (GTK_WIDGET (calendar));
2834 g_object_freeze_notify (G_OBJECT (calendar));
2835 g_object_notify (G_OBJECT (calendar), "month");
2836 g_object_notify (G_OBJECT (calendar), "year");
2837 g_object_thaw_notify (G_OBJECT (calendar));
2839 g_signal_emit (calendar,
2840 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
2846 hildon_calendar_select_day (HildonCalendar *calendar,
2850 HildonCalendarPrivate *priv;
2851 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2852 g_return_if_fail (day <= 31);
2853 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
2855 for (row = 0; row < 6; row ++)
2856 for (col = 0; col < 7; col++)
2858 if (calendar->day_month[row][col] == MONTH_CURRENT
2859 && calendar->day[row][col] == day)
2861 calendar->focus_row = row;
2862 calendar->focus_col = col;
2866 if (calendar->month != priv->current_month ||
2867 calendar->year != priv->current_year)
2868 hildon_calendar_unmark_day (calendar, priv->current_day);
2870 /* Deselect the old day */
2871 if (calendar->selected_day > 0)
2875 selected_day = calendar->selected_day;
2876 calendar->selected_day = 0;
2877 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2879 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), selected_day);
2883 calendar->selected_day = day;
2885 /*printf("Selected day = %d\n", day);*/
2887 /* Select the new day */
2890 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2892 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), day);
2896 g_object_notify (G_OBJECT (calendar), "day");
2897 g_signal_emit (calendar,
2898 hildon_calendar_signals[DAY_SELECTED_SIGNAL],
2903 hildon_calendar_select_and_focus_day (HildonCalendar *calendar,
2906 gint old_focus_row = calendar->focus_row;
2907 gint old_focus_col = calendar->focus_col;
2911 for (row = 0; row < 6; row ++)
2912 for (col = 0; col < 7; col++)
2914 if (calendar->day_month[row][col] == MONTH_CURRENT
2915 && calendar->day[row][col] == day)
2917 calendar->focus_row = row;
2918 calendar->focus_col = col;
2922 if (old_focus_row != -1 && old_focus_col != -1)
2923 hildon_calendar_paint_day (GTK_WIDGET (calendar), old_focus_row, old_focus_col);
2925 hildon_calendar_select_day (calendar, day);
2929 hildon_calendar_clear_marks (HildonCalendar *calendar)
2933 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2935 for (day = 0; day < 31; day++)
2937 calendar->marked_date[day] = FALSE;
2940 calendar->num_marked_dates = 0;
2942 if (GTK_WIDGET_DRAWABLE (calendar))
2944 hildon_calendar_paint_main (GTK_WIDGET (calendar));
2949 hildon_calendar_mark_day (HildonCalendar *calendar,
2952 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), FALSE);
2953 if (day >= 1 && day <= 31 && calendar->marked_date[day-1] == FALSE)
2955 calendar->marked_date[day - 1] = TRUE;
2956 calendar->num_marked_dates++;
2958 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2959 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), day-1);
2966 hildon_calendar_unmark_day (HildonCalendar *calendar,
2969 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), FALSE);
2971 if (day >= 1 && day <= 31 && calendar->marked_date[day-1] == TRUE)
2973 calendar->marked_date[day - 1] = FALSE;
2974 calendar->num_marked_dates--;
2976 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2977 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), day-1);
2984 hildon_calendar_get_date (HildonCalendar *calendar,
2989 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2992 *year = calendar->year;
2995 *month = calendar->month;
2998 *day = calendar->selected_day;
3002 arrow_action (HildonCalendar *calendar,
3007 case ARROW_YEAR_LEFT:
3008 hildon_calendar_set_year_prev (calendar);
3010 case ARROW_YEAR_RIGHT:
3011 hildon_calendar_set_year_next (calendar);
3013 case ARROW_MONTH_LEFT:
3014 hildon_calendar_set_month_prev (calendar);
3016 case ARROW_MONTH_RIGHT:
3017 hildon_calendar_set_month_next (calendar);
3023 hildon_calendar_select_and_focus_day(calendar, calendar->selected_day);
3027 calendar_timer (gpointer data)
3029 HildonCalendar *calendar = data;
3030 HildonCalendarPrivate *private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
3031 gboolean retval = FALSE;
3032 GtkSettings *settings;
3035 gdk_window_process_updates (((GtkWidget *) calendar)->window, TRUE);
3037 settings = gtk_settings_get_default ();
3038 g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
3041 GDK_THREADS_ENTER ();
3043 if (private_data->timer)
3045 arrow_action (calendar, private_data->click_child);
3047 if (private_data->need_timer)
3049 private_data->need_timer = FALSE;
3050 private_data->timer = g_timeout_add (/*CALENDAR_TIMER_DELAY*/timeout,
3051 (GSourceFunc) calendar_timer,
3052 (gpointer) calendar);
3058 GDK_THREADS_LEAVE ();
3064 start_spinning (GtkWidget *widget,
3067 HildonCalendarPrivate *private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3068 GtkSettings *settings;
3071 settings = gtk_settings_get_default ();
3072 g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
3075 private_data->click_child = click_child;
3077 if (!private_data->timer)
3079 private_data->need_timer = TRUE;
3080 private_data->timer = g_timeout_add (/*CALENDAR_INITIAL_TIMER_DELAY*/timeout,
3087 stop_spinning (GtkWidget *widget)
3089 HildonCalendarPrivate *private_data;
3091 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3093 if (private_data->timer)
3095 g_source_remove (private_data->timer);
3096 private_data->timer = 0;
3097 private_data->need_timer = FALSE;
3102 hildon_calendar_destroy (GtkObject *object)
3104 stop_spinning (GTK_WIDGET (object));
3106 GTK_OBJECT_CLASS (parent_class)->destroy (object);
3110 hildon_calendar_grab_notify (GtkWidget *widget,
3111 gboolean was_grabbed)
3114 stop_spinning (widget);
3118 hildon_calendar_focus_out (GtkWidget *widget,
3119 GdkEventFocus *event)
3121 HildonCalendarPrivate *private_data;
3123 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3125 stop_spinning (widget);
3127 private_data->in_drag = 0;
3133 hildon_calendar_button_press (GtkWidget *widget,
3134 GdkEventButton *event)
3136 HildonCalendar *calendar;
3137 HildonCalendarPrivate *private_data;
3140 calendar = HILDON_CALENDAR (widget);
3141 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3144 if (event->type == GDK_2BUTTON_PRESS)
3146 if (event->window == private_data->main_win)
3147 hildon_calendar_main_button (widget, event);
3149 else if (event->window == private_data->main_win)
3151 gint x = (gint) (event->x);
3152 gint y = (gint) (event->y);
3153 gint row = row_from_y (calendar, y);
3154 gint col = column_from_x (calendar, x);
3155 private_data->pressed_day = calendar->day[row][col];
3157 if ((calendar->year == private_data->min_year &&
3158 calendar->month == 0
3159 && calendar->day_month[row][col] == MONTH_PREV) ||
3160 (calendar->year == private_data->max_year &&
3161 calendar->month == 11 &&
3162 calendar->day_month[row][col] == MONTH_NEXT))
3164 else if (calendar->day_month[row][col] == MONTH_CURRENT)
3165 hildon_calendar_select_and_focus_day (calendar, private_data->pressed_day);
3167 /* Remember month where button was pressed */
3168 private_data->pressed_month = calendar->month;
3169 private_data->slide_stylus = TRUE;
3172 if (!GTK_WIDGET_HAS_FOCUS (widget))
3173 gtk_widget_grab_focus (widget);
3175 for (arrow = ARROW_YEAR_LEFT; arrow <= ARROW_MONTH_RIGHT; arrow++)
3177 if (event->window == private_data->arrow_win[arrow])
3180 /* only call the action on single click, not double */
3181 if (event->type == GDK_BUTTON_PRESS)
3183 if (event->button == 1)
3184 start_spinning (widget, arrow);
3186 arrow_action (calendar, arrow);
3197 hildon_calendar_button_release (GtkWidget *widget,
3198 GdkEventButton *event)
3200 HildonCalendar *calendar;
3201 HildonCalendarPrivate *private_data;
3203 calendar = HILDON_CALENDAR (widget);
3204 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3206 if (event->window == private_data->main_win)
3208 hildon_calendar_main_button (widget, event);
3209 gint x = (gint) (event->x);
3210 gint y = (gint) (event->y);
3211 gint row = row_from_y (calendar, y);
3212 gint col = column_from_x (calendar, x);
3213 private_data->prev_col = -1;
3214 private_data->prev_row = -1;
3216 if ((private_data->pressed_day == calendar->day[row][col]) &&
3217 (private_data->pressed_month == calendar->month))
3219 if (!private_data->is_bad_day)
3221 g_signal_emit (calendar, hildon_calendar_signals[SELECTED_DATE_SIGNAL], 0);
3225 private_data->is_bad_day = FALSE;
3230 if (event->button == 1)
3232 stop_spinning (widget);
3234 if (private_data->in_drag)
3235 private_data->in_drag = 0;
3238 private_data->slide_stylus = FALSE;
3243 hildon_calendar_motion_notify (GtkWidget *widget,
3244 GdkEventMotion *event)
3246 HildonCalendar *calendar;
3247 HildonCalendarPrivate *private_data;
3248 gint event_x, event_y;
3250 gint old_row, old_col;
3252 calendar = HILDON_CALENDAR (widget);
3253 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3254 event_x = (gint) (event->x);
3255 event_y = (gint) (event->y);
3257 if (event->window == private_data->main_win)
3259 /* Hildon: make active day to move, when stylus is slided */
3260 if (private_data->slide_stylus)
3262 gint c_row = row_from_y (calendar, event_y);
3263 gint c_col = column_from_x (calendar, event_x);
3265 if (calendar->day_month[c_row][c_col] == MONTH_PREV ||
3266 calendar->day_month[c_row][c_col] == MONTH_NEXT)
3268 else if ((private_data->prev_row != c_row || private_data->prev_col != c_col) &&
3269 (calendar->highlight_row != -1 && calendar->highlight_col != -1))
3271 hildon_calendar_select_and_focus_day (calendar,
3272 calendar->day[c_row][c_col]);
3273 /* Update passive focus indicators work weekday number and name */
3274 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3275 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3277 private_data->prev_col = c_col;
3278 private_data->prev_row = c_row;
3280 if (private_data->in_drag)
3282 if (gtk_drag_check_threshold (widget,
3283 private_data->drag_start_x, private_data->drag_start_y,
3284 event->x, event->y))
3286 GdkDragContext *context;
3287 GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
3288 gtk_target_list_add_text_targets (target_list, 0);
3289 context = gtk_drag_begin (widget, target_list, GDK_ACTION_COPY,
3290 1, (GdkEvent *)event);
3293 private_data->in_drag = 0;
3295 gtk_target_list_unref (target_list);
3296 gtk_drag_set_icon_default (context);
3301 row = row_from_y (calendar, event_y);
3302 col = column_from_x (calendar, event_x);
3304 if (row != calendar->highlight_row || calendar->highlight_col != col)
3306 old_row = calendar->highlight_row;
3307 old_col = calendar->highlight_col;
3308 if (old_row > -1 && old_col > -1)
3310 calendar->highlight_row = -1;
3311 calendar->highlight_col = -1;
3312 hildon_calendar_paint_day (widget, old_row, old_col);
3315 calendar->highlight_row = row;
3316 calendar->highlight_col = col;
3318 if (row > -1 && col > -1)
3319 hildon_calendar_paint_day (widget, row, col);
3328 hildon_calendar_enter_notify (GtkWidget *widget,
3329 GdkEventCrossing *event)
3331 HildonCalendar *calendar;
3332 HildonCalendarPrivate *private_data;
3334 calendar = HILDON_CALENDAR (widget);
3335 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3337 if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
3339 private_data->arrow_state[ARROW_MONTH_LEFT] = GTK_STATE_PRELIGHT;
3340 hildon_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
3343 if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
3345 private_data->arrow_state[ARROW_MONTH_RIGHT] = GTK_STATE_PRELIGHT;
3346 hildon_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
3349 if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
3351 private_data->arrow_state[ARROW_YEAR_LEFT] = GTK_STATE_PRELIGHT;
3352 hildon_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
3355 if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
3357 private_data->arrow_state[ARROW_YEAR_RIGHT] = GTK_STATE_PRELIGHT;
3358 hildon_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
3365 hildon_calendar_leave_notify (GtkWidget *widget,
3366 GdkEventCrossing *event)
3368 HildonCalendar *calendar;
3369 HildonCalendarPrivate *private_data;
3373 calendar = HILDON_CALENDAR (widget);
3374 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3376 if (event->window == private_data->main_win)
3378 row = calendar->highlight_row;
3379 col = calendar->highlight_col;
3380 calendar->highlight_row = -1;
3381 calendar->highlight_col = -1;
3382 if (row > -1 && col > -1)
3383 hildon_calendar_paint_day (widget, row, col);
3386 if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
3388 private_data->arrow_state[ARROW_MONTH_LEFT] = GTK_STATE_NORMAL;
3389 hildon_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
3392 if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
3394 private_data->arrow_state[ARROW_MONTH_RIGHT] = GTK_STATE_NORMAL;
3395 hildon_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
3398 if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
3400 private_data->arrow_state[ARROW_YEAR_LEFT] = GTK_STATE_NORMAL;
3401 hildon_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
3404 if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
3406 private_data->arrow_state[ARROW_YEAR_RIGHT] = GTK_STATE_NORMAL;
3407 hildon_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
3414 hildon_calendar_paint_arrow (GtkWidget *widget,
3417 HildonCalendarPrivate *private_data;
3420 HildonCalendar *calendar;
3422 guint arrow_hlength, arrow_vlength;
3423 /* gint width, height;*/
3425 calendar = HILDON_CALENDAR (widget);
3426 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3427 gtk_widget_style_get (widget,
3428 "scroll-arrow-hlength", &arrow_hlength,
3429 "scroll-arrow-vlength", &arrow_vlength,
3432 if (private_data->freeze_count)
3434 private_data->dirty_header = 1;
3437 window = private_data->arrow_win[arrow];
3440 state = private_data->arrow_state[arrow];
3443 /* gdk_window_clear (window);*/
3444 gdk_window_set_background (window, &(widget)->style->bg[state]);
3445 /* gdk_drawable_get_size (window, &width, &height);*/
3446 /* gdk_window_clear_area (window,
3450 gdk_window_clear(window);
3452 /* Hildon: added support for dimmed arrows */
3453 if (((private_data->min_year && calendar->year <= private_data->min_year) ||
3454 (private_data->max_year && calendar->year >= private_data->max_year)))
3456 if (private_data->min_year &&
3457 calendar->year <= private_data->min_year)
3459 if (arrow == ARROW_YEAR_LEFT)
3460 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3461 GTK_SHADOW_OUT, NULL, widget, "calendar",
3462 GTK_ARROW_LEFT, TRUE,
3463 0, 0, arrow_vlength, arrow_hlength);
3464 else if (arrow == ARROW_YEAR_RIGHT || arrow == ARROW_MONTH_RIGHT)
3465 gtk_paint_arrow (widget->style, window, state,
3466 GTK_SHADOW_OUT, NULL, widget, "calendar",
3467 GTK_ARROW_RIGHT, TRUE,
3468 0, 0, arrow_vlength, arrow_hlength);
3469 else if (arrow == ARROW_MONTH_LEFT && calendar->month != 0)
3470 gtk_paint_arrow (widget->style, window, state,
3471 GTK_SHADOW_OUT, NULL, widget, "calendar",
3472 GTK_ARROW_LEFT, TRUE,
3473 0, 0, arrow_vlength, arrow_hlength);
3474 else if (arrow == ARROW_MONTH_LEFT && !calendar->month)
3475 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3476 GTK_SHADOW_OUT, NULL, widget, "calendar",
3477 GTK_ARROW_LEFT, TRUE,
3478 0, 0, arrow_vlength, arrow_hlength);
3480 else if (private_data->max_year &&
3481 calendar->year >= private_data->max_year)
3483 if (arrow == ARROW_YEAR_RIGHT)
3484 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3485 GTK_SHADOW_OUT, NULL, widget, "calendar",
3486 GTK_ARROW_RIGHT, TRUE,
3487 0, 0, arrow_vlength, arrow_hlength);
3488 else if (arrow == ARROW_YEAR_LEFT || arrow == ARROW_MONTH_LEFT)
3489 gtk_paint_arrow (widget->style, window, state,
3490 GTK_SHADOW_OUT, NULL, widget, "calendar",
3491 GTK_ARROW_LEFT, TRUE,
3492 0, 0, arrow_vlength, arrow_hlength);
3493 else if (arrow == ARROW_MONTH_RIGHT && calendar->month != 11)
3494 gtk_paint_arrow (widget->style, window, state,
3495 GTK_SHADOW_OUT, NULL, widget, "calendar",
3496 GTK_ARROW_RIGHT, TRUE,
3497 0, 0, arrow_vlength, arrow_hlength);
3498 else if (arrow == ARROW_MONTH_RIGHT && calendar->month == 11)
3499 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3500 GTK_SHADOW_OUT, NULL, widget, "calendar",
3501 GTK_ARROW_RIGHT, TRUE,
3502 0, 0, arrow_vlength, arrow_hlength);
3507 if (arrow == ARROW_MONTH_LEFT || arrow == ARROW_YEAR_LEFT)
3508 gtk_paint_arrow (widget->style, window, state,
3509 GTK_SHADOW_OUT, NULL, widget, "calendar",
3510 GTK_ARROW_LEFT, TRUE,
3511 /* width/2 - 3, height/2 - 4, 8, 8);*/
3512 0, 0, arrow_vlength, arrow_hlength);
3514 gtk_paint_arrow (widget->style, window, state,
3515 GTK_SHADOW_OUT, NULL, widget, "calendar",
3516 GTK_ARROW_RIGHT, TRUE,
3517 /* width/2 - 2, height/2 - 4, 8, 8);*/
3518 0, 0, arrow_vlength, arrow_hlength);
3524 hildon_calendar_freeze (HildonCalendar *calendar)
3526 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
3528 HILDON_CALENDAR_GET_PRIVATE (calendar)->freeze_count++;
3532 hildon_calendar_thaw (HildonCalendar *calendar)
3534 HildonCalendarPrivate *private_data;
3536 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
3538 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
3540 if (private_data->freeze_count)
3541 if (!(--private_data->freeze_count))
3543 if (private_data->dirty_header)
3544 if (GTK_WIDGET_DRAWABLE (calendar))
3545 hildon_calendar_paint_header (GTK_WIDGET (calendar));
3547 if (private_data->dirty_day_names)
3548 if (GTK_WIDGET_DRAWABLE (calendar))
3549 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3551 if (private_data->dirty_week)
3552 if (GTK_WIDGET_DRAWABLE (calendar))
3553 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3555 if (private_data->dirty_main)
3556 if (GTK_WIDGET_DRAWABLE (calendar))
3557 hildon_calendar_paint_main (GTK_WIDGET (calendar));
3562 hildon_calendar_set_background (GtkWidget *widget)
3564 HildonCalendar *calendar;
3565 HildonCalendarPrivate *private_data;
3568 calendar = HILDON_CALENDAR (widget);
3569 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3571 if (GTK_WIDGET_REALIZED (widget))
3573 for (i = 0; i < 4; i++)
3575 if (private_data->arrow_win[i])
3576 gdk_window_set_background (private_data->arrow_win[i],
3577 HEADER_BG_COLOR (widget));
3579 if (private_data->header_win)
3580 gdk_window_set_background (private_data->header_win,
3581 HEADER_BG_COLOR (widget));
3582 if (private_data->day_name_win)
3583 gdk_window_set_background (private_data->day_name_win,
3584 BACKGROUND_COLOR (widget));
3585 if (private_data->week_win)
3586 gdk_window_set_background (private_data->week_win,
3587 BACKGROUND_COLOR (widget));
3588 if (private_data->main_win)
3589 gdk_window_set_background (private_data->main_win,
3590 BACKGROUND_COLOR (widget));
3592 gdk_window_set_background (widget->window,
3593 BACKGROUND_COLOR (widget));
3598 hildon_calendar_style_set (GtkWidget *widget,
3599 GtkStyle *previous_style)
3601 if (previous_style && GTK_WIDGET_REALIZED (widget))
3602 hildon_calendar_set_background(widget);
3606 hildon_calendar_state_changed (GtkWidget *widget,
3607 GtkStateType previous_state)
3609 HildonCalendarPrivate *private_data;
3612 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3614 if (!GTK_WIDGET_IS_SENSITIVE (widget))
3616 private_data->in_drag = 0;
3617 stop_spinning (widget);
3620 for (i = 0; i < 4; i++)
3621 if (GTK_WIDGET_IS_SENSITIVE (widget))
3622 private_data->arrow_state[i] = GTK_STATE_NORMAL;
3624 private_data->arrow_state[i] = GTK_STATE_INSENSITIVE;
3626 hildon_calendar_set_background (widget);
3630 hildon_calendar_finalize (GObject *object)
3632 HildonCalendarPrivate *private_data;
3635 private_data = HILDON_CALENDAR_GET_PRIVATE (object);
3637 for (i = 0; i < 7; i++)
3638 g_free (private_data->abbreviated_dayname[i]);
3639 for (i = 0; i < 12; i++)
3640 g_free (private_data->monthname[i]);
3641 g_free (private_data);
3643 (* G_OBJECT_CLASS (parent_class)->finalize) (object);
3647 hildon_calendar_scroll (GtkWidget *widget,
3648 GdkEventScroll *event)
3650 HildonCalendar *calendar = HILDON_CALENDAR (widget);
3652 if (event->direction == GDK_SCROLL_UP)
3654 if (!GTK_WIDGET_HAS_FOCUS (widget))
3655 gtk_widget_grab_focus (widget);
3656 hildon_calendar_set_month_prev (calendar);
3658 else if (event->direction == GDK_SCROLL_DOWN)
3660 if (!GTK_WIDGET_HAS_FOCUS (widget))
3661 gtk_widget_grab_focus (widget);
3662 hildon_calendar_set_month_next (calendar);
3671 move_focus (HildonCalendar *calendar,
3674 GtkTextDirection text_dir = gtk_widget_get_direction (GTK_WIDGET (calendar));
3676 if ((text_dir == GTK_TEXT_DIR_LTR && direction == -1) ||
3677 (text_dir == GTK_TEXT_DIR_RTL && direction == 1))
3679 if (calendar->focus_col > 0)
3680 calendar->focus_col--;
3681 else if (calendar->focus_row > 0)
3683 calendar->focus_col = 6;
3684 calendar->focus_row--;
3689 if (calendar->focus_col < 6)
3690 calendar->focus_col++;
3691 else if (calendar->focus_row < 5)
3693 calendar->focus_col = 0;
3694 calendar->focus_row++;
3700 hildon_calendar_key_press (GtkWidget *widget,
3703 HildonCalendar *calendar;
3704 HildonCalendarPrivate *priv;
3705 GtkSettings *settings;
3712 calendar = HILDON_CALENDAR (widget);
3713 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
3716 old_focus_row = calendar->focus_row;
3717 old_focus_col = calendar->focus_col;
3719 settings = gtk_settings_get_default ();
3720 g_object_get (settings, "hildon-keyboard-navigation", &knav, NULL);
3722 switch (event->keyval)
3727 if (event->state & GDK_CONTROL_MASK)
3728 hildon_calendar_set_month_prev (calendar);
3731 /* if we are at the first allowed day of the minimum year/month then do nothing */
3732 if (calendar->year == priv->min_year && calendar->month == 0 &&
3733 calendar->day_month[old_focus_row][old_focus_col-1] == MONTH_PREV)
3735 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3738 else /* else normal */
3740 move_focus (calendar, -1);
3743 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3744 hildon_calendar_paint_day (widget, calendar->focus_row,
3745 calendar->focus_col);
3749 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3750 if (day_month == MONTH_CURRENT && calendar->selected_day != 1)
3752 hildon_calendar_select_day(calendar, calendar->selected_day - 1);
3756 if (calendar->month != 0) {
3757 calendar->selected_day = month_length[leap (calendar->year)][calendar->month];
3759 calendar->selected_day = month_length[leap (calendar->year -1)][12];
3761 hildon_calendar_set_month_prev (calendar);
3763 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3764 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3772 if (event->state & GDK_CONTROL_MASK)
3773 hildon_calendar_set_month_next (calendar);
3776 if (calendar->year == priv->max_year && calendar->month == 11 &&
3777 calendar->day_month[old_focus_row][old_focus_col+1] == MONTH_NEXT)
3779 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3784 move_focus (calendar, 1);
3787 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3788 hildon_calendar_paint_day (widget, calendar->focus_row,
3789 calendar->focus_col);
3793 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3794 if (day_month == MONTH_CURRENT)
3796 hildon_calendar_select_day (calendar, calendar->selected_day + 1);
3800 calendar->selected_day = 1;
3801 hildon_calendar_set_month_next (calendar);
3803 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3804 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3812 if (event->state & GDK_CONTROL_MASK)
3813 hildon_calendar_set_year_prev (calendar);
3816 if (calendar->year == priv->min_year && calendar->month == 0 &&
3817 calendar->day_month[old_focus_row-1][old_focus_col] == MONTH_PREV)
3819 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3824 if (calendar->focus_row > 0)
3825 calendar->focus_row--;
3828 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3829 hildon_calendar_paint_day (widget, calendar->focus_row,
3830 calendar->focus_col);
3834 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3835 if (day_month == MONTH_CURRENT)
3837 if ((calendar->selected_day - 7) <= 0)
3839 if (calendar->month != 0)
3840 calendar->selected_day = month_length[leap (calendar->year)][calendar->month];
3842 calendar->selected_day = month_length[leap (calendar->year - 1)][12];
3843 hildon_calendar_set_month_prev (calendar);
3847 hildon_calendar_select_day (calendar, calendar->selected_day - 7);
3852 calendar->selected_day = calendar->day[calendar->focus_row][calendar->focus_col];
3853 hildon_calendar_set_month_prev (calendar);
3855 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3856 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3864 if (event->state & GDK_CONTROL_MASK)
3865 hildon_calendar_set_year_next (calendar);
3868 if (calendar->year == priv->max_year && calendar->month == 11 &&
3869 calendar->day_month[old_focus_row+1][old_focus_col] == MONTH_NEXT)
3871 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3877 if (calendar->focus_row < 5)
3878 calendar->focus_row++;
3881 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3882 hildon_calendar_paint_day (widget, calendar->focus_row,
3883 calendar->focus_col);
3887 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3888 if (day_month == MONTH_CURRENT)
3890 if ((calendar->selected_day + 7) >
3891 month_length[leap (calendar->year)][calendar->month + 1])
3893 calendar->selected_day = 1;
3894 hildon_calendar_set_month_next (calendar);
3898 hildon_calendar_select_day (calendar, calendar->selected_day + 7);
3903 calendar->selected_day = calendar->day[calendar->focus_row][calendar->focus_col];
3904 hildon_calendar_set_month_next (calendar);
3906 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3907 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3915 row = calendar->focus_row;
3916 col = calendar->focus_col;
3917 day = calendar->day[row][col];
3919 if (row > -1 && col > -1)
3922 hildon_calendar_freeze (calendar);
3924 if (calendar->day_month[row][col] == MONTH_PREV)
3925 hildon_calendar_set_month_prev (calendar);
3926 else if (calendar->day_month[row][col] == MONTH_NEXT)
3927 hildon_calendar_set_month_next (calendar);
3929 hildon_calendar_select_and_focus_day (calendar, day);
3931 hildon_calendar_thaw (calendar);
3939 hildon_calendar_set_display_option (HildonCalendar *calendar,
3940 HildonCalendarDisplayOptions flag,
3943 HildonCalendarDisplayOptions flags;
3946 flags = calendar->display_flags | flag;
3948 flags = calendar->display_flags & ~flag;
3950 hildon_calendar_set_display_options (calendar, flags);
3954 hildon_calendar_get_display_option (HildonCalendar *calendar,
3955 HildonCalendarDisplayOptions flag)
3957 return (calendar->display_flags & flag) != 0;
3962 hildon_calendar_set_property (GObject *object,
3964 const GValue *value,
3967 HildonCalendar *calendar;
3968 HildonCalendarPrivate *private_data;
3971 calendar = HILDON_CALENDAR (object);
3972 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
3977 hildon_calendar_select_month (calendar,
3979 g_value_get_int (value));
3982 hildon_calendar_select_month (calendar,
3983 g_value_get_int (value),
3987 hildon_calendar_select_day (calendar,
3988 g_value_get_int (value));
3990 case PROP_SHOW_HEADING:
3991 hildon_calendar_set_display_option (calendar,
3992 HILDON_CALENDAR_SHOW_HEADING,
3993 g_value_get_boolean (value));
3995 case PROP_SHOW_DAY_NAMES:
3996 hildon_calendar_set_display_option (calendar,
3997 HILDON_CALENDAR_SHOW_DAY_NAMES,
3998 g_value_get_boolean (value));
4000 case PROP_NO_MONTH_CHANGE:
4001 hildon_calendar_set_display_option (calendar,
4002 HILDON_CALENDAR_NO_MONTH_CHANGE,
4003 g_value_get_boolean (value));
4005 case PROP_SHOW_WEEK_NUMBERS:
4006 hildon_calendar_set_display_option (calendar,
4007 HILDON_CALENDAR_SHOW_WEEK_NUMBERS,
4008 g_value_get_boolean (value));
4010 case PROP_WEEK_START:
4011 private_data->week_start = g_value_get_int (value);
4014 val = g_value_get_int (value);
4015 if (val <= private_data->max_year ||
4016 val == 0 || private_data->max_year == 0)
4018 private_data->min_year = val;
4019 if (val && (calendar->year < val))
4020 hildon_calendar_select_month (calendar,
4022 private_data->min_year);
4025 g_warning("min-year cannot be greater than max-year");
4028 val = g_value_get_int (value);
4029 if (val >= private_data->min_year ||
4030 val == 0 || private_data->min_year == 0)
4032 private_data->max_year = val;
4033 if (val && (calendar->year > val))
4034 hildon_calendar_select_month (calendar,
4036 private_data->max_year);
4039 g_warning("max-year cannot be less than min-year");
4042 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
4048 hildon_calendar_get_property (GObject *object,
4053 HildonCalendar *calendar;
4054 HildonCalendarPrivate *private_data;
4056 calendar = HILDON_CALENDAR (object);
4057 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
4062 g_value_set_int (value, calendar->year);
4065 g_value_set_int (value, calendar->month);
4068 g_value_set_int (value, calendar->selected_day);
4070 case PROP_SHOW_HEADING:
4071 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4072 HILDON_CALENDAR_SHOW_HEADING));
4074 case PROP_SHOW_DAY_NAMES:
4075 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4076 HILDON_CALENDAR_SHOW_DAY_NAMES));
4078 case PROP_NO_MONTH_CHANGE:
4079 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4080 HILDON_CALENDAR_NO_MONTH_CHANGE));
4082 case PROP_SHOW_WEEK_NUMBERS:
4083 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4084 HILDON_CALENDAR_SHOW_WEEK_NUMBERS));
4086 case PROP_WEEK_START:
4087 g_value_set_int (value, private_data->week_start);
4090 g_value_set_int (value, private_data->min_year);
4093 g_value_set_int (value, private_data->max_year);
4096 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
4103 hildon_calendar_drag_data_get (GtkWidget *widget,
4104 GdkDragContext *context,
4105 GtkSelectionData *selection_data,
4109 HildonCalendar *calendar = HILDON_CALENDAR (widget);
4114 date = g_date_new_dmy (calendar->selected_day, calendar->month + 1, calendar->year);
4115 len = g_date_strftime (str, 127, "%x", date);
4116 gtk_selection_data_set_text (selection_data, str, len);
4121 /* Get/set whether drag_motion requested the drag data and
4122 * drag_data_received should thus not actually insert the data,
4123 * since the data doesn't result from a drop.
4126 set_status_pending (GdkDragContext *context,
4127 GdkDragAction suggested_action)
4129 g_object_set_data (G_OBJECT (context),
4130 "gtk-calendar-status-pending",
4131 GINT_TO_POINTER (suggested_action));
4134 static GdkDragAction
4135 get_status_pending (GdkDragContext *context)
4137 return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
4138 "gtk-calendar-status-pending"));
4142 hildon_calendar_drag_leave (GtkWidget *widget,
4143 GdkDragContext *context,
4146 HildonCalendarPrivate *private_data;
4148 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
4149 private_data->drag_highlight = 0;
4150 gtk_drag_unhighlight (widget);
4155 hildon_calendar_drag_motion (GtkWidget *widget,
4156 GdkDragContext *context,
4161 HildonCalendarPrivate *private_data;
4164 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
4166 if (!private_data->drag_highlight)
4168 private_data->drag_highlight = 1;
4169 gtk_drag_highlight (widget);
4172 target = gtk_drag_dest_find_target (widget, context, NULL);
4173 if (target == GDK_NONE)
4174 gdk_drag_status (context, 0, time);
4176 set_status_pending (context, context->suggested_action);
4177 gtk_drag_get_data (widget, context, target, time);
4184 hildon_calendar_drag_drop (GtkWidget *widget,
4185 GdkDragContext *context,
4192 target = gtk_drag_dest_find_target (widget, context, NULL);
4193 if (target != GDK_NONE)
4195 gtk_drag_get_data (widget, context,
4205 hildon_calendar_drag_data_received (GtkWidget *widget,
4206 GdkDragContext *context,
4209 GtkSelectionData *selection_data,
4213 HildonCalendar *calendar = HILDON_CALENDAR (widget);
4214 guint day, month, year;
4217 GdkDragAction suggested_action;
4219 suggested_action = get_status_pending (context);
4221 if (suggested_action)
4223 set_status_pending (context, 0);
4225 /* We are getting this data due to a request in drag_motion,
4226 * rather than due to a request in drag_drop, so we are just
4227 * supposed to call drag_status, not actually paste in the
4230 str = (gchar *) gtk_selection_data_get_text (selection_data);
4233 date = g_date_new ();
4234 g_date_set_parse (date, str);
4235 if (!g_date_valid (date))
4236 suggested_action = 0;
4241 suggested_action = 0;
4243 gdk_drag_status (context, suggested_action, time);
4248 date = g_date_new ();
4249 str = (gchar *) gtk_selection_data_get_text (selection_data);
4252 g_date_set_parse (date, str);
4256 if (!g_date_valid (date))
4258 g_warning ("Received invalid date data\n");
4260 gtk_drag_finish (context, FALSE, FALSE, time);
4264 day = g_date_get_day (date);
4265 month = g_date_get_month (date);
4266 year = g_date_get_year (date);
4269 gtk_drag_finish (context, TRUE, FALSE, time);
4272 g_object_freeze_notify (G_OBJECT (calendar));
4273 if (!(calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
4274 && (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING))
4275 hildon_calendar_select_month (calendar, month - 1, year);
4276 hildon_calendar_select_day (calendar, day);
4277 g_object_thaw_notify (G_OBJECT (calendar));
4280 /* This function return TRUE if we should mark date and FALSE
4284 hildon_calendar_check_current_date (HildonCalendar *calendar,
4288 HildonCalendarPrivate *private_data;
4290 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
4292 if (calendar->month == private_data->current_month &&
4293 calendar->year == private_data->current_year)
4295 gtk_paint_box( GTK_WIDGET (calendar)->style,
4296 private_data->main_win,
4298 GTK_SHADOW_NONE, NULL,
4299 GTK_WIDGET (calendar), "current-day",
4306 #define __HILDON_CALENDAR_C__