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: Rodrigo Novo <rodrigo.novo@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
50 * #HildonCalendar has been deprecated since Hildon 2.2 and should not
51 * be used in newly written code. Use #HildonDateSelector instead.
56 #undef HILDON_DISABLE_DEPRECATED
62 #define _GNU_SOURCE /* needed for GNU nl_langinfo_l */
66 #ifdef HAVE_SYS_TIME_H
75 #include <glib/gprintf.h>
76 #include <gdk/gdkkeysyms.h>
77 #include <gtk/gtkprivate.h>
79 #include "hildon-calendar.h"
80 #include "hildon-marshalers.h"
81 #include "hildon-calendar-private.h"
83 /***************************************************************************/
84 /* The following date routines are taken from the lib_date package. Keep
85 * them separate in case we want to update them if a newer lib_date comes
88 typedef unsigned int N_int;
90 typedef unsigned long N_long;
92 typedef signed long Z_long;
94 typedef enum { false = FALSE , true = TRUE } boolean;
96 #define and && /* logical (boolean) operators: lower case */
100 static const N_int month_length [2][13] =
102 { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
103 { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
106 static const N_int days_in_months[2][14] =
108 { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
109 { 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
112 static Z_long calc_days (N_int year, N_int mm, N_int dd);
114 static N_int day_of_week (N_int year, N_int mm, N_int dd);
116 static Z_long dates_difference (N_int year1, N_int mm1, N_int dd1,
117 N_int year2, N_int mm2, N_int dd2);
119 static N_int weeks_in_year (N_int year);
124 return ((((year % 4) == 0) and ((year % 100) != 0)) or ((year % 400) == 0));
128 day_of_week (N_int year,
134 days = calc_days (year, mm, dd);
141 return( (N_int) days );
145 weeks_in_year (N_int year)
147 return (52 + ((day_of_week(year,1,1)==4) or (day_of_week(year,12,31)==4)));
151 check_date (N_int year,
155 if (year < 1) return(false);
156 if ((mm < 1) or (mm > 12)) return(false);
157 if ((dd < 1) or (dd > month_length[leap(year)][mm])) return(false);
162 week_number (N_int year,
168 first = day_of_week (year,1,1) - 1;
169 return( (N_int) ( (dates_difference(year,1,1, year,mm,dd) + first) / 7L ) +
174 year_to_days (N_int year)
176 return ( year * 365L + (year / 4) - (year / 100) + (year / 400) );
180 calc_days (N_int year,
186 if (year < 1) return(0L);
187 if ((mm < 1) or (mm > 12)) return(0L);
188 if ((dd < 1) or (dd > month_length[(lp = leap(year))][mm])) return(0L);
189 return( year_to_days(--year) + days_in_months[lp][mm] + dd );
193 week_of_year (N_int *week,
198 if (check_date(*year,mm,dd))
200 *week = week_number(*year,mm,dd);
202 *week = weeks_in_year(--(*year));
203 else if (*week > weeks_in_year(*year))
214 dates_difference (N_int year1,
221 return (calc_days (year2, mm2, dd2) - calc_days (year1, mm1, dd1));
224 /*** END OF lib_date routines ********************************************/
226 /* HILDON: Spacings modified */
227 #define HILDON_ARROW_SEP 5 /* Space between arrows and data */
229 #define HILDON_DAY_WIDTH 26
231 #define HILDON_DAY_HEIGHT 25
233 /* additional widths given to week number and day windows */
235 #define HILDON_WEEKS_EXTRA_WIDTH 8
237 #define HILDON_DAYS_EXTRA_WIDTH 8
239 /* Spacing around day/week headers and main area, inside those windows */
241 #define CALENDAR_MARGIN 0
243 /* Spacing around day/week headers and main area, outside those windows */
245 #define INNER_BORDER 0 /* 4 */
247 /* Separation between day headers and main area */
249 #define CALENDAR_YSEP 3 /* 4 */
251 /* Separation between week headers and main area */
253 #define CALENDAR_XSEP 6 /* 4 */
255 #define DAY_XSEP 0 /* not really good for small calendar */
257 #define DAY_YSEP 0 /* not really good for small calendar */
260 #define HEADER_FG_COLOR(widget) \
261 (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
263 #define HEADER_BG_COLOR(widget) \
264 (& (widget)->style->bg[GTK_WIDGET_STATE (widget)])
266 #define SELECTED_BG_COLOR(widget) \
267 (& (widget)->style->base[GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE])
269 #define SELECTED_FG_COLOR(widget) \
270 (& (widget)->style->text[GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE])
272 #define NORMAL_DAY_COLOR(widget) \
273 (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
275 #define PREV_MONTH_COLOR(widget) \
276 (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
278 #define NEXT_MONTH_COLOR(widget) \
279 (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
281 #define MARKED_COLOR(widget) \
282 (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
284 #define BACKGROUND_COLOR(widget) \
285 (& (widget)->style->base[GTK_WIDGET_STATE (widget)])
287 #define HIGHLIGHT_BACK_COLOR(widget) \
288 (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
290 #define CALENDAR_INITIAL_TIMER_DELAY 200
292 #define CALENDAR_TIMER_DELAY 20
308 MONTH_CHANGED_SIGNAL,
310 DAY_SELECTED_DOUBLE_CLICK_SIGNAL,
315 ERRONEOUS_DATE_SIGNAL,
316 SELECTED_DATE_SIGNAL,
328 PROP_NO_MONTH_CHANGE,
329 PROP_SHOW_WEEK_NUMBERS,
336 static gint hildon_calendar_signals [LAST_SIGNAL] = { 0 };
338 static GtkWidgetClass* parent_class = NULL;
340 typedef void (*HildonCalendarSignalDate) (GtkObject *object, guint arg1, guint arg2, guint arg3, gpointer data);
343 hildon_calendar_class_init (HildonCalendarClass *class);
346 hildon_calendar_init (HildonCalendar *calendar);
349 hildon_calendar_finalize (GObject *calendar);
352 hildon_calendar_destroy (GtkObject *calendar);
355 hildon_calendar_set_property (GObject *object,
361 hildon_calendar_get_property (GObject *object,
367 hildon_calendar_realize (GtkWidget *widget);
370 hildon_calendar_unrealize (GtkWidget *widget);
373 hildon_calendar_size_request (GtkWidget *widget,
374 GtkRequisition *requisition);
377 hildon_calendar_size_allocate (GtkWidget *widget,
378 GtkAllocation *allocation);
381 hildon_calendar_expose (GtkWidget *widget,
382 GdkEventExpose *event);
385 hildon_calendar_button_press (GtkWidget *widget,
386 GdkEventButton *event);
389 hildon_calendar_button_release (GtkWidget *widget,
390 GdkEventButton *event);
393 hildon_calendar_main_button (GtkWidget *widget,
394 GdkEventButton *event);
397 hildon_calendar_motion_notify (GtkWidget *widget,
398 GdkEventMotion *event);
401 hildon_calendar_enter_notify (GtkWidget *widget,
402 GdkEventCrossing *event);
405 hildon_calendar_leave_notify (GtkWidget *widget,
406 GdkEventCrossing *event);
409 hildon_calendar_key_press (GtkWidget *widget,
413 hildon_calendar_scroll (GtkWidget *widget,
414 GdkEventScroll *event);
417 hildon_calendar_grab_notify (GtkWidget *widget,
418 gboolean was_grabbed);
421 hildon_calendar_focus_out (GtkWidget *widget,
422 GdkEventFocus *event);
425 hildon_calendar_state_changed (GtkWidget *widget,
426 GtkStateType previous_state);
429 hildon_calendar_style_set (GtkWidget *widget,
430 GtkStyle *previous_style);
433 hildon_calendar_paint_header (GtkWidget *widget);
436 hildon_calendar_paint_footer (GtkWidget *widget);
439 hildon_calendar_paint_day_names (GtkWidget *widget);
442 hildon_calendar_paint_week_numbers (GtkWidget *widget);
445 hildon_calendar_paint_main (GtkWidget *widget);
448 hildon_calendar_select_and_focus_day (HildonCalendar *calendar,
452 hildon_calendar_paint_arrow (GtkWidget *widget,
456 hildon_calendar_paint_day_num (GtkWidget *widget,
460 hildon_calendar_paint_day (GtkWidget *widget,
465 hildon_calendar_compute_days (HildonCalendar *calendar);
468 left_x_for_column (HildonCalendar *calendar,
472 top_y_for_row (HildonCalendar *calendar,
476 hildon_calendar_drag_data_get (GtkWidget *widget,
477 GdkDragContext *context,
478 GtkSelectionData *selection_data,
483 hildon_calendar_drag_data_received (GtkWidget *widget,
484 GdkDragContext *context,
487 GtkSelectionData *selection_data,
492 hildon_calendar_drag_motion (GtkWidget *widget,
493 GdkDragContext *context,
499 hildon_calendar_drag_leave (GtkWidget *widget,
500 GdkDragContext *context,
504 hildon_calendar_drag_drop (GtkWidget *widget,
505 GdkDragContext *context,
510 /* This function was added because we need to mark current day according to
515 hildon_calendar_check_current_date (HildonCalendar *calendar,
520 hildon_calendar_get_type (void)
522 static GType calendar_type = 0;
526 static const GTypeInfo calendar_info =
528 sizeof (HildonCalendarClass),
529 NULL, /* base_init */
530 NULL, /* base_finalize */
531 (GClassInitFunc) hildon_calendar_class_init,
532 NULL, /* class_finalize */
533 NULL, /* class_data */
534 sizeof (HildonCalendar),
536 (GInstanceInitFunc) hildon_calendar_init,
539 calendar_type = g_type_register_static (GTK_TYPE_WIDGET, "HildonCalendar",
543 return calendar_type;
547 locales_init (HildonCalendarPrivate *priv)
549 /* Hildon: This is not exactly portable, see
550 * http://bugzilla.gnome.org/show_bug.cgi?id=343415
551 * The labels need to be instance variables as the startup wizard changes
556 l = newlocale (LC_TIME_MASK, setlocale (LC_MESSAGES, NULL), NULL);
558 priv->abbreviated_dayname[0] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_1, l),
559 -1, NULL, NULL, NULL);
560 priv->abbreviated_dayname[1] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_2, l),
561 -1, NULL, NULL, NULL);
562 priv->abbreviated_dayname[2] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_3, l),
563 -1, NULL, NULL, NULL) ;
564 priv->abbreviated_dayname[3] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_4, l),
565 -1, NULL, NULL, NULL);
566 priv->abbreviated_dayname[4] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_5, l),
567 -1, NULL, NULL, NULL);
568 priv->abbreviated_dayname[5] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_6, l),
569 -1, NULL, NULL, NULL);
570 priv->abbreviated_dayname[6] = g_locale_to_utf8 (nl_langinfo_l(ABDAY_7, l),
571 -1, NULL, NULL, NULL);
572 priv->monthname[0] = g_locale_to_utf8 (nl_langinfo_l(MON_1, l),
573 -1, NULL, NULL, NULL);
574 priv->monthname[1] = g_locale_to_utf8 (nl_langinfo_l(MON_2, l),
575 -1, NULL, NULL, NULL);
576 priv->monthname[2] = g_locale_to_utf8 (nl_langinfo_l(MON_3, l),
577 -1, NULL, NULL, NULL);
578 priv->monthname[3] = g_locale_to_utf8 (nl_langinfo_l(MON_4, l),
579 -1, NULL, NULL, NULL);
580 priv->monthname[4] = g_locale_to_utf8 (nl_langinfo_l(MON_5, l),
581 -1, NULL, NULL, NULL);
582 priv->monthname[5] = g_locale_to_utf8 (nl_langinfo_l(MON_6, l),
583 -1, NULL, NULL, NULL);
584 priv->monthname[6] = g_locale_to_utf8 (nl_langinfo_l(MON_7, l),
585 -1, NULL, NULL, NULL);
586 priv->monthname[7] = g_locale_to_utf8 (nl_langinfo_l(MON_8, l),
587 -1, NULL, NULL, NULL);
588 priv->monthname[8] = g_locale_to_utf8 (nl_langinfo_l(MON_9, l),
589 -1, NULL, NULL, NULL);
590 priv->monthname[9] = g_locale_to_utf8 (nl_langinfo_l(MON_10, l),
591 -1, NULL, NULL, NULL);
592 priv->monthname[10] = g_locale_to_utf8 (nl_langinfo_l(MON_11, l),
593 -1, NULL, NULL, NULL);
594 priv->monthname[11] = g_locale_to_utf8 (nl_langinfo_l(MON_12, l),
595 -1, NULL, NULL, NULL);
601 hildon_calendar_class_init (HildonCalendarClass *class)
603 GObjectClass *gobject_class;
604 GtkObjectClass *object_class;
605 GtkWidgetClass *widget_class;
607 gobject_class = (GObjectClass*) class;
608 object_class = (GtkObjectClass*) class;
609 widget_class = (GtkWidgetClass*) class;
611 parent_class = g_type_class_peek_parent (class);
613 gobject_class->set_property = hildon_calendar_set_property;
614 gobject_class->get_property = hildon_calendar_get_property;
615 gobject_class->finalize = hildon_calendar_finalize;
617 object_class->destroy = hildon_calendar_destroy;
619 widget_class->realize = hildon_calendar_realize;
620 widget_class->unrealize = hildon_calendar_unrealize;
621 widget_class->expose_event = hildon_calendar_expose;
622 widget_class->size_request = hildon_calendar_size_request;
623 widget_class->size_allocate = hildon_calendar_size_allocate;
624 widget_class->button_press_event = hildon_calendar_button_press;
625 widget_class->button_release_event = hildon_calendar_button_release;
626 widget_class->motion_notify_event = hildon_calendar_motion_notify;
627 widget_class->enter_notify_event = hildon_calendar_enter_notify;
628 widget_class->leave_notify_event = hildon_calendar_leave_notify;
629 widget_class->key_press_event = hildon_calendar_key_press;
630 widget_class->scroll_event = hildon_calendar_scroll;
631 widget_class->style_set = hildon_calendar_style_set;
632 widget_class->state_changed = hildon_calendar_state_changed;
633 widget_class->grab_notify = hildon_calendar_grab_notify;
634 widget_class->focus_out_event = hildon_calendar_focus_out;
636 widget_class->drag_data_get = hildon_calendar_drag_data_get;
637 widget_class->drag_motion = hildon_calendar_drag_motion;
638 widget_class->drag_leave = hildon_calendar_drag_leave;
639 widget_class->drag_drop = hildon_calendar_drag_drop;
640 widget_class->drag_data_received = hildon_calendar_drag_data_received;
642 class->month_changed = NULL;
643 class->day_selected = NULL;
644 class->day_selected_double_click = NULL;
645 class->prev_month = NULL;
646 class->next_month = NULL;
647 class->prev_year = NULL;
648 class->next_year = NULL;
651 * HildonCalendar:year:
655 g_object_class_install_property (gobject_class,
657 g_param_spec_int ("year",
661 GTK_PARAM_READWRITE));
664 * HildonCalendar:month:
666 * The selected month as number between 0 and 11.
668 g_object_class_install_property (gobject_class,
670 g_param_spec_int ("month",
672 "The selected month (as a number between 0 and 11)",
674 GTK_PARAM_READWRITE));
677 * HildonCalendar:day:
679 * The selected day as number between 1 and 31 or 0 to unselect the currently selected day.
681 g_object_class_install_property (gobject_class,
683 g_param_spec_int ("day",
685 "The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day)",
687 GTK_PARAM_READWRITE));
690 * HildonCalendar:show-heading:
692 * Determines whether a heading is displayed.
695 g_object_class_install_property (gobject_class,
697 g_param_spec_boolean ("show-heading",
699 "If TRUE, a heading is displayed",
701 GTK_PARAM_READWRITE));
704 * HildonCalendar:show-day-names:
706 * Determines whether day names are displayed.
709 g_object_class_install_property (gobject_class,
711 g_param_spec_boolean ("show-day-names",
713 "If TRUE, day names are displayed",
715 GTK_PARAM_READWRITE));
717 * HildonCalendar:no-month-change:
719 * Determines whether the selected month can be changed.
722 g_object_class_install_property (gobject_class,
723 PROP_NO_MONTH_CHANGE,
724 g_param_spec_boolean ("no-month-change",
726 "If TRUE, the selected month cannot be changed",
728 GTK_PARAM_READWRITE));
731 * HildonCalendar:show-week-numbers:
733 * Determines whether week numbers are displayed.
736 g_object_class_install_property (gobject_class,
737 PROP_SHOW_WEEK_NUMBERS,
738 g_param_spec_boolean ("show-week-numbers",
740 "If TRUE, week numbers are displayed",
742 GTK_PARAM_READWRITE));
745 * HildonCalendar:week-start:
747 * Determines the start day of the week (0 for Sunday, 1 for Monday etc.)
750 g_object_class_install_property (gobject_class,
752 g_param_spec_int ("week-start",
754 "First day of the week; 0 for Sunday, 1 for Monday etc.",
756 GTK_PARAM_READWRITE));
759 * HildonCalendar:min-year:
761 * Minimum valid year (0 if no limit).
764 g_object_class_install_property (gobject_class,
766 g_param_spec_int ("min-year",
767 "Minimum valid year",
768 "Minimum valid year (0 if no limit)",
770 GTK_PARAM_READWRITE));
773 * HildonCalendar:max-year:
775 * Maximum valid year (0 if no limit).
778 g_object_class_install_property (gobject_class,
780 g_param_spec_int ("max-year",
781 "Maximum valid year",
782 "Maximum valid year (0 if no limit)",
784 GTK_PARAM_READWRITE));
786 hildon_calendar_signals[MONTH_CHANGED_SIGNAL] =
787 g_signal_new ("month_changed",
788 G_OBJECT_CLASS_TYPE (gobject_class),
790 G_STRUCT_OFFSET (HildonCalendarClass, month_changed),
792 _hildon_marshal_VOID__VOID,
795 hildon_calendar_signals[DAY_SELECTED_SIGNAL] =
796 g_signal_new ("day_selected",
797 G_OBJECT_CLASS_TYPE (gobject_class),
799 G_STRUCT_OFFSET (HildonCalendarClass, day_selected),
801 _hildon_marshal_VOID__VOID,
804 hildon_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
805 g_signal_new ("day_selected_double_click",
806 G_OBJECT_CLASS_TYPE (gobject_class),
808 G_STRUCT_OFFSET (HildonCalendarClass, day_selected_double_click),
810 _hildon_marshal_VOID__VOID,
813 hildon_calendar_signals[PREV_MONTH_SIGNAL] =
814 g_signal_new ("prev_month",
815 G_OBJECT_CLASS_TYPE (gobject_class),
817 G_STRUCT_OFFSET (HildonCalendarClass, prev_month),
819 _hildon_marshal_VOID__VOID,
822 hildon_calendar_signals[NEXT_MONTH_SIGNAL] =
823 g_signal_new ("next_month",
824 G_OBJECT_CLASS_TYPE (gobject_class),
826 G_STRUCT_OFFSET (HildonCalendarClass, next_month),
828 _hildon_marshal_VOID__VOID,
831 hildon_calendar_signals[PREV_YEAR_SIGNAL] =
832 g_signal_new ("prev_year",
833 G_OBJECT_CLASS_TYPE (gobject_class),
835 G_STRUCT_OFFSET (HildonCalendarClass, prev_year),
837 _hildon_marshal_VOID__VOID,
840 hildon_calendar_signals[NEXT_YEAR_SIGNAL] =
841 g_signal_new ("next_year",
842 G_OBJECT_CLASS_TYPE (gobject_class),
844 G_STRUCT_OFFSET (HildonCalendarClass, next_year),
846 _hildon_marshal_VOID__VOID,
850 * HildonCalendar::erroneous-date:
852 * Emitted when the user tries to set a date which is outside the boundaries
853 * set by min-year and max-year properties.
856 hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL] =
857 g_signal_new ("erroneous_date",
858 G_OBJECT_CLASS_TYPE (gobject_class),
862 _hildon_marshal_VOID__VOID,
865 * HildonCalendar::selected-date:
867 * Emitted on button-release when the user has selected a date.
870 hildon_calendar_signals[SELECTED_DATE_SIGNAL] =
871 g_signal_new ("selected_date",
872 G_OBJECT_CLASS_TYPE(gobject_class),
876 _hildon_marshal_VOID__VOID,
881 hildon_calendar_init (HildonCalendar *calendar)
886 /* char buffer[255];*/
887 /* time_t tmp_time;*/
889 HildonCalendarPrivate *private_data;
890 /* gchar *year_before;*/
894 GDateWeekday week_1stday;
898 widget = GTK_WIDGET (calendar);
899 GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
901 calendar->private_data = g_malloc (sizeof (HildonCalendarPrivate));
902 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
906 tm = localtime (&secs);
907 calendar->month = tm->tm_mon;
908 calendar->year = 1900 + tm->tm_year;
911 calendar->marked_date[i] = FALSE;
912 calendar->num_marked_dates = 0;
913 calendar->selected_day = tm->tm_mday;
915 calendar->display_flags = ( HILDON_CALENDAR_SHOW_HEADING |
916 HILDON_CALENDAR_SHOW_DAY_NAMES );
918 /* Hildon: we should mark current day and we need to store current date */
919 private_data->current_day = tm->tm_mday;
920 private_data->current_month = tm->tm_mon;
921 private_data->current_year = tm->tm_year + 1900;
923 /* Hildon: following lines are for stylus sliding */
924 private_data->slide_stylus = FALSE;
925 private_data->prev_row = -1;
926 private_data->prev_col = -1;
928 /* Hildon: is_bad_day indicate if day was selected out of legal range */
929 private_data->is_bad_day = FALSE;
931 calendar->highlight_row = -1;
932 calendar->highlight_col = -1;
934 calendar->focus_row = -1;
935 calendar->focus_col = -1;
936 calendar->xor_gc = NULL;
938 private_data->max_year_width = 0;
939 private_data->max_month_width = 0;
940 private_data->max_day_char_width = 0;
941 private_data->max_week_char_width = 0;
943 private_data->max_day_char_ascent = 0;
944 private_data->max_day_char_descent = 0;
945 private_data->max_label_char_ascent = 0;
946 private_data->max_label_char_descent = 0;
948 /* private_data->arrow_width = 10;*/
950 private_data->freeze_count = 0;
952 private_data->dirty_header = 0;
953 private_data->dirty_day_names = 0;
954 private_data->dirty_week = 0;
955 private_data->dirty_main = 0;
957 private_data->need_timer = 0;
958 private_data->timer = 0;
959 private_data->click_child = -1;
961 private_data->in_drag = 0;
962 private_data->drag_highlight = 0;
964 private_data->min_year = 0;
965 private_data->max_year = 0;
967 gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_COPY);
968 gtk_drag_dest_add_text_targets (widget);
971 private_data->year_before = 0;
973 /* Translate to calendar:YM if you want years to be displayed
974 * before months; otherwise translate to calendar:MY.
975 * Do *not* translate it to anything else, if it
976 * it isn't calendar:YM or calendar:MY it will not work.
978 * Note that this flipping is in top the text direction flipping,
979 * so if you have a default text direction of RTL and YM, then
980 * the year will appear on the right.
982 year_before = _("calendar:MY");
983 if (strcmp (year_before, "calendar:YM") == 0)
984 private_data->year_before = 1;
985 else if (strcmp (year_before, "calendar:MY") != 0)
986 g_warning ("Whoever translated calendar:MY did so wrongly.\n");
988 langinfo = nl_langinfo (_NL_TIME_FIRST_WEEKDAY);
989 first_weekday = langinfo[0];
990 langinfo = nl_langinfo (_NL_TIME_WEEK_1STDAY);
991 week_origin = GPOINTER_TO_UINT (langinfo);
992 if (week_origin == 19971130)
993 week_1stday = G_DATE_SUNDAY;
994 else if (week_origin == 19971201)
995 week_1stday = G_DATE_MONDAY;
996 else if (g_date_valid_dmy ((week_origin % 100),
997 (week_origin / 100) % 100,
998 (week_origin / 10000)))
1001 date = g_date_new_dmy ((week_origin % 100),
1002 (week_origin / 100) % 100,
1003 (week_origin / 10000));
1004 week_1stday = g_date_get_weekday (date);
1009 g_warning ("Invalid value set for _NL_TIME_WEEK_1STDAY");
1010 week_1stday = G_DATE_SUNDAY;
1013 private_data->week_start = (week_1stday + first_weekday - 1) % 7;
1015 locales_init (private_data);
1019 hildon_calendar_new (void)
1021 return g_object_new (HILDON_TYPE_CALENDAR, NULL);
1024 /* column_from_x: returns the column 0-6 that the
1025 * x pixel of the xwindow is in */
1027 column_from_x (HildonCalendar *calendar,
1031 gint x_left, x_right;
1035 for (c = 0; c < 7; c++)
1037 x_left = left_x_for_column (calendar, c);
1038 x_right = x_left + HILDON_CALENDAR_GET_PRIVATE (calendar)->day_width;
1040 if (event_x >= x_left && event_x < x_right)
1051 row_height (HildonCalendar *calendar)
1053 return (HILDON_CALENDAR_GET_PRIVATE (calendar)->main_h - CALENDAR_MARGIN
1054 - ((calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1055 ? CALENDAR_YSEP : CALENDAR_MARGIN)) / 6;
1059 /* row_from_y: returns the row 0-5 that the
1060 * y pixel of the xwindow is in */
1062 row_from_y (HildonCalendar *calendar,
1067 gint y_top, y_bottom;
1071 for (r = 0; r < 6; r++)
1073 y_top = top_y_for_row (calendar, r);
1074 y_bottom = y_top + HILDON_DAY_HEIGHT /*height*/;
1076 if (event_y >= y_top && event_y < y_bottom)
1086 /* left_x_for_column: returns the x coordinate
1087 * for the left of the column */
1089 left_x_for_column (HildonCalendar *calendar,
1095 if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
1096 column = 6 - column;
1098 width = HILDON_CALENDAR_GET_PRIVATE (calendar)->day_width;
1099 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1100 x_left = CALENDAR_XSEP + (width + DAY_XSEP) * column;
1102 x_left = CALENDAR_MARGIN + (width + DAY_XSEP) * column;
1107 /* top_y_for_row: returns the y coordinate
1108 * for the top of the row */
1110 top_y_for_row (HildonCalendar *calendar,
1113 return (HILDON_CALENDAR_GET_PRIVATE (calendar)->main_h
1114 - (CALENDAR_MARGIN + (6 - row)
1115 * HILDON_DAY_HEIGHT));
1119 hildon_calendar_set_month_prev (HildonCalendar *calendar)
1121 HildonCalendarPrivate *priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1124 if (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1127 if (calendar->month == 0)
1129 if (!priv->min_year || calendar->year > priv->min_year)
1131 calendar->month = 11;
1138 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1140 hildon_calendar_freeze (calendar);
1141 hildon_calendar_compute_days (calendar);
1143 g_signal_emit (calendar,
1144 hildon_calendar_signals[PREV_MONTH_SIGNAL],
1146 g_signal_emit (calendar,
1147 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1150 if (month_len < calendar->selected_day)
1152 calendar->selected_day = 0;
1153 hildon_calendar_select_day (calendar, month_len);
1157 if (calendar->selected_day < 0)
1158 calendar->selected_day = calendar->selected_day + 1 + month_length[leap (calendar->year)][calendar->month + 1];
1159 hildon_calendar_select_day (calendar, calendar->selected_day);
1162 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1163 hildon_calendar_thaw (calendar);
1167 hildon_calendar_set_month_next (HildonCalendar *calendar)
1169 HildonCalendarPrivate *priv;
1172 g_return_if_fail (GTK_IS_WIDGET (calendar));
1174 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1176 if (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1179 if (calendar->month == 11)
1181 if (!priv->max_year || calendar->year < priv->max_year)
1183 calendar->month = 0;
1190 hildon_calendar_freeze (calendar);
1191 hildon_calendar_compute_days (calendar);
1192 g_signal_emit (calendar,
1193 hildon_calendar_signals[NEXT_MONTH_SIGNAL],
1195 g_signal_emit (calendar,
1196 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1199 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1201 if (month_len < calendar->selected_day)
1203 calendar->selected_day = 0;
1204 hildon_calendar_select_day (calendar, month_len);
1207 hildon_calendar_select_day (calendar, calendar->selected_day);
1209 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1210 hildon_calendar_thaw (calendar);
1214 hildon_calendar_set_year_prev (HildonCalendar *calendar)
1216 HildonCalendarPrivate *priv;
1219 g_return_if_fail (GTK_IS_WIDGET (calendar));
1221 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1223 if (!priv->min_year || priv->min_year < calendar->year)
1226 hildon_calendar_freeze (calendar);
1227 hildon_calendar_compute_days (calendar);
1228 g_signal_emit (calendar,
1229 hildon_calendar_signals[PREV_YEAR_SIGNAL],
1231 g_signal_emit (calendar,
1232 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1235 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1237 if (month_len < calendar->selected_day)
1239 calendar->selected_day = 0;
1240 hildon_calendar_select_day (calendar, month_len);
1243 hildon_calendar_select_day (calendar, calendar->selected_day);
1245 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1246 hildon_calendar_thaw (calendar);
1250 hildon_calendar_set_year_next (HildonCalendar *calendar)
1252 HildonCalendarPrivate *priv;
1255 g_return_if_fail (GTK_IS_WIDGET (calendar));
1256 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
1258 hildon_calendar_freeze (calendar);
1260 if (!priv->max_year || priv->max_year > calendar->year)
1263 hildon_calendar_compute_days (calendar);
1264 g_signal_emit (calendar,
1265 hildon_calendar_signals[NEXT_YEAR_SIGNAL],
1267 g_signal_emit (calendar,
1268 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
1271 month_len = month_length[leap (calendar->year)][calendar->month + 1];
1273 if (month_len < calendar->selected_day)
1275 calendar->selected_day = 0;
1276 hildon_calendar_select_day (calendar, month_len);
1279 hildon_calendar_select_day (calendar, calendar->selected_day);
1280 gtk_widget_queue_draw (GTK_WIDGET (calendar));
1281 hildon_calendar_thaw (calendar);
1285 hildon_calendar_main_button (GtkWidget *widget,
1286 GdkEventButton *event)
1288 HildonCalendar *calendar;
1289 HildonCalendarPrivate *private_data;
1295 calendar = HILDON_CALENDAR (widget);
1296 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1298 x = (gint) (event->x);
1299 y = (gint) (event->y);
1301 row = row_from_y (calendar, y);
1302 col = column_from_x (calendar, x);
1304 /* If row or column isn't found, just return. */
1305 if (row == -1 || col == -1)
1308 day_month = calendar->day_month[row][col];
1310 if ((calendar->year == private_data->min_year &&
1311 calendar->month == 0 && day_month == MONTH_PREV) ||
1312 (calendar->year == private_data->max_year &&
1313 calendar->month == 11 && day_month == MONTH_NEXT))
1315 private_data->is_bad_day = TRUE;
1316 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
1320 if (event->type == GDK_BUTTON_RELEASE)
1322 day = calendar->day[row][col];
1324 if (day_month == MONTH_PREV)
1326 hildon_calendar_set_month_prev (calendar);
1328 else if (day_month == MONTH_NEXT)
1330 hildon_calendar_set_month_next (calendar);
1333 if (!GTK_WIDGET_HAS_FOCUS (widget))
1334 gtk_widget_grab_focus (widget);
1336 if (event->button == 1)
1338 private_data->in_drag = 1;
1339 private_data->drag_start_x = x;
1340 private_data->drag_start_y = y;
1343 hildon_calendar_select_and_focus_day (calendar, day);
1345 else if (event->type == GDK_2BUTTON_PRESS)
1347 private_data->in_drag = 0;
1348 private_data->slide_stylus = FALSE;
1349 if (day_month == MONTH_CURRENT)
1350 g_signal_emit (calendar,
1351 hildon_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL], 0);
1356 hildon_calendar_realize_arrows (GtkWidget *widget)
1358 HildonCalendar *calendar;
1359 HildonCalendarPrivate *private_data;
1360 GdkWindowAttr attributes;
1361 gint attributes_mask;
1363 guint arrow_vlength, arrow_hlength;
1364 /*gboolean year_left;*/
1366 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1368 calendar = HILDON_CALENDAR (widget);
1369 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1371 gtk_widget_style_get (widget,
1372 "scroll-arrow-hlength", &arrow_hlength,
1373 "scroll-arrow-vlength", &arrow_vlength,
1376 if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1377 year_left = private_data->year_before;
1379 year_left = !private_data->year_before;
1381 /* Arrow windows ------------------------------------- */
1382 if (! (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1383 && (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING))
1385 attributes.wclass = GDK_INPUT_OUTPUT;
1386 attributes.window_type = GDK_WINDOW_CHILD;
1387 attributes.visual = gtk_widget_get_visual (widget);
1388 attributes.colormap = gtk_widget_get_colormap (widget);
1389 attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
1390 | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1391 | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
1392 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1394 attributes.width = arrow_vlength;
1395 attributes.height = arrow_hlength;
1397 attributes.x = (widget->allocation.width - private_data->max_year_width) / 2 - arrow_vlength - HILDON_ARROW_SEP;
1398 private_data->arrow_win[ARROW_YEAR_LEFT] = gdk_window_new (private_data->header_win,
1399 &attributes, attributes_mask);
1401 attributes.x = (widget->allocation.width + private_data->max_year_width) / 2 + HILDON_ARROW_SEP;
1402 private_data->arrow_win[ARROW_YEAR_RIGHT] = gdk_window_new (private_data->header_win,
1403 &attributes, attributes_mask);
1404 attributes.x = (widget->allocation.width - private_data->max_month_width) / 2 - arrow_vlength - HILDON_ARROW_SEP;
1405 private_data->arrow_win[ARROW_MONTH_LEFT] = gdk_window_new (private_data->footer_win,
1406 &attributes, attributes_mask);
1407 attributes.x = (widget->allocation.width + private_data->max_month_width) / 2 + HILDON_ARROW_SEP;
1408 private_data->arrow_win[ARROW_MONTH_RIGHT] = gdk_window_new (private_data->footer_win,
1409 &attributes, attributes_mask);
1412 for (i = 0; i < 4; i++)
1416 case ARROW_MONTH_LEFT:
1418 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1419 - (3 + 2*private_data->arrow_width
1420 + private_data->max_month_width));
1424 case ARROW_MONTH_RIGHT:
1426 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1427 - 3 - private_data->arrow_width);
1429 attributes.x = (private_data->arrow_width
1430 + private_data->max_month_width);
1432 case ARROW_YEAR_LEFT:
1436 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1437 - (3 + 2*private_data->arrow_width
1438 + private_data->max_year_width));
1440 case ARROW_YEAR_RIGHT:
1442 attributes.x = (private_data->arrow_width
1443 + private_data->max_year_width);
1445 attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
1446 - 3 - private_data->arrow_width);
1449 private_data->arrow_win[i] = gdk_window_new (private_data->header_win,
1453 for (i = 0; i < 4; i++)
1455 if (GTK_WIDGET_IS_SENSITIVE (widget))
1456 private_data->arrow_state[i] = GTK_STATE_NORMAL;
1458 private_data->arrow_state[i] = GTK_STATE_INSENSITIVE;
1459 gdk_window_set_background (private_data->arrow_win[i],
1460 HEADER_BG_COLOR (GTK_WIDGET (calendar)));
1461 gdk_window_show (private_data->arrow_win[i]);
1462 gdk_window_set_user_data (private_data->arrow_win[i], widget);
1467 for (i = 0; i < 4; i++)
1468 private_data->arrow_win[i] = NULL;
1473 hildon_calendar_realize_header (GtkWidget *widget)
1475 HildonCalendar *calendar;
1476 HildonCalendarPrivate *private_data;
1477 GdkWindowAttr attributes;
1478 gint attributes_mask;
1479 guint arrow_hlength;
1481 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1483 calendar = HILDON_CALENDAR (widget);
1484 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1486 gtk_widget_style_get (widget,
1487 "scroll-arrow-hlength", &arrow_hlength,
1489 /* Header window ------------------------------------- */
1490 if (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING)
1492 attributes.wclass = GDK_INPUT_OUTPUT;
1493 attributes.window_type = GDK_WINDOW_CHILD;
1494 attributes.visual = gtk_widget_get_visual (widget);
1495 attributes.colormap = gtk_widget_get_colormap (widget);
1496 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
1497 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1498 attributes.x = 0 /*widget->style->xthickness*/;
1499 attributes.y = 0 /*widget->style->ythickness*/;
1500 attributes.width = widget->allocation.width; /* - 2 * attributes.x */;
1501 attributes.height = arrow_hlength /*private_data->header_h - 2 * attributes.y*/;
1502 private_data->header_win = gdk_window_new (widget->window,
1503 &attributes, attributes_mask);
1505 attributes.y = arrow_hlength + 2 * CALENDAR_YSEP + private_data->main_h + private_data->day_name_h;
1507 private_data->footer_win = gdk_window_new(widget->window,
1508 &attributes, attributes_mask);
1510 gdk_window_set_background (private_data->header_win,
1511 HEADER_BG_COLOR (widget));
1512 gdk_window_set_background (private_data->footer_win,
1513 HEADER_BG_COLOR (widget));
1515 gdk_window_show (private_data->header_win);
1516 gdk_window_show (private_data->footer_win);
1517 gdk_window_set_user_data (private_data->header_win, widget);
1518 gdk_window_set_user_data (private_data->footer_win, widget);
1522 private_data->header_win = NULL;
1523 private_data->footer_win = NULL;
1525 hildon_calendar_realize_arrows (widget);
1529 hildon_calendar_realize_day_names (GtkWidget *widget)
1531 HildonCalendar *calendar;
1532 HildonCalendarPrivate *private_data;
1533 GdkWindowAttr attributes;
1534 gint attributes_mask;
1536 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1538 calendar = HILDON_CALENDAR (widget);
1539 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1541 /* Day names window --------------------------------- */
1542 if ( calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1544 attributes.wclass = GDK_INPUT_OUTPUT;
1545 attributes.window_type = GDK_WINDOW_CHILD;
1546 attributes.visual = gtk_widget_get_visual (widget);
1547 attributes.colormap = gtk_widget_get_colormap (widget);
1548 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
1549 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1550 attributes.x = HILDON_DAY_WIDTH + HILDON_WEEKS_EXTRA_WIDTH/*(widget->style->xthickness + INNER_BORDER)*/;
1551 attributes.y = private_data->header_h;
1552 attributes.width = widget->allocation.width - attributes.x;
1553 attributes.height = private_data->day_name_h;
1554 private_data->day_name_win = gdk_window_new (widget->window,
1557 gdk_window_set_background (private_data->day_name_win,
1558 BACKGROUND_COLOR ( GTK_WIDGET (calendar)));
1560 gdk_window_show (private_data->day_name_win);
1561 gdk_window_set_user_data (private_data->day_name_win, widget);
1565 private_data->day_name_win = NULL;
1570 hildon_calendar_realize_week_numbers (GtkWidget *widget)
1572 HildonCalendar *calendar;
1573 HildonCalendarPrivate *private_data;
1574 GdkWindowAttr attributes;
1575 gint attributes_mask;
1577 g_return_if_fail (HILDON_IS_CALENDAR (widget));
1579 calendar = HILDON_CALENDAR (widget);
1580 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1582 /* Week number window -------------------------------- */
1583 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1585 attributes.wclass = GDK_INPUT_OUTPUT;
1586 attributes.window_type = GDK_WINDOW_CHILD;
1587 attributes.visual = gtk_widget_get_visual (widget);
1588 attributes.colormap = gtk_widget_get_colormap (widget);
1589 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
1591 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1592 attributes.x = 0 /*widget->style->xthickness + INNER_BORDER*/;
1593 attributes.y = private_data->header_h;
1594 /*+ (widget->style->ythickness + INNER_BORDER))*/;
1595 attributes.width = HILDON_DAY_WIDTH + HILDON_WEEKS_EXTRA_WIDTH;
1596 attributes.height = private_data->main_h + private_data->day_name_h;
1597 private_data->week_win = gdk_window_new (widget->window,
1598 &attributes, attributes_mask);
1599 gdk_window_set_background (private_data->week_win,
1600 BACKGROUND_COLOR (GTK_WIDGET (calendar)));
1601 gdk_window_show (private_data->week_win);
1602 gdk_window_set_user_data (private_data->week_win, widget);
1606 private_data->week_win = NULL;
1611 hildon_calendar_realize (GtkWidget *widget)
1613 HildonCalendar *calendar;
1614 HildonCalendarPrivate *private_data;
1615 GdkWindowAttr attributes;
1616 gint attributes_mask;
1619 calendar = HILDON_CALENDAR (widget);
1620 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1622 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1623 hildon_calendar_compute_days (calendar);
1625 attributes.x = widget->allocation.x;
1626 attributes.y = widget->allocation.y;
1627 attributes.width = widget->allocation.width;
1628 attributes.height = widget->allocation.height;
1629 attributes.wclass = GDK_INPUT_OUTPUT;
1630 attributes.window_type = GDK_WINDOW_CHILD;
1631 attributes.event_mask = (gtk_widget_get_events (widget)
1632 | GDK_EXPOSURE_MASK |GDK_KEY_PRESS_MASK | GDK_SCROLL_MASK);
1633 attributes.visual = gtk_widget_get_visual (widget);
1634 attributes.colormap = gtk_widget_get_colormap (widget);
1636 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1637 widget->window = gdk_window_new (widget->parent->window,
1638 &attributes, attributes_mask);
1640 widget->style = gtk_style_attach (widget->style, widget->window);
1642 /* Header window ------------------------------------- */
1643 hildon_calendar_realize_header (widget);
1644 /* Day names window --------------------------------- */
1645 hildon_calendar_realize_day_names (widget);
1646 /* Week number window -------------------------------- */
1647 hildon_calendar_realize_week_numbers (widget);
1648 /* Main Window -------------------------------------- */
1649 attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
1650 | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1651 | GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
1653 attributes.x = HILDON_DAY_WIDTH + HILDON_WEEKS_EXTRA_WIDTH /*private_data->week_width + (widget->style->ythickness + INNER_BORDER)*/;
1654 attributes.y = (private_data->header_h + private_data->day_name_h
1655 + (widget->style->ythickness + INNER_BORDER));
1656 attributes.width = (widget->allocation.width - attributes.x
1657 /*- (widget->style->xthickness + INNER_BORDER)*/);
1658 attributes.height = private_data->main_h;
1659 private_data->main_win = gdk_window_new (widget->window,
1660 &attributes, attributes_mask);
1661 gdk_window_set_background (private_data->main_win,
1662 BACKGROUND_COLOR ( GTK_WIDGET ( calendar)));
1663 gdk_window_show (private_data->main_win);
1664 gdk_window_set_user_data (private_data->main_win, widget);
1665 gdk_window_set_background (widget->window, BACKGROUND_COLOR (widget));
1666 gdk_window_show (widget->window);
1667 gdk_window_set_user_data (widget->window, widget);
1669 /* Set widgets gc */
1670 calendar->gc = gdk_gc_new (widget->window);
1672 values.foreground = widget->style->white;
1673 values.function = GDK_XOR;
1674 calendar->xor_gc = gdk_gc_new_with_values (widget->window,
1681 hildon_calendar_unrealize (GtkWidget *widget)
1683 HildonCalendar *calendar;
1684 HildonCalendarPrivate *private_data;
1687 calendar = HILDON_CALENDAR (widget);
1688 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1690 if (private_data->header_win)
1692 for (i = 0; i < 4; i++)
1694 if (private_data->arrow_win[i])
1696 gdk_window_set_user_data (private_data->arrow_win[i], NULL);
1697 gdk_window_destroy (private_data->arrow_win[i]);
1698 private_data->arrow_win[i] = NULL;
1701 gdk_window_set_user_data (private_data->header_win, NULL);
1702 gdk_window_destroy (private_data->header_win);
1703 private_data->header_win = NULL;
1704 gdk_window_set_user_data (private_data->footer_win, NULL);
1705 gdk_window_destroy (private_data->footer_win);
1706 private_data->footer_win = NULL;
1709 if (private_data->week_win)
1711 gdk_window_set_user_data (private_data->week_win, NULL);
1712 gdk_window_destroy (private_data->week_win);
1713 private_data->week_win = NULL;
1716 if (private_data->main_win)
1718 gdk_window_set_user_data (private_data->main_win, NULL);
1719 gdk_window_destroy (private_data->main_win);
1720 private_data->main_win = NULL;
1722 if (private_data->day_name_win)
1724 gdk_window_set_user_data (private_data->day_name_win, NULL);
1725 gdk_window_destroy (private_data->day_name_win);
1726 private_data->day_name_win = NULL;
1728 if (calendar->xor_gc)
1729 g_object_unref (calendar->xor_gc);
1731 g_object_unref (calendar->gc);
1733 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
1734 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
1738 hildon_calendar_size_request (GtkWidget *widget,
1739 GtkRequisition *requisition)
1741 HildonCalendar *calendar;
1742 HildonCalendarPrivate *private_data;
1743 PangoLayout *layout;
1744 PangoRectangle logical_rect;
1749 /*gint calendar_margin = CALENDAR_MARGIN;*/
1750 gint header_width, main_width;
1751 gint max_header_height = 0;
1756 calendar = HILDON_CALENDAR (widget);
1757 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1758 gtk_widget_style_get (GTK_WIDGET (widget),
1759 "focus-line-width", &focus_width,
1760 "focus-padding", &focus_padding,
1761 "scroll-arrow-hlength", &arrow_hlength,
1764 layout = gtk_widget_create_pango_layout (widget, NULL);
1767 * Calculate the requisition width for the widget.
1772 if (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING)
1774 private_data->max_month_width = 0;
1775 for (i = 0; i < 12; i++)
1777 pango_layout_set_text (layout, private_data->monthname[i], -1);
1778 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1779 private_data->max_month_width = MAX (private_data->max_month_width,
1780 logical_rect.width + 8);
1781 max_header_height = MAX (max_header_height, logical_rect.height);
1783 private_data->max_year_width = 0;
1784 for (i=0; i<10; i++)
1786 g_snprintf (buffer, sizeof (buffer), "%d%d%d%d", i,i,i,i);
1787 pango_layout_set_text (layout, buffer, -1);
1788 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1789 private_data->max_year_width = MAX (private_data->max_year_width,
1790 logical_rect.width + 8);
1791 max_header_height = MAX (max_header_height, logical_rect.height);
1796 private_data->max_month_width = 0;
1797 private_data->max_year_width = 0;
1800 if (calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
1801 header_width = (private_data->max_month_width
1802 + private_data->max_year_width
1805 header_width = (private_data->max_month_width
1806 + private_data->max_year_width
1807 + 4 * private_data->arrow_width + 3 * 3);
1809 /* Mainwindow labels width */
1811 private_data->max_day_char_width = 0;
1812 private_data->min_day_width = 0;
1813 private_data->max_label_char_ascent = 0;
1814 private_data->max_label_char_descent = 0;
1816 for (i = 0; i < 9; i++)
1818 g_snprintf (buffer, sizeof (buffer), "%d%d", i, i);
1819 pango_layout_set_text (layout, buffer, -1);
1820 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1821 private_data->min_day_width = MAX (private_data->min_day_width,
1822 logical_rect.width);
1824 private_data->max_day_char_ascent = MAX (private_data->max_label_char_ascent,
1825 PANGO_ASCENT (logical_rect));
1826 private_data->max_day_char_descent = MAX (private_data->max_label_char_descent,
1827 PANGO_DESCENT (logical_rect));
1829 /* We add one to max_day_char_width to be able to make the marked day "bold" */
1830 private_data->max_day_char_width = private_data->min_day_width / 2 + 1;
1832 if (calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1833 for (i = 0; i < 7; i++)
1835 pango_layout_set_text (layout, private_data->abbreviated_dayname[i], -1);
1836 pango_layout_line_get_pixel_extents (pango_layout_get_lines (layout)->data, NULL, &logical_rect);
1838 /* Hildon: add 4 so that passive focus wouldn't overlap day names */
1839 private_data->min_day_width = MAX (private_data->min_day_width, logical_rect.width + 4);
1840 private_data->max_label_char_ascent = MAX (private_data->max_label_char_ascent,
1841 PANGO_ASCENT (logical_rect));
1842 private_data->max_label_char_descent = MAX (private_data->max_label_char_descent,
1843 PANGO_DESCENT (logical_rect));
1846 private_data->max_week_char_width = 0;
1847 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1848 for (i = 0; i < 9; i++)
1850 g_snprintf (buffer, sizeof (buffer), "%d%d", i, i);
1851 pango_layout_set_text (layout, buffer, -1);
1852 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1853 private_data->max_week_char_width = MAX (private_data->max_week_char_width,
1854 logical_rect.width / 2);
1857 main_width = (7 * (private_data->min_day_width + (focus_padding + focus_width) * 2) + (DAY_XSEP * 6) + CALENDAR_MARGIN * 2
1858 + (private_data->max_week_char_width
1859 ? private_data->max_week_char_width * 2 + (focus_padding + focus_width) * 2 + CALENDAR_XSEP * 2
1862 /* requisition->width = MAX (header_width, main_width + INNER_BORDER * 2) + widget->style->xthickness * 2;
1864 * FIXME: header_width is broken, when Calendar is themed !
1865 * Next line is workaround for this bug
1867 requisition->width = (main_width + INNER_BORDER * 2) + widget->style->xthickness * 2 + HILDON_WEEKS_EXTRA_WIDTH + HILDON_DAYS_EXTRA_WIDTH;
1870 * Calculate the requisition height for the widget.
1871 * This is Hildon calculation
1874 if (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING)
1875 private_data->header_h = arrow_hlength + CALENDAR_YSEP;
1877 private_data->header_h = 0;
1879 if (calendar->display_flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
1880 private_data->day_name_h = HILDON_DAY_HEIGHT;
1882 private_data->day_name_h = 0;
1884 private_data->main_h = 6 * HILDON_DAY_HEIGHT;
1885 requisition->height = 2 * private_data->header_h + private_data->day_name_h + private_data->main_h;
1887 g_object_unref (layout);
1891 hildon_calendar_size_allocate (GtkWidget *widget,
1892 GtkAllocation *allocation)
1894 HildonCalendar *calendar;
1895 HildonCalendarPrivate *private_data;
1896 gint xthickness = widget->style->xthickness;
1897 /*gint ythickness = widget->style->xthickness;*/
1899 gint arrow_vlength, arrow_hlength;
1901 widget->allocation = *allocation;
1903 calendar = HILDON_CALENDAR (widget);
1904 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
1906 if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1907 year_left = private_data->year_before;
1909 year_left = !private_data->year_before;
1911 gtk_widget_style_get (widget,
1912 "scroll-arrow-vlength", &arrow_vlength,
1913 "scroll-arrow-hlength", &arrow_hlength,
1916 if (calendar->display_flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
1918 /* this variable is introduced to avoid breaking week_width because
1919 of HILDON_WEEKS_EXTRA_WIDTH and HILDON_DAYS_EXTRA_WIDTH appearing
1920 in calculation of day_width */
1921 int real_day_width = (private_data->min_day_width
1922 * ((allocation->width
1923 - (xthickness + INNER_BORDER) * 2
1924 - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2))
1925 / (7 * private_data->min_day_width + private_data->max_week_char_width * 2));
1927 private_data->day_width = (private_data->min_day_width
1928 * ((allocation->width
1929 - (HILDON_WEEKS_EXTRA_WIDTH + HILDON_DAYS_EXTRA_WIDTH)
1930 - (xthickness + INNER_BORDER) * 2
1931 - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2))
1932 / (7 * private_data->min_day_width + private_data->max_week_char_width * 2));
1933 private_data->week_width = ((allocation->width - (xthickness + INNER_BORDER) * 2
1934 - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2 )
1935 - real_day_width * 7 + CALENDAR_MARGIN + CALENDAR_XSEP);
1939 private_data->day_width = (allocation->width
1940 - (xthickness + INNER_BORDER) * 2
1941 - (CALENDAR_MARGIN * 2)
1942 - (DAY_XSEP * 6))/7;
1943 private_data->week_width = 0;
1946 if (GTK_WIDGET_REALIZED (widget))
1948 gdk_window_move_resize (widget->window,
1949 allocation->x, allocation->y,
1950 allocation->width, allocation->height);
1951 if (private_data->header_win)
1952 gdk_window_move_resize (private_data->header_win,
1953 0, 0, widget->allocation.width, arrow_hlength);
1954 if (private_data->arrow_win[ARROW_YEAR_LEFT])
1957 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_LEFT],
1959 private_data->arrow_width,
1960 private_data->header_h - 7);
1962 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_LEFT],
1963 (allocation->width - 2 * xthickness
1964 - (3 + 2*private_data->arrow_width
1965 + private_data->max_year_width)),
1967 private_data->arrow_width,
1968 private_data->header_h - 7);*/
1970 gdk_window_move (private_data->arrow_win[ARROW_YEAR_LEFT],
1971 (widget->allocation.width - private_data->max_year_width) / 2 - arrow_vlength - HILDON_ARROW_SEP, 0);
1973 if (private_data->arrow_win[ARROW_YEAR_RIGHT])
1976 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_RIGHT],
1977 (private_data->arrow_width
1978 + private_data->max_year_width),
1980 private_data->arrow_width,
1981 private_data->header_h - 7);
1983 gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_RIGHT],
1984 (allocation->width - 2 * xthickness
1985 - 3 - private_data->arrow_width),
1987 private_data->arrow_width,
1988 private_data->header_h - 7);*/
1989 gdk_window_move (private_data->arrow_win[ARROW_YEAR_RIGHT],
1990 (widget->allocation.width + private_data->max_year_width) / 2 + HILDON_ARROW_SEP, 0);
1992 if (private_data->footer_win)
1993 gdk_window_move_resize (private_data->footer_win,
1994 0, private_data->header_h + private_data->day_name_h + private_data->main_h + CALENDAR_YSEP,
1995 widget->allocation.width, arrow_hlength);
1997 if (private_data->arrow_win[ARROW_MONTH_LEFT])
2000 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_LEFT],
2001 (allocation->width - 2 * xthickness
2002 - (3 + 2*private_data->arrow_width
2003 + private_data->max_month_width)),
2005 private_data->arrow_width,
2006 private_data->header_h - 7);
2008 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_LEFT],
2010 private_data->arrow_width,
2011 private_data->header_h - 7);
2014 gdk_window_move (private_data->arrow_win[ARROW_MONTH_LEFT],
2015 (widget->allocation.width - private_data->max_month_width) / 2 - arrow_vlength - HILDON_ARROW_SEP, 0);
2017 if (private_data->arrow_win[ARROW_MONTH_RIGHT])
2020 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_RIGHT],
2021 (allocation->width - 2 * xthickness
2022 - 3 - private_data->arrow_width),
2024 private_data->arrow_width,
2025 private_data->header_h - 7);
2027 gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_RIGHT],
2028 (private_data->arrow_width
2029 + private_data->max_month_width),
2031 private_data->arrow_width,
2032 private_data->header_h - 7);*/
2033 gdk_window_move (private_data->arrow_win[ARROW_MONTH_RIGHT],
2034 (widget->allocation.width + private_data->max_month_width) / 2 + HILDON_ARROW_SEP, 0);
2038 if (private_data->day_name_win)
2039 gdk_window_move_resize (private_data->day_name_win,
2040 private_data->week_width, /*xthickness + INNER_BORDER*/
2041 private_data->header_h /*+ (widget->style->ythickness + INNER_BORDER)*/,
2042 widget->allocation.width - private_data->week_width /*- (xthickness + INNER_BORDER) * 2*/,
2043 private_data->day_name_h);
2044 if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
2046 if (private_data->week_win)
2047 gdk_window_move_resize (private_data->week_win,
2048 0 /*(xthickness + INNER_BORDER)*/,
2049 private_data->header_h /*+ (widget->style->ythickness + INNER_BORDER)*/,
2051 private_data->main_h + private_data->day_name_h);
2052 gdk_window_move_resize (private_data->main_win,
2053 private_data->week_width /* + (xthickness + INNER_BORDER)*/,
2054 private_data->header_h + private_data->day_name_h
2055 /*+ (widget->style->ythickness + INNER_BORDER)*/,
2056 widget->allocation.width - private_data->week_width
2057 /*- (xthickness + INNER_BORDER) * 2*/,
2058 private_data->main_h);
2062 gdk_window_move_resize (private_data->main_win,
2063 0 /*(xthickness + INNER_BORDER)*/,
2064 private_data->header_h + private_data->day_name_h
2065 /*+ (widget->style->ythickness + INNER_BORDER)*/,
2066 widget->allocation.width
2067 - private_data->week_width
2068 /*- (xthickness + INNER_BORDER) * 2*/,
2069 private_data->main_h);
2070 if (private_data->week_win)
2071 gdk_window_move_resize (private_data->week_win,
2072 widget->allocation.width
2073 - private_data->week_width
2074 /*- (xthickness + INNER_BORDER)*/,
2075 private_data->header_h + private_data->day_name_h
2076 /*+ (widget->style->ythickness + INNER_BORDER)*/,
2077 private_data->week_width,
2078 private_data->main_h);
2084 hildon_calendar_expose (GtkWidget *widget,
2085 GdkEventExpose *event)
2087 HildonCalendar *calendar;
2088 HildonCalendarPrivate *private_data;
2090 calendar = HILDON_CALENDAR (widget);
2091 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2093 if (GTK_WIDGET_DRAWABLE (widget))
2095 if (event->window == private_data->main_win)
2096 hildon_calendar_paint_main (widget);
2098 if (event->window == private_data->header_win)
2099 hildon_calendar_paint_header (widget);
2100 if (event->window == private_data->footer_win)
2101 hildon_calendar_paint_footer(widget);
2103 if (event->window == private_data->day_name_win)
2104 hildon_calendar_paint_day_names (widget);
2106 if (event->window == private_data->week_win)
2107 hildon_calendar_paint_week_numbers (widget);
2110 /* FIXME This appeared after 2.6 -> 2.10 migration. Without this the
2111 * arrows disappear when spinning through the calendar. Apparently, something
2112 * overdraws them somehow or the expose events go into blackhole. This is
2113 * a dirty fix... but kinda works */
2115 hildon_calendar_paint_header (widget);
2116 hildon_calendar_paint_footer (widget);
2122 hildon_calendar_paint_header (GtkWidget *widget)
2124 HildonCalendar *calendar;
2128 gint header_width, cal_height;
2129 HildonCalendarPrivate *private_data;
2130 PangoLayout *layout;
2131 PangoRectangle logical_rect;
2134 calendar = HILDON_CALENDAR (widget);
2135 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2137 if (private_data->freeze_count)
2139 private_data->dirty_header = 1;
2143 private_data->dirty_header = 0;
2147 gdk_window_clear (private_data->header_win);
2149 header_width = widget->allocation.width /*- 2 * widget->style->xthickness*/;
2150 cal_height = widget->allocation.height;
2152 g_snprintf (buffer, sizeof (buffer), "%d", calendar->year);
2153 layout = gtk_widget_create_pango_layout (widget, buffer);
2154 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2156 gtk_widget_style_get (widget, "scroll-arrow-hlength", &arrow_hlength, NULL);
2158 y = (arrow_hlength - logical_rect.height) / 2;
2159 x = (widget->allocation.width - logical_rect.width) / 2;
2161 /* Draw year and its arrows */
2162 gdk_gc_set_foreground (gc, HEADER_FG_COLOR (GTK_WIDGET (calendar)));
2163 gdk_draw_layout (private_data->header_win, gc, x, y, layout);
2165 hildon_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
2166 hildon_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
2168 g_object_unref (layout);
2172 hildon_calendar_paint_footer (GtkWidget *widget)
2174 HildonCalendar *calendar;
2178 gint header_width, cal_height;
2179 HildonCalendarPrivate *private_data;
2180 PangoLayout *layout;
2181 PangoRectangle logical_rect;
2184 calendar = HILDON_CALENDAR (widget);
2185 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2187 if (private_data->freeze_count)
2189 private_data->dirty_header = 1;
2193 private_data->dirty_header = 0;
2197 gdk_window_clear (private_data->footer_win);
2199 header_width = widget->allocation.width - 2 * widget->style->xthickness;
2200 cal_height = widget->allocation.height;
2202 /* Draw month and its arrows */
2203 g_snprintf (buffer, sizeof (buffer), "%s", private_data->monthname[calendar->month]);
2204 layout = gtk_widget_create_pango_layout (widget, buffer);
2205 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2207 gtk_widget_style_get (widget, "scroll-arrow-hlength", &arrow_hlength, NULL);
2209 x = (widget->allocation.width - logical_rect.width) / 2;
2210 y = (arrow_hlength - logical_rect.height) / 2;
2212 gdk_gc_set_foreground (gc, HEADER_FG_COLOR(GTK_WIDGET (calendar)));
2213 gdk_draw_layout (private_data->footer_win, gc, x, y, layout);
2215 hildon_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
2216 hildon_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
2218 g_object_unref(layout);
2222 hildon_calendar_paint_day_names (GtkWidget *widget)
2224 HildonCalendar *calendar;
2228 int day_width, cal_width;
2231 PangoLayout *layout;
2232 PangoRectangle logical_rect;
2233 HildonCalendarPrivate *private_data;
2237 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2238 calendar = HILDON_CALENDAR (widget);
2239 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2242 gtk_widget_style_get (GTK_WIDGET (widget),
2243 "focus-line-width", &focus_width,
2244 "focus-padding", &focus_padding,
2247 * Handle freeze/thaw functionality
2250 if (private_data->freeze_count)
2252 private_data->dirty_day_names = 1;
2255 private_data->dirty_day_names = 0;
2261 gdk_window_clear (private_data->day_name_win);
2263 day_width = private_data->day_width;
2264 cal_width = widget->allocation.width;
2265 cal_height = widget->allocation.height;
2266 day_wid_sep = day_width + DAY_XSEP;
2269 * Draw rectangles as inverted background for the labels.
2276 layout = gtk_widget_create_pango_layout (widget, NULL);
2278 gdk_gc_set_foreground (gc, SELECTED_FG_COLOR (widget));
2279 for (i = 0; i < 7; i++)
2281 guint x = left_x_for_column (calendar, i);
2283 if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
2287 day = (day + private_data->week_start) % 7;
2288 g_snprintf (buffer, sizeof (buffer), "%s", private_data->abbreviated_dayname[day]);
2290 pango_layout_set_text (layout, buffer, -1);
2291 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2293 /* Hildon: draw passive focus for day name */
2294 if (calendar->focus_col == i)
2295 gtk_paint_box(GTK_WIDGET (calendar)->style,
2296 private_data->day_name_win,
2298 GTK_SHADOW_OUT, NULL,
2299 GTK_WIDGET (calendar), "passive-focus",
2302 logical_rect.width + 4,
2305 gdk_draw_layout (private_data->day_name_win, gc,
2307 CALENDAR_MARGIN + focus_width + focus_padding + logical_rect.y,
2310 g_object_unref (layout);
2314 hildon_calendar_paint_week_numbers (GtkWidget *widget)
2316 HildonCalendar *calendar;
2318 guint row, week = 0, year;
2322 HildonCalendarPrivate *private_data;
2323 PangoLayout *layout;
2324 PangoRectangle logical_rect;
2328 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2329 g_return_if_fail (widget->window != NULL);
2330 calendar = HILDON_CALENDAR (widget);
2331 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2335 * Handle freeze/thaw functionality
2338 if (private_data->freeze_count)
2340 private_data->dirty_week = 1;
2343 private_data->dirty_week = 0;
2345 gtk_widget_style_get (GTK_WIDGET (widget),
2346 "focus-line-width", &focus_width,
2347 "focus-padding", &focus_padding,
2354 gdk_window_clear (private_data->week_win);
2357 * Draw a rectangle as inverted background for the labels.
2360 gdk_gc_set_foreground (gc, SELECTED_BG_COLOR (widget));
2362 /* Hildon: don't paint background for weekday window */
2368 layout = gtk_widget_create_pango_layout (widget, NULL);
2370 gdk_gc_set_foreground (gc, SELECTED_FG_COLOR (widget));
2371 gdk_draw_line(private_data->week_win, gc,
2372 HILDON_DAY_WIDTH + 7,
2374 HILDON_DAY_WIDTH + 7,
2375 private_data->main_h + private_data->day_name_h);
2377 for (row = 0; row < 6; row++)
2379 year = calendar->year;
2380 if (calendar->day[row][6] < 15 && row > 3 && calendar->month == 11)
2383 g_return_if_fail (week_of_year (&week, &year,
2384 ((calendar->day[row][6] < 15 && row > 3 ? 1 : 0)
2385 + calendar->month) % 12 + 1, calendar->day[row][6]));
2387 g_snprintf (buffer, sizeof (buffer), "%d", week);
2388 pango_layout_set_text (layout, buffer, -1);
2389 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2391 /* Hildon: draw passive focus for week */
2392 if (calendar->focus_row == row)
2394 guint y = top_y_for_row (calendar, calendar->focus_row + 1);
2396 gtk_paint_box(GTK_WIDGET (calendar)->style,
2397 private_data->week_win,
2399 GTK_SHADOW_OUT, NULL,
2400 GTK_WIDGET (calendar), "passive-focus",
2402 private_data->week_width/* - 4*/,
2406 y_loc = private_data->day_name_h + top_y_for_row (calendar, row) + (HILDON_DAY_HEIGHT - logical_rect.height) / 2;
2407 x_loc = (HILDON_DAY_WIDTH - logical_rect.width) / 2;
2409 gdk_draw_layout (private_data->week_win, gc, x_loc, y_loc, layout);
2412 g_object_unref (layout);
2416 hildon_calendar_paint_day_num (GtkWidget *widget,
2419 HildonCalendar *calendar;
2420 gint r, c, row, col;
2421 HildonCalendarPrivate *private_data;
2422 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2424 calendar = HILDON_CALENDAR (widget);
2426 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2430 for (r = 0; r < 6; r++)
2431 for (c = 0; c < 7; c++)
2432 if (calendar->day_month[r][c] == MONTH_CURRENT &&
2433 calendar->day[r][c] == day)
2439 g_return_if_fail (row != -1);
2440 g_return_if_fail (col != -1);
2442 hildon_calendar_paint_day (widget, row, col);
2446 hildon_calendar_paint_day (GtkWidget *widget,
2450 HildonCalendar *calendar;
2460 HildonCalendarPrivate *private_data;
2461 PangoLayout *layout;
2462 PangoRectangle logical_rect;
2464 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2465 g_return_if_fail (row < 6);
2466 g_return_if_fail (col < 7);
2467 calendar = HILDON_CALENDAR (widget);
2468 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2470 if (private_data->main_win == NULL) return;
2473 * Handle freeze/thaw functionality
2476 if (private_data->freeze_count)
2478 private_data->dirty_main = 1;
2482 gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
2484 day = calendar->day[row][col];
2485 x_left = left_x_for_column (calendar, col);
2486 y_top = top_y_for_row (calendar, row);
2488 gdk_window_clear_area (private_data->main_win, x_left, y_top,
2489 HILDON_DAY_WIDTH, HILDON_DAY_HEIGHT);
2493 if (calendar->day_month[row][col] == MONTH_PREV)
2495 gdk_gc_set_foreground (gc, PREV_MONTH_COLOR (GTK_WIDGET (calendar)));
2497 else if (calendar->day_month[row][col] == MONTH_NEXT)
2499 gdk_gc_set_foreground (gc, NEXT_MONTH_COLOR (GTK_WIDGET (calendar)));
2503 if (calendar->selected_day == day)
2505 /* Hildon: use custom graphics */
2506 gtk_paint_box(GTK_WIDGET (calendar)->style,
2507 private_data->main_win,
2509 GTK_SHADOW_NONE, NULL,
2510 GTK_WIDGET (calendar), "active-day",
2515 if (calendar->marked_date[day-1])
2516 gdk_gc_set_foreground (gc, MARKED_COLOR (GTK_WIDGET (calendar)));
2518 gdk_gc_set_foreground (gc, NORMAL_DAY_COLOR (GTK_WIDGET (calendar)));
2519 if (calendar->selected_day == day)
2520 gdk_gc_set_foreground (gc, SELECTED_FG_COLOR (GTK_WIDGET (calendar)));
2522 gdk_gc_set_foreground (gc, & (GTK_WIDGET (calendar)->style->fg[GTK_WIDGET_STATE (calendar)]));
2525 if (GTK_WIDGET_HAS_FOCUS (calendar) &&
2526 calendar->focus_row == row &&
2527 calendar->focus_col == col)
2531 if (calendar->selected_day == day)
2532 state = GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE;
2534 state = GTK_STATE_NORMAL;
2536 gtk_paint_focus (widget->style,
2537 private_data->main_win,
2538 (calendar->selected_day == day)
2539 ? GTK_STATE_SELECTED : GTK_STATE_NORMAL,
2540 NULL, widget, "calendar-day",
2546 /* Hildon: paint green indicator for current day */
2547 if ((day == private_data->current_day && calendar->selected_day !=
2548 private_data->current_day) && (calendar->day_month[row][col] == MONTH_CURRENT))
2549 hildon_calendar_check_current_date (calendar, x_left, y_top);
2551 g_snprintf (buffer, sizeof (buffer), "%d", day);
2552 layout = gtk_widget_create_pango_layout (widget, buffer);
2553 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2555 x_loc = x_left + (HILDON_DAY_WIDTH - logical_rect.width) / 2;
2556 y_loc = y_top + (HILDON_DAY_HEIGHT - logical_rect.height) / 2;
2558 gdk_draw_layout (private_data->main_win, gc,
2559 x_loc, y_loc, layout);
2560 if (calendar->marked_date[day-1] &&
2561 calendar->day_month[row][col] == MONTH_CURRENT)
2562 gdk_draw_layout (private_data->main_win, gc,
2563 x_loc-1, y_loc, layout);
2565 g_object_unref (layout);
2569 hildon_calendar_paint_main (GtkWidget *widget)
2571 HildonCalendar *calendar;
2572 HildonCalendarPrivate *private_data;
2575 g_return_if_fail (HILDON_IS_CALENDAR (widget));
2576 g_return_if_fail (widget->window != NULL);
2578 calendar = HILDON_CALENDAR (widget);
2579 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
2581 if (private_data->freeze_count)
2583 private_data->dirty_main = 1;
2586 private_data->dirty_main = 0;
2587 gdk_window_clear (private_data->main_win);
2589 for (col = 0; col < 7; col++)
2590 for (row = 0; row < 6; row++)
2591 hildon_calendar_paint_day (widget, row, col);
2595 hildon_calendar_compute_days (HildonCalendar *calendar)
2597 HildonCalendarPrivate *private_data;
2600 gint ndays_in_month;
2601 gint ndays_in_prev_month;
2607 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2609 private_data = HILDON_CALENDAR_GET_PRIVATE (GTK_WIDGET (calendar));
2611 year = calendar->year;
2612 month = calendar->month + 1;
2614 ndays_in_month = month_length[leap (year)][month];
2616 first_day = day_of_week (year, month, 1);
2617 first_day = (first_day + 7 - private_data->week_start) % 7;
2619 /* Compute days of previous month */
2621 ndays_in_prev_month = month_length[leap (year)][month-1];
2623 ndays_in_prev_month = month_length[leap (year)][12];
2624 day = ndays_in_prev_month - first_day + 1;
2629 for (col = 0; col < first_day; col++)
2631 calendar->day[row][col] = day;
2632 calendar->day_month[row][col] = MONTH_PREV;
2637 /* Compute days of current month */
2639 for (day = 1; day <= ndays_in_month; day++)
2641 calendar->day[row][col] = day;
2642 calendar->day_month[row][col] = MONTH_CURRENT;
2652 /* Compute days of next month */
2654 for (; row <= 5; row++)
2656 for (; col <= 6; col++)
2658 calendar->day[row][col] = day;
2659 calendar->day_month[row][col] = MONTH_NEXT;
2667 * hildon_calendar_get_display_options:
2668 * @calendar: a #HildonCalendar
2670 * Returns the current display options of @calendar.
2672 * Return value: the display options.
2674 HildonCalendarDisplayOptions
2675 hildon_calendar_get_display_options (HildonCalendar *calendar)
2677 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), 0);
2679 return calendar->display_flags;
2683 * hildon_calendar_set_display_options:
2684 * @calendar: a #HildonCalendar
2685 * @flags: the display options to set
2687 * Sets display options (whether to display the heading and the month
2692 hildon_calendar_set_display_options (HildonCalendar *calendar,
2693 HildonCalendarDisplayOptions flags)
2695 HildonCalendarPrivate *private_data;
2699 HildonCalendarDisplayOptions old_flags;
2701 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2703 widget = GTK_WIDGET (calendar);
2704 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
2705 old_flags = calendar->display_flags;
2707 if (GTK_WIDGET_REALIZED (widget))
2709 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_NO_MONTH_CHANGE)
2712 if (! (flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
2713 && (private_data->header_win))
2715 calendar->display_flags &= ~HILDON_CALENDAR_NO_MONTH_CHANGE;
2716 hildon_calendar_realize_arrows (widget);
2720 for (i = 0; i < 4; i++)
2722 if (private_data->arrow_win[i])
2724 gdk_window_set_user_data (private_data->arrow_win[i],
2726 gdk_window_destroy (private_data->arrow_win[i]);
2727 private_data->arrow_win[i] = NULL;
2733 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_HEADING)
2737 if (flags & HILDON_CALENDAR_SHOW_HEADING)
2739 calendar->display_flags |= HILDON_CALENDAR_SHOW_HEADING;
2740 hildon_calendar_realize_header (widget);
2744 for (i = 0; i < 4; i++)
2746 if (private_data->arrow_win[i])
2748 gdk_window_set_user_data (private_data->arrow_win[i],
2750 gdk_window_destroy (private_data->arrow_win[i]);
2751 private_data->arrow_win[i] = NULL;
2754 gdk_window_set_user_data (private_data->header_win, NULL);
2755 gdk_window_destroy (private_data->header_win);
2756 private_data->header_win = NULL;
2761 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_DAY_NAMES)
2765 if (flags & HILDON_CALENDAR_SHOW_DAY_NAMES)
2767 calendar->display_flags |= HILDON_CALENDAR_SHOW_DAY_NAMES;
2768 hildon_calendar_realize_day_names (widget);
2772 gdk_window_set_user_data (private_data->day_name_win, NULL);
2773 gdk_window_destroy (private_data->day_name_win);
2774 private_data->day_name_win = NULL;
2778 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
2782 if (flags & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
2784 calendar->display_flags |= HILDON_CALENDAR_SHOW_WEEK_NUMBERS;
2785 hildon_calendar_realize_week_numbers (widget);
2789 gdk_window_set_user_data (private_data->week_win, NULL);
2790 gdk_window_destroy (private_data->week_win);
2791 private_data->week_win = NULL;
2795 if ((flags ^ calendar->display_flags) & HILDON_CALENDAR_WEEK_START_MONDAY)
2796 g_warning ("HILDON_CALENDAR_WEEK_START_MONDAY is ignored; the first day of the week is determined from the locale");
2798 calendar->display_flags = flags;
2800 gtk_widget_queue_resize (GTK_WIDGET (calendar));
2804 calendar->display_flags = flags;
2806 g_object_freeze_notify (G_OBJECT (calendar));
2807 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_HEADING)
2808 g_object_notify (G_OBJECT (calendar), "show-heading");
2809 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_DAY_NAMES)
2810 g_object_notify (G_OBJECT (calendar), "show-day-names");
2811 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_NO_MONTH_CHANGE)
2812 g_object_notify (G_OBJECT (calendar), "no-month-change");
2813 if ((old_flags ^ calendar->display_flags) & HILDON_CALENDAR_SHOW_WEEK_NUMBERS)
2814 g_object_notify (G_OBJECT (calendar), "show-week-numbers");
2815 g_object_thaw_notify (G_OBJECT (calendar));
2819 hildon_calendar_select_month (HildonCalendar *calendar,
2823 HildonCalendarPrivate *priv;
2825 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), FALSE);
2826 g_return_val_if_fail (month <= 11, FALSE);
2828 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
2830 if (priv->max_year && year > priv->max_year)
2831 year = priv->max_year;
2832 if (priv->min_year && year < priv->min_year)
2833 year = priv->min_year;
2835 calendar->month = month;
2836 calendar->year = year;
2838 hildon_calendar_compute_days (calendar);
2840 gtk_widget_queue_draw (GTK_WIDGET (calendar));
2842 g_object_freeze_notify (G_OBJECT (calendar));
2843 g_object_notify (G_OBJECT (calendar), "month");
2844 g_object_notify (G_OBJECT (calendar), "year");
2845 g_object_thaw_notify (G_OBJECT (calendar));
2847 g_signal_emit (calendar,
2848 hildon_calendar_signals[MONTH_CHANGED_SIGNAL],
2854 hildon_calendar_select_day (HildonCalendar *calendar,
2858 HildonCalendarPrivate *priv;
2859 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2860 g_return_if_fail (day <= 31);
2861 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
2863 for (row = 0; row < 6; row ++)
2864 for (col = 0; col < 7; col++)
2866 if (calendar->day_month[row][col] == MONTH_CURRENT
2867 && calendar->day[row][col] == day)
2869 calendar->focus_row = row;
2870 calendar->focus_col = col;
2874 if (calendar->month != priv->current_month ||
2875 calendar->year != priv->current_year)
2876 hildon_calendar_unmark_day (calendar, priv->current_day);
2878 /* Deselect the old day */
2879 if (calendar->selected_day > 0)
2883 selected_day = calendar->selected_day;
2884 calendar->selected_day = 0;
2885 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2887 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), selected_day);
2891 calendar->selected_day = day;
2893 /*printf("Selected day = %d\n", day);*/
2895 /* Select the new day */
2898 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2900 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), day);
2904 g_object_notify (G_OBJECT (calendar), "day");
2905 g_signal_emit (calendar,
2906 hildon_calendar_signals[DAY_SELECTED_SIGNAL],
2911 hildon_calendar_select_and_focus_day (HildonCalendar *calendar,
2914 gint old_focus_row = calendar->focus_row;
2915 gint old_focus_col = calendar->focus_col;
2919 for (row = 0; row < 6; row ++)
2920 for (col = 0; col < 7; col++)
2922 if (calendar->day_month[row][col] == MONTH_CURRENT
2923 && calendar->day[row][col] == day)
2925 calendar->focus_row = row;
2926 calendar->focus_col = col;
2930 if (old_focus_row != -1 && old_focus_col != -1)
2931 hildon_calendar_paint_day (GTK_WIDGET (calendar), old_focus_row, old_focus_col);
2933 hildon_calendar_select_day (calendar, day);
2937 hildon_calendar_clear_marks (HildonCalendar *calendar)
2941 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
2943 for (day = 0; day < 31; day++)
2945 calendar->marked_date[day] = FALSE;
2948 calendar->num_marked_dates = 0;
2950 if (GTK_WIDGET_DRAWABLE (calendar))
2952 hildon_calendar_paint_main (GTK_WIDGET (calendar));
2957 hildon_calendar_mark_day (HildonCalendar *calendar,
2960 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), FALSE);
2961 if (day >= 1 && day <= 31 && calendar->marked_date[day-1] == FALSE)
2963 calendar->marked_date[day - 1] = TRUE;
2964 calendar->num_marked_dates++;
2966 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2967 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), day-1);
2974 hildon_calendar_unmark_day (HildonCalendar *calendar,
2977 g_return_val_if_fail (HILDON_IS_CALENDAR (calendar), FALSE);
2979 if (day >= 1 && day <= 31 && calendar->marked_date[day-1] == TRUE)
2981 calendar->marked_date[day - 1] = FALSE;
2982 calendar->num_marked_dates--;
2984 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2985 hildon_calendar_paint_day_num (GTK_WIDGET (calendar), day-1);
2992 hildon_calendar_get_date (HildonCalendar *calendar,
2997 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
3000 *year = calendar->year;
3003 *month = calendar->month;
3006 *day = calendar->selected_day;
3010 arrow_action (HildonCalendar *calendar,
3015 case ARROW_YEAR_LEFT:
3016 hildon_calendar_set_year_prev (calendar);
3018 case ARROW_YEAR_RIGHT:
3019 hildon_calendar_set_year_next (calendar);
3021 case ARROW_MONTH_LEFT:
3022 hildon_calendar_set_month_prev (calendar);
3024 case ARROW_MONTH_RIGHT:
3025 hildon_calendar_set_month_next (calendar);
3031 hildon_calendar_select_and_focus_day(calendar, calendar->selected_day);
3035 calendar_timer (gpointer data)
3037 HildonCalendar *calendar = data;
3038 HildonCalendarPrivate *private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
3039 gboolean retval = FALSE;
3040 GtkSettings *settings;
3043 gdk_window_process_updates (((GtkWidget *) calendar)->window, TRUE);
3045 settings = gtk_settings_get_default ();
3046 g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
3049 GDK_THREADS_ENTER ();
3051 if (private_data->timer)
3053 arrow_action (calendar, private_data->click_child);
3055 if (private_data->need_timer)
3057 private_data->need_timer = FALSE;
3058 private_data->timer = g_timeout_add (/*CALENDAR_TIMER_DELAY*/timeout,
3059 (GSourceFunc) calendar_timer,
3060 (gpointer) calendar);
3066 GDK_THREADS_LEAVE ();
3072 start_spinning (GtkWidget *widget,
3075 HildonCalendarPrivate *private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3076 GtkSettings *settings;
3079 settings = gtk_settings_get_default ();
3080 g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
3083 private_data->click_child = click_child;
3085 if (!private_data->timer)
3087 private_data->need_timer = TRUE;
3088 private_data->timer = g_timeout_add (/*CALENDAR_INITIAL_TIMER_DELAY*/timeout,
3095 stop_spinning (GtkWidget *widget)
3097 HildonCalendarPrivate *private_data;
3099 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3101 if (private_data->timer)
3103 g_source_remove (private_data->timer);
3104 private_data->timer = 0;
3105 private_data->need_timer = FALSE;
3110 hildon_calendar_destroy (GtkObject *object)
3112 stop_spinning (GTK_WIDGET (object));
3114 GTK_OBJECT_CLASS (parent_class)->destroy (object);
3118 hildon_calendar_grab_notify (GtkWidget *widget,
3119 gboolean was_grabbed)
3122 stop_spinning (widget);
3126 hildon_calendar_focus_out (GtkWidget *widget,
3127 GdkEventFocus *event)
3129 HildonCalendarPrivate *private_data;
3131 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3133 stop_spinning (widget);
3135 private_data->in_drag = 0;
3141 hildon_calendar_button_press (GtkWidget *widget,
3142 GdkEventButton *event)
3144 HildonCalendar *calendar;
3145 HildonCalendarPrivate *private_data;
3148 calendar = HILDON_CALENDAR (widget);
3149 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3152 if (event->type == GDK_2BUTTON_PRESS)
3154 if (event->window == private_data->main_win)
3155 hildon_calendar_main_button (widget, event);
3157 else if (event->window == private_data->main_win)
3159 gint x = (gint) (event->x);
3160 gint y = (gint) (event->y);
3161 gint row = row_from_y (calendar, y);
3162 gint col = column_from_x (calendar, x);
3163 private_data->pressed_day = calendar->day[row][col];
3165 if ((calendar->year == private_data->min_year &&
3166 calendar->month == 0
3167 && calendar->day_month[row][col] == MONTH_PREV) ||
3168 (calendar->year == private_data->max_year &&
3169 calendar->month == 11 &&
3170 calendar->day_month[row][col] == MONTH_NEXT))
3172 else if (calendar->day_month[row][col] == MONTH_CURRENT)
3173 hildon_calendar_select_and_focus_day (calendar, private_data->pressed_day);
3175 /* Remember month where button was pressed */
3176 private_data->pressed_month = calendar->month;
3177 private_data->slide_stylus = TRUE;
3180 if (!GTK_WIDGET_HAS_FOCUS (widget))
3181 gtk_widget_grab_focus (widget);
3183 for (arrow = ARROW_YEAR_LEFT; arrow <= ARROW_MONTH_RIGHT; arrow++)
3185 if (event->window == private_data->arrow_win[arrow])
3188 /* only call the action on single click, not double */
3189 if (event->type == GDK_BUTTON_PRESS)
3191 if (event->button == 1)
3192 start_spinning (widget, arrow);
3194 arrow_action (calendar, arrow);
3205 hildon_calendar_button_release (GtkWidget *widget,
3206 GdkEventButton *event)
3208 HildonCalendar *calendar;
3209 HildonCalendarPrivate *private_data;
3211 calendar = HILDON_CALENDAR (widget);
3212 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3214 if (event->window == private_data->main_win)
3216 hildon_calendar_main_button (widget, event);
3217 gint x = (gint) (event->x);
3218 gint y = (gint) (event->y);
3219 gint row = row_from_y (calendar, y);
3220 gint col = column_from_x (calendar, x);
3221 private_data->prev_col = -1;
3222 private_data->prev_row = -1;
3224 if ((private_data->pressed_day == calendar->day[row][col]) &&
3225 (private_data->pressed_month == calendar->month))
3227 if (!private_data->is_bad_day)
3229 g_signal_emit (calendar, hildon_calendar_signals[SELECTED_DATE_SIGNAL], 0);
3233 private_data->is_bad_day = FALSE;
3238 if (event->button == 1)
3240 stop_spinning (widget);
3242 if (private_data->in_drag)
3243 private_data->in_drag = 0;
3246 private_data->slide_stylus = FALSE;
3251 hildon_calendar_motion_notify (GtkWidget *widget,
3252 GdkEventMotion *event)
3254 HildonCalendar *calendar;
3255 HildonCalendarPrivate *private_data;
3256 gint event_x, event_y;
3258 gint old_row, old_col;
3260 calendar = HILDON_CALENDAR (widget);
3261 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3262 event_x = (gint) (event->x);
3263 event_y = (gint) (event->y);
3265 if (event->window == private_data->main_win)
3267 /* Hildon: make active day to move, when stylus is slided */
3268 if (private_data->slide_stylus)
3270 gint c_row = row_from_y (calendar, event_y);
3271 gint c_col = column_from_x (calendar, event_x);
3273 if (calendar->day_month[c_row][c_col] == MONTH_PREV ||
3274 calendar->day_month[c_row][c_col] == MONTH_NEXT)
3276 else if ((private_data->prev_row != c_row || private_data->prev_col != c_col) &&
3277 (calendar->highlight_row != -1 && calendar->highlight_col != -1))
3279 hildon_calendar_select_and_focus_day (calendar,
3280 calendar->day[c_row][c_col]);
3281 /* Update passive focus indicators work weekday number and name */
3282 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3283 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3285 private_data->prev_col = c_col;
3286 private_data->prev_row = c_row;
3288 if (private_data->in_drag)
3290 if (gtk_drag_check_threshold (widget,
3291 private_data->drag_start_x, private_data->drag_start_y,
3292 event->x, event->y))
3294 GdkDragContext *context;
3295 GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
3296 gtk_target_list_add_text_targets (target_list, 0);
3297 context = gtk_drag_begin (widget, target_list, GDK_ACTION_COPY,
3298 1, (GdkEvent *)event);
3301 private_data->in_drag = 0;
3303 gtk_target_list_unref (target_list);
3304 gtk_drag_set_icon_default (context);
3309 row = row_from_y (calendar, event_y);
3310 col = column_from_x (calendar, event_x);
3312 if (row != calendar->highlight_row || calendar->highlight_col != col)
3314 old_row = calendar->highlight_row;
3315 old_col = calendar->highlight_col;
3316 if (old_row > -1 && old_col > -1)
3318 calendar->highlight_row = -1;
3319 calendar->highlight_col = -1;
3320 hildon_calendar_paint_day (widget, old_row, old_col);
3323 calendar->highlight_row = row;
3324 calendar->highlight_col = col;
3326 if (row > -1 && col > -1)
3327 hildon_calendar_paint_day (widget, row, col);
3336 hildon_calendar_enter_notify (GtkWidget *widget,
3337 GdkEventCrossing *event)
3339 HildonCalendar *calendar;
3340 HildonCalendarPrivate *private_data;
3342 calendar = HILDON_CALENDAR (widget);
3343 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3345 if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
3347 private_data->arrow_state[ARROW_MONTH_LEFT] = GTK_STATE_PRELIGHT;
3348 hildon_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
3351 if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
3353 private_data->arrow_state[ARROW_MONTH_RIGHT] = GTK_STATE_PRELIGHT;
3354 hildon_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
3357 if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
3359 private_data->arrow_state[ARROW_YEAR_LEFT] = GTK_STATE_PRELIGHT;
3360 hildon_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
3363 if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
3365 private_data->arrow_state[ARROW_YEAR_RIGHT] = GTK_STATE_PRELIGHT;
3366 hildon_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
3373 hildon_calendar_leave_notify (GtkWidget *widget,
3374 GdkEventCrossing *event)
3376 HildonCalendar *calendar;
3377 HildonCalendarPrivate *private_data;
3381 calendar = HILDON_CALENDAR (widget);
3382 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3384 if (event->window == private_data->main_win)
3386 row = calendar->highlight_row;
3387 col = calendar->highlight_col;
3388 calendar->highlight_row = -1;
3389 calendar->highlight_col = -1;
3390 if (row > -1 && col > -1)
3391 hildon_calendar_paint_day (widget, row, col);
3394 if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
3396 private_data->arrow_state[ARROW_MONTH_LEFT] = GTK_STATE_NORMAL;
3397 hildon_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
3400 if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
3402 private_data->arrow_state[ARROW_MONTH_RIGHT] = GTK_STATE_NORMAL;
3403 hildon_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
3406 if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
3408 private_data->arrow_state[ARROW_YEAR_LEFT] = GTK_STATE_NORMAL;
3409 hildon_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
3412 if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
3414 private_data->arrow_state[ARROW_YEAR_RIGHT] = GTK_STATE_NORMAL;
3415 hildon_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
3422 hildon_calendar_paint_arrow (GtkWidget *widget,
3425 HildonCalendarPrivate *private_data;
3428 HildonCalendar *calendar;
3430 guint arrow_hlength, arrow_vlength;
3431 /* gint width, height;*/
3433 calendar = HILDON_CALENDAR (widget);
3434 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3435 gtk_widget_style_get (widget,
3436 "scroll-arrow-hlength", &arrow_hlength,
3437 "scroll-arrow-vlength", &arrow_vlength,
3440 if (private_data->freeze_count)
3442 private_data->dirty_header = 1;
3445 window = private_data->arrow_win[arrow];
3448 state = private_data->arrow_state[arrow];
3451 /* gdk_window_clear (window);*/
3452 gdk_window_set_background (window, &(widget)->style->bg[state]);
3453 /* gdk_drawable_get_size (window, &width, &height);*/
3454 /* gdk_window_clear_area (window,
3458 gdk_window_clear(window);
3460 /* Hildon: added support for dimmed arrows */
3461 if (((private_data->min_year && calendar->year <= private_data->min_year) ||
3462 (private_data->max_year && calendar->year >= private_data->max_year)))
3464 if (private_data->min_year &&
3465 calendar->year <= private_data->min_year)
3467 if (arrow == ARROW_YEAR_LEFT)
3468 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3469 GTK_SHADOW_OUT, NULL, widget, "calendar",
3470 GTK_ARROW_LEFT, TRUE,
3471 0, 0, arrow_vlength, arrow_hlength);
3472 else if (arrow == ARROW_YEAR_RIGHT || arrow == ARROW_MONTH_RIGHT)
3473 gtk_paint_arrow (widget->style, window, state,
3474 GTK_SHADOW_OUT, NULL, widget, "calendar",
3475 GTK_ARROW_RIGHT, TRUE,
3476 0, 0, arrow_vlength, arrow_hlength);
3477 else if (arrow == ARROW_MONTH_LEFT && calendar->month != 0)
3478 gtk_paint_arrow (widget->style, window, state,
3479 GTK_SHADOW_OUT, NULL, widget, "calendar",
3480 GTK_ARROW_LEFT, TRUE,
3481 0, 0, arrow_vlength, arrow_hlength);
3482 else if (arrow == ARROW_MONTH_LEFT && !calendar->month)
3483 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3484 GTK_SHADOW_OUT, NULL, widget, "calendar",
3485 GTK_ARROW_LEFT, TRUE,
3486 0, 0, arrow_vlength, arrow_hlength);
3488 else if (private_data->max_year &&
3489 calendar->year >= private_data->max_year)
3491 if (arrow == ARROW_YEAR_RIGHT)
3492 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3493 GTK_SHADOW_OUT, NULL, widget, "calendar",
3494 GTK_ARROW_RIGHT, TRUE,
3495 0, 0, arrow_vlength, arrow_hlength);
3496 else if (arrow == ARROW_YEAR_LEFT || arrow == ARROW_MONTH_LEFT)
3497 gtk_paint_arrow (widget->style, window, state,
3498 GTK_SHADOW_OUT, NULL, widget, "calendar",
3499 GTK_ARROW_LEFT, TRUE,
3500 0, 0, arrow_vlength, arrow_hlength);
3501 else if (arrow == ARROW_MONTH_RIGHT && calendar->month != 11)
3502 gtk_paint_arrow (widget->style, window, state,
3503 GTK_SHADOW_OUT, NULL, widget, "calendar",
3504 GTK_ARROW_RIGHT, TRUE,
3505 0, 0, arrow_vlength, arrow_hlength);
3506 else if (arrow == ARROW_MONTH_RIGHT && calendar->month == 11)
3507 gtk_paint_arrow (widget->style, window, GTK_STATE_INSENSITIVE,
3508 GTK_SHADOW_OUT, NULL, widget, "calendar",
3509 GTK_ARROW_RIGHT, TRUE,
3510 0, 0, arrow_vlength, arrow_hlength);
3515 if (arrow == ARROW_MONTH_LEFT || arrow == ARROW_YEAR_LEFT)
3516 gtk_paint_arrow (widget->style, window, state,
3517 GTK_SHADOW_OUT, NULL, widget, "calendar",
3518 GTK_ARROW_LEFT, TRUE,
3519 /* width/2 - 3, height/2 - 4, 8, 8);*/
3520 0, 0, arrow_vlength, arrow_hlength);
3522 gtk_paint_arrow (widget->style, window, state,
3523 GTK_SHADOW_OUT, NULL, widget, "calendar",
3524 GTK_ARROW_RIGHT, TRUE,
3525 /* width/2 - 2, height/2 - 4, 8, 8);*/
3526 0, 0, arrow_vlength, arrow_hlength);
3532 hildon_calendar_freeze (HildonCalendar *calendar)
3534 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
3536 HILDON_CALENDAR_GET_PRIVATE (calendar)->freeze_count++;
3540 hildon_calendar_thaw (HildonCalendar *calendar)
3542 HildonCalendarPrivate *private_data;
3544 g_return_if_fail (HILDON_IS_CALENDAR (calendar));
3546 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
3548 if (private_data->freeze_count)
3549 if (!(--private_data->freeze_count))
3551 if (private_data->dirty_header)
3552 if (GTK_WIDGET_DRAWABLE (calendar))
3553 hildon_calendar_paint_header (GTK_WIDGET (calendar));
3555 if (private_data->dirty_day_names)
3556 if (GTK_WIDGET_DRAWABLE (calendar))
3557 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3559 if (private_data->dirty_week)
3560 if (GTK_WIDGET_DRAWABLE (calendar))
3561 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3563 if (private_data->dirty_main)
3564 if (GTK_WIDGET_DRAWABLE (calendar))
3565 hildon_calendar_paint_main (GTK_WIDGET (calendar));
3570 hildon_calendar_set_background (GtkWidget *widget)
3572 HildonCalendar *calendar;
3573 HildonCalendarPrivate *private_data;
3576 calendar = HILDON_CALENDAR (widget);
3577 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3579 if (GTK_WIDGET_REALIZED (widget))
3581 for (i = 0; i < 4; i++)
3583 if (private_data->arrow_win[i])
3584 gdk_window_set_background (private_data->arrow_win[i],
3585 HEADER_BG_COLOR (widget));
3587 if (private_data->header_win)
3588 gdk_window_set_background (private_data->header_win,
3589 HEADER_BG_COLOR (widget));
3590 if (private_data->day_name_win)
3591 gdk_window_set_background (private_data->day_name_win,
3592 BACKGROUND_COLOR (widget));
3593 if (private_data->week_win)
3594 gdk_window_set_background (private_data->week_win,
3595 BACKGROUND_COLOR (widget));
3596 if (private_data->main_win)
3597 gdk_window_set_background (private_data->main_win,
3598 BACKGROUND_COLOR (widget));
3600 gdk_window_set_background (widget->window,
3601 BACKGROUND_COLOR (widget));
3606 hildon_calendar_style_set (GtkWidget *widget,
3607 GtkStyle *previous_style)
3609 if (previous_style && GTK_WIDGET_REALIZED (widget))
3610 hildon_calendar_set_background(widget);
3614 hildon_calendar_state_changed (GtkWidget *widget,
3615 GtkStateType previous_state)
3617 HildonCalendarPrivate *private_data;
3620 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
3622 if (!GTK_WIDGET_IS_SENSITIVE (widget))
3624 private_data->in_drag = 0;
3625 stop_spinning (widget);
3628 for (i = 0; i < 4; i++)
3629 if (GTK_WIDGET_IS_SENSITIVE (widget))
3630 private_data->arrow_state[i] = GTK_STATE_NORMAL;
3632 private_data->arrow_state[i] = GTK_STATE_INSENSITIVE;
3634 hildon_calendar_set_background (widget);
3638 hildon_calendar_finalize (GObject *object)
3640 HildonCalendarPrivate *private_data;
3643 private_data = HILDON_CALENDAR_GET_PRIVATE (object);
3645 for (i = 0; i < 7; i++)
3646 g_free (private_data->abbreviated_dayname[i]);
3647 for (i = 0; i < 12; i++)
3648 g_free (private_data->monthname[i]);
3649 g_free (private_data);
3651 (* G_OBJECT_CLASS (parent_class)->finalize) (object);
3655 hildon_calendar_scroll (GtkWidget *widget,
3656 GdkEventScroll *event)
3658 HildonCalendar *calendar = HILDON_CALENDAR (widget);
3660 if (event->direction == GDK_SCROLL_UP)
3662 if (!GTK_WIDGET_HAS_FOCUS (widget))
3663 gtk_widget_grab_focus (widget);
3664 hildon_calendar_set_month_prev (calendar);
3666 else if (event->direction == GDK_SCROLL_DOWN)
3668 if (!GTK_WIDGET_HAS_FOCUS (widget))
3669 gtk_widget_grab_focus (widget);
3670 hildon_calendar_set_month_next (calendar);
3679 move_focus (HildonCalendar *calendar,
3682 GtkTextDirection text_dir = gtk_widget_get_direction (GTK_WIDGET (calendar));
3684 if ((text_dir == GTK_TEXT_DIR_LTR && direction == -1) ||
3685 (text_dir == GTK_TEXT_DIR_RTL && direction == 1))
3687 if (calendar->focus_col > 0)
3688 calendar->focus_col--;
3689 else if (calendar->focus_row > 0)
3691 calendar->focus_col = 6;
3692 calendar->focus_row--;
3697 if (calendar->focus_col < 6)
3698 calendar->focus_col++;
3699 else if (calendar->focus_row < 5)
3701 calendar->focus_col = 0;
3702 calendar->focus_row++;
3708 hildon_calendar_key_press (GtkWidget *widget,
3711 HildonCalendar *calendar;
3712 HildonCalendarPrivate *priv;
3713 GtkSettings *settings;
3720 calendar = HILDON_CALENDAR (widget);
3721 priv = HILDON_CALENDAR_GET_PRIVATE (calendar);
3724 old_focus_row = calendar->focus_row;
3725 old_focus_col = calendar->focus_col;
3727 settings = gtk_settings_get_default ();
3728 g_object_get (settings, "hildon-keyboard-navigation", &knav, NULL);
3730 switch (event->keyval)
3735 if (event->state & GDK_CONTROL_MASK)
3736 hildon_calendar_set_month_prev (calendar);
3739 /* if we are at the first allowed day of the minimum year/month then do nothing */
3740 if (calendar->year == priv->min_year && calendar->month == 0 &&
3741 calendar->day_month[old_focus_row][old_focus_col-1] == MONTH_PREV)
3743 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3746 else /* else normal */
3748 move_focus (calendar, -1);
3751 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3752 hildon_calendar_paint_day (widget, calendar->focus_row,
3753 calendar->focus_col);
3757 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3758 if (day_month == MONTH_CURRENT && calendar->selected_day != 1)
3760 hildon_calendar_select_day(calendar, calendar->selected_day - 1);
3764 if (calendar->month != 0) {
3765 calendar->selected_day = month_length[leap (calendar->year)][calendar->month];
3767 calendar->selected_day = month_length[leap (calendar->year -1)][12];
3769 hildon_calendar_set_month_prev (calendar);
3771 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3772 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3780 if (event->state & GDK_CONTROL_MASK)
3781 hildon_calendar_set_month_next (calendar);
3784 if (calendar->year == priv->max_year && calendar->month == 11 &&
3785 calendar->day_month[old_focus_row][old_focus_col+1] == MONTH_NEXT)
3787 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3792 move_focus (calendar, 1);
3795 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3796 hildon_calendar_paint_day (widget, calendar->focus_row,
3797 calendar->focus_col);
3801 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3802 if (day_month == MONTH_CURRENT)
3804 hildon_calendar_select_day (calendar, calendar->selected_day + 1);
3808 calendar->selected_day = 1;
3809 hildon_calendar_set_month_next (calendar);
3811 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3812 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3820 if (event->state & GDK_CONTROL_MASK)
3821 hildon_calendar_set_year_prev (calendar);
3824 if (calendar->year == priv->min_year && calendar->month == 0 &&
3825 calendar->day_month[old_focus_row-1][old_focus_col] == MONTH_PREV)
3827 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3832 if (calendar->focus_row > 0)
3833 calendar->focus_row--;
3836 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3837 hildon_calendar_paint_day (widget, calendar->focus_row,
3838 calendar->focus_col);
3842 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3843 if (day_month == MONTH_CURRENT)
3845 if ((calendar->selected_day - 7) <= 0)
3847 if (calendar->month != 0)
3848 calendar->selected_day = month_length[leap (calendar->year)][calendar->month];
3850 calendar->selected_day = month_length[leap (calendar->year - 1)][12];
3851 hildon_calendar_set_month_prev (calendar);
3855 hildon_calendar_select_day (calendar, calendar->selected_day - 7);
3860 calendar->selected_day = calendar->day[calendar->focus_row][calendar->focus_col];
3861 hildon_calendar_set_month_prev (calendar);
3863 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3864 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3872 if (event->state & GDK_CONTROL_MASK)
3873 hildon_calendar_set_year_next (calendar);
3876 if (calendar->year == priv->max_year && calendar->month == 11 &&
3877 calendar->day_month[old_focus_row+1][old_focus_col] == MONTH_NEXT)
3879 g_signal_emit (calendar, hildon_calendar_signals[ERRONEOUS_DATE_SIGNAL], 0);
3885 if (calendar->focus_row < 5)
3886 calendar->focus_row++;
3889 hildon_calendar_paint_day (widget, old_focus_row, old_focus_col);
3890 hildon_calendar_paint_day (widget, calendar->focus_row,
3891 calendar->focus_col);
3895 gint day_month = calendar->day_month[calendar->focus_row][calendar->focus_col];
3896 if (day_month == MONTH_CURRENT)
3898 if ((calendar->selected_day + 7) >
3899 month_length[leap (calendar->year)][calendar->month + 1])
3901 calendar->selected_day = 1;
3902 hildon_calendar_set_month_next (calendar);
3906 hildon_calendar_select_day (calendar, calendar->selected_day + 7);
3911 calendar->selected_day = calendar->day[calendar->focus_row][calendar->focus_col];
3912 hildon_calendar_set_month_next (calendar);
3914 hildon_calendar_paint_week_numbers (GTK_WIDGET (calendar));
3915 hildon_calendar_paint_day_names (GTK_WIDGET (calendar));
3923 row = calendar->focus_row;
3924 col = calendar->focus_col;
3925 day = calendar->day[row][col];
3927 if (row > -1 && col > -1)
3930 hildon_calendar_freeze (calendar);
3932 if (calendar->day_month[row][col] == MONTH_PREV)
3933 hildon_calendar_set_month_prev (calendar);
3934 else if (calendar->day_month[row][col] == MONTH_NEXT)
3935 hildon_calendar_set_month_next (calendar);
3937 hildon_calendar_select_and_focus_day (calendar, day);
3939 hildon_calendar_thaw (calendar);
3947 hildon_calendar_set_display_option (HildonCalendar *calendar,
3948 HildonCalendarDisplayOptions flag,
3951 HildonCalendarDisplayOptions flags;
3954 flags = calendar->display_flags | flag;
3956 flags = calendar->display_flags & ~flag;
3958 hildon_calendar_set_display_options (calendar, flags);
3962 hildon_calendar_get_display_option (HildonCalendar *calendar,
3963 HildonCalendarDisplayOptions flag)
3965 return (calendar->display_flags & flag) != 0;
3970 hildon_calendar_set_property (GObject *object,
3972 const GValue *value,
3975 HildonCalendar *calendar;
3976 HildonCalendarPrivate *private_data;
3979 calendar = HILDON_CALENDAR (object);
3980 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
3985 hildon_calendar_select_month (calendar,
3987 g_value_get_int (value));
3990 hildon_calendar_select_month (calendar,
3991 g_value_get_int (value),
3995 hildon_calendar_select_day (calendar,
3996 g_value_get_int (value));
3998 case PROP_SHOW_HEADING:
3999 hildon_calendar_set_display_option (calendar,
4000 HILDON_CALENDAR_SHOW_HEADING,
4001 g_value_get_boolean (value));
4003 case PROP_SHOW_DAY_NAMES:
4004 hildon_calendar_set_display_option (calendar,
4005 HILDON_CALENDAR_SHOW_DAY_NAMES,
4006 g_value_get_boolean (value));
4008 case PROP_NO_MONTH_CHANGE:
4009 hildon_calendar_set_display_option (calendar,
4010 HILDON_CALENDAR_NO_MONTH_CHANGE,
4011 g_value_get_boolean (value));
4013 case PROP_SHOW_WEEK_NUMBERS:
4014 hildon_calendar_set_display_option (calendar,
4015 HILDON_CALENDAR_SHOW_WEEK_NUMBERS,
4016 g_value_get_boolean (value));
4018 case PROP_WEEK_START:
4019 private_data->week_start = g_value_get_int (value);
4022 val = g_value_get_int (value);
4023 if (val <= private_data->max_year ||
4024 val == 0 || private_data->max_year == 0)
4026 private_data->min_year = val;
4027 if (val && (calendar->year < val))
4028 hildon_calendar_select_month (calendar,
4030 private_data->min_year);
4033 g_warning("min-year cannot be greater than max-year");
4036 val = g_value_get_int (value);
4037 if (val >= private_data->min_year ||
4038 val == 0 || private_data->min_year == 0)
4040 private_data->max_year = val;
4041 if (val && (calendar->year > val))
4042 hildon_calendar_select_month (calendar,
4044 private_data->max_year);
4047 g_warning("max-year cannot be less than min-year");
4050 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
4056 hildon_calendar_get_property (GObject *object,
4061 HildonCalendar *calendar;
4062 HildonCalendarPrivate *private_data;
4064 calendar = HILDON_CALENDAR (object);
4065 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
4070 g_value_set_int (value, calendar->year);
4073 g_value_set_int (value, calendar->month);
4076 g_value_set_int (value, calendar->selected_day);
4078 case PROP_SHOW_HEADING:
4079 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4080 HILDON_CALENDAR_SHOW_HEADING));
4082 case PROP_SHOW_DAY_NAMES:
4083 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4084 HILDON_CALENDAR_SHOW_DAY_NAMES));
4086 case PROP_NO_MONTH_CHANGE:
4087 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4088 HILDON_CALENDAR_NO_MONTH_CHANGE));
4090 case PROP_SHOW_WEEK_NUMBERS:
4091 g_value_set_boolean (value, hildon_calendar_get_display_option (calendar,
4092 HILDON_CALENDAR_SHOW_WEEK_NUMBERS));
4094 case PROP_WEEK_START:
4095 g_value_set_int (value, private_data->week_start);
4098 g_value_set_int (value, private_data->min_year);
4101 g_value_set_int (value, private_data->max_year);
4104 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
4111 hildon_calendar_drag_data_get (GtkWidget *widget,
4112 GdkDragContext *context,
4113 GtkSelectionData *selection_data,
4117 HildonCalendar *calendar = HILDON_CALENDAR (widget);
4122 date = g_date_new_dmy (calendar->selected_day, calendar->month + 1, calendar->year);
4123 len = g_date_strftime (str, 127, "%x", date);
4124 gtk_selection_data_set_text (selection_data, str, len);
4129 /* Get/set whether drag_motion requested the drag data and
4130 * drag_data_received should thus not actually insert the data,
4131 * since the data doesn't result from a drop.
4134 set_status_pending (GdkDragContext *context,
4135 GdkDragAction suggested_action)
4137 g_object_set_data (G_OBJECT (context),
4138 "gtk-calendar-status-pending",
4139 GINT_TO_POINTER (suggested_action));
4142 static GdkDragAction
4143 get_status_pending (GdkDragContext *context)
4145 return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
4146 "gtk-calendar-status-pending"));
4150 hildon_calendar_drag_leave (GtkWidget *widget,
4151 GdkDragContext *context,
4154 HildonCalendarPrivate *private_data;
4156 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
4157 private_data->drag_highlight = 0;
4158 gtk_drag_unhighlight (widget);
4163 hildon_calendar_drag_motion (GtkWidget *widget,
4164 GdkDragContext *context,
4169 HildonCalendarPrivate *private_data;
4172 private_data = HILDON_CALENDAR_GET_PRIVATE (widget);
4174 if (!private_data->drag_highlight)
4176 private_data->drag_highlight = 1;
4177 gtk_drag_highlight (widget);
4180 target = gtk_drag_dest_find_target (widget, context, NULL);
4181 if (target == GDK_NONE)
4182 gdk_drag_status (context, 0, time);
4184 set_status_pending (context, context->suggested_action);
4185 gtk_drag_get_data (widget, context, target, time);
4192 hildon_calendar_drag_drop (GtkWidget *widget,
4193 GdkDragContext *context,
4200 target = gtk_drag_dest_find_target (widget, context, NULL);
4201 if (target != GDK_NONE)
4203 gtk_drag_get_data (widget, context,
4213 hildon_calendar_drag_data_received (GtkWidget *widget,
4214 GdkDragContext *context,
4217 GtkSelectionData *selection_data,
4221 HildonCalendar *calendar = HILDON_CALENDAR (widget);
4222 guint day, month, year;
4225 GdkDragAction suggested_action;
4227 suggested_action = get_status_pending (context);
4229 if (suggested_action)
4231 set_status_pending (context, 0);
4233 /* We are getting this data due to a request in drag_motion,
4234 * rather than due to a request in drag_drop, so we are just
4235 * supposed to call drag_status, not actually paste in the
4238 str = (gchar *) gtk_selection_data_get_text (selection_data);
4241 date = g_date_new ();
4242 g_date_set_parse (date, str);
4243 if (!g_date_valid (date))
4244 suggested_action = 0;
4249 suggested_action = 0;
4251 gdk_drag_status (context, suggested_action, time);
4256 date = g_date_new ();
4257 str = (gchar *) gtk_selection_data_get_text (selection_data);
4260 g_date_set_parse (date, str);
4264 if (!g_date_valid (date))
4266 g_warning ("Received invalid date data\n");
4268 gtk_drag_finish (context, FALSE, FALSE, time);
4272 day = g_date_get_day (date);
4273 month = g_date_get_month (date);
4274 year = g_date_get_year (date);
4277 gtk_drag_finish (context, TRUE, FALSE, time);
4280 g_object_freeze_notify (G_OBJECT (calendar));
4281 if (!(calendar->display_flags & HILDON_CALENDAR_NO_MONTH_CHANGE)
4282 && (calendar->display_flags & HILDON_CALENDAR_SHOW_HEADING))
4283 hildon_calendar_select_month (calendar, month - 1, year);
4284 hildon_calendar_select_day (calendar, day);
4285 g_object_thaw_notify (G_OBJECT (calendar));
4288 /* This function return TRUE if we should mark date and FALSE
4292 hildon_calendar_check_current_date (HildonCalendar *calendar,
4296 HildonCalendarPrivate *private_data;
4298 private_data = HILDON_CALENDAR_GET_PRIVATE (calendar);
4300 if (calendar->month == private_data->current_month &&
4301 calendar->year == private_data->current_year)
4303 gtk_paint_box( GTK_WIDGET (calendar)->style,
4304 private_data->main_win,
4306 GTK_SHADOW_NONE, NULL,
4307 GTK_WIDGET (calendar), "current-day",
4314 #define __HILDON_CALENDAR_C__