Pileus Git - ~andy/gtk/blob - gtk/gtkcalendar.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GTK Calendar Widget
   5  * Copyright (C) 1998 Cesar Miquel, Shawn T. Amundson and Mattias Groenlund
   6  *
   7  * lib_date routines
   8  * Copyright (c) 1995, 1996, 1997, 1998 by Steffen Beyer
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library. If not, see <http://www.gnu.org/licenses/>.Free
  22  */
  23
  24 /*
  25  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  26  * file for a list of people on the GTK+ Team.  See the ChangeLog
  27  * files for a list of changes.  These files are distributed with
  28  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  29  */
  30
  31 /**
  32  * SECTION:gtkcalendar
  33  * @Short_description: Displays a calendar and allows the user to select a date
  34  * @Title: GtkCalendar
  35  *
  36  * #GtkCalendar is a widget that displays a Gregorian calendar, one month
  37  * at a time. It can be created with gtk_calendar_new().
  38  *
  39  * The month and year currently displayed can be altered with
  40  * gtk_calendar_select_month(). The exact day can be selected from the
  41  * displayed month using gtk_calendar_select_day().
  42  *
  43  * To place a visual marker on a particular day, use gtk_calendar_mark_day()
  44  * and to remove the marker, gtk_calendar_unmark_day(). Alternative, all
  45  * marks can be cleared with gtk_calendar_clear_marks().
  46  *
  47  * The way in which the calendar itself is displayed can be altered using
  48  * gtk_calendar_set_display_options().
  49  *
  50  * The selected date can be retrieved from a #GtkCalendar using
  51  * gtk_calendar_get_date().
  52  *
  53  * Users should be aware that, although the Gregorian calendar is the legal
  54  * calendar in most countries, it was adopted progressively between 1582 and
  55  * 1929. Display before these dates is likely to be historically incorrect.
  56  */
  57
  58 #include "config.h"
  59
  60 #ifdef HAVE_SYS_TIME_H
  61 #include <sys/time.h>
  62 #endif
  63 #ifdef HAVE__NL_TIME_FIRST_WEEKDAY
  64 #include <langinfo.h>
  65 #endif
  66 #include <string.h>
  67 #include <stdlib.h>
  68 #include <time.h>
  69
  70 #include <glib.h>
  71
  72 #ifdef G_OS_WIN32
  73 #include <windows.h>
  74 #endif
  75
  76 #include "gtkcalendar.h"
  77 #include "gtkdnd.h"
  78 #include "gtkintl.h"
  79 #include "gtkmain.h"
  80 #include "gtkmarshalers.h"
  81 #include "gtktooltip.h"
  82 #include "gtkprivate.h"
  83
  84 /***************************************************************************/
  85 /* The following date routines are taken from the lib_date package.
  86  * They have been minimally edited to avoid conflict with types defined
  87  * in win32 headers.
  88  */
  89
  90 static const guint month_length[2][13] =
  91 {
  92   { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  93   { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  94 };
  95
  96 static const guint days_in_months[2][14] =
  97 {
  98   { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
  99   { 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
 100 };
 101
 102 static glong  calc_days(guint year, guint mm, guint dd);
 103 static guint  day_of_week(guint year, guint mm, guint dd);
 104 static glong  dates_difference(guint year1, guint mm1, guint dd1,
 105                                guint year2, guint mm2, guint dd2);
 106 static guint  weeks_in_year(guint year);
 107
 108 static gboolean
 109 leap (guint year)
 110 {
 111   return((((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0));
 112 }
 113
 114 static guint
 115 day_of_week (guint year, guint mm, guint dd)
 116 {
 117   glong  days;
 118
 119   days = calc_days(year, mm, dd);
 120   if (days > 0L)
 121     {
 122       days--;
 123       days %= 7L;
 124       days++;
 125     }
 126   return( (guint) days );
 127 }
 128
 129 static guint weeks_in_year(guint year)
 130 {
 131   return(52 + ((day_of_week(year,1,1)==4) || (day_of_week(year,12,31)==4)));
 132 }
 133
 134 static gboolean
 135 check_date(guint year, guint mm, guint dd)
 136 {
 137   if (year < 1) return FALSE;
 138   if ((mm < 1) || (mm > 12)) return FALSE;
 139   if ((dd < 1) || (dd > month_length[leap(year)][mm])) return FALSE;
 140   return TRUE;
 141 }
 142
 143 static guint
 144 week_number(guint year, guint mm, guint dd)
 145 {
 146   guint first;
 147
 148   first = day_of_week(year,1,1) - 1;
 149   return( (guint) ( (dates_difference(year,1,1, year,mm,dd) + first) / 7L ) +
 150           (first < 4) );
 151 }
 152
 153 static glong
 154 year_to_days(guint year)
 155 {
 156   return( year * 365L + (year / 4) - (year / 100) + (year / 400) );
 157 }
 158
 159
 160 static glong
 161 calc_days(guint year, guint mm, guint dd)
 162 {
 163   gboolean lp;
 164
 165   if (year < 1) return(0L);
 166   if ((mm < 1) || (mm > 12)) return(0L);
 167   if ((dd < 1) || (dd > month_length[(lp = leap(year))][mm])) return(0L);
 168   return( year_to_days(--year) + days_in_months[lp][mm] + dd );
 169 }
 170
 171 static gboolean
 172 week_of_year(guint *week, guint *year, guint mm, guint dd)
 173 {
 174   if (check_date(*year,mm,dd))
 175     {
 176       *week = week_number(*year,mm,dd);
 177       if (*week == 0)
 178         *week = weeks_in_year(--(*year));
 179       else if (*week > weeks_in_year(*year))
 180         {
 181           *week = 1;
 182           (*year)++;
 183         }
 184       return TRUE;
 185     }
 186   return FALSE;
 187 }
 188
 189 static glong
 190 dates_difference(guint year1, guint mm1, guint dd1,
 191                  guint year2, guint mm2, guint dd2)
 192 {
 193   return( calc_days(year2, mm2, dd2) - calc_days(year1, mm1, dd1) );
 194 }
 195
 196 /*** END OF lib_date routines ********************************************/
 197
 198 /* Spacing around day/week headers and main area, inside those windows */
 199 #define CALENDAR_MARGIN          0
 200
 201 #define DAY_XSEP                 0 /* not really good for small calendar */
 202 #define DAY_YSEP                 0 /* not really good for small calendar */
 203
 204 #define SCROLL_DELAY_FACTOR      5
 205
 206 enum {
 207   ARROW_YEAR_LEFT,
 208   ARROW_YEAR_RIGHT,
 209   ARROW_MONTH_LEFT,
 210   ARROW_MONTH_RIGHT
 211 };
 212
 213 enum {
 214   MONTH_PREV,
 215   MONTH_CURRENT,
 216   MONTH_NEXT
 217 };
 218
 219 enum {
 220   MONTH_CHANGED_SIGNAL,
 221   DAY_SELECTED_SIGNAL,
 222   DAY_SELECTED_DOUBLE_CLICK_SIGNAL,
 223   PREV_MONTH_SIGNAL,
 224   NEXT_MONTH_SIGNAL,
 225   PREV_YEAR_SIGNAL,
 226   NEXT_YEAR_SIGNAL,
 227   LAST_SIGNAL
 228 };
 229
 230 enum
 231 {
 232   PROP_0,
 233   PROP_YEAR,
 234   PROP_MONTH,
 235   PROP_DAY,
 236   PROP_SHOW_HEADING,
 237   PROP_SHOW_DAY_NAMES,
 238   PROP_NO_MONTH_CHANGE,
 239   PROP_SHOW_WEEK_NUMBERS,
 240   PROP_SHOW_DETAILS,
 241   PROP_DETAIL_WIDTH_CHARS,
 242   PROP_DETAIL_HEIGHT_ROWS
 243 };
 244
 245 static guint gtk_calendar_signals[LAST_SIGNAL] = { 0 };
 246
 247 struct _GtkCalendarPrivate
 248 {
 249   GtkCalendarDisplayOptions display_flags;
 250
 251   GdkWindow *main_win;
 252   GdkWindow *arrow_win[4];
 253
 254   gchar grow_space [32];
 255
 256   gint  month;
 257   gint  year;
 258   gint  selected_day;
 259
 260   gint  day_month[6][7];
 261   gint  day[6][7];
 262
 263   gint  num_marked_dates;
 264   gint  marked_date[31];
 265
 266   gint  focus_row;
 267   gint  focus_col;
 268
 269   guint header_h;
 270   guint day_name_h;
 271   guint main_h;
 272
 273   guint arrow_prelight : 4;
 274   guint arrow_width;
 275   guint max_month_width;
 276   guint max_year_width;
 277
 278   guint day_width;
 279   guint week_width;
 280
 281   guint min_day_width;
 282   guint max_day_char_width;
 283   guint max_day_char_ascent;
 284   guint max_day_char_descent;
 285   guint max_label_char_ascent;
 286   guint max_label_char_descent;
 287   guint max_week_char_width;
 288
 289   /* flags */
 290   guint year_before : 1;
 291
 292   guint need_timer  : 1;
 293
 294   guint in_drag : 1;
 295   guint drag_highlight : 1;
 296
 297   guint32 timer;
 298   gint click_child;
 299
 300   gint week_start;
 301
 302   gint drag_start_x;
 303   gint drag_start_y;
 304
 305   /* Optional callback, used to display extra information for each day. */
 306   GtkCalendarDetailFunc detail_func;
 307   gpointer              detail_func_user_data;
 308   GDestroyNotify        detail_func_destroy;
 309
 310   /* Size requistion for details provided by the hook. */
 311   gint detail_height_rows;
 312   gint detail_width_chars;
 313   gint detail_overflow[6];
 314 };
 315
 316 #define GTK_CALENDAR_GET_PRIVATE(widget)  (GTK_CALENDAR (widget)->priv)
 317
 318 static void gtk_calendar_finalize     (GObject      *calendar);
 319 static void gtk_calendar_destroy      (GtkWidget    *widget);
 320 static void gtk_calendar_set_property (GObject      *object,
 321                                        guint         prop_id,
 322                                        const GValue *value,
 323                                        GParamSpec   *pspec);
 324 static void gtk_calendar_get_property (GObject      *object,
 325                                        guint         prop_id,
 326                                        GValue       *value,
 327                                        GParamSpec   *pspec);
 328
 329 static void     gtk_calendar_realize        (GtkWidget        *widget);
 330 static void     gtk_calendar_unrealize      (GtkWidget        *widget);
 331 static void     gtk_calendar_map            (GtkWidget        *widget);
 332 static void     gtk_calendar_unmap          (GtkWidget        *widget);
 333 static void     gtk_calendar_get_preferred_width  (GtkWidget   *widget,
 334                                                    gint        *minimum,
 335                                                    gint        *natural);
 336 static void     gtk_calendar_get_preferred_height (GtkWidget   *widget,
 337                                                    gint        *minimum,
 338                                                    gint        *natural);
 339 static void     gtk_calendar_size_allocate  (GtkWidget        *widget,
 340                                              GtkAllocation    *allocation);
 341 static gboolean gtk_calendar_draw           (GtkWidget        *widget,
 342                                              cairo_t          *cr);
 343 static gboolean gtk_calendar_button_press   (GtkWidget        *widget,
 344                                              GdkEventButton   *event);
 345 static gboolean gtk_calendar_button_release (GtkWidget        *widget,
 346                                              GdkEventButton   *event);
 347 static gboolean gtk_calendar_motion_notify  (GtkWidget        *widget,
 348                                              GdkEventMotion   *event);
 349 static gboolean gtk_calendar_enter_notify   (GtkWidget        *widget,
 350                                              GdkEventCrossing *event);
 351 static gboolean gtk_calendar_leave_notify   (GtkWidget        *widget,
 352                                              GdkEventCrossing *event);
 353 static gboolean gtk_calendar_scroll         (GtkWidget        *widget,
 354                                              GdkEventScroll   *event);
 355 static gboolean gtk_calendar_key_press      (GtkWidget        *widget,
 356                                              GdkEventKey      *event);
 357 static gboolean gtk_calendar_focus_out      (GtkWidget        *widget,
 358                                              GdkEventFocus    *event);
 359 static void     gtk_calendar_grab_notify    (GtkWidget        *widget,
 360                                              gboolean          was_grabbed);
 361 static void     gtk_calendar_state_flags_changed  (GtkWidget     *widget,
 362                                                    GtkStateFlags  previous_state);
 363 static gboolean gtk_calendar_query_tooltip  (GtkWidget        *widget,
 364                                              gint              x,
 365                                              gint              y,
 366                                              gboolean          keyboard_mode,
 367                                              GtkTooltip       *tooltip);
 368
 369 static void     gtk_calendar_drag_data_get      (GtkWidget        *widget,
 370                                                  GdkDragContext   *context,
 371                                                  GtkSelectionData *selection_data,
 372                                                  guint             info,
 373                                                  guint             time);
 374 static void     gtk_calendar_drag_data_received (GtkWidget        *widget,
 375                                                  GdkDragContext   *context,
 376                                                  gint              x,
 377                                                  gint              y,
 378                                                  GtkSelectionData *selection_data,
 379                                                  guint             info,
 380                                                  guint             time);
 381 static gboolean gtk_calendar_drag_motion        (GtkWidget        *widget,
 382                                                  GdkDragContext   *context,
 383                                                  gint              x,
 384                                                  gint              y,
 385                                                  guint             time);
 386 static void     gtk_calendar_drag_leave         (GtkWidget        *widget,
 387                                                  GdkDragContext   *context,
 388                                                  guint             time);
 389 static gboolean gtk_calendar_drag_drop          (GtkWidget        *widget,
 390                                                  GdkDragContext   *context,
 391                                                  gint              x,
 392                                                  gint              y,
 393                                                  guint             time);
 394
 395
 396 static void calendar_start_spinning (GtkCalendar *calendar,
 397                                      gint         click_child);
 398 static void calendar_stop_spinning  (GtkCalendar *calendar);
 399
 400 static void calendar_invalidate_day     (GtkCalendar *widget,
 401                                          gint       row,
 402                                          gint       col);
 403 static void calendar_invalidate_day_num (GtkCalendar *widget,
 404                                          gint       day);
 405 static void calendar_invalidate_arrow   (GtkCalendar *widget,
 406                                          guint      arrow);
 407
 408 static void calendar_compute_days      (GtkCalendar *calendar);
 409 static gint calendar_get_xsep          (GtkCalendar *calendar);
 410 static gint calendar_get_ysep          (GtkCalendar *calendar);
 411 static gint calendar_get_inner_border  (GtkCalendar *calendar);
 412
 413 static char    *default_abbreviated_dayname[7];
 414 static char    *default_monthname[12];
 415
 416 G_DEFINE_TYPE (GtkCalendar, gtk_calendar, GTK_TYPE_WIDGET)
 417
 418 static void
 419 gtk_calendar_class_init (GtkCalendarClass *class)
 420 {
 421   GObjectClass   *gobject_class;
 422   GtkWidgetClass *widget_class;
 423
 424   gobject_class = (GObjectClass*)  class;
 425   widget_class = (GtkWidgetClass*) class;
 426
 427   gobject_class->set_property = gtk_calendar_set_property;
 428   gobject_class->get_property = gtk_calendar_get_property;
 429   gobject_class->finalize = gtk_calendar_finalize;
 430
 431   widget_class->destroy = gtk_calendar_destroy;
 432   widget_class->realize = gtk_calendar_realize;
 433   widget_class->unrealize = gtk_calendar_unrealize;
 434   widget_class->map = gtk_calendar_map;
 435   widget_class->unmap = gtk_calendar_unmap;
 436   widget_class->draw = gtk_calendar_draw;
 437   widget_class->get_preferred_width = gtk_calendar_get_preferred_width;
 438   widget_class->get_preferred_height = gtk_calendar_get_preferred_height;
 439   widget_class->size_allocate = gtk_calendar_size_allocate;
 440   widget_class->button_press_event = gtk_calendar_button_press;
 441   widget_class->button_release_event = gtk_calendar_button_release;
 442   widget_class->motion_notify_event = gtk_calendar_motion_notify;
 443   widget_class->enter_notify_event = gtk_calendar_enter_notify;
 444   widget_class->leave_notify_event = gtk_calendar_leave_notify;
 445   widget_class->key_press_event = gtk_calendar_key_press;
 446   widget_class->scroll_event = gtk_calendar_scroll;
 447   widget_class->state_flags_changed = gtk_calendar_state_flags_changed;
 448   widget_class->grab_notify = gtk_calendar_grab_notify;
 449   widget_class->focus_out_event = gtk_calendar_focus_out;
 450   widget_class->query_tooltip = gtk_calendar_query_tooltip;
 451
 452   widget_class->drag_data_get = gtk_calendar_drag_data_get;
 453   widget_class->drag_motion = gtk_calendar_drag_motion;
 454   widget_class->drag_leave = gtk_calendar_drag_leave;
 455   widget_class->drag_drop = gtk_calendar_drag_drop;
 456   widget_class->drag_data_received = gtk_calendar_drag_data_received;
 457
 458   gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_CALENDAR);
 459
 460   /**
 461    * GtkCalendar:year:
 462    *
 463    * The selected year.
 464    * This property gets initially set to the current year.
 465    */
 466   g_object_class_install_property (gobject_class,
 467                                    PROP_YEAR,
 468                                    g_param_spec_int ("year",
 469                                                      P_("Year"),
 470                                                      P_("The selected year"),
 471                                                      0, G_MAXINT >> 9, 0,
 472                                                      GTK_PARAM_READWRITE));
 473
 474   /**
 475    * GtkCalendar:month:
 476    *
 477    * The selected month (as a number between 0 and 11).
 478    * This property gets initially set to the current month.
 479    */
 480   g_object_class_install_property (gobject_class,
 481                                    PROP_MONTH,
 482                                    g_param_spec_int ("month",
 483                                                      P_("Month"),
 484                                                      P_("The selected month (as a number between 0 and 11)"),
 485                                                      0, 11, 0,
 486                                                      GTK_PARAM_READWRITE));
 487
 488   /**
 489    * GtkCalendar:day:
 490    *
 491    * The selected day (as a number between 1 and 31, or 0
 492    * to unselect the currently selected day).
 493    * This property gets initially set to the current day.
 494    */
 495   g_object_class_install_property (gobject_class,
 496                                    PROP_DAY,
 497                                    g_param_spec_int ("day",
 498                                                      P_("Day"),
 499                                                      P_("The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day)"),
 500                                                      0, 31, 0,
 501                                                      GTK_PARAM_READWRITE));
 502
 503 /**
 504  * GtkCalendar:show-heading:
 505  *
 506  * Determines whether a heading is displayed.
 507  *
 508  * Since: 2.4
 509  */
 510   g_object_class_install_property (gobject_class,
 511                                    PROP_SHOW_HEADING,
 512                                    g_param_spec_boolean ("show-heading",
 513                                                          P_("Show Heading"),
 514                                                          P_("If TRUE, a heading is displayed"),
 515                                                          TRUE,
 516                                                          GTK_PARAM_READWRITE));
 517
 518 /**
 519  * GtkCalendar:show-day-names:
 520  *
 521  * Determines whether day names are displayed.
 522  *
 523  * Since: 2.4
 524  */
 525   g_object_class_install_property (gobject_class,
 526                                    PROP_SHOW_DAY_NAMES,
 527                                    g_param_spec_boolean ("show-day-names",
 528                                                          P_("Show Day Names"),
 529                                                          P_("If TRUE, day names are displayed"),
 530                                                          TRUE,
 531                                                          GTK_PARAM_READWRITE));
 532 /**
 533  * GtkCalendar:no-month-change:
 534  *
 535  * Determines whether the selected month can be changed.
 536  *
 537  * Since: 2.4
 538  */
 539   g_object_class_install_property (gobject_class,
 540                                    PROP_NO_MONTH_CHANGE,
 541                                    g_param_spec_boolean ("no-month-change",
 542                                                          P_("No Month Change"),
 543                                                          P_("If TRUE, the selected month cannot be changed"),
 544                                                          FALSE,
 545                                                          GTK_PARAM_READWRITE));
 546
 547 /**
 548  * GtkCalendar:show-week-numbers:
 549  *
 550  * Determines whether week numbers are displayed.
 551  *
 552  * Since: 2.4
 553  */
 554   g_object_class_install_property (gobject_class,
 555                                    PROP_SHOW_WEEK_NUMBERS,
 556                                    g_param_spec_boolean ("show-week-numbers",
 557                                                          P_("Show Week Numbers"),
 558                                                          P_("If TRUE, week numbers are displayed"),
 559                                                          FALSE,
 560                                                          GTK_PARAM_READWRITE));
 561
 562 /**
 563  * GtkCalendar:detail-width-chars:
 564  *
 565  * Width of a detail cell, in characters.
 566  * A value of 0 allows any width. See gtk_calendar_set_detail_func().
 567  *
 568  * Since: 2.14
 569  */
 570   g_object_class_install_property (gobject_class,
 571                                    PROP_DETAIL_WIDTH_CHARS,
 572                                    g_param_spec_int ("detail-width-chars",
 573                                                      P_("Details Width"),
 574                                                      P_("Details width in characters"),
 575                                                      0, 127, 0,
 576                                                      GTK_PARAM_READWRITE));
 577
 578 /**
 579  * GtkCalendar:detail-height-rows:
 580  *
 581  * Height of a detail cell, in rows.
 582  * A value of 0 allows any width. See gtk_calendar_set_detail_func().
 583  *
 584  * Since: 2.14
 585  */
 586   g_object_class_install_property (gobject_class,
 587                                    PROP_DETAIL_HEIGHT_ROWS,
 588                                    g_param_spec_int ("detail-height-rows",
 589                                                      P_("Details Height"),
 590                                                      P_("Details height in rows"),
 591                                                      0, 127, 0,
 592                                                      GTK_PARAM_READWRITE));
 593
 594 /**
 595  * GtkCalendar:show-details:
 596  *
 597  * Determines whether details are shown directly in the widget, or if they are
 598  * available only as tooltip. When this property is set days with details are
 599  * marked.
 600  *
 601  * Since: 2.14
 602  */
 603   g_object_class_install_property (gobject_class,
 604                                    PROP_SHOW_DETAILS,
 605                                    g_param_spec_boolean ("show-details",
 606                                                          P_("Show Details"),
 607                                                          P_("If TRUE, details are shown"),
 608                                                          TRUE,
 609                                                          GTK_PARAM_READWRITE));
 610
 611
 612   /**
 613    * GtkCalendar:inner-border:
 614    *
 615    * The spacing around the day/week headers and main area.
 616    */
 617   gtk_widget_class_install_style_property (widget_class,
 618                                            g_param_spec_int ("inner-border",
 619                                                              P_("Inner border"),
 620                                                              P_("Inner border space"),
 621                                                              0, G_MAXINT, 4,
 622                                                              GTK_PARAM_READABLE));
 623
 624   /**
 625    * GtkCalndar:vertical-separation:
 626    *
 627    * Separation between day headers and main area.
 628    */
 629   gtk_widget_class_install_style_property (widget_class,
 630                                            g_param_spec_int ("vertical-separation",
 631                                                              P_("Vertical separation"),
 632                                                              P_("Space between day headers and main area"),
 633                                                              0, G_MAXINT, 4,
 634                                                              GTK_PARAM_READABLE));
 635
 636   /**
 637    * GtkCalendar:horizontal-separation:
 638    *
 639    * Separation between week headers and main area.
 640    */
 641   gtk_widget_class_install_style_property (widget_class,
 642                                            g_param_spec_int ("horizontal-separation",
 643                                                              P_("Horizontal separation"),
 644                                                              P_("Space between week headers and main area"),
 645                                                              0, G_MAXINT, 4,
 646                                                              GTK_PARAM_READABLE));
 647
 648   /**
 649    * GtkCalendar::month-changed:
 650    * @calendar: the object which received the signal.
 651    *
 652    * Emitted when the user clicks a button to change the selected month on a
 653    * calendar.
 654    */
 655   gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =
 656     g_signal_new (I_("month-changed"),
 657                   G_OBJECT_CLASS_TYPE (gobject_class),
 658                   G_SIGNAL_RUN_FIRST,
 659                   G_STRUCT_OFFSET (GtkCalendarClass, month_changed),
 660                   NULL, NULL,
 661                   _gtk_marshal_VOID__VOID,
 662                   G_TYPE_NONE, 0);
 663
 664   /**
 665    * GtkCalendar::day-selected:
 666    * @calendar: the object which received the signal.
 667    *
 668    * Emitted when the user selects a day.
 669    */
 670   gtk_calendar_signals[DAY_SELECTED_SIGNAL] =
 671     g_signal_new (I_("day-selected"),
 672                   G_OBJECT_CLASS_TYPE (gobject_class),
 673                   G_SIGNAL_RUN_FIRST,
 674                   G_STRUCT_OFFSET (GtkCalendarClass, day_selected),
 675                   NULL, NULL,
 676                   _gtk_marshal_VOID__VOID,
 677                   G_TYPE_NONE, 0);
 678
 679   /**
 680    * GtkCalendar::day-selected-double-click:
 681    * @calendar: the object which received the signal.
 682    *
 683    * Emitted when the user double-clicks a day.
 684    */
 685   gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
 686     g_signal_new (I_("day-selected-double-click"),
 687                   G_OBJECT_CLASS_TYPE (gobject_class),
 688                   G_SIGNAL_RUN_FIRST,
 689                   G_STRUCT_OFFSET (GtkCalendarClass, day_selected_double_click),
 690                   NULL, NULL,
 691                   _gtk_marshal_VOID__VOID,
 692                   G_TYPE_NONE, 0);
 693
 694   /**
 695    * GtkCalendar::prev-month:
 696    * @calendar: the object which received the signal.
 697    *
 698    * Emitted when the user switched to the previous month.
 699    */
 700   gtk_calendar_signals[PREV_MONTH_SIGNAL] =
 701     g_signal_new (I_("prev-month"),
 702                   G_OBJECT_CLASS_TYPE (gobject_class),
 703                   G_SIGNAL_RUN_FIRST,
 704                   G_STRUCT_OFFSET (GtkCalendarClass, prev_month),
 705                   NULL, NULL,
 706                   _gtk_marshal_VOID__VOID,
 707                   G_TYPE_NONE, 0);
 708
 709   /**
 710    * GtkCalendar::next-month:
 711    * @calendar: the object which received the signal.
 712    *
 713    * Emitted when the user switched to the next month.
 714    */
 715   gtk_calendar_signals[NEXT_MONTH_SIGNAL] =
 716     g_signal_new (I_("next-month"),
 717                   G_OBJECT_CLASS_TYPE (gobject_class),
 718                   G_SIGNAL_RUN_FIRST,
 719                   G_STRUCT_OFFSET (GtkCalendarClass, next_month),
 720                   NULL, NULL,
 721                   _gtk_marshal_VOID__VOID,
 722                   G_TYPE_NONE, 0);
 723
 724   /**
 725    * GtkCalendar::prev-year:
 726    * @calendar: the object which received the signal.
 727    *
 728    * Emitted when user switched to the previous year.
 729    */
 730   gtk_calendar_signals[PREV_YEAR_SIGNAL] =
 731     g_signal_new (I_("prev-year"),
 732                   G_OBJECT_CLASS_TYPE (gobject_class),
 733                   G_SIGNAL_RUN_FIRST,
 734                   G_STRUCT_OFFSET (GtkCalendarClass, prev_year),
 735                   NULL, NULL,
 736                   _gtk_marshal_VOID__VOID,
 737                   G_TYPE_NONE, 0);
 738
 739   /**
 740    * GtkCalendar::next-year:
 741    * @calendar: the object which received the signal.
 742    *
 743    * Emitted when user switched to the next year.
 744    */
 745   gtk_calendar_signals[NEXT_YEAR_SIGNAL] =
 746     g_signal_new (I_("next-year"),
 747                   G_OBJECT_CLASS_TYPE (gobject_class),
 748                   G_SIGNAL_RUN_FIRST,
 749                   G_STRUCT_OFFSET (GtkCalendarClass, next_year),
 750                   NULL, NULL,
 751                   _gtk_marshal_VOID__VOID,
 752                   G_TYPE_NONE, 0);
 753
 754   g_type_class_add_private (gobject_class, sizeof (GtkCalendarPrivate));
 755 }
 756
 757 static void
 758 gtk_calendar_init (GtkCalendar *calendar)
 759 {
 760   GtkWidget *widget = GTK_WIDGET (calendar);
 761   time_t secs;
 762   struct tm *tm;
 763   gint i;
 764 #ifdef G_OS_WIN32
 765   wchar_t wbuffer[100];
 766 #else
 767   char buffer[255];
 768   time_t tmp_time;
 769 #endif
 770   GtkCalendarPrivate *priv;
 771   gchar *year_before;
 772 #ifdef HAVE__NL_TIME_FIRST_WEEKDAY
 773   union { unsigned int word; char *string; } langinfo;
 774   gint week_1stday = 0;
 775   gint first_weekday = 1;
 776   guint week_origin;
 777 #else
 778   gchar *week_start;
 779 #endif
 780
 781   priv = calendar->priv = G_TYPE_INSTANCE_GET_PRIVATE (calendar,
 782                                                        GTK_TYPE_CALENDAR,
 783                                                        GtkCalendarPrivate);
 784
 785   gtk_widget_set_can_focus (widget, TRUE);
 786   gtk_widget_set_has_window (widget, FALSE);
 787
 788   if (!default_abbreviated_dayname[0])
 789     for (i=0; i<7; i++)
 790       {
 791 #ifndef G_OS_WIN32
 792         tmp_time= (i+3)*86400;
 793         strftime ( buffer, sizeof (buffer), "%a", gmtime (&tmp_time));
 794         default_abbreviated_dayname[i] = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);
 795 #else
 796         if (!GetLocaleInfoW (GetThreadLocale (), LOCALE_SABBREVDAYNAME1 + (i+6)%7,
 797                              wbuffer, G_N_ELEMENTS (wbuffer)))
 798           default_abbreviated_dayname[i] = g_strdup_printf ("(%d)", i);
 799         else
 800           default_abbreviated_dayname[i] = g_utf16_to_utf8 (wbuffer, -1, NULL, NULL, NULL);
 801 #endif
 802       }
 803
 804   if (!default_monthname[0])
 805     for (i=0; i<12; i++)
 806       {
 807 #ifndef G_OS_WIN32
 808         tmp_time=i*2764800;
 809         strftime ( buffer, sizeof (buffer), "%B", gmtime (&tmp_time));
 810         default_monthname[i] = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);
 811 #else
 812         if (!GetLocaleInfoW (GetThreadLocale (), LOCALE_SMONTHNAME1 + i,
 813                              wbuffer, G_N_ELEMENTS (wbuffer)))
 814           default_monthname[i] = g_strdup_printf ("(%d)", i);
 815         else
 816           default_monthname[i] = g_utf16_to_utf8 (wbuffer, -1, NULL, NULL, NULL);
 817 #endif
 818       }
 819
 820   /* Set defaults */
 821   secs = time (NULL);
 822   tm = localtime (&secs);
 823   priv->month = tm->tm_mon;
 824   priv->year  = 1900 + tm->tm_year;
 825
 826   for (i=0;i<31;i++)
 827     priv->marked_date[i] = FALSE;
 828   priv->num_marked_dates = 0;
 829   priv->selected_day = tm->tm_mday;
 830
 831   priv->display_flags = (GTK_CALENDAR_SHOW_HEADING |
 832                              GTK_CALENDAR_SHOW_DAY_NAMES |
 833                              GTK_CALENDAR_SHOW_DETAILS);
 834
 835   priv->focus_row = -1;
 836   priv->focus_col = -1;
 837
 838   priv->max_year_width = 0;
 839   priv->max_month_width = 0;
 840   priv->max_day_char_width = 0;
 841   priv->max_week_char_width = 0;
 842
 843   priv->max_day_char_ascent = 0;
 844   priv->max_day_char_descent = 0;
 845   priv->max_label_char_ascent = 0;
 846   priv->max_label_char_descent = 0;
 847
 848   priv->arrow_width = 10;
 849
 850   priv->need_timer = 0;
 851   priv->timer = 0;
 852   priv->click_child = -1;
 853
 854   priv->in_drag = 0;
 855   priv->drag_highlight = 0;
 856
 857   gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_COPY);
 858   gtk_drag_dest_add_text_targets (widget);
 859
 860   priv->year_before = 0;
 861
 862   /* Translate to calendar:YM if you want years to be displayed
 863    * before months; otherwise translate to calendar:MY.
 864    * Do *not* translate it to anything else, if it
 865    * it isn't calendar:YM or calendar:MY it will not work.
 866    *
 867    * Note that the ordering described here is logical order, which is
 868    * further influenced by BIDI ordering. Thus, if you have a default
 869    * text direction of RTL and specify "calendar:YM", then the year
 870    * will appear to the right of the month.
 871    */
 872   year_before = _("calendar:MY");
 873   if (strcmp (year_before, "calendar:YM") == 0)
 874     priv->year_before = 1;
 875   else if (strcmp (year_before, "calendar:MY") != 0)
 876     g_warning ("Whoever translated calendar:MY did so wrongly.\n");
 877
 878 #ifdef G_OS_WIN32
 879   priv->week_start = 0;
 880   week_start = NULL;
 881
 882   if (GetLocaleInfoW (GetThreadLocale (), LOCALE_IFIRSTDAYOFWEEK,
 883                       wbuffer, G_N_ELEMENTS (wbuffer)))
 884     week_start = g_utf16_to_utf8 (wbuffer, -1, NULL, NULL, NULL);
 885
 886   if (week_start != NULL)
 887     {
 888       priv->week_start = (week_start[0] - '0' + 1) % 7;
 889       g_free(week_start);
 890     }
 891 #else
 892 #ifdef HAVE__NL_TIME_FIRST_WEEKDAY
 893   langinfo.string = nl_langinfo (_NL_TIME_FIRST_WEEKDAY);
 894   first_weekday = langinfo.string[0];
 895   langinfo.string = nl_langinfo (_NL_TIME_WEEK_1STDAY);
 896   week_origin = langinfo.word;
 897   if (week_origin == 19971130) /* Sunday */
 898     week_1stday = 0;
 899   else if (week_origin == 19971201) /* Monday */
 900     week_1stday = 1;
 901   else
 902     g_warning ("Unknown value of _NL_TIME_WEEK_1STDAY.\n");
 903
 904   priv->week_start = (week_1stday + first_weekday - 1) % 7;
 905 #else
 906   /* Translate to calendar:week_start:0 if you want Sunday to be the
 907    * first day of the week to calendar:week_start:1 if you want Monday
 908    * to be the first day of the week, and so on.
 909    */
 910   week_start = _("calendar:week_start:0");
 911
 912   if (strncmp (week_start, "calendar:week_start:", 20) == 0)
 913     priv->week_start = *(week_start + 20) - '0';
 914   else
 915     priv->week_start = -1;
 916
 917   if (priv->week_start < 0 || priv->week_start > 6)
 918     {
 919       g_warning ("Whoever translated calendar:week_start:0 did so wrongly.\n");
 920       priv->week_start = 0;
 921     }
 922 #endif
 923 #endif
 924
 925   calendar_compute_days (calendar);
 926 }
 927
 928 \f
 929 /****************************************
 930  *          Utility Functions           *
 931  ****************************************/
 932
 933 static void
 934 calendar_queue_refresh (GtkCalendar *calendar)
 935 {
 936   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
 937
 938   if (!(priv->detail_func) ||
 939       !(priv->display_flags & GTK_CALENDAR_SHOW_DETAILS) ||
 940        (priv->detail_width_chars && priv->detail_height_rows))
 941     gtk_widget_queue_draw (GTK_WIDGET (calendar));
 942   else
 943     gtk_widget_queue_resize (GTK_WIDGET (calendar));
 944 }
 945
 946 static void
 947 calendar_set_month_next (GtkCalendar *calendar)
 948 {
 949   gint month_len;
 950   GtkCalendarPrivate *priv = calendar->priv;
 951
 952   if (priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
 953     return;
 954
 955   if (priv->month == 11)
 956     {
 957       priv->month = 0;
 958       priv->year++;
 959     }
 960   else
 961     priv->month++;
 962
 963   calendar_compute_days (calendar);
 964   g_signal_emit (calendar,
 965                  gtk_calendar_signals[NEXT_MONTH_SIGNAL],
 966                  0);
 967   g_signal_emit (calendar,
 968                  gtk_calendar_signals[MONTH_CHANGED_SIGNAL],
 969                  0);
 970
 971   month_len = month_length[leap (priv->year)][priv->month + 1];
 972
 973   if (month_len < priv->selected_day)
 974     {
 975       priv->selected_day = 0;
 976       gtk_calendar_select_day (calendar, month_len);
 977     }
 978   else
 979     gtk_calendar_select_day (calendar, priv->selected_day);
 980
 981   calendar_queue_refresh (calendar);
 982 }
 983
 984 static void
 985 calendar_set_year_prev (GtkCalendar *calendar)
 986 {
 987   GtkCalendarPrivate *priv = calendar->priv;
 988   gint month_len;
 989
 990   priv->year--;
 991   calendar_compute_days (calendar);
 992   g_signal_emit (calendar,
 993                  gtk_calendar_signals[PREV_YEAR_SIGNAL],
 994                  0);
 995   g_signal_emit (calendar,
 996                  gtk_calendar_signals[MONTH_CHANGED_SIGNAL],
 997                  0);
 998
 999   month_len = month_length[leap (priv->year)][priv->month + 1];
1000
1001   if (month_len < priv->selected_day)
1002     {
1003       priv->selected_day = 0;
1004       gtk_calendar_select_day (calendar, month_len);
1005     }
1006   else
1007     gtk_calendar_select_day (calendar, priv->selected_day);
1008
1009   calendar_queue_refresh (calendar);
1010 }
1011
1012 static void
1013 calendar_set_year_next (GtkCalendar *calendar)
1014 {
1015   GtkCalendarPrivate *priv = calendar->priv;
1016   gint month_len;
1017
1018   priv->year++;
1019   calendar_compute_days (calendar);
1020   g_signal_emit (calendar,
1021                  gtk_calendar_signals[NEXT_YEAR_SIGNAL],
1022                  0);
1023   g_signal_emit (calendar,
1024                  gtk_calendar_signals[MONTH_CHANGED_SIGNAL],
1025                  0);
1026
1027   month_len = month_length[leap (priv->year)][priv->month + 1];
1028
1029   if (month_len < priv->selected_day)
1030     {
1031       priv->selected_day = 0;
1032       gtk_calendar_select_day (calendar, month_len);
1033     }
1034   else
1035     gtk_calendar_select_day (calendar, priv->selected_day);
1036
1037   calendar_queue_refresh (calendar);
1038 }
1039
1040 static void
1041 calendar_compute_days (GtkCalendar *calendar)
1042 {
1043   GtkCalendarPrivate *priv = calendar->priv;
1044   gint month;
1045   gint year;
1046   gint ndays_in_month;
1047   gint ndays_in_prev_month;
1048   gint first_day;
1049   gint row;
1050   gint col;
1051   gint day;
1052
1053   year = priv->year;
1054   month = priv->month + 1;
1055
1056   ndays_in_month = month_length[leap (year)][month];
1057
1058   first_day = day_of_week (year, month, 1);
1059   first_day = (first_day + 7 - priv->week_start) % 7;
1060
1061   /* Compute days of previous month */
1062   if (month > 1)
1063     ndays_in_prev_month = month_length[leap (year)][month-1];
1064   else
1065     ndays_in_prev_month = month_length[leap (year)][12];
1066   day = ndays_in_prev_month - first_day + 1;
1067
1068   row = 0;
1069   if (first_day > 0)
1070     {
1071       for (col = 0; col < first_day; col++)
1072         {
1073           priv->day[row][col] = day;
1074           priv->day_month[row][col] = MONTH_PREV;
1075           day++;
1076         }
1077     }
1078
1079   /* Compute days of current month */
1080   col = first_day;
1081   for (day = 1; day <= ndays_in_month; day++)
1082     {
1083       priv->day[row][col] = day;
1084       priv->day_month[row][col] = MONTH_CURRENT;
1085
1086       col++;
1087       if (col == 7)
1088         {
1089           row++;
1090           col = 0;
1091         }
1092     }
1093
1094   /* Compute days of next month */
1095   day = 1;
1096   for (; row <= 5; row++)
1097     {
1098       for (; col <= 6; col++)
1099         {
1100           priv->day[row][col] = day;
1101           priv->day_month[row][col] = MONTH_NEXT;
1102           day++;
1103         }
1104       col = 0;
1105     }
1106 }
1107
1108 static void
1109 calendar_select_and_focus_day (GtkCalendar *calendar,
1110                                guint        day)
1111 {
1112   GtkCalendarPrivate *priv = calendar->priv;
1113   gint old_focus_row = priv->focus_row;
1114   gint old_focus_col = priv->focus_col;
1115   gint row;
1116   gint col;
1117
1118   for (row = 0; row < 6; row ++)
1119     for (col = 0; col < 7; col++)
1120       {
1121         if (priv->day_month[row][col] == MONTH_CURRENT
1122             && priv->day[row][col] == day)
1123           {
1124             priv->focus_row = row;
1125             priv->focus_col = col;
1126           }
1127       }
1128
1129   if (old_focus_row != -1 && old_focus_col != -1)
1130     calendar_invalidate_day (calendar, old_focus_row, old_focus_col);
1131
1132   gtk_calendar_select_day (calendar, day);
1133 }
1134
1135 \f
1136 /****************************************
1137  *     Layout computation utilities     *
1138  ****************************************/
1139
1140 static gint
1141 calendar_row_height (GtkCalendar *calendar)
1142 {
1143   GtkCalendarPrivate *priv = calendar->priv;
1144
1145   return (GTK_CALENDAR_GET_PRIVATE (calendar)->main_h - CALENDAR_MARGIN
1146           - ((priv->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
1147              ? calendar_get_ysep (calendar) : CALENDAR_MARGIN)) / 6;
1148 }
1149
1150
1151 /* calendar_left_x_for_column: returns the x coordinate
1152  * for the left of the column */
1153 static gint
1154 calendar_left_x_for_column (GtkCalendar *calendar,
1155                             gint         column)
1156 {
1157   GtkCalendarPrivate *priv = calendar->priv;
1158   gint width;
1159   gint x_left;
1160   gint week_width;
1161   gint calendar_xsep = calendar_get_xsep (calendar);
1162   GtkStyleContext *context;
1163   GtkStateFlags state;
1164   gint inner_border = calendar_get_inner_border (calendar);
1165   GtkBorder padding;
1166
1167   context = gtk_widget_get_style_context (GTK_WIDGET (calendar));
1168   state = gtk_widget_get_state_flags (GTK_WIDGET (calendar));
1169   gtk_style_context_get_padding (context, state, &padding);
1170
1171   week_width = priv->week_width + padding.left + inner_border;
1172
1173   if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
1174     {
1175       column = 6 - column;
1176       week_width = 0;
1177     }
1178
1179   width = GTK_CALENDAR_GET_PRIVATE (calendar)->day_width;
1180   if (priv->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
1181     x_left = week_width + calendar_xsep + (width + DAY_XSEP) * column;
1182   else
1183     x_left = week_width + CALENDAR_MARGIN + (width + DAY_XSEP) * column;
1184
1185   return x_left;
1186 }
1187
1188 /* column_from_x: returns the column 0-6 that the
1189  * x pixel of the xwindow is in */
1190 static gint
1191 calendar_column_from_x (GtkCalendar *calendar,
1192                         gint         event_x)
1193 {
1194   gint c, column;
1195   gint x_left, x_right;
1196
1197   column = -1;
1198
1199   for (c = 0; c < 7; c++)
1200     {
1201       x_left = calendar_left_x_for_column (calendar, c);
1202       x_right = x_left + GTK_CALENDAR_GET_PRIVATE (calendar)->day_width;
1203
1204       if (event_x >= x_left && event_x < x_right)
1205         {
1206           column = c;
1207           break;
1208         }
1209     }
1210
1211   return column;
1212 }
1213
1214 /* calendar_top_y_for_row: returns the y coordinate
1215  * for the top of the row */
1216 static gint
1217 calendar_top_y_for_row (GtkCalendar *calendar,
1218                         gint         row)
1219 {
1220   GtkStyleContext *context;
1221   GtkAllocation allocation;
1222   gint inner_border = calendar_get_inner_border (calendar);
1223   GtkStateFlags state;
1224   GtkBorder padding;
1225
1226   gtk_widget_get_allocation (GTK_WIDGET (calendar), &allocation);
1227   context = gtk_widget_get_style_context (GTK_WIDGET (calendar));
1228   state = gtk_widget_get_state_flags (GTK_WIDGET (calendar));
1229
1230   gtk_style_context_get_padding (context, state, &padding);
1231
1232   return  allocation.height
1233           - padding.top - inner_border
1234           - (CALENDAR_MARGIN + (6 - row)
1235              * calendar_row_height (calendar));
1236 }
1237
1238 /* row_from_y: returns the row 0-5 that the
1239  * y pixel of the xwindow is in */
1240 static gint
1241 calendar_row_from_y (GtkCalendar *calendar,
1242                      gint         event_y)
1243 {
1244   gint r, row;
1245   gint height;
1246   gint y_top, y_bottom;
1247
1248   height = calendar_row_height (calendar);
1249   row = -1;
1250
1251   for (r = 0; r < 6; r++)
1252     {
1253       y_top = calendar_top_y_for_row (calendar, r);
1254       y_bottom = y_top + height;
1255
1256       if (event_y >= y_top && event_y < y_bottom)
1257         {
1258           row = r;
1259           break;
1260         }
1261     }
1262
1263   return row;
1264 }
1265
1266 static void
1267 calendar_arrow_rectangle (GtkCalendar  *calendar,
1268                           guint         arrow,
1269                           GdkRectangle *rect)
1270 {
1271   GtkWidget *widget = GTK_WIDGET (calendar);
1272   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1273   GtkAllocation allocation;
1274   GtkStyleContext *context;
1275   GtkStateFlags state;
1276   GtkBorder padding;
1277   gboolean year_left;
1278
1279   gtk_widget_get_allocation (widget, &allocation);
1280   context = gtk_widget_get_style_context (widget);
1281   state = gtk_widget_get_state_flags (widget);
1282
1283   gtk_style_context_get_padding (context, state, &padding);
1284
1285   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1286     year_left = priv->year_before;
1287   else
1288     year_left = !priv->year_before;
1289
1290   rect->y = 3;
1291   rect->width = priv->arrow_width;
1292   rect->height = priv->header_h - 7;
1293
1294   switch (arrow)
1295     {
1296     case ARROW_MONTH_LEFT:
1297       if (year_left)
1298         rect->x = (allocation.width - padding.left - padding.right
1299                    - (3 + 2 * priv->arrow_width + priv->max_month_width));
1300       else
1301         rect->x = 3;
1302       break;
1303     case ARROW_MONTH_RIGHT:
1304       if (year_left)
1305         rect->x = (allocation.width - padding.left - padding.right
1306                    - 3 - priv->arrow_width);
1307       else
1308         rect->x = (priv->arrow_width + priv->max_month_width);
1309       break;
1310     case ARROW_YEAR_LEFT:
1311       if (year_left)
1312         rect->x = 3;
1313       else
1314         rect->x = (allocation.width - padding.left - padding.right
1315                    - (3 + 2 * priv->arrow_width + priv->max_year_width));
1316       break;
1317     case ARROW_YEAR_RIGHT:
1318       if (year_left)
1319         rect->x = (priv->arrow_width + priv->max_year_width);
1320       else
1321         rect->x = (allocation.width - padding.left - padding.right
1322                    - 3 - priv->arrow_width);
1323       break;
1324     }
1325
1326   rect->x += padding.left;
1327   rect->y += padding.top;
1328 }
1329
1330 static void
1331 calendar_day_rectangle (GtkCalendar  *calendar,
1332                         gint          row,
1333                         gint          col,
1334                         GdkRectangle *rect)
1335 {
1336   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1337
1338   rect->x = calendar_left_x_for_column (calendar, col);
1339   rect->y = calendar_top_y_for_row (calendar, row);
1340   rect->height = calendar_row_height (calendar);
1341   rect->width = priv->day_width;
1342 }
1343
1344 static void
1345 calendar_set_month_prev (GtkCalendar *calendar)
1346 {
1347   GtkCalendarPrivate *priv = calendar->priv;
1348   gint month_len;
1349
1350   if (priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1351     return;
1352
1353   if (priv->month == 0)
1354     {
1355       priv->month = 11;
1356       priv->year--;
1357     }
1358   else
1359     priv->month--;
1360
1361   month_len = month_length[leap (priv->year)][priv->month + 1];
1362
1363   calendar_compute_days (calendar);
1364
1365   g_signal_emit (calendar,
1366                  gtk_calendar_signals[PREV_MONTH_SIGNAL],
1367                  0);
1368   g_signal_emit (calendar,
1369                  gtk_calendar_signals[MONTH_CHANGED_SIGNAL],
1370                  0);
1371
1372   if (month_len < priv->selected_day)
1373     {
1374       priv->selected_day = 0;
1375       gtk_calendar_select_day (calendar, month_len);
1376     }
1377   else
1378     {
1379       if (priv->selected_day < 0)
1380         priv->selected_day = priv->selected_day + 1 + month_length[leap (priv->year)][priv->month + 1];
1381       gtk_calendar_select_day (calendar, priv->selected_day);
1382     }
1383
1384   calendar_queue_refresh (calendar);
1385 }
1386
1387 \f
1388 /****************************************
1389  *           Basic object methods       *
1390  ****************************************/
1391
1392 static void
1393 gtk_calendar_finalize (GObject *object)
1394 {
1395   G_OBJECT_CLASS (gtk_calendar_parent_class)->finalize (object);
1396 }
1397
1398 static void
1399 gtk_calendar_destroy (GtkWidget *widget)
1400 {
1401   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1402
1403   calendar_stop_spinning (GTK_CALENDAR (widget));
1404
1405   /* Call the destroy function for the extra display callback: */
1406   if (priv->detail_func_destroy && priv->detail_func_user_data)
1407     {
1408       priv->detail_func_destroy (priv->detail_func_user_data);
1409       priv->detail_func_user_data = NULL;
1410       priv->detail_func_destroy = NULL;
1411     }
1412
1413   GTK_WIDGET_CLASS (gtk_calendar_parent_class)->destroy (widget);
1414 }
1415
1416
1417 static void
1418 calendar_set_display_option (GtkCalendar              *calendar,
1419                              GtkCalendarDisplayOptions flag,
1420                              gboolean                  setting)
1421 {
1422   GtkCalendarPrivate *priv = calendar->priv;
1423   GtkCalendarDisplayOptions flags;
1424
1425   if (setting)
1426     flags = priv->display_flags | flag;
1427   else
1428     flags = priv->display_flags & ~flag;
1429   gtk_calendar_set_display_options (calendar, flags);
1430 }
1431
1432 static gboolean
1433 calendar_get_display_option (GtkCalendar              *calendar,
1434                              GtkCalendarDisplayOptions flag)
1435 {
1436   GtkCalendarPrivate *priv = calendar->priv;
1437
1438   return (priv->display_flags & flag) != 0;
1439 }
1440
1441 static void
1442 gtk_calendar_set_property (GObject      *object,
1443                            guint         prop_id,
1444                            const GValue *value,
1445                            GParamSpec   *pspec)
1446 {
1447   GtkCalendar *calendar = GTK_CALENDAR (object);
1448   GtkCalendarPrivate *priv = calendar->priv;
1449
1450   switch (prop_id)
1451     {
1452     case PROP_YEAR:
1453       gtk_calendar_select_month (calendar,
1454                                  priv->month,
1455                                  g_value_get_int (value));
1456       break;
1457     case PROP_MONTH:
1458       gtk_calendar_select_month (calendar,
1459                                  g_value_get_int (value),
1460                                  priv->year);
1461       break;
1462     case PROP_DAY:
1463       gtk_calendar_select_day (calendar,
1464                                g_value_get_int (value));
1465       break;
1466     case PROP_SHOW_HEADING:
1467       calendar_set_display_option (calendar,
1468                                    GTK_CALENDAR_SHOW_HEADING,
1469                                    g_value_get_boolean (value));
1470       break;
1471     case PROP_SHOW_DAY_NAMES:
1472       calendar_set_display_option (calendar,
1473                                    GTK_CALENDAR_SHOW_DAY_NAMES,
1474                                    g_value_get_boolean (value));
1475       break;
1476     case PROP_NO_MONTH_CHANGE:
1477       calendar_set_display_option (calendar,
1478                                    GTK_CALENDAR_NO_MONTH_CHANGE,
1479                                    g_value_get_boolean (value));
1480       break;
1481     case PROP_SHOW_WEEK_NUMBERS:
1482       calendar_set_display_option (calendar,
1483                                    GTK_CALENDAR_SHOW_WEEK_NUMBERS,
1484                                    g_value_get_boolean (value));
1485       break;
1486     case PROP_SHOW_DETAILS:
1487       calendar_set_display_option (calendar,
1488                                    GTK_CALENDAR_SHOW_DETAILS,
1489                                    g_value_get_boolean (value));
1490       break;
1491     case PROP_DETAIL_WIDTH_CHARS:
1492       gtk_calendar_set_detail_width_chars (calendar,
1493                                            g_value_get_int (value));
1494       break;
1495     case PROP_DETAIL_HEIGHT_ROWS:
1496       gtk_calendar_set_detail_height_rows (calendar,
1497                                            g_value_get_int (value));
1498       break;
1499     default:
1500       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1501       break;
1502     }
1503 }
1504
1505 static void
1506 gtk_calendar_get_property (GObject      *object,
1507                            guint         prop_id,
1508                            GValue       *value,
1509                            GParamSpec   *pspec)
1510 {
1511   GtkCalendar *calendar = GTK_CALENDAR (object);
1512   GtkCalendarPrivate *priv = calendar->priv;
1513
1514   switch (prop_id)
1515     {
1516     case PROP_YEAR:
1517       g_value_set_int (value, priv->year);
1518       break;
1519     case PROP_MONTH:
1520       g_value_set_int (value, priv->month);
1521       break;
1522     case PROP_DAY:
1523       g_value_set_int (value, priv->selected_day);
1524       break;
1525     case PROP_SHOW_HEADING:
1526       g_value_set_boolean (value, calendar_get_display_option (calendar,
1527                                                                GTK_CALENDAR_SHOW_HEADING));
1528       break;
1529     case PROP_SHOW_DAY_NAMES:
1530       g_value_set_boolean (value, calendar_get_display_option (calendar,
1531                                                                GTK_CALENDAR_SHOW_DAY_NAMES));
1532       break;
1533     case PROP_NO_MONTH_CHANGE:
1534       g_value_set_boolean (value, calendar_get_display_option (calendar,
1535                                                                GTK_CALENDAR_NO_MONTH_CHANGE));
1536       break;
1537     case PROP_SHOW_WEEK_NUMBERS:
1538       g_value_set_boolean (value, calendar_get_display_option (calendar,
1539                                                                GTK_CALENDAR_SHOW_WEEK_NUMBERS));
1540       break;
1541     case PROP_SHOW_DETAILS:
1542       g_value_set_boolean (value, calendar_get_display_option (calendar,
1543                                                                GTK_CALENDAR_SHOW_DETAILS));
1544       break;
1545     case PROP_DETAIL_WIDTH_CHARS:
1546       g_value_set_int (value, priv->detail_width_chars);
1547       break;
1548     case PROP_DETAIL_HEIGHT_ROWS:
1549       g_value_set_int (value, priv->detail_height_rows);
1550       break;
1551     default:
1552       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1553       break;
1554     }
1555 }
1556
1557 \f
1558 /****************************************
1559  *             Realization              *
1560  ****************************************/
1561
1562 static void
1563 calendar_realize_arrows (GtkCalendar *calendar)
1564 {
1565   GtkWidget *widget = GTK_WIDGET (calendar);
1566   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1567   GdkWindowAttr attributes;
1568   gint attributes_mask;
1569   gint i;
1570   GtkAllocation allocation;
1571
1572   if (! (priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1573       && (priv->display_flags & GTK_CALENDAR_SHOW_HEADING))
1574     {
1575       gtk_widget_get_allocation (widget, &allocation);
1576
1577       attributes.wclass = GDK_INPUT_ONLY;
1578       attributes.window_type = GDK_WINDOW_CHILD;
1579       attributes.event_mask = (gtk_widget_get_events (widget)
1580                                | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1581                                | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
1582       attributes_mask = GDK_WA_X | GDK_WA_Y;
1583       for (i = 0; i < 4; i++)
1584         {
1585           GdkRectangle rect;
1586           calendar_arrow_rectangle (calendar, i, &rect);
1587
1588           attributes.x = allocation.x + rect.x;
1589           attributes.y = allocation.y + rect.y;
1590           attributes.width = rect.width;
1591           attributes.height = rect.height;
1592           priv->arrow_win[i] = gdk_window_new (gtk_widget_get_window (widget),
1593                                                &attributes,
1594                                                attributes_mask);
1595
1596           gtk_widget_register_window (widget, priv->arrow_win[i]);
1597         }
1598       priv->arrow_prelight = 0x0;
1599     }
1600   else
1601     {
1602       for (i = 0; i < 4; i++)
1603         priv->arrow_win[i] = NULL;
1604     }
1605 }
1606
1607 static void
1608 calendar_unrealize_arrows (GtkCalendar *calendar)
1609 {
1610   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1611   gint i;
1612
1613   for (i = 0; i < 4; i++)
1614     {
1615       if (priv->arrow_win[i])
1616         {
1617           gtk_widget_unregister_window (GTK_WIDGET (calendar), priv->arrow_win[i]);
1618           gdk_window_destroy (priv->arrow_win[i]);
1619           priv->arrow_win[i] = NULL;
1620         }
1621     }
1622
1623 }
1624
1625 static gint
1626 calendar_get_inner_border (GtkCalendar *calendar)
1627 {
1628   gint inner_border;
1629
1630   gtk_widget_style_get (GTK_WIDGET (calendar),
1631                         "inner-border", &inner_border,
1632                         NULL);
1633
1634   return inner_border;
1635 }
1636
1637 static gint
1638 calendar_get_xsep (GtkCalendar *calendar)
1639 {
1640   gint xsep;
1641
1642   gtk_widget_style_get (GTK_WIDGET (calendar),
1643                         "horizontal-separation", &xsep,
1644                         NULL);
1645
1646   return xsep;
1647 }
1648
1649 static gint
1650 calendar_get_ysep (GtkCalendar *calendar)
1651 {
1652   gint ysep;
1653
1654   gtk_widget_style_get (GTK_WIDGET (calendar),
1655                         "vertical-separation", &ysep,
1656                         NULL);
1657
1658   return ysep;
1659 }
1660
1661 static void
1662 gtk_calendar_realize (GtkWidget *widget)
1663 {
1664   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1665   GdkWindowAttr attributes;
1666   gint attributes_mask;
1667   gint inner_border = calendar_get_inner_border (GTK_CALENDAR (widget));
1668   GtkStyleContext *context;
1669   GtkAllocation allocation;
1670   GtkStateFlags state = 0;
1671   GtkBorder padding;
1672
1673   context = gtk_widget_get_style_context (widget);
1674   state = gtk_widget_get_state_flags (widget);
1675   gtk_style_context_get_padding (context, state, &padding);
1676
1677   gtk_widget_get_allocation (widget, &allocation);
1678
1679   GTK_WIDGET_CLASS (gtk_calendar_parent_class)->realize (widget);
1680
1681   attributes.wclass = GDK_INPUT_ONLY;
1682   attributes.window_type = GDK_WINDOW_CHILD;
1683   attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
1684                            | GDK_SCROLL_MASK
1685                            | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1686                            | GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
1687
1688   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1689     attributes.x = priv->week_width + padding.left + inner_border;
1690   else
1691     attributes.x = padding.left + inner_border;
1692
1693   attributes.y = priv->header_h + priv->day_name_h + padding.top + inner_border;
1694   attributes.width = allocation.width - attributes.x - (padding.right + inner_border);
1695
1696   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
1697     attributes.width -= priv->week_width;
1698
1699   attributes.height = priv->main_h;
1700   attributes_mask = GDK_WA_X | GDK_WA_Y;
1701
1702   attributes.x += allocation.x;
1703   attributes.y += allocation.y;
1704
1705   priv->main_win = gdk_window_new (gtk_widget_get_window (widget),
1706                                    &attributes, attributes_mask);
1707   gtk_widget_register_window (widget, priv->main_win);
1708
1709   calendar_realize_arrows (GTK_CALENDAR (widget));
1710 }
1711
1712 static void
1713 gtk_calendar_unrealize (GtkWidget *widget)
1714 {
1715   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1716
1717   calendar_unrealize_arrows (GTK_CALENDAR (widget));
1718
1719   if (priv->main_win)
1720     {
1721       gtk_widget_unregister_window (widget, priv->main_win);
1722       gdk_window_destroy (priv->main_win);
1723       priv->main_win = NULL;
1724     }
1725
1726   GTK_WIDGET_CLASS (gtk_calendar_parent_class)->unrealize (widget);
1727 }
1728
1729 static void
1730 calendar_map_arrows (GtkCalendar *calendar)
1731 {
1732   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1733   gint i;
1734
1735   for (i = 0; i < 4; i++)
1736     {
1737       if (priv->arrow_win[i])
1738         gdk_window_show (priv->arrow_win[i]);
1739     }
1740 }
1741
1742 static void
1743 calendar_unmap_arrows (GtkCalendar *calendar)
1744 {
1745   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1746   gint i;
1747
1748   for (i = 0; i < 4; i++)
1749     {
1750       if (priv->arrow_win[i])
1751         gdk_window_hide (priv->arrow_win[i]);
1752     }
1753 }
1754
1755 static void
1756 gtk_calendar_map (GtkWidget *widget)
1757 {
1758   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1759
1760   GTK_WIDGET_CLASS (gtk_calendar_parent_class)->map (widget);
1761
1762   gdk_window_show (priv->main_win);
1763
1764   calendar_map_arrows (GTK_CALENDAR (widget));
1765 }
1766
1767 static void
1768 gtk_calendar_unmap (GtkWidget *widget)
1769 {
1770   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1771
1772   calendar_unmap_arrows (GTK_CALENDAR (widget));
1773
1774   gdk_window_hide (priv->main_win);
1775
1776   GTK_WIDGET_CLASS (gtk_calendar_parent_class)->unmap (widget);
1777 }
1778
1779 static gchar*
1780 gtk_calendar_get_detail (GtkCalendar *calendar,
1781                          gint         row,
1782                          gint         column)
1783 {
1784   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
1785   gint year, month;
1786
1787   if (priv->detail_func == NULL)
1788     return NULL;
1789
1790   year = priv->year;
1791   month = priv->month + priv->day_month[row][column] - MONTH_CURRENT;
1792
1793   if (month < 0)
1794     {
1795       month += 12;
1796       year -= 1;
1797     }
1798   else if (month > 11)
1799     {
1800       month -= 12;
1801       year += 1;
1802     }
1803
1804   return priv->detail_func (calendar,
1805                             year, month,
1806                             priv->day[row][column],
1807                             priv->detail_func_user_data);
1808 }
1809
1810 static gboolean
1811 gtk_calendar_query_tooltip (GtkWidget  *widget,
1812                             gint        x,
1813                             gint        y,
1814                             gboolean    keyboard_mode,
1815                             GtkTooltip *tooltip)
1816 {
1817   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1818   GtkCalendar *calendar = GTK_CALENDAR (widget);
1819   gchar *detail = NULL;
1820   GdkRectangle day_rect;
1821   gint row, col;
1822
1823   col = calendar_column_from_x (calendar, x);
1824   row = calendar_row_from_y (calendar, y);
1825
1826   if (col != -1 && row != -1 &&
1827       (0 != (priv->detail_overflow[row] & (1 << col)) ||
1828       0 == (priv->display_flags & GTK_CALENDAR_SHOW_DETAILS)))
1829     {
1830       detail = gtk_calendar_get_detail (calendar, row, col);
1831       calendar_day_rectangle (calendar, row, col, &day_rect);
1832     }
1833
1834   if (detail)
1835     {
1836       gtk_tooltip_set_tip_area (tooltip, &day_rect);
1837       gtk_tooltip_set_markup (tooltip, detail);
1838
1839       g_free (detail);
1840
1841       return TRUE;
1842     }
1843
1844   if (GTK_WIDGET_CLASS (gtk_calendar_parent_class)->query_tooltip)
1845     return GTK_WIDGET_CLASS (gtk_calendar_parent_class)->query_tooltip (widget, x, y, keyboard_mode, tooltip);
1846
1847   return FALSE;
1848 }
1849
1850 \f
1851 /****************************************
1852  *       Size Request and Allocate      *
1853  ****************************************/
1854
1855 static void
1856 gtk_calendar_size_request (GtkWidget      *widget,
1857                            GtkRequisition *requisition)
1858 {
1859   GtkCalendar *calendar = GTK_CALENDAR (widget);
1860   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
1861   GtkStyleContext *context;
1862   GtkStateFlags state;
1863   GtkBorder padding;
1864   PangoLayout *layout;
1865   PangoRectangle logical_rect;
1866
1867   gint height;
1868   gint i, r, c;
1869   gint calendar_margin = CALENDAR_MARGIN;
1870   gint header_width, main_width;
1871   gint max_header_height = 0;
1872   gint focus_width;
1873   gint focus_padding;
1874   gint max_detail_height;
1875   gint inner_border = calendar_get_inner_border (calendar);
1876   gint calendar_ysep = calendar_get_ysep (calendar);
1877   gint calendar_xsep = calendar_get_xsep (calendar);
1878
1879   gtk_widget_style_get (GTK_WIDGET (widget),
1880                         "focus-line-width", &focus_width,
1881                         "focus-padding", &focus_padding,
1882                         NULL);
1883
1884   layout = gtk_widget_create_pango_layout (widget, NULL);
1885
1886   /*
1887    * Calculate the requisition  width for the widget.
1888    */
1889
1890   /* Header width */
1891
1892   if (priv->display_flags & GTK_CALENDAR_SHOW_HEADING)
1893     {
1894       priv->max_month_width = 0;
1895       for (i = 0; i < 12; i++)
1896         {
1897           pango_layout_set_text (layout, default_monthname[i], -1);
1898           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1899           priv->max_month_width = MAX (priv->max_month_width,
1900                                                logical_rect.width + 8);
1901           max_header_height = MAX (max_header_height, logical_rect.height);
1902         }
1903
1904       priv->max_year_width = 0;
1905       /* Translators:  This is a text measurement template.
1906        * Translate it to the widest year text
1907        *
1908        * If you don't understand this, leave it as "2000"
1909        */
1910       pango_layout_set_text (layout, C_("year measurement template", "2000"), -1);
1911       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1912       priv->max_year_width = MAX (priv->max_year_width,
1913                                   logical_rect.width + 8);
1914       max_header_height = MAX (max_header_height, logical_rect.height);
1915     }
1916   else
1917     {
1918       priv->max_month_width = 0;
1919       priv->max_year_width = 0;
1920     }
1921
1922   if (priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1923     header_width = (priv->max_month_width
1924                     + priv->max_year_width
1925                     + 3 * 3);
1926   else
1927     header_width = (priv->max_month_width
1928                     + priv->max_year_width
1929                     + 4 * priv->arrow_width + 3 * 3);
1930
1931   /* Mainwindow labels width */
1932
1933   priv->max_day_char_width = 0;
1934   priv->max_day_char_ascent = 0;
1935   priv->max_day_char_descent = 0;
1936   priv->min_day_width = 0;
1937
1938   for (i = 0; i < 9; i++)
1939     {
1940       gchar buffer[32];
1941       g_snprintf (buffer, sizeof (buffer), C_("calendar:day:digits", "%d"), i * 11);
1942       pango_layout_set_text (layout, buffer, -1);
1943       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1944       priv->min_day_width = MAX (priv->min_day_width,
1945                                          logical_rect.width);
1946
1947       priv->max_day_char_ascent = MAX (priv->max_day_char_ascent,
1948                                                PANGO_ASCENT (logical_rect));
1949       priv->max_day_char_descent = MAX (priv->max_day_char_descent,
1950                                                 PANGO_DESCENT (logical_rect));
1951     }
1952
1953   priv->max_label_char_ascent = 0;
1954   priv->max_label_char_descent = 0;
1955   if (priv->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
1956     for (i = 0; i < 7; i++)
1957       {
1958         pango_layout_set_text (layout, default_abbreviated_dayname[i], -1);
1959         pango_layout_line_get_pixel_extents (pango_layout_get_lines_readonly (layout)->data, NULL, &logical_rect);
1960
1961         priv->min_day_width = MAX (priv->min_day_width, logical_rect.width);
1962         priv->max_label_char_ascent = MAX (priv->max_label_char_ascent,
1963                                                    PANGO_ASCENT (logical_rect));
1964         priv->max_label_char_descent = MAX (priv->max_label_char_descent,
1965                                                     PANGO_DESCENT (logical_rect));
1966       }
1967
1968   priv->max_week_char_width = 0;
1969   if (priv->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
1970     for (i = 0; i < 9; i++)
1971       {
1972         gchar buffer[32];
1973         g_snprintf (buffer, sizeof (buffer), C_("calendar:week:digits", "%d"), i * 11);
1974         pango_layout_set_text (layout, buffer, -1);
1975         pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1976         priv->max_week_char_width = MAX (priv->max_week_char_width,
1977                                            logical_rect.width / 2);
1978       }
1979
1980   /* Calculate detail extents. Do this as late as possible since
1981    * pango_layout_set_markup is called which alters font settings. */
1982   max_detail_height = 0;
1983
1984   if (priv->detail_func && (priv->display_flags & GTK_CALENDAR_SHOW_DETAILS))
1985     {
1986       gchar *markup, *tail;
1987
1988       if (priv->detail_width_chars || priv->detail_height_rows)
1989         {
1990           gint rows = MAX (1, priv->detail_height_rows) - 1;
1991           gsize len = priv->detail_width_chars + rows + 16;
1992
1993           markup = tail = g_alloca (len);
1994
1995           memcpy (tail,     "<small>", 7);
1996           tail += 7;
1997
1998           memset (tail, 'm', priv->detail_width_chars);
1999           tail += priv->detail_width_chars;
2000
2001           memset (tail, '\n', rows);
2002           tail += rows;
2003
2004           memcpy (tail,     "</small>", 9);
2005           tail += 9;
2006
2007           g_assert (len == (tail - markup));
2008
2009           pango_layout_set_markup (layout, markup, -1);
2010           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2011
2012           if (priv->detail_width_chars)
2013             priv->min_day_width = MAX (priv->min_day_width, logical_rect.width);
2014           if (priv->detail_height_rows)
2015             max_detail_height = MAX (max_detail_height, logical_rect.height);
2016         }
2017
2018       if (!priv->detail_width_chars || !priv->detail_height_rows)
2019         for (r = 0; r < 6; r++)
2020           for (c = 0; c < 7; c++)
2021             {
2022               gchar *detail = gtk_calendar_get_detail (calendar, r, c);
2023
2024               if (detail)
2025                 {
2026                   markup = g_strconcat ("<small>", detail, "</small>", NULL);
2027                   pango_layout_set_markup (layout, markup, -1);
2028
2029                   if (priv->detail_width_chars)
2030                     {
2031                       pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
2032                       pango_layout_set_width (layout, PANGO_SCALE * priv->min_day_width);
2033                     }
2034
2035                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2036
2037                   if (!priv->detail_width_chars)
2038                     priv->min_day_width = MAX (priv->min_day_width, logical_rect.width);
2039                   if (!priv->detail_height_rows)
2040                     max_detail_height = MAX (max_detail_height, logical_rect.height);
2041
2042                   g_free (markup);
2043                   g_free (detail);
2044                 }
2045             }
2046     }
2047
2048   /* We add one to max_day_char_width to be able to make the marked day "bold" */
2049   priv->max_day_char_width = priv->min_day_width / 2 + 1;
2050
2051   main_width = (7 * (priv->min_day_width + (focus_padding + focus_width) * 2) + (DAY_XSEP * 6) + CALENDAR_MARGIN * 2
2052                 + (priv->max_week_char_width
2053                    ? priv->max_week_char_width * 2 + (focus_padding + focus_width) * 2 + calendar_xsep * 2
2054                    : 0));
2055
2056   context = gtk_widget_get_style_context (widget);
2057   state = gtk_widget_get_state_flags (widget);
2058   gtk_style_context_get_padding (context, state, &padding);
2059
2060   requisition->width = MAX (header_width, main_width + inner_border * 2) + padding.left + padding.right;
2061
2062   /*
2063    * Calculate the requisition height for the widget.
2064    */
2065
2066   if (priv->display_flags & GTK_CALENDAR_SHOW_HEADING)
2067     {
2068       priv->header_h = (max_header_height + calendar_ysep * 2);
2069     }
2070   else
2071     {
2072       priv->header_h = 0;
2073     }
2074
2075   if (priv->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
2076     {
2077       priv->day_name_h = (priv->max_label_char_ascent
2078                                   + priv->max_label_char_descent
2079                                   + 2 * (focus_padding + focus_width) + calendar_margin);
2080       calendar_margin = calendar_ysep;
2081     }
2082   else
2083     {
2084       priv->day_name_h = 0;
2085     }
2086
2087   priv->main_h = (CALENDAR_MARGIN + calendar_margin
2088                           + 6 * (priv->max_day_char_ascent
2089                                  + priv->max_day_char_descent
2090                                  + max_detail_height
2091                                  + 2 * (focus_padding + focus_width))
2092                           + DAY_YSEP * 5);
2093
2094   height = priv->header_h + priv->day_name_h + priv->main_h;
2095
2096   requisition->height = height + padding.top + padding.bottom + (inner_border * 2);
2097
2098   g_object_unref (layout);
2099 }
2100
2101 static void
2102 gtk_calendar_get_preferred_width (GtkWidget *widget,
2103                                   gint      *minimum,
2104                                   gint      *natural)
2105 {
2106   GtkRequisition requisition;
2107
2108   gtk_calendar_size_request (widget, &requisition);
2109
2110   *minimum = *natural = requisition.width;
2111 }
2112
2113 static void
2114 gtk_calendar_get_preferred_height (GtkWidget *widget,
2115                                    gint      *minimum,
2116                                    gint      *natural)
2117 {
2118   GtkRequisition requisition;
2119
2120   gtk_calendar_size_request (widget, &requisition);
2121
2122   *minimum = *natural = requisition.height;
2123 }
2124
2125 static void
2126 gtk_calendar_size_allocate (GtkWidget     *widget,
2127                             GtkAllocation *allocation)
2128 {
2129   GtkCalendar *calendar = GTK_CALENDAR (widget);
2130   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
2131   GtkStyleContext *context;
2132   GtkStateFlags state;
2133   GtkBorder padding;
2134   guint i;
2135   gint inner_border = calendar_get_inner_border (calendar);
2136   gint calendar_xsep = calendar_get_xsep (calendar);
2137
2138   context = gtk_widget_get_style_context (widget);
2139   state = gtk_widget_get_state_flags (widget);
2140   gtk_style_context_get_padding (context, state, &padding);
2141
2142   gtk_widget_set_allocation (widget, allocation);
2143
2144   if (priv->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
2145     {
2146       priv->day_width = (priv->min_day_width
2147                          * ((allocation->width - (inner_border * 2) - padding.left - padding.right
2148                              - (CALENDAR_MARGIN * 2) -  (DAY_XSEP * 6) - calendar_xsep * 2))
2149                          / (7 * priv->min_day_width + priv->max_week_char_width * 2));
2150       priv->week_width = ((allocation->width - (inner_border * 2) - padding.left - padding.right
2151                            - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - calendar_xsep * 2 )
2152                           - priv->day_width * 7 + CALENDAR_MARGIN + calendar_xsep);
2153     }
2154   else
2155     {
2156       priv->day_width = (allocation->width
2157                          - (inner_border * 2)
2158                          - padding.left - padding.right
2159                          - (CALENDAR_MARGIN * 2)
2160                          - (DAY_XSEP * 6))/7;
2161       priv->week_width = 0;
2162     }
2163
2164   if (gtk_widget_get_realized (widget))
2165     {
2166       if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
2167         gdk_window_move_resize (priv->main_win,
2168                                 allocation->x
2169                                  + priv->week_width + padding.left + inner_border,
2170                                 allocation->y
2171                                  + priv->header_h + priv->day_name_h
2172                                  + (padding.top + inner_border),
2173                                 allocation->width - priv->week_width
2174                                 - (inner_border * 2) - padding.left - padding.right,
2175                                 priv->main_h);
2176       else
2177         gdk_window_move_resize (priv->main_win,
2178                                 allocation->x
2179                                  + padding.left + inner_border,
2180                                 allocation->y
2181                                  + priv->header_h + priv->day_name_h
2182                                  + padding.top + inner_border,
2183                                 allocation->width - priv->week_width
2184                                 - (inner_border * 2) - padding.left - padding.right,
2185                                 priv->main_h);
2186
2187       for (i = 0 ; i < 4 ; i++)
2188         {
2189           if (priv->arrow_win[i])
2190             {
2191               GdkRectangle rect;
2192               calendar_arrow_rectangle (calendar, i, &rect);
2193
2194               gdk_window_move_resize (priv->arrow_win[i],
2195                                       allocation->x + rect.x,
2196                                       allocation->y + rect.y,
2197                                       rect.width, rect.height);
2198             }
2199         }
2200     }
2201 }
2202
2203 \f
2204 /****************************************
2205  *              Repainting              *
2206  ****************************************/
2207
2208 static void
2209 calendar_paint_header (GtkCalendar *calendar, cairo_t *cr)
2210 {
2211   GtkWidget *widget = GTK_WIDGET (calendar);
2212   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2213   GtkAllocation allocation;
2214   GtkStyleContext *context;
2215   GtkStateFlags state;
2216   GtkBorder padding;
2217   char buffer[255];
2218   gint x, y;
2219   gint header_width;
2220   gint max_month_width;
2221   gint max_year_width;
2222   PangoLayout *layout;
2223   PangoRectangle logical_rect;
2224   gboolean year_left;
2225   time_t tmp_time;
2226   struct tm *tm;
2227   gchar *str;
2228
2229   context = gtk_widget_get_style_context (widget);
2230   state = gtk_widget_get_state_flags (widget);
2231   gtk_style_context_get_padding (context, state, &padding);
2232
2233   cairo_save (cr);
2234   cairo_translate (cr, padding.left, padding.top);
2235
2236   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
2237     year_left = priv->year_before;
2238   else
2239     year_left = !priv->year_before;
2240
2241   gtk_widget_get_allocation (widget, &allocation);
2242
2243   header_width = allocation.width - padding.left - padding.right;
2244
2245   max_month_width = priv->max_month_width;
2246   max_year_width = priv->max_year_width;
2247
2248   gtk_style_context_save (context);
2249   gtk_style_context_add_class (context, GTK_STYLE_CLASS_HEADER);
2250
2251   gtk_render_background (context, cr, 0, 0, header_width, priv->header_h);
2252   gtk_render_frame (context, cr, 0, 0, header_width, priv->header_h);
2253
2254   tmp_time = 1;  /* Jan 1 1970, 00:00:01 UTC */
2255   tm = gmtime (&tmp_time);
2256   tm->tm_year = priv->year - 1900;
2257
2258   /* Translators: This dictates how the year is displayed in
2259    * gtkcalendar widget.  See strftime() manual for the format.
2260    * Use only ASCII in the translation.
2261    *
2262    * Also look for the msgid "2000".
2263    * Translate that entry to a year with the widest output of this
2264    * msgid.
2265    *
2266    * "%Y" is appropriate for most locales.
2267    */
2268   strftime (buffer, sizeof (buffer), C_("calendar year format", "%Y"), tm);
2269   str = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);
2270   layout = gtk_widget_create_pango_layout (widget, str);
2271   g_free (str);
2272
2273   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2274
2275   /* Draw title */
2276   y = (priv->header_h - logical_rect.height) / 2;
2277
2278   /* Draw year and its arrows */
2279
2280   if (priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
2281     if (year_left)
2282       x = 3 + (max_year_width - logical_rect.width)/2;
2283     else
2284       x = header_width - (3 + max_year_width
2285                           - (max_year_width - logical_rect.width)/2);
2286   else
2287     if (year_left)
2288       x = 3 + priv->arrow_width + (max_year_width - logical_rect.width)/2;
2289     else
2290       x = header_width - (3 + priv->arrow_width + max_year_width
2291                           - (max_year_width - logical_rect.width)/2);
2292
2293   gtk_render_layout (context, cr, x, y, layout);
2294
2295   /* Draw month */
2296   g_snprintf (buffer, sizeof (buffer), "%s", default_monthname[priv->month]);
2297   pango_layout_set_text (layout, buffer, -1);
2298   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2299
2300   if (priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
2301     if (year_left)
2302       x = header_width - (3 + max_month_width
2303                           - (max_month_width - logical_rect.width)/2);
2304     else
2305     x = 3 + (max_month_width - logical_rect.width) / 2;
2306   else
2307     if (year_left)
2308       x = header_width - (3 + priv->arrow_width + max_month_width
2309                           - (max_month_width - logical_rect.width)/2);
2310     else
2311     x = 3 + priv->arrow_width + (max_month_width - logical_rect.width)/2;
2312
2313   gtk_render_layout (context, cr, x, y, layout);
2314   g_object_unref (layout);
2315
2316   gtk_style_context_restore (context);
2317   cairo_restore (cr);
2318 }
2319
2320 static void
2321 calendar_paint_day_names (GtkCalendar *calendar,
2322                           cairo_t     *cr)
2323 {
2324   GtkWidget *widget = GTK_WIDGET (calendar);
2325   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2326   GtkStyleContext *context;
2327   GtkStateFlags state;
2328   GtkBorder padding;
2329   GtkAllocation allocation;
2330   char buffer[255];
2331   int day,i;
2332   int day_width, cal_width;
2333   int day_wid_sep;
2334   PangoLayout *layout;
2335   PangoRectangle logical_rect;
2336   gint focus_padding;
2337   gint focus_width;
2338   gint calendar_ysep = calendar_get_ysep (calendar);
2339   gint calendar_xsep = calendar_get_xsep (calendar);
2340   gint inner_border = calendar_get_inner_border (calendar);
2341
2342   context = gtk_widget_get_style_context (widget);
2343   state = gtk_widget_get_state_flags (widget);
2344   gtk_style_context_get_padding (context, state, &padding);
2345
2346   cairo_save (cr);
2347
2348   cairo_translate (cr,
2349                    padding.left + inner_border,
2350                    priv->header_h + padding.top + inner_border);
2351
2352   gtk_widget_style_get (GTK_WIDGET (widget),
2353                         "focus-line-width", &focus_width,
2354                         "focus-padding", &focus_padding,
2355                         NULL);
2356
2357   gtk_widget_get_allocation (widget, &allocation);
2358
2359   day_width = priv->day_width;
2360   cal_width = allocation.width - (inner_border * 2) - padding.left - padding.right;
2361   day_wid_sep = day_width + DAY_XSEP;
2362
2363   /*
2364    * Draw rectangles as inverted background for the labels.
2365    */
2366
2367   gtk_style_context_save (context);
2368   gtk_style_context_add_class (context, GTK_STYLE_CLASS_HIGHLIGHT);
2369
2370   gtk_render_background (context, cr,
2371                          CALENDAR_MARGIN, CALENDAR_MARGIN,
2372                          cal_width - CALENDAR_MARGIN * 2,
2373                          priv->day_name_h - CALENDAR_MARGIN);
2374
2375   if (priv->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
2376     gtk_render_background (context, cr,
2377                            CALENDAR_MARGIN,
2378                            priv->day_name_h - calendar_ysep,
2379                            priv->week_width - calendar_ysep - CALENDAR_MARGIN,
2380                            calendar_ysep);
2381
2382   /*
2383    * Write the labels
2384    */
2385   layout = gtk_widget_create_pango_layout (widget, NULL);
2386
2387   for (i = 0; i < 7; i++)
2388     {
2389       if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
2390         day = 6 - i;
2391       else
2392         day = i;
2393       day = (day + priv->week_start) % 7;
2394       g_snprintf (buffer, sizeof (buffer), "%s", default_abbreviated_dayname[day]);
2395
2396       pango_layout_set_text (layout, buffer, -1);
2397       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2398
2399       gtk_render_layout (context, cr,
2400                          (CALENDAR_MARGIN +
2401                           + (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ?
2402                              (priv->week_width + (priv->week_width ? calendar_xsep : 0))
2403                              : 0)
2404                           + day_wid_sep * i
2405                           + (day_width - logical_rect.width)/2),
2406                          CALENDAR_MARGIN + focus_width + focus_padding + logical_rect.y,
2407                          layout);
2408     }
2409
2410   g_object_unref (layout);
2411
2412   gtk_style_context_restore (context);
2413   cairo_restore (cr);
2414 }
2415
2416 static void
2417 calendar_paint_week_numbers (GtkCalendar *calendar,
2418                              cairo_t     *cr)
2419 {
2420   GtkWidget *widget = GTK_WIDGET (calendar);
2421   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2422   GtkStyleContext *context;
2423   GtkStateFlags state;
2424   GtkBorder padding;
2425   guint week = 0, year;
2426   gint row, x_loc, y_loc;
2427   gint day_height;
2428   char buffer[32];
2429   PangoLayout *layout;
2430   PangoRectangle logical_rect;
2431   gint focus_padding;
2432   gint focus_width;
2433   gint calendar_xsep = calendar_get_xsep (calendar);
2434   gint inner_border = calendar_get_inner_border (calendar);
2435   gint x, y;
2436
2437   context = gtk_widget_get_style_context (widget);
2438   state = gtk_widget_get_state_flags (widget);
2439   gtk_style_context_get_padding (context, state, &padding);
2440
2441   cairo_save (cr);
2442
2443   y = priv->header_h + priv->day_name_h + (padding.top + inner_border);
2444   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
2445     x = padding.left + inner_border;
2446   else
2447     x = gtk_widget_get_allocated_width (widget) - priv->week_width - (padding.right + inner_border);
2448
2449   gtk_widget_style_get (GTK_WIDGET (widget),
2450                         "focus-line-width", &focus_width,
2451                         "focus-padding", &focus_padding,
2452                         NULL);
2453
2454   gtk_style_context_save (context);
2455   gtk_style_context_add_class (context, GTK_STYLE_CLASS_HIGHLIGHT);
2456
2457   if (priv->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
2458     gtk_render_background (context, cr,
2459                            x + CALENDAR_MARGIN, y,
2460                            priv->week_width - CALENDAR_MARGIN,
2461                            priv->main_h - CALENDAR_MARGIN);
2462   else
2463     gtk_render_background (context, cr,
2464                            x + CALENDAR_MARGIN,
2465                            y + CALENDAR_MARGIN,
2466                            priv->week_width - CALENDAR_MARGIN,
2467                            priv->main_h - 2 * CALENDAR_MARGIN);
2468
2469   /*
2470    * Write the labels
2471    */
2472
2473   layout = gtk_widget_create_pango_layout (widget, NULL);
2474   day_height = calendar_row_height (calendar);
2475
2476   for (row = 0; row < 6; row++)
2477     {
2478       gboolean result;
2479
2480       year = priv->year;
2481       if (priv->day[row][6] < 15 && row > 3 && priv->month == 11)
2482         year++;
2483
2484       result = week_of_year (&week, &year,
2485                              ((priv->day[row][6] < 15 && row > 3 ? 1 : 0)
2486                               + priv->month) % 12 + 1, priv->day[row][6]);
2487       g_return_if_fail (result);
2488
2489       /* Translators: this defines whether the week numbers should use
2490        * localized digits or the ones used in English (0123...).
2491        *
2492        * Translate to "%Id" if you want to use localized digits, or
2493        * translate to "%d" otherwise.
2494        *
2495        * Note that translating this doesn't guarantee that you get localized
2496        * digits. That needs support from your system and locale definition
2497        * too.
2498        */
2499       g_snprintf (buffer, sizeof (buffer), C_("calendar:week:digits", "%d"), week);
2500       pango_layout_set_text (layout, buffer, -1);
2501       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2502
2503       y_loc = calendar_top_y_for_row (calendar, row) + (day_height - logical_rect.height) / 2;
2504
2505       x_loc = x + (priv->week_width
2506                    - logical_rect.width
2507                    - calendar_xsep - focus_padding - focus_width);
2508
2509       gtk_render_layout (context, cr, x_loc, y_loc, layout);
2510     }
2511
2512   g_object_unref (layout);
2513
2514   gtk_style_context_restore (context);
2515   cairo_restore (cr);
2516 }
2517
2518 static void
2519 calendar_invalidate_day_num (GtkCalendar *calendar,
2520                              gint         day)
2521 {
2522   GtkCalendarPrivate *priv = calendar->priv;
2523   gint r, c, row, col;
2524
2525   row = -1;
2526   col = -1;
2527   for (r = 0; r < 6; r++)
2528     for (c = 0; c < 7; c++)
2529       if (priv->day_month[r][c] == MONTH_CURRENT &&
2530           priv->day[r][c] == day)
2531         {
2532           row = r;
2533           col = c;
2534         }
2535
2536   g_return_if_fail (row != -1);
2537   g_return_if_fail (col != -1);
2538
2539   calendar_invalidate_day (calendar, row, col);
2540 }
2541
2542 static void
2543 calendar_invalidate_day (GtkCalendar *calendar,
2544                          gint         row,
2545                          gint         col)
2546 {
2547   GdkRectangle day_rect;
2548   GtkAllocation allocation;
2549
2550   gtk_widget_get_allocation (GTK_WIDGET (calendar), &allocation);
2551   calendar_day_rectangle (calendar, row, col, &day_rect);
2552   gtk_widget_queue_draw_area (GTK_WIDGET (calendar),
2553                               allocation.x + day_rect.x,
2554                               allocation.y + day_rect.y,
2555                               day_rect.width, day_rect.height);
2556 }
2557
2558 static gboolean
2559 is_color_attribute (PangoAttribute *attribute,
2560                     gpointer        data)
2561 {
2562   return (attribute->klass->type == PANGO_ATTR_FOREGROUND ||
2563           attribute->klass->type == PANGO_ATTR_BACKGROUND);
2564 }
2565
2566 static void
2567 calendar_paint_day (GtkCalendar *calendar,
2568                     cairo_t     *cr,
2569                     gint         row,
2570                     gint         col)
2571 {
2572   GtkWidget *widget = GTK_WIDGET (calendar);
2573   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2574   GtkStyleContext *context;
2575   GtkStateFlags state = 0;
2576   gchar *detail;
2577   gchar buffer[32];
2578   gint day;
2579   gint x_loc, y_loc;
2580   GdkRectangle day_rect;
2581
2582   PangoLayout *layout;
2583   PangoRectangle logical_rect;
2584   gboolean overflow = FALSE;
2585   gboolean show_details;
2586
2587   g_return_if_fail (row < 6);
2588   g_return_if_fail (col < 7);
2589
2590   context = gtk_widget_get_style_context (widget);
2591   state = gtk_widget_get_state_flags (widget);
2592
2593   day = priv->day[row][col];
2594   show_details = (priv->display_flags & GTK_CALENDAR_SHOW_DETAILS);
2595
2596   calendar_day_rectangle (calendar, row, col, &day_rect);
2597
2598   gtk_style_context_save (context);
2599
2600   state &= ~(GTK_STATE_FLAG_INCONSISTENT | GTK_STATE_FLAG_ACTIVE | GTK_STATE_FLAG_SELECTED);
2601
2602   if (priv->day_month[row][col] == MONTH_PREV ||
2603       priv->day_month[row][col] == MONTH_NEXT)
2604     state |= GTK_STATE_FLAG_INCONSISTENT;
2605   else
2606     {
2607       if (priv->marked_date[day-1])
2608         state |= GTK_STATE_FLAG_ACTIVE;
2609
2610       if (priv->selected_day == day)
2611         {
2612           state |= GTK_STATE_FLAG_SELECTED;
2613
2614           gtk_style_context_set_state (context, state);
2615           gtk_render_background (context, cr,
2616                                  day_rect.x, day_rect.y,
2617                                  day_rect.width, day_rect.height);
2618         }
2619     }
2620
2621   gtk_style_context_set_state (context, state);
2622
2623   /* Translators: this defines whether the day numbers should use
2624    * localized digits or the ones used in English (0123...).
2625    *
2626    * Translate to "%Id" if you want to use localized digits, or
2627    * translate to "%d" otherwise.
2628    *
2629    * Note that translating this doesn't guarantee that you get localized
2630    * digits. That needs support from your system and locale definition
2631    * too.
2632    */
2633   g_snprintf (buffer, sizeof (buffer), C_("calendar:day:digits", "%d"), day);
2634
2635   /* Get extra information to show, if any: */
2636
2637   detail = gtk_calendar_get_detail (calendar, row, col);
2638
2639   layout = gtk_widget_create_pango_layout (widget, buffer);
2640   pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
2641   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2642
2643   x_loc = day_rect.x + (day_rect.width - logical_rect.width) / 2;
2644   y_loc = day_rect.y;
2645
2646   gtk_render_layout (context, cr, x_loc, y_loc, layout);
2647
2648   if (priv->day_month[row][col] == MONTH_CURRENT &&
2649      (priv->marked_date[day-1] || (detail && !show_details)))
2650     gtk_render_layout (context, cr, x_loc - 1, y_loc, layout);
2651
2652   y_loc += priv->max_day_char_descent;
2653
2654   if (priv->detail_func && show_details)
2655     {
2656       GdkRGBA color;
2657
2658       cairo_save (cr);
2659
2660       gtk_style_context_get_color (context, state, &color);
2661       gdk_cairo_set_source_rgba (cr, &color);
2662
2663       cairo_set_line_width (cr, 1);
2664       cairo_move_to (cr, day_rect.x + 2, y_loc + 0.5);
2665       cairo_line_to (cr, day_rect.x + day_rect.width - 2, y_loc + 0.5);
2666       cairo_stroke (cr);
2667
2668       cairo_restore (cr);
2669
2670       y_loc += 2;
2671     }
2672
2673   if (detail && show_details)
2674     {
2675       gchar *markup = g_strconcat ("<small>", detail, "</small>", NULL);
2676       pango_layout_set_markup (layout, markup, -1);
2677       g_free (markup);
2678
2679       if (day == priv->selected_day)
2680         {
2681           /* Stripping colors as they conflict with selection marking. */
2682
2683           PangoAttrList *attrs = pango_layout_get_attributes (layout);
2684           PangoAttrList *colors = NULL;
2685
2686           if (attrs)
2687             colors = pango_attr_list_filter (attrs, is_color_attribute, NULL);
2688           if (colors)
2689             pango_attr_list_unref (colors);
2690         }
2691
2692       pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
2693       pango_layout_set_width (layout, PANGO_SCALE * day_rect.width);
2694
2695       if (priv->detail_height_rows)
2696         {
2697           gint dy = day_rect.height - (y_loc - day_rect.y);
2698           pango_layout_set_height (layout, PANGO_SCALE * dy);
2699           pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
2700         }
2701
2702       cairo_move_to (cr, day_rect.x, y_loc);
2703       pango_cairo_show_layout (cr, layout);
2704     }
2705
2706   if (gtk_widget_has_visible_focus (widget) &&
2707       priv->focus_row == row && priv->focus_col == col)
2708     gtk_render_focus (context, cr,
2709                       day_rect.x, day_rect.y,
2710                       day_rect.width, day_rect.height);
2711
2712   if (overflow)
2713     priv->detail_overflow[row] |= (1 << col);
2714   else
2715     priv->detail_overflow[row] &= ~(1 << col);
2716
2717   gtk_style_context_restore (context);
2718   g_object_unref (layout);
2719   g_free (detail);
2720 }
2721
2722 static void
2723 calendar_paint_main (GtkCalendar *calendar,
2724                      cairo_t     *cr)
2725 {
2726   gint row, col;
2727
2728   cairo_save (cr);
2729
2730   for (col = 0; col < 7; col++)
2731     for (row = 0; row < 6; row++)
2732       calendar_paint_day (calendar, cr, row, col);
2733
2734   cairo_restore (cr);
2735 }
2736
2737 static void
2738 calendar_invalidate_arrow (GtkCalendar *calendar,
2739                            guint        arrow)
2740 {
2741   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2742
2743   if (priv->display_flags & GTK_CALENDAR_SHOW_HEADING &&
2744       priv->arrow_win[arrow])
2745     {
2746       GdkRectangle rect;
2747       GtkAllocation allocation;
2748
2749       calendar_arrow_rectangle (calendar, arrow, &rect);
2750       gtk_widget_get_allocation (GTK_WIDGET (calendar), &allocation);
2751       gtk_widget_queue_draw_area (GTK_WIDGET (calendar),
2752                                   allocation.x + rect.x,
2753                                   allocation.y + rect.y,
2754                                   rect.width, rect.height);
2755     }
2756 }
2757
2758 static void
2759 calendar_paint_arrow (GtkCalendar *calendar,
2760                       cairo_t     *cr,
2761                       guint        arrow)
2762 {
2763   GtkWidget *widget = GTK_WIDGET (calendar);
2764   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
2765   GtkStyleContext *context;
2766   GtkStateFlags state;
2767   GdkRectangle rect;
2768   gdouble angle;
2769
2770   if (!priv->arrow_win[arrow])
2771     return;
2772
2773   calendar_arrow_rectangle (calendar, arrow, &rect);
2774
2775   cairo_save (cr);
2776
2777   context = gtk_widget_get_style_context (widget);
2778   state = gtk_widget_get_state_flags (widget);
2779
2780   if (priv->arrow_prelight & (1 << arrow))
2781     state |= GTK_STATE_FLAG_PRELIGHT;
2782   else
2783     state &= ~(GTK_STATE_FLAG_PRELIGHT);
2784
2785   gtk_style_context_save (context);
2786   gtk_style_context_set_state (context, state);
2787   gtk_style_context_add_class (context, GTK_STYLE_CLASS_BUTTON);
2788
2789   gtk_render_background (context, cr,
2790                          rect.x, rect.y,
2791                          rect.width, rect.height);
2792
2793   if (arrow == ARROW_MONTH_LEFT || arrow == ARROW_YEAR_LEFT)
2794     angle = 3 * (G_PI / 2);
2795   else
2796     angle = G_PI / 2;
2797
2798   gtk_render_arrow (context, cr, angle,
2799                     rect.x + (rect.width - 8) / 2,
2800                     rect.y + (rect.height - 8) / 2,
2801                     8);
2802
2803   gtk_style_context_restore (context);
2804   cairo_restore (cr);
2805 }
2806
2807 static gboolean
2808 gtk_calendar_draw (GtkWidget *widget,
2809                    cairo_t   *cr)
2810 {
2811   GtkCalendar *calendar = GTK_CALENDAR (widget);
2812   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
2813   int i;
2814
2815   if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
2816     {
2817       GtkStyleContext *context;
2818
2819       context = gtk_widget_get_style_context (widget);
2820
2821       gtk_style_context_save (context);
2822       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2823
2824       gtk_render_background (context, cr, 0, 0,
2825                              gtk_widget_get_allocated_width (widget),
2826                              gtk_widget_get_allocated_height (widget));
2827       gtk_render_frame (context, cr, 0, 0,
2828                         gtk_widget_get_allocated_width (widget),
2829                         gtk_widget_get_allocated_height (widget));
2830
2831       gtk_style_context_restore (context);
2832     }
2833
2834   calendar_paint_main (calendar, cr);
2835
2836   if (priv->display_flags & GTK_CALENDAR_SHOW_HEADING)
2837     {
2838       calendar_paint_header (calendar, cr);
2839       for (i = 0; i < 4; i++)
2840         calendar_paint_arrow (calendar, cr, i);
2841     }
2842
2843   if (priv->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
2844     calendar_paint_day_names (calendar, cr);
2845
2846   if (priv->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
2847     calendar_paint_week_numbers (calendar, cr);
2848
2849   return FALSE;
2850 }
2851
2852
2853 /****************************************
2854  *           Mouse handling             *
2855  ****************************************/
2856
2857 static void
2858 calendar_arrow_action (GtkCalendar *calendar,
2859                        guint        arrow)
2860 {
2861   switch (arrow)
2862     {
2863     case ARROW_YEAR_LEFT:
2864       calendar_set_year_prev (calendar);
2865       break;
2866     case ARROW_YEAR_RIGHT:
2867       calendar_set_year_next (calendar);
2868       break;
2869     case ARROW_MONTH_LEFT:
2870       calendar_set_month_prev (calendar);
2871       break;
2872     case ARROW_MONTH_RIGHT:
2873       calendar_set_month_next (calendar);
2874       break;
2875     default:;
2876       /* do nothing */
2877     }
2878 }
2879
2880 static gboolean
2881 calendar_timer (gpointer data)
2882 {
2883   GtkCalendar *calendar = data;
2884   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2885   gboolean retval = FALSE;
2886
2887   if (priv->timer)
2888     {
2889       calendar_arrow_action (calendar, priv->click_child);
2890
2891       if (priv->need_timer)
2892         {
2893           GtkSettings *settings;
2894           guint        timeout;
2895
2896           settings = gtk_widget_get_settings (GTK_WIDGET (calendar));
2897           g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
2898
2899           priv->need_timer = FALSE;
2900           priv->timer = gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT_IDLE,
2901                                             timeout * SCROLL_DELAY_FACTOR,
2902                                             (GSourceFunc) calendar_timer,
2903                                             (gpointer) calendar, NULL);
2904         }
2905       else
2906         retval = TRUE;
2907     }
2908
2909   return retval;
2910 }
2911
2912 static void
2913 calendar_start_spinning (GtkCalendar *calendar,
2914                          gint         click_child)
2915 {
2916   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2917
2918   priv->click_child = click_child;
2919
2920   if (!priv->timer)
2921     {
2922       GtkSettings *settings;
2923       guint        timeout;
2924
2925       settings = gtk_widget_get_settings (GTK_WIDGET (calendar));
2926       g_object_get (settings, "gtk-timeout-initial", &timeout, NULL);
2927
2928       priv->need_timer = TRUE;
2929       priv->timer = gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT_IDLE,
2930                                         timeout,
2931                                         (GSourceFunc) calendar_timer,
2932                                         (gpointer) calendar, NULL);
2933     }
2934 }
2935
2936 static void
2937 calendar_stop_spinning (GtkCalendar *calendar)
2938 {
2939   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2940
2941   if (priv->timer)
2942     {
2943       g_source_remove (priv->timer);
2944       priv->timer = 0;
2945       priv->need_timer = FALSE;
2946     }
2947 }
2948
2949 static void
2950 calendar_main_button_press (GtkCalendar    *calendar,
2951                             GdkEventButton *event)
2952 {
2953   GtkWidget *widget = GTK_WIDGET (calendar);
2954   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
2955   gint x, y;
2956   gint win_x, win_y;
2957   gint row, col;
2958   gint day_month;
2959   gint day;
2960   GtkAllocation allocation;
2961
2962   x = (gint) (event->x);
2963   y = (gint) (event->y);
2964
2965   gdk_window_get_position (priv->main_win, &win_x, &win_y);
2966   gtk_widget_get_allocation (widget, &allocation);
2967
2968   row = calendar_row_from_y (calendar, y + win_y - allocation.y);
2969   col = calendar_column_from_x (calendar, x + win_x - allocation.x);
2970
2971   /* If row or column isn't found, just return. */
2972   if (row == -1 || col == -1)
2973     return;
2974
2975   day_month = priv->day_month[row][col];
2976
2977   if (event->type == GDK_BUTTON_PRESS)
2978     {
2979       day = priv->day[row][col];
2980
2981       if (day_month == MONTH_PREV)
2982         calendar_set_month_prev (calendar);
2983       else if (day_month == MONTH_NEXT)
2984         calendar_set_month_next (calendar);
2985
2986       if (!gtk_widget_has_focus (widget))
2987         gtk_widget_grab_focus (widget);
2988
2989       if (event->button == GDK_BUTTON_PRIMARY)
2990         {
2991           priv->in_drag = 1;
2992           priv->drag_start_x = x;
2993           priv->drag_start_y = y;
2994         }
2995
2996       calendar_select_and_focus_day (calendar, day);
2997     }
2998   else if (event->type == GDK_2BUTTON_PRESS)
2999     {
3000       priv->in_drag = 0;
3001       if (day_month == MONTH_CURRENT)
3002         g_signal_emit (calendar,
3003                        gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL],
3004                        0);
3005     }
3006 }
3007
3008 static gboolean
3009 gtk_calendar_button_press (GtkWidget      *widget,
3010                            GdkEventButton *event)
3011 {
3012   GtkCalendar *calendar = GTK_CALENDAR (widget);
3013   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3014   gint arrow = -1;
3015
3016   if (event->window == priv->main_win)
3017     calendar_main_button_press (calendar, event);
3018
3019   if (!gtk_widget_has_focus (widget))
3020     gtk_widget_grab_focus (widget);
3021
3022   for (arrow = ARROW_YEAR_LEFT; arrow <= ARROW_MONTH_RIGHT; arrow++)
3023     {
3024       if (event->window == priv->arrow_win[arrow])
3025         {
3026
3027           /* only call the action on single click, not double */
3028           if (event->type == GDK_BUTTON_PRESS)
3029             {
3030               if (event->button == GDK_BUTTON_PRIMARY)
3031                 calendar_start_spinning (calendar, arrow);
3032
3033               calendar_arrow_action (calendar, arrow);
3034             }
3035
3036           return TRUE;
3037         }
3038     }
3039
3040   return FALSE;
3041 }
3042
3043 static gboolean
3044 gtk_calendar_button_release (GtkWidget    *widget,
3045                              GdkEventButton *event)
3046 {
3047   GtkCalendar *calendar = GTK_CALENDAR (widget);
3048   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3049
3050   if (event->button == GDK_BUTTON_PRIMARY)
3051     {
3052       calendar_stop_spinning (calendar);
3053
3054       if (priv->in_drag)
3055         priv->in_drag = 0;
3056     }
3057
3058   return TRUE;
3059 }
3060
3061 static gboolean
3062 gtk_calendar_motion_notify (GtkWidget      *widget,
3063                             GdkEventMotion *event)
3064 {
3065   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3066
3067   if (priv->in_drag)
3068     {
3069       if (gtk_drag_check_threshold (widget,
3070                                     priv->drag_start_x, priv->drag_start_y,
3071                                     event->x, event->y))
3072         {
3073           GdkDragContext *context;
3074           GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
3075           gtk_target_list_add_text_targets (target_list, 0);
3076           context = gtk_drag_begin (widget, target_list, GDK_ACTION_COPY,
3077                                     1, (GdkEvent *)event);
3078
3079           priv->in_drag = 0;
3080           gtk_target_list_unref (target_list);
3081           gtk_drag_set_icon_default (context);
3082         }
3083     }
3084
3085   return TRUE;
3086 }
3087
3088 static gboolean
3089 gtk_calendar_enter_notify (GtkWidget        *widget,
3090                            GdkEventCrossing *event)
3091 {
3092   GtkCalendar *calendar = GTK_CALENDAR (widget);
3093   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3094
3095   if (event->window == priv->arrow_win[ARROW_MONTH_LEFT])
3096     {
3097       priv->arrow_prelight |= (1 << ARROW_MONTH_LEFT);
3098       calendar_invalidate_arrow (calendar, ARROW_MONTH_LEFT);
3099     }
3100
3101   if (event->window == priv->arrow_win[ARROW_MONTH_RIGHT])
3102     {
3103       priv->arrow_prelight |= (1 << ARROW_MONTH_RIGHT);
3104       calendar_invalidate_arrow (calendar, ARROW_MONTH_RIGHT);
3105     }
3106
3107   if (event->window == priv->arrow_win[ARROW_YEAR_LEFT])
3108     {
3109       priv->arrow_prelight |= (1 << ARROW_YEAR_LEFT);
3110       calendar_invalidate_arrow (calendar, ARROW_YEAR_LEFT);
3111     }
3112
3113   if (event->window == priv->arrow_win[ARROW_YEAR_RIGHT])
3114     {
3115       priv->arrow_prelight |= (1 << ARROW_YEAR_RIGHT);
3116       calendar_invalidate_arrow (calendar, ARROW_YEAR_RIGHT);
3117     }
3118
3119   return TRUE;
3120 }
3121
3122 static gboolean
3123 gtk_calendar_leave_notify (GtkWidget        *widget,
3124                            GdkEventCrossing *event)
3125 {
3126   GtkCalendar *calendar = GTK_CALENDAR (widget);
3127   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3128
3129   if (event->window == priv->arrow_win[ARROW_MONTH_LEFT])
3130     {
3131       priv->arrow_prelight &= ~(1 << ARROW_MONTH_LEFT);
3132       calendar_invalidate_arrow (calendar, ARROW_MONTH_LEFT);
3133     }
3134
3135   if (event->window == priv->arrow_win[ARROW_MONTH_RIGHT])
3136     {
3137       priv->arrow_prelight &= ~(1 << ARROW_MONTH_RIGHT);
3138       calendar_invalidate_arrow (calendar, ARROW_MONTH_RIGHT);
3139     }
3140
3141   if (event->window == priv->arrow_win[ARROW_YEAR_LEFT])
3142     {
3143       priv->arrow_prelight &= ~(1 << ARROW_YEAR_LEFT);
3144       calendar_invalidate_arrow (calendar, ARROW_YEAR_LEFT);
3145     }
3146
3147   if (event->window == priv->arrow_win[ARROW_YEAR_RIGHT])
3148     {
3149       priv->arrow_prelight &= ~(1 << ARROW_YEAR_RIGHT);
3150       calendar_invalidate_arrow (calendar, ARROW_YEAR_RIGHT);
3151     }
3152
3153   return TRUE;
3154 }
3155
3156 static gboolean
3157 gtk_calendar_scroll (GtkWidget      *widget,
3158                      GdkEventScroll *event)
3159 {
3160   GtkCalendar *calendar = GTK_CALENDAR (widget);
3161
3162   if (event->direction == GDK_SCROLL_UP)
3163     {
3164       if (!gtk_widget_has_focus (widget))
3165         gtk_widget_grab_focus (widget);
3166       calendar_set_month_prev (calendar);
3167     }
3168   else if (event->direction == GDK_SCROLL_DOWN)
3169     {
3170       if (!gtk_widget_has_focus (widget))
3171         gtk_widget_grab_focus (widget);
3172       calendar_set_month_next (calendar);
3173     }
3174   else
3175     return FALSE;
3176
3177   return TRUE;
3178 }
3179
3180 \f
3181 /****************************************
3182  *             Key handling              *
3183  ****************************************/
3184
3185 static void
3186 move_focus (GtkCalendar *calendar,
3187             gint         direction)
3188 {
3189   GtkCalendarPrivate *priv = calendar->priv;
3190   GtkTextDirection text_dir = gtk_widget_get_direction (GTK_WIDGET (calendar));
3191
3192   if ((text_dir == GTK_TEXT_DIR_LTR && direction == -1) ||
3193       (text_dir == GTK_TEXT_DIR_RTL && direction == 1))
3194     {
3195       if (priv->focus_col > 0)
3196           priv->focus_col--;
3197       else if (priv->focus_row > 0)
3198         {
3199           priv->focus_col = 6;
3200           priv->focus_row--;
3201         }
3202
3203       if (priv->focus_col < 0)
3204         priv->focus_col = 6;
3205       if (priv->focus_row < 0)
3206         priv->focus_row = 5;
3207     }
3208   else
3209     {
3210       if (priv->focus_col < 6)
3211         priv->focus_col++;
3212       else if (priv->focus_row < 5)
3213         {
3214           priv->focus_col = 0;
3215           priv->focus_row++;
3216         }
3217
3218       if (priv->focus_col < 0)
3219         priv->focus_col = 0;
3220       if (priv->focus_row < 0)
3221         priv->focus_row = 0;
3222     }
3223 }
3224
3225 static gboolean
3226 gtk_calendar_key_press (GtkWidget   *widget,
3227                         GdkEventKey *event)
3228 {
3229   GtkCalendar *calendar = GTK_CALENDAR (widget);
3230   GtkCalendarPrivate *priv = calendar->priv;
3231   gint return_val;
3232   gint old_focus_row;
3233   gint old_focus_col;
3234   gint row, col, day;
3235
3236   return_val = FALSE;
3237
3238   old_focus_row = priv->focus_row;
3239   old_focus_col = priv->focus_col;
3240
3241   switch (event->keyval)
3242     {
3243     case GDK_KEY_KP_Left:
3244     case GDK_KEY_Left:
3245       return_val = TRUE;
3246       if (event->state & GDK_CONTROL_MASK)
3247         calendar_set_month_prev (calendar);
3248       else
3249         {
3250           move_focus (calendar, -1);
3251           calendar_invalidate_day (calendar, old_focus_row, old_focus_col);
3252           calendar_invalidate_day (calendar, priv->focus_row,
3253                                    priv->focus_col);
3254         }
3255       break;
3256     case GDK_KEY_KP_Right:
3257     case GDK_KEY_Right:
3258       return_val = TRUE;
3259       if (event->state & GDK_CONTROL_MASK)
3260         calendar_set_month_next (calendar);
3261       else
3262         {
3263           move_focus (calendar, 1);
3264           calendar_invalidate_day (calendar, old_focus_row, old_focus_col);
3265           calendar_invalidate_day (calendar, priv->focus_row,
3266                                    priv->focus_col);
3267         }
3268       break;
3269     case GDK_KEY_KP_Up:
3270     case GDK_KEY_Up:
3271       return_val = TRUE;
3272       if (event->state & GDK_CONTROL_MASK)
3273         calendar_set_year_prev (calendar);
3274       else
3275         {
3276           if (priv->focus_row > 0)
3277             priv->focus_row--;
3278           if (priv->focus_row < 0)
3279             priv->focus_row = 5;
3280           if (priv->focus_col < 0)
3281             priv->focus_col = 6;
3282           calendar_invalidate_day (calendar, old_focus_row, old_focus_col);
3283           calendar_invalidate_day (calendar, priv->focus_row,
3284                                    priv->focus_col);
3285         }
3286       break;
3287     case GDK_KEY_KP_Down:
3288     case GDK_KEY_Down:
3289       return_val = TRUE;
3290       if (event->state & GDK_CONTROL_MASK)
3291         calendar_set_year_next (calendar);
3292       else
3293         {
3294           if (priv->focus_row < 5)
3295             priv->focus_row++;
3296           if (priv->focus_col < 0)
3297             priv->focus_col = 0;
3298           calendar_invalidate_day (calendar, old_focus_row, old_focus_col);
3299           calendar_invalidate_day (calendar, priv->focus_row,
3300                                    priv->focus_col);
3301         }
3302       break;
3303     case GDK_KEY_KP_Space:
3304     case GDK_KEY_space:
3305       row = priv->focus_row;
3306       col = priv->focus_col;
3307
3308       if (row > -1 && col > -1)
3309         {
3310           return_val = TRUE;
3311
3312           day = priv->day[row][col];
3313           if (priv->day_month[row][col] == MONTH_PREV)
3314             calendar_set_month_prev (calendar);
3315           else if (priv->day_month[row][col] == MONTH_NEXT)
3316             calendar_set_month_next (calendar);
3317
3318           calendar_select_and_focus_day (calendar, day);
3319         }
3320     }
3321
3322   return return_val;
3323 }
3324
3325 \f
3326 /****************************************
3327  *           Misc widget methods        *
3328  ****************************************/
3329
3330 static void
3331 gtk_calendar_state_flags_changed (GtkWidget     *widget,
3332                                   GtkStateFlags  previous_state)
3333 {
3334   GtkCalendar *calendar = GTK_CALENDAR (widget);
3335   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3336
3337   if (!gtk_widget_is_sensitive (widget))
3338     {
3339       priv->in_drag = 0;
3340       calendar_stop_spinning (calendar);
3341     }
3342 }
3343
3344 static void
3345 gtk_calendar_grab_notify (GtkWidget *widget,
3346                           gboolean   was_grabbed)
3347 {
3348   if (!was_grabbed)
3349     calendar_stop_spinning (GTK_CALENDAR (widget));
3350 }
3351
3352 static gboolean
3353 gtk_calendar_focus_out (GtkWidget     *widget,
3354                         GdkEventFocus *event)
3355 {
3356   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3357   GtkCalendar *calendar = GTK_CALENDAR (widget);
3358
3359   calendar_queue_refresh (calendar);
3360   calendar_stop_spinning (calendar);
3361
3362   priv->in_drag = 0;
3363
3364   return FALSE;
3365 }
3366
3367 \f
3368 /****************************************
3369  *          Drag and Drop               *
3370  ****************************************/
3371
3372 static void
3373 gtk_calendar_drag_data_get (GtkWidget        *widget,
3374                             GdkDragContext   *context,
3375                             GtkSelectionData *selection_data,
3376                             guint             info,
3377                             guint             time)
3378 {
3379   GtkCalendar *calendar = GTK_CALENDAR (widget);
3380   GtkCalendarPrivate *priv = calendar->priv;
3381   GDate *date;
3382   gchar str[128];
3383   gsize len;
3384
3385   date = g_date_new_dmy (priv->selected_day, priv->month + 1, priv->year);
3386   len = g_date_strftime (str, 127, "%x", date);
3387   gtk_selection_data_set_text (selection_data, str, len);
3388
3389   g_free (date);
3390 }
3391
3392 /* Get/set whether drag_motion requested the drag data and
3393  * drag_data_received should thus not actually insert the data,
3394  * since the data doesn't result from a drop.
3395  */
3396 static void
3397 set_status_pending (GdkDragContext *context,
3398                     GdkDragAction   suggested_action)
3399 {
3400   g_object_set_data (G_OBJECT (context),
3401                      I_("gtk-calendar-status-pending"),
3402                      GINT_TO_POINTER (suggested_action));
3403 }
3404
3405 static GdkDragAction
3406 get_status_pending (GdkDragContext *context)
3407 {
3408   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
3409                                              "gtk-calendar-status-pending"));
3410 }
3411
3412 static void
3413 gtk_calendar_drag_leave (GtkWidget      *widget,
3414                          GdkDragContext *context,
3415                          guint           time)
3416 {
3417   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3418
3419   priv->drag_highlight = 0;
3420   gtk_drag_unhighlight (widget);
3421
3422 }
3423
3424 static gboolean
3425 gtk_calendar_drag_motion (GtkWidget      *widget,
3426                           GdkDragContext *context,
3427                           gint            x,
3428                           gint            y,
3429                           guint           time)
3430 {
3431   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
3432   GdkAtom target;
3433
3434   if (!priv->drag_highlight)
3435     {
3436       priv->drag_highlight = 1;
3437       gtk_drag_highlight (widget);
3438     }
3439
3440   target = gtk_drag_dest_find_target (widget, context, NULL);
3441   if (target == GDK_NONE || gdk_drag_context_get_suggested_action (context) == 0)
3442     gdk_drag_status (context, 0, time);
3443   else
3444     {
3445       set_status_pending (context, gdk_drag_context_get_suggested_action (context));
3446       gtk_drag_get_data (widget, context, target, time);
3447     }
3448
3449   return TRUE;
3450 }
3451
3452 static gboolean
3453 gtk_calendar_drag_drop (GtkWidget      *widget,
3454                         GdkDragContext *context,
3455                         gint            x,
3456                         gint            y,
3457                         guint           time)
3458 {
3459   GdkAtom target;
3460
3461   target = gtk_drag_dest_find_target (widget, context, NULL);
3462   if (target != GDK_NONE)
3463     {
3464       gtk_drag_get_data (widget, context,
3465                          target,
3466                          time);
3467       return TRUE;
3468     }
3469
3470   return FALSE;
3471 }
3472
3473 static void
3474 gtk_calendar_drag_data_received (GtkWidget        *widget,
3475                                  GdkDragContext   *context,
3476                                  gint              x,
3477                                  gint              y,
3478                                  GtkSelectionData *selection_data,
3479                                  guint             info,
3480                                  guint             time)
3481 {
3482   GtkCalendar *calendar = GTK_CALENDAR (widget);
3483   GtkCalendarPrivate *priv = calendar->priv;
3484   guint day, month, year;
3485   gchar *str;
3486   GDate *date;
3487   GdkDragAction suggested_action;
3488
3489   suggested_action = get_status_pending (context);
3490
3491   if (suggested_action)
3492     {
3493       set_status_pending (context, 0);
3494
3495       /* We are getting this data due to a request in drag_motion,
3496        * rather than due to a request in drag_drop, so we are just
3497        * supposed to call drag_status, not actually paste in the
3498        * data.
3499        */
3500       str = (gchar*) gtk_selection_data_get_text (selection_data);
3501
3502       if (str)
3503         {
3504           date = g_date_new ();
3505           g_date_set_parse (date, str);
3506           if (!g_date_valid (date))
3507               suggested_action = 0;
3508           g_date_free (date);
3509           g_free (str);
3510         }
3511       else
3512         suggested_action = 0;
3513
3514       gdk_drag_status (context, suggested_action, time);
3515
3516       return;
3517     }
3518
3519   date = g_date_new ();
3520   str = (gchar*) gtk_selection_data_get_text (selection_data);
3521   if (str)
3522     {
3523       g_date_set_parse (date, str);
3524       g_free (str);
3525     }
3526
3527   if (!g_date_valid (date))
3528     {
3529       g_warning ("Received invalid date data\n");
3530       g_date_free (date);
3531       gtk_drag_finish (context, FALSE, FALSE, time);
3532       return;
3533     }
3534
3535   day = g_date_get_day (date);
3536   month = g_date_get_month (date);
3537   year = g_date_get_year (date);
3538   g_date_free (date);
3539
3540   gtk_drag_finish (context, TRUE, FALSE, time);
3541
3542
3543   g_object_freeze_notify (G_OBJECT (calendar));
3544   if (!(priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
3545       && (priv->display_flags & GTK_CALENDAR_SHOW_HEADING))
3546     gtk_calendar_select_month (calendar, month - 1, year);
3547   gtk_calendar_select_day (calendar, day);
3548   g_object_thaw_notify (G_OBJECT (calendar));
3549 }
3550
3551 \f
3552 /****************************************
3553  *              Public API              *
3554  ****************************************/
3555
3556 /**
3557  * gtk_calendar_new:
3558  *
3559  * Creates a new calendar, with the current date being selected.
3560  *
3561  * Return value: a newly #GtkCalendar widget
3562  **/
3563 GtkWidget*
3564 gtk_calendar_new (void)
3565 {
3566   return g_object_new (GTK_TYPE_CALENDAR, NULL);
3567 }
3568
3569 /**
3570  * gtk_calendar_get_display_options:
3571  * @calendar: a #GtkCalendar
3572  *
3573  * Returns the current display options of @calendar.
3574  *
3575  * Return value: the display options.
3576  *
3577  * Since: 2.4
3578  **/
3579 GtkCalendarDisplayOptions
3580 gtk_calendar_get_display_options (GtkCalendar         *calendar)
3581 {
3582   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), 0);
3583
3584   return calendar->priv->display_flags;
3585 }
3586
3587 /**
3588  * gtk_calendar_set_display_options:
3589  * @calendar: a #GtkCalendar
3590  * @flags: the display options to set
3591  *
3592  * Sets display options (whether to display the heading and the month
3593  * headings).
3594  *
3595  * Since: 2.4
3596  **/
3597 void
3598 gtk_calendar_set_display_options (GtkCalendar          *calendar,
3599                                   GtkCalendarDisplayOptions flags)
3600 {
3601   GtkWidget *widget = GTK_WIDGET (calendar);
3602   GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
3603   gint resize = 0;
3604   GtkCalendarDisplayOptions old_flags;
3605
3606   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3607
3608   old_flags = priv->display_flags;
3609
3610   if (gtk_widget_get_realized (widget))
3611     {
3612       if ((flags ^ priv->display_flags) & GTK_CALENDAR_NO_MONTH_CHANGE)
3613         {
3614           resize ++;
3615           if (! (flags & GTK_CALENDAR_NO_MONTH_CHANGE)
3616               && (priv->display_flags & GTK_CALENDAR_SHOW_HEADING))
3617             {
3618               priv->display_flags &= ~GTK_CALENDAR_NO_MONTH_CHANGE;
3619               calendar_realize_arrows (calendar);
3620               if (gtk_widget_get_mapped (widget))
3621                 calendar_map_arrows (calendar);
3622             }
3623           else
3624             {
3625               calendar_unrealize_arrows (calendar);
3626             }
3627         }
3628
3629       if ((flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_HEADING)
3630         {
3631           resize++;
3632
3633           if (flags & GTK_CALENDAR_SHOW_HEADING)
3634             {
3635               priv->display_flags |= GTK_CALENDAR_SHOW_HEADING;
3636               calendar_realize_arrows (calendar);
3637               if (gtk_widget_get_mapped (widget))
3638                 calendar_map_arrows (calendar);
3639             }
3640           else
3641             {
3642               calendar_unrealize_arrows (calendar);
3643             }
3644         }
3645
3646       if ((flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_DAY_NAMES)
3647         {
3648           resize++;
3649
3650           if (flags & GTK_CALENDAR_SHOW_DAY_NAMES)
3651             priv->display_flags |= GTK_CALENDAR_SHOW_DAY_NAMES;
3652         }
3653
3654       if ((flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
3655         {
3656           resize++;
3657
3658           if (flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
3659             priv->display_flags |= GTK_CALENDAR_SHOW_WEEK_NUMBERS;
3660         }
3661
3662       if ((flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_DETAILS)
3663         resize++;
3664
3665       priv->display_flags = flags;
3666       if (resize)
3667         gtk_widget_queue_resize (GTK_WIDGET (calendar));
3668     }
3669   else
3670     priv->display_flags = flags;
3671
3672   g_object_freeze_notify (G_OBJECT (calendar));
3673   if ((old_flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_HEADING)
3674     g_object_notify (G_OBJECT (calendar), "show-heading");
3675   if ((old_flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_DAY_NAMES)
3676     g_object_notify (G_OBJECT (calendar), "show-day-names");
3677   if ((old_flags ^ priv->display_flags) & GTK_CALENDAR_NO_MONTH_CHANGE)
3678     g_object_notify (G_OBJECT (calendar), "no-month-change");
3679   if ((old_flags ^ priv->display_flags) & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
3680     g_object_notify (G_OBJECT (calendar), "show-week-numbers");
3681   g_object_thaw_notify (G_OBJECT (calendar));
3682 }
3683
3684 /**
3685  * gtk_calendar_select_month:
3686  * @calendar: a #GtkCalendar
3687  * @month: a month number between 0 and 11.
3688  * @year: the year the month is in.
3689  *
3690  * Shifts the calendar to a different month.
3691  **/
3692 void
3693 gtk_calendar_select_month (GtkCalendar *calendar,
3694                            guint        month,
3695                            guint        year)
3696 {
3697   GtkCalendarPrivate *priv;
3698
3699   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3700   g_return_if_fail (month <= 11);
3701
3702   priv = calendar->priv;
3703
3704   priv->month = month;
3705   priv->year  = year;
3706
3707   calendar_compute_days (calendar);
3708   calendar_queue_refresh (calendar);
3709
3710   g_object_freeze_notify (G_OBJECT (calendar));
3711   g_object_notify (G_OBJECT (calendar), "month");
3712   g_object_notify (G_OBJECT (calendar), "year");
3713   g_object_thaw_notify (G_OBJECT (calendar));
3714
3715   g_signal_emit (calendar,
3716                  gtk_calendar_signals[MONTH_CHANGED_SIGNAL],
3717                  0);
3718 }
3719
3720 /**
3721  * gtk_calendar_select_day:
3722  * @calendar: a #GtkCalendar.
3723  * @day: the day number between 1 and 31, or 0 to unselect
3724  *   the currently selected day.
3725  *
3726  * Selects a day from the current month.
3727  **/
3728 void
3729 gtk_calendar_select_day (GtkCalendar *calendar,
3730                          guint        day)
3731 {
3732   GtkCalendarPrivate *priv;
3733
3734   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3735   g_return_if_fail (day <= 31);
3736
3737   priv = calendar->priv;
3738
3739   /* Deselect the old day */
3740   if (priv->selected_day > 0)
3741     {
3742       gint selected_day;
3743
3744       selected_day = priv->selected_day;
3745       priv->selected_day = 0;
3746       if (gtk_widget_is_drawable (GTK_WIDGET (calendar)))
3747         calendar_invalidate_day_num (calendar, selected_day);
3748     }
3749
3750   priv->selected_day = day;
3751
3752   /* Select the new day */
3753   if (day != 0)
3754     {
3755       if (gtk_widget_is_drawable (GTK_WIDGET (calendar)))
3756         calendar_invalidate_day_num (calendar, day);
3757     }
3758
3759   g_object_notify (G_OBJECT (calendar), "day");
3760
3761   g_signal_emit (calendar,
3762                  gtk_calendar_signals[DAY_SELECTED_SIGNAL],
3763                  0);
3764 }
3765
3766 /**
3767  * gtk_calendar_clear_marks:
3768  * @calendar: a #GtkCalendar
3769  *
3770  * Remove all visual markers.
3771  **/
3772 void
3773 gtk_calendar_clear_marks (GtkCalendar *calendar)
3774 {
3775   GtkCalendarPrivate *priv;
3776   guint day;
3777
3778   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3779
3780   priv = calendar->priv;
3781
3782   for (day = 0; day < 31; day++)
3783     {
3784       priv->marked_date[day] = FALSE;
3785     }
3786
3787   priv->num_marked_dates = 0;
3788   calendar_queue_refresh (calendar);
3789 }
3790
3791 /**
3792  * gtk_calendar_mark_day:
3793  * @calendar: a #GtkCalendar
3794  * @day: the day number to mark between 1 and 31.
3795  *
3796  * Places a visual marker on a particular day.
3797  */
3798 void
3799 gtk_calendar_mark_day (GtkCalendar *calendar,
3800                        guint        day)
3801 {
3802   GtkCalendarPrivate *priv;
3803
3804   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3805
3806   priv = calendar->priv;
3807
3808   if (day >= 1 && day <= 31 && !priv->marked_date[day-1])
3809     {
3810       priv->marked_date[day - 1] = TRUE;
3811       priv->num_marked_dates++;
3812       calendar_invalidate_day_num (calendar, day);
3813     }
3814 }
3815
3816 /**
3817  * gtk_calendar_get_day_is_marked:
3818  * @calendar: a #GtkCalendar
3819  * @day: the day number between 1 and 31.
3820  *
3821  * Returns if the @day of the @calendar is already marked.
3822  *
3823  * Returns: whether the day is marked.
3824  *
3825  * Since: 3.0
3826  */
3827 gboolean
3828 gtk_calendar_get_day_is_marked (GtkCalendar *calendar,
3829                                 guint        day)
3830 {
3831   GtkCalendarPrivate *priv;
3832
3833   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), FALSE);
3834
3835   priv = calendar->priv;
3836
3837   if (day >= 1 && day <= 31)
3838     return priv->marked_date[day - 1];
3839
3840   return FALSE;
3841 }
3842
3843 /**
3844  * gtk_calendar_unmark_day:
3845  * @calendar: a #GtkCalendar.
3846  * @day: the day number to unmark between 1 and 31.
3847  *
3848  * Removes the visual marker from a particular day.
3849  */
3850 void
3851 gtk_calendar_unmark_day (GtkCalendar *calendar,
3852                          guint        day)
3853 {
3854   GtkCalendarPrivate *priv;
3855
3856   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3857
3858   priv = calendar->priv;
3859
3860   if (day >= 1 && day <= 31 && priv->marked_date[day-1])
3861     {
3862       priv->marked_date[day - 1] = FALSE;
3863       priv->num_marked_dates--;
3864       calendar_invalidate_day_num (calendar, day);
3865     }
3866 }
3867
3868 /**
3869  * gtk_calendar_get_date:
3870  * @calendar: a #GtkCalendar
3871  * @year: (out) (allow-none): location to store the year as a decimal
3872  *     number (e.g. 2011), or %NULL
3873  * @month: (out) (allow-none): location to store the month number
3874  *     (between 0 and 11), or %NULL
3875  * @day: (out) (allow-none): location to store the day number (between
3876  *     1 and 31), or %NULL
3877  *
3878  * Obtains the selected date from a #GtkCalendar.
3879  */
3880 void
3881 gtk_calendar_get_date (GtkCalendar *calendar,
3882                        guint       *year,
3883                        guint       *month,
3884                        guint       *day)
3885 {
3886   GtkCalendarPrivate *priv;
3887
3888   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3889
3890   priv = calendar->priv;
3891
3892   if (year)
3893     *year = priv->year;
3894
3895   if (month)
3896     *month = priv->month;
3897
3898   if (day)
3899     *day = priv->selected_day;
3900 }
3901
3902 /**
3903  * gtk_calendar_set_detail_func:
3904  * @calendar: a #GtkCalendar.
3905  * @func: a function providing details for each day.
3906  * @data: data to pass to @func invokations.
3907  * @destroy: a function for releasing @data.
3908  *
3909  * Installs a function which provides Pango markup with detail information
3910  * for each day. Examples for such details are holidays or appointments. That
3911  * information is shown below each day when #GtkCalendar:show-details is set.
3912  * A tooltip containing with full detail information is provided, if the entire
3913  * text should not fit into the details area, or if #GtkCalendar:show-details
3914  * is not set.
3915  *
3916  * The size of the details area can be restricted by setting the
3917  * #GtkCalendar:detail-width-chars and #GtkCalendar:detail-height-rows
3918  * properties.
3919  *
3920  * Since: 2.14
3921  */
3922 void
3923 gtk_calendar_set_detail_func (GtkCalendar           *calendar,
3924                               GtkCalendarDetailFunc  func,
3925                               gpointer               data,
3926                               GDestroyNotify         destroy)
3927 {
3928   GtkCalendarPrivate *priv;
3929
3930   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3931
3932   priv = GTK_CALENDAR_GET_PRIVATE (calendar);
3933
3934   if (priv->detail_func_destroy)
3935     priv->detail_func_destroy (priv->detail_func_user_data);
3936
3937   priv->detail_func = func;
3938   priv->detail_func_user_data = data;
3939   priv->detail_func_destroy = destroy;
3940
3941   gtk_widget_set_has_tooltip (GTK_WIDGET (calendar),
3942                               NULL != priv->detail_func);
3943   gtk_widget_queue_resize (GTK_WIDGET (calendar));
3944 }
3945
3946 /**
3947  * gtk_calendar_set_detail_width_chars:
3948  * @calendar: a #GtkCalendar.
3949  * @chars: detail width in characters.
3950  *
3951  * Updates the width of detail cells.
3952  * See #GtkCalendar:detail-width-chars.
3953  *
3954  * Since: 2.14
3955  */
3956 void
3957 gtk_calendar_set_detail_width_chars (GtkCalendar *calendar,
3958                                      gint         chars)
3959 {
3960   GtkCalendarPrivate *priv;
3961
3962   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3963
3964   priv = GTK_CALENDAR_GET_PRIVATE (calendar);
3965
3966   if (chars != priv->detail_width_chars)
3967     {
3968       priv->detail_width_chars = chars;
3969       g_object_notify (G_OBJECT (calendar), "detail-width-chars");
3970       gtk_widget_queue_resize_no_redraw (GTK_WIDGET (calendar));
3971     }
3972 }
3973
3974 /**
3975  * gtk_calendar_set_detail_height_rows:
3976  * @calendar: a #GtkCalendar.
3977  * @rows: detail height in rows.
3978  *
3979  * Updates the height of detail cells.
3980  * See #GtkCalendar:detail-height-rows.
3981  *
3982  * Since: 2.14
3983  */
3984 void
3985 gtk_calendar_set_detail_height_rows (GtkCalendar *calendar,
3986                                      gint         rows)
3987 {
3988   GtkCalendarPrivate *priv;
3989
3990   g_return_if_fail (GTK_IS_CALENDAR (calendar));
3991
3992   priv = GTK_CALENDAR_GET_PRIVATE (calendar);
3993
3994   if (rows != priv->detail_height_rows)
3995     {
3996       priv->detail_height_rows = rows;
3997       g_object_notify (G_OBJECT (calendar), "detail-height-rows");
3998       gtk_widget_queue_resize_no_redraw (GTK_WIDGET (calendar));
3999     }
4000 }
4001
4002 /**
4003  * gtk_calendar_get_detail_width_chars:
4004  * @calendar: a #GtkCalendar.
4005  *
4006  * Queries the width of detail cells, in characters.
4007  * See #GtkCalendar:detail-width-chars.
4008  *
4009  * Since: 2.14
4010  *
4011  * Return value: The width of detail cells, in characters.
4012  */
4013 gint
4014 gtk_calendar_get_detail_width_chars (GtkCalendar *calendar)
4015 {
4016   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), 0);
4017   return GTK_CALENDAR_GET_PRIVATE (calendar)->detail_width_chars;
4018 }
4019
4020 /**
4021  * gtk_calendar_get_detail_height_rows:
4022  * @calendar: a #GtkCalendar.
4023  *
4024  * Queries the height of detail cells, in rows.
4025  * See #GtkCalendar:detail-width-chars.
4026  *
4027  * Since: 2.14
4028  *
4029  * Return value: The height of detail cells, in rows.
4030  */
4031 gint
4032 gtk_calendar_get_detail_height_rows (GtkCalendar *calendar)
4033 {
4034   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), 0);
4035   return GTK_CALENDAR_GET_PRIVATE (calendar)->detail_height_rows;
4036 }