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 Grönlund
   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, write to the Free
  22  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 /*
  26  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  27  * file for a list of people on the GTK+ Team.  See the ChangeLog
  28  * files for a list of changes.  These files are distributed with
  29  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  30  */
  31
  32 #include "config.h"
  33
  34 #ifdef HAVE_SYS_TIME_H
  35 #include <sys/time.h>
  36 #endif
  37 #include <string.h>
  38 #include <stdlib.h>
  39 #include <time.h>
  40 #include <stdio.h>
  41 #include "gtkcalendar.h"
  42 #include "gdk/gdkkeysyms.h"
  43
  44 /***************************************************************************/
  45 /* The following date routines are taken from the lib_date package.  Keep
  46  * them seperate in case we want to update them if a newer lib_date comes
  47  * out with fixes.  */
  48
  49 typedef  unsigned   int     N_int;
  50 typedef  unsigned   long    N_long;
  51 typedef  signed     long    Z_long;
  52 typedef enum { false = FALSE , true = TRUE } boolean;
  53
  54 #define and         &&      /* logical (boolean) operators: lower case */
  55 #define or          ||
  56
  57 static const N_int month_length[2][13] =
  58 {
  59   { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  60   { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  61 };
  62
  63 static const N_int days_in_months[2][14] =
  64 {
  65   { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
  66   { 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
  67 };
  68
  69 static Z_long  calc_days(N_int year, N_int mm, N_int dd);
  70 static N_int   day_of_week(N_int year, N_int mm, N_int dd);
  71 static Z_long  dates_difference(N_int year1, N_int mm1, N_int dd1,
  72                                 N_int year2, N_int mm2, N_int dd2);
  73 static N_int   weeks_in_year(N_int year);
  74
  75 static boolean
  76 leap(N_int year)
  77 {
  78   return((((year % 4) == 0) and ((year % 100) != 0)) or ((year % 400) == 0));
  79 }
  80
  81 static N_int
  82 day_of_week(N_int year, N_int mm, N_int dd)
  83 {
  84   Z_long  days;
  85
  86   days = calc_days(year, mm, dd);
  87   if (days > 0L)
  88     {
  89       days--;
  90       days %= 7L;
  91       days++;
  92     }
  93   return( (N_int) days );
  94 }
  95
  96 static N_int weeks_in_year(N_int year)
  97 {
  98   return(52 + ((day_of_week(year,1,1)==4) or (day_of_week(year,12,31)==4)));
  99 }
 100
 101 static boolean
 102 check_date(N_int year, N_int mm, N_int dd)
 103 {
 104   if (year < 1) return(false);
 105   if ((mm < 1) or (mm > 12)) return(false);
 106   if ((dd < 1) or (dd > month_length[leap(year)][mm])) return(false);
 107   return(true);
 108 }
 109
 110 static N_int
 111 week_number(N_int year, N_int mm, N_int dd)
 112 {
 113   N_int first;
 114
 115   first = day_of_week(year,1,1) - 1;
 116   return( (N_int) ( (dates_difference(year,1,1, year,mm,dd) + first) / 7L ) +
 117           (first < 4) );
 118 }
 119
 120 static Z_long
 121 year_to_days(N_int year)
 122 {
 123   return( year * 365L + (year / 4) - (year / 100) + (year / 400) );
 124 }
 125
 126
 127 static Z_long
 128 calc_days(N_int year, N_int mm, N_int dd)
 129 {
 130   boolean lp;
 131
 132   if (year < 1) return(0L);
 133   if ((mm < 1) or (mm > 12)) return(0L);
 134   if ((dd < 1) or (dd > month_length[(lp = leap(year))][mm])) return(0L);
 135   return( year_to_days(--year) + days_in_months[lp][mm] + dd );
 136 }
 137
 138 static boolean
 139 week_of_year(N_int *week, N_int *year, N_int mm, N_int dd)
 140 {
 141   if (check_date(*year,mm,dd))
 142     {
 143       *week = week_number(*year,mm,dd);
 144       if (*week == 0)
 145         *week = weeks_in_year(--(*year));
 146       else if (*week > weeks_in_year(*year))
 147         {
 148           *week = 1;
 149           (*year)++;
 150         }
 151       return(true);
 152     }
 153   return(false);
 154 }
 155
 156 static Z_long
 157 dates_difference(N_int year1, N_int mm1, N_int dd1,
 158                  N_int year2, N_int mm2, N_int dd2)
 159 {
 160   return( calc_days(year2, mm2, dd2) - calc_days(year1, mm1, dd1) );
 161 }
 162
 163 /*** END OF lib_date routines ********************************************/
 164
 165 /* Spacing around day/week headers and main area, inside those windows */
 166 #define CALENDAR_MARGIN          0
 167 /* Spacing around day/week headers and main area, outside those windows */
 168 #define INNER_BORDER             4
 169 /* Separation between day headers and main area */
 170 #define CALENDAR_YSEP            4
 171 /* Separation between week headers and main area */
 172 #define CALENDAR_XSEP            4
 173
 174 #define DAY_XSEP                 0 /* not really good for small calendar */
 175 #define DAY_YSEP                 0 /* not really good for small calendar */
 176
 177 /* Color usage */
 178 #define HEADER_FG_COLOR(widget)          (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
 179 #define HEADER_BG_COLOR(widget)          (& (widget)->style->bg[GTK_WIDGET_STATE (widget)])
 180 #define DAY_NAME_COLOR(widget)           (& (widget)->style->base[GTK_STATE_SELECTED])
 181 #define NORMAL_DAY_COLOR(widget)         (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
 182 #define SELECTION_FOCUS_COLOR(widget)    (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
 183 #define SELECTION_NO_FOCUS_COLOR(widget) (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
 184 #define PREV_MONTH_COLOR(widget)         (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
 185 #define NEXT_MONTH_COLOR(widget)         (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
 186 #define MARKED_COLOR(widget)             (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
 187 #define FOREGROUND_COLOR(widget)         (& (widget)->style->fg[GTK_WIDGET_STATE (widget)])
 188 #define BACKGROUND_COLOR(widget)         (& (widget)->style->base[GTK_WIDGET_STATE (widget)])
 189 #define HIGHLIGHT_BACK_COLOR(widget)     (& (widget)->style->mid[GTK_WIDGET_STATE (widget)])
 190
 191 enum {
 192   ARROW_YEAR_LEFT,
 193   ARROW_YEAR_RIGHT,
 194   ARROW_MONTH_LEFT,
 195   ARROW_MONTH_RIGHT
 196 };
 197
 198 enum {
 199   MONTH_PREV,
 200   MONTH_CURRENT,
 201   MONTH_NEXT
 202 };
 203
 204 enum {
 205   MONTH_CHANGED_SIGNAL,
 206   DAY_SELECTED_SIGNAL,
 207   DAY_SELECTED_DOUBLE_CLICK_SIGNAL,
 208   PREV_MONTH_SIGNAL,
 209   NEXT_MONTH_SIGNAL,
 210   PREV_YEAR_SIGNAL,
 211   NEXT_YEAR_SIGNAL,
 212   LAST_SIGNAL
 213 };
 214
 215 static gint gtk_calendar_signals[LAST_SIGNAL] = { 0 };
 216
 217 static GtkWidgetClass *parent_class = NULL;
 218
 219 typedef struct _GtkCalendarPrivateData GtkCalendarPrivateData;
 220 struct _GtkCalendarPrivateData
 221 {
 222   GdkWindow *header_win;
 223   GdkWindow *day_name_win;
 224   GdkWindow *main_win;
 225   GdkWindow *week_win;
 226   GdkWindow *arrow_win[4];
 227
 228   guint header_h;
 229   guint day_name_h;
 230   guint main_h;
 231
 232   guint      arrow_state[4];
 233   guint      arrow_width;
 234   guint      max_month_width;
 235   guint      max_year_width;
 236
 237   guint day_width;
 238   guint week_width;
 239
 240   guint min_day_width;
 241   guint max_day_char_width;
 242   guint max_day_char_ascent;
 243   guint max_day_char_descent;
 244   guint max_label_char_ascent;
 245   guint max_label_char_descent;
 246   guint max_week_char_width;
 247
 248   guint freeze_count;
 249
 250   /* flags */
 251   guint dirty_header : 1;
 252   guint dirty_day_names : 1;
 253   guint dirty_main : 1;
 254   guint dirty_week : 1;
 255 };
 256
 257 #define GTK_CALENDAR_PRIVATE_DATA(widget)  (((GtkCalendarPrivateData*)(GTK_CALENDAR (widget)->private_data)))
 258
 259 typedef void (*GtkCalendarSignalDate) (GtkObject *object, guint arg1, guint arg2, guint arg3, gpointer data);
 260
 261 static void gtk_calendar_class_init     (GtkCalendarClass *class);
 262 static void gtk_calendar_init           (GtkCalendar *calendar);
 263 static void gtk_calendar_finalize       (GObject *calendar);
 264 static void gtk_calendar_realize        (GtkWidget *widget);
 265 static void gtk_calendar_unrealize      (GtkWidget *widget);
 266 static void gtk_calendar_size_request   (GtkWidget *widget,
 267                                          GtkRequisition *requisition);
 268 static void gtk_calendar_size_allocate  (GtkWidget *widget,
 269                                          GtkAllocation *allocation);
 270 static gint gtk_calendar_expose         (GtkWidget *widget,
 271                                          GdkEventExpose *event);
 272 static gint gtk_calendar_button_press   (GtkWidget *widget,
 273                                          GdkEventButton *event);
 274 static void gtk_calendar_main_button    (GtkWidget *widget,
 275                                          GdkEventButton *event);
 276 static gint gtk_calendar_motion_notify  (GtkWidget *widget,
 277                                          GdkEventMotion *event);
 278 static gint gtk_calendar_enter_notify   (GtkWidget *widget,
 279                                          GdkEventCrossing *event);
 280 static gint gtk_calendar_leave_notify   (GtkWidget *widget,
 281                                          GdkEventCrossing *event);
 282 static gint gtk_calendar_key_press      (GtkWidget         *widget,
 283                                          GdkEventKey       *event);
 284 static void gtk_calendar_state_changed  (GtkWidget *widget,
 285                                          GtkStateType previous_state);
 286 static void gtk_calendar_style_set      (GtkWidget *widget,
 287                                          GtkStyle  *previous_style);
 288 static void gtk_calendar_paint_header       (GtkWidget *widget);
 289 static void gtk_calendar_paint_day_names    (GtkWidget *widget);
 290 static void gtk_calendar_paint_week_numbers (GtkWidget *widget);
 291 static void gtk_calendar_paint_main         (GtkWidget *widget);
 292
 293
 294 static void gtk_calendar_paint_arrow    (GtkWidget    *widget,
 295                                          guint         arrow);
 296 static void gtk_calendar_paint_day_num  (GtkWidget    *widget,
 297                                          gint          day);
 298 static void gtk_calendar_paint_day      (GtkWidget    *widget,
 299                                          gint          row,
 300                                          gint          col);
 301 static void gtk_calendar_compute_days   (GtkCalendar  *calendar);
 302 static gint left_x_for_column           (GtkCalendar  *calendar,
 303                                          gint          column);
 304 static gint top_y_for_row               (GtkCalendar  *calendar,
 305                                          gint          row);
 306
 307 static char    *default_abbreviated_dayname[7];
 308 static char    *default_monthname[12];
 309
 310 GtkType
 311 gtk_calendar_get_type (void)
 312 {
 313   static GtkType calendar_type = 0;
 314
 315   if (!calendar_type)
 316     {
 317       static const GTypeInfo calendar_info =
 318       {
 319         sizeof (GtkCalendarClass),
 320         NULL,           /* base_init */
 321         NULL,           /* base_finalize */
 322         (GClassInitFunc) gtk_calendar_class_init,
 323         NULL,           /* class_finalize */
 324         NULL,           /* class_data */
 325         sizeof (GtkCalendar),
 326         16,             /* n_preallocs */
 327         (GInstanceInitFunc) gtk_calendar_init,
 328       };
 329
 330       calendar_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkCalendar", &calendar_info, 0);
 331     }
 332
 333   return calendar_type;
 334 }
 335
 336 static void
 337 gtk_calendar_class_init (GtkCalendarClass *class)
 338 {
 339   GObjectClass   *gobject_class;
 340   GtkObjectClass *object_class;
 341   GtkWidgetClass *widget_class;
 342
 343   gobject_class = (GObjectClass*)  class;
 344   object_class = (GtkObjectClass*) class;
 345   widget_class = (GtkWidgetClass*) class;
 346
 347   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 348
 349   gobject_class->finalize = gtk_calendar_finalize;
 350
 351   widget_class->realize = gtk_calendar_realize;
 352   widget_class->unrealize = gtk_calendar_unrealize;
 353   widget_class->expose_event = gtk_calendar_expose;
 354   widget_class->size_request = gtk_calendar_size_request;
 355   widget_class->size_allocate = gtk_calendar_size_allocate;
 356   widget_class->button_press_event = gtk_calendar_button_press;
 357   widget_class->motion_notify_event = gtk_calendar_motion_notify;
 358   widget_class->enter_notify_event = gtk_calendar_enter_notify;
 359   widget_class->leave_notify_event = gtk_calendar_leave_notify;
 360   widget_class->key_press_event = gtk_calendar_key_press;
 361   widget_class->style_set = gtk_calendar_style_set;
 362   widget_class->state_changed = gtk_calendar_state_changed;
 363
 364   class->month_changed = NULL;
 365   class->day_selected = NULL;
 366   class->day_selected_double_click = NULL;
 367   class->prev_month = NULL;
 368   class->next_month = NULL;
 369   class->prev_year = NULL;
 370   class->next_year = NULL;
 371
 372   gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =
 373     gtk_signal_new ("month_changed",
 374                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 375                     GTK_SIGNAL_OFFSET (GtkCalendarClass, month_changed),
 376                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 377   gtk_calendar_signals[DAY_SELECTED_SIGNAL] =
 378     gtk_signal_new ("day_selected",
 379                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 380                     GTK_SIGNAL_OFFSET (GtkCalendarClass, day_selected),
 381                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 382   gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
 383     gtk_signal_new ("day_selected_double_click",
 384                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 385                     GTK_SIGNAL_OFFSET (GtkCalendarClass, day_selected_double_click),
 386                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 387   gtk_calendar_signals[PREV_MONTH_SIGNAL] =
 388     gtk_signal_new ("prev_month",
 389                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 390                     GTK_SIGNAL_OFFSET (GtkCalendarClass, prev_month),
 391                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 392   gtk_calendar_signals[NEXT_MONTH_SIGNAL] =
 393     gtk_signal_new ("next_month",
 394                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 395                     GTK_SIGNAL_OFFSET (GtkCalendarClass, next_month),
 396                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 397   gtk_calendar_signals[PREV_YEAR_SIGNAL] =
 398     gtk_signal_new ("prev_year",
 399                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 400                     GTK_SIGNAL_OFFSET (GtkCalendarClass, prev_year),
 401                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 402   gtk_calendar_signals[NEXT_YEAR_SIGNAL] =
 403     gtk_signal_new ("next_year",
 404                     GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 405                     GTK_SIGNAL_OFFSET (GtkCalendarClass, next_year),
 406                     gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
 407 }
 408
 409 static void
 410 gtk_calendar_init (GtkCalendar *calendar)
 411 {
 412   time_t secs;
 413   struct tm *tm;
 414   gint i;
 415   char buffer[255];
 416   time_t tmp_time;
 417   GtkWidget *widget;
 418   GtkCalendarPrivateData *private_data;
 419
 420   widget = GTK_WIDGET (calendar);
 421   GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
 422
 423   calendar->private_data = (gpointer) g_malloc (sizeof (GtkCalendarPrivateData));
 424   private_data = GTK_CALENDAR_PRIVATE_DATA (calendar);
 425
 426   if (!default_abbreviated_dayname[0])
 427     for (i=0; i<7; i++)
 428       {
 429         tmp_time= (i+3)*86400;
 430         strftime ( buffer, sizeof (buffer), "%a", gmtime (&tmp_time));
 431         default_abbreviated_dayname[i] = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);
 432       }
 433
 434   if (!default_monthname[0])
 435     for (i=0; i<12; i++)
 436       {
 437         tmp_time=i*2764800;
 438         strftime ( buffer, sizeof (buffer), "%B", gmtime (&tmp_time));
 439         default_monthname[i] = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);
 440       }
 441
 442   /* Set defaults */
 443   secs = time (NULL);
 444   tm = localtime (&secs);
 445   calendar->month = tm->tm_mon;
 446   calendar->year  = 1900 + tm->tm_year;
 447
 448   for (i=0;i<31;i++)
 449     calendar->marked_date[i] = FALSE;
 450   calendar->num_marked_dates = 0;
 451   calendar->selected_day = tm->tm_mday;
 452
 453   calendar->display_flags = ( GTK_CALENDAR_SHOW_HEADING |
 454                               GTK_CALENDAR_SHOW_DAY_NAMES );
 455
 456   calendar->highlight_row = -1;
 457   calendar->highlight_col = -1;
 458
 459   calendar->focus_row = -1;
 460   calendar->focus_col = -1;
 461   calendar->xor_gc = NULL;
 462
 463   private_data->max_year_width = 0;
 464   private_data->max_month_width = 0;
 465   private_data->max_day_char_width = 0;
 466   private_data->max_week_char_width = 0;
 467
 468   private_data->max_day_char_ascent = 0;
 469   private_data->max_day_char_descent = 0;
 470   private_data->max_label_char_ascent = 0;
 471   private_data->max_label_char_descent = 0;
 472
 473   private_data->arrow_width = 10;
 474
 475   private_data->freeze_count = 0;
 476
 477   private_data->dirty_header = 0;
 478   private_data->dirty_day_names = 0;
 479   private_data->dirty_week = 0;
 480   private_data->dirty_main = 0;
 481 }
 482
 483 GtkWidget*
 484 gtk_calendar_new (void)
 485 {
 486   return GTK_WIDGET (gtk_type_new (GTK_TYPE_CALENDAR));
 487 }
 488
 489 /* column_from_x: returns the column 0-6 that the
 490  * x pixel of the xwindow is in */
 491 static gint
 492 column_from_x (GtkCalendar *calendar,
 493                gint         event_x)
 494 {
 495   gint c, column;
 496   gint x_left, x_right;
 497
 498   column = -1;
 499
 500   for (c = 0; c < 7; c++)
 501     {
 502       x_left = left_x_for_column (calendar, c);
 503       x_right = x_left + GTK_CALENDAR_PRIVATE_DATA (calendar)->day_width;
 504
 505       if (event_x >= x_left && event_x < x_right)
 506         {
 507           column = c;
 508           break;
 509         }
 510     }
 511
 512   return column;
 513 }
 514
 515 static gint
 516 row_height (GtkCalendar *calendar)
 517 {
 518   return (GTK_CALENDAR_PRIVATE_DATA (calendar)->main_h - CALENDAR_MARGIN
 519           - ((calendar->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
 520              ? CALENDAR_YSEP : CALENDAR_MARGIN)) / 6;
 521 }
 522
 523
 524 /* row_from_y: returns the row 0-5 that the
 525  * y pixel of the xwindow is in */
 526 static gint
 527 row_from_y (GtkCalendar *calendar,
 528             gint         event_y)
 529 {
 530   gint r, row;
 531   gint height;
 532   gint y_top, y_bottom;
 533
 534   height = row_height (calendar);
 535   row = -1;
 536
 537   for (r = 0; r < 6; r++)
 538     {
 539       y_top = top_y_for_row (calendar, r);
 540       y_bottom = y_top + height;
 541
 542       if (event_y >= y_top && event_y < y_bottom)
 543         {
 544           row = r;
 545           break;
 546         }
 547     }
 548
 549   return row;
 550 }
 551
 552 /* left_x_for_column: returns the x coordinate
 553  * for the left of the column */
 554 static gint
 555 left_x_for_column (GtkCalendar *calendar,
 556                    gint         column)
 557 {
 558   gint width;
 559   gint x_left;
 560
 561   if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
 562     column = 6 - column;
 563
 564   width = GTK_CALENDAR_PRIVATE_DATA (calendar)->day_width;
 565   if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
 566     x_left = CALENDAR_XSEP + (width + DAY_XSEP) * column;
 567   else
 568     x_left = CALENDAR_MARGIN + (width + DAY_XSEP) * column;
 569
 570   return x_left;
 571 }
 572
 573 /* top_y_for_row: returns the y coordinate
 574  * for the top of the row */
 575 static gint
 576 top_y_for_row (GtkCalendar *calendar,
 577                gint         row)
 578 {
 579
 580   return (GTK_CALENDAR_PRIVATE_DATA (calendar)->main_h
 581           - (CALENDAR_MARGIN + (6 - row)
 582              * row_height (calendar)));
 583 }
 584
 585 /* This function should be done by the toolkit, but we don't like the
 586  * GTK arrows because they don't look good on this widget */
 587 static void
 588 draw_arrow_right (GdkWindow *window,
 589                   GdkGC     *gc,
 590                   gint       x,
 591                   gint       y,
 592                   gint       size)
 593 {
 594   gint i;
 595
 596   for (i = 0; i <= size / 2; i++)
 597     {
 598       gdk_draw_line (window, gc,
 599                      x + i,
 600                      y + i,
 601                      x + i,
 602                      y + size - i);
 603     }
 604 }
 605
 606 /* This function should be done by the toolkit, but we don't like the
 607  * GTK arrows because they don't look good on this widget */
 608 static void
 609 draw_arrow_left (GdkWindow *window,
 610                  GdkGC     *gc,
 611                  gint       x,
 612                  gint       y,
 613                  gint       size)
 614 {
 615   gint i;
 616
 617   for (i = 0; i <= size / 2; i++)
 618     {
 619       gdk_draw_line (window, gc,
 620                      x + size/2 - i,
 621                      y + i,
 622                      x + size/2 - i,
 623                      y + size - i);
 624     }
 625 }
 626
 627 static void
 628 gtk_calendar_set_month_prev (GtkCalendar *calendar)
 629 {
 630   gint month_len;
 631
 632   if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
 633     return;
 634
 635   if (calendar->month == 0)
 636     {
 637       calendar->month = 11;
 638       calendar->year--;
 639     }
 640   else
 641     calendar->month--;
 642
 643   month_len = month_length[leap (calendar->year)][calendar->month + 1];
 644
 645   gtk_calendar_freeze (calendar);
 646   gtk_calendar_compute_days (calendar);
 647
 648   gtk_signal_emit (GTK_OBJECT (calendar),
 649                    gtk_calendar_signals[PREV_MONTH_SIGNAL]);
 650   gtk_signal_emit (GTK_OBJECT (calendar),
 651                    gtk_calendar_signals[MONTH_CHANGED_SIGNAL]);
 652
 653   if (month_len < calendar->selected_day)
 654     {
 655       calendar->selected_day = 0;
 656       gtk_calendar_select_day (calendar, month_len);
 657     }
 658   else
 659     {
 660       if (calendar->selected_day < 0)
 661         calendar->selected_day = calendar->selected_day + 1 + month_length[leap (calendar->year)][calendar->month + 1];
 662       gtk_calendar_select_day (calendar, calendar->selected_day);
 663     }
 664
 665   gtk_widget_queue_draw (GTK_WIDGET (calendar));
 666   gtk_calendar_thaw (calendar);
 667 }
 668
 669
 670 static void
 671 gtk_calendar_set_month_next (GtkCalendar *calendar)
 672 {
 673   gint month_len;
 674
 675   g_return_if_fail (GTK_IS_WIDGET (calendar));
 676
 677   if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
 678     return;
 679
 680
 681   if (calendar->month == 11)
 682     {
 683       calendar->month = 0;
 684       calendar->year++;
 685     }
 686   else
 687     calendar->month++;
 688
 689   gtk_calendar_freeze (calendar);
 690   gtk_calendar_compute_days (calendar);
 691   gtk_signal_emit (GTK_OBJECT (calendar),
 692                    gtk_calendar_signals[NEXT_MONTH_SIGNAL]);
 693   gtk_signal_emit (GTK_OBJECT (calendar),
 694                    gtk_calendar_signals[MONTH_CHANGED_SIGNAL]);
 695
 696   month_len = month_length[leap (calendar->year)][calendar->month + 1];
 697
 698   if (month_len < calendar->selected_day)
 699     {
 700       calendar->selected_day = 0;
 701       gtk_calendar_select_day (calendar, month_len);
 702     }
 703   else
 704     gtk_calendar_select_day (calendar, calendar->selected_day);
 705
 706   gtk_widget_queue_draw (GTK_WIDGET (calendar));
 707   gtk_calendar_thaw (calendar);
 708 }
 709
 710 static void
 711 gtk_calendar_set_year_prev (GtkCalendar *calendar)
 712 {
 713   gint month_len;
 714
 715   g_return_if_fail (GTK_IS_WIDGET (calendar));
 716
 717   calendar->year--;
 718   gtk_calendar_freeze (calendar);
 719   gtk_calendar_compute_days (calendar);
 720   gtk_signal_emit (GTK_OBJECT (calendar),
 721                    gtk_calendar_signals[PREV_YEAR_SIGNAL]);
 722   gtk_signal_emit (GTK_OBJECT (calendar),
 723                    gtk_calendar_signals[MONTH_CHANGED_SIGNAL]);
 724
 725   month_len = month_length[leap (calendar->year)][calendar->month + 1];
 726
 727   if (month_len < calendar->selected_day)
 728     {
 729       calendar->selected_day = 0;
 730       gtk_calendar_select_day (calendar, month_len);
 731     }
 732   else
 733     gtk_calendar_select_day (calendar, calendar->selected_day);
 734
 735   gtk_widget_queue_draw (GTK_WIDGET (calendar));
 736   gtk_calendar_thaw (calendar);
 737 }
 738
 739 static void
 740 gtk_calendar_set_year_next (GtkCalendar *calendar)
 741 {
 742   gint month_len;
 743   GtkWidget *widget;
 744
 745   g_return_if_fail (GTK_IS_WIDGET (calendar));
 746
 747   widget = GTK_WIDGET (calendar);
 748
 749   gtk_calendar_freeze (calendar);
 750
 751   calendar->year++;
 752   gtk_calendar_compute_days (calendar);
 753   gtk_signal_emit (GTK_OBJECT (calendar),
 754                    gtk_calendar_signals[NEXT_YEAR_SIGNAL]);
 755   gtk_signal_emit (GTK_OBJECT (calendar),
 756                    gtk_calendar_signals[MONTH_CHANGED_SIGNAL]);
 757
 758   month_len = month_length[leap (calendar->year)][calendar->month + 1];
 759
 760   if (month_len < calendar->selected_day)
 761     {
 762       calendar->selected_day = 0;
 763       gtk_calendar_select_day (calendar, month_len);
 764     }
 765   else
 766     gtk_calendar_select_day (calendar, calendar->selected_day);
 767
 768   gtk_widget_queue_draw (GTK_WIDGET (calendar));
 769   gtk_calendar_thaw (calendar);
 770 }
 771
 772 static void
 773 gtk_calendar_main_button (GtkWidget      *widget,
 774                           GdkEventButton *event)
 775 {
 776   GtkCalendar *calendar;
 777   gint x, y;
 778   gint row, col;
 779   gint day_month;
 780   gint old_focus_row, old_focus_col;
 781
 782   calendar = GTK_CALENDAR (widget);
 783
 784   x = (gint) (event->x);
 785   y = (gint) (event->y);
 786
 787   row = row_from_y (calendar, y);
 788   col = column_from_x (calendar, x);
 789
 790   /* If row or column isn't found, just return. */
 791   if (row == -1 || col == -1)
 792     return;
 793
 794   day_month = calendar->day_month[row][col];
 795
 796   if (day_month == MONTH_CURRENT)
 797     {
 798       if (event->type == GDK_2BUTTON_PRESS)
 799         gtk_signal_emit (GTK_OBJECT (calendar),
 800                          gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL]);
 801       else
 802         {
 803           if (!GTK_WIDGET_HAS_FOCUS (widget))
 804             gtk_widget_grab_focus (widget);
 805           old_focus_row = calendar->focus_row;
 806           old_focus_col = calendar->focus_col;
 807           calendar->focus_row = row;
 808           calendar->focus_col = col;
 809           gtk_calendar_paint_day (widget, old_focus_row, old_focus_col);
 810           gtk_calendar_select_day (calendar, calendar->day[row][col]);
 811         }
 812     }
 813   else if (day_month == MONTH_PREV)
 814     gtk_calendar_set_month_prev (calendar);
 815   else if (day_month == MONTH_NEXT)
 816     gtk_calendar_set_month_next (calendar);
 817 }
 818
 819 static void
 820 gtk_calendar_realize_arrows (GtkWidget *widget)
 821 {
 822   GtkCalendar *calendar;
 823   GtkCalendarPrivateData *private_data;
 824   GdkWindowAttr attributes;
 825   gint attributes_mask;
 826   gint i;
 827
 828   g_return_if_fail (GTK_IS_CALENDAR (widget));
 829
 830   calendar = GTK_CALENDAR (widget);
 831   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
 832
 833   /* Arrow windows ------------------------------------- */
 834   if (! (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
 835       && (calendar->display_flags & GTK_CALENDAR_SHOW_HEADING))
 836     {
 837       attributes.wclass = GDK_INPUT_OUTPUT;
 838       attributes.window_type = GDK_WINDOW_CHILD;
 839       attributes.visual = gtk_widget_get_visual (widget);
 840       attributes.colormap = gtk_widget_get_colormap (widget);
 841       attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
 842                                | GDK_BUTTON_PRESS_MASK  | GDK_BUTTON_RELEASE_MASK
 843                                | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
 844       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 845       attributes.y = 3;
 846       attributes.width = private_data->arrow_width;
 847       attributes.height = private_data->header_h - 7;
 848       for (i = 0; i < 4; i++)
 849         {
 850           switch (i)
 851             {
 852             case ARROW_MONTH_LEFT:
 853               attributes.x = 3;
 854               break;
 855             case ARROW_MONTH_RIGHT:
 856               attributes.x = (private_data->arrow_width
 857                               + private_data->max_month_width);
 858               break;
 859             case ARROW_YEAR_LEFT:
 860               attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
 861                               - (3 + 2*private_data->arrow_width
 862                                  + private_data->max_year_width));
 863               break;
 864             case ARROW_YEAR_RIGHT:
 865               attributes.x = (widget->allocation.width - 2 * widget->style->xthickness
 866                               - 3 - private_data->arrow_width);
 867               break;
 868             }
 869           private_data->arrow_win[i] = gdk_window_new (private_data->header_win,
 870                                                        &attributes,
 871                                                        attributes_mask);
 872           private_data->arrow_state[i] = GTK_STATE_NORMAL;
 873           gdk_window_set_background (private_data->arrow_win[i],
 874                                      HEADER_BG_COLOR (GTK_WIDGET (calendar)));
 875           gdk_window_show (private_data->arrow_win[i]);
 876           gdk_window_set_user_data (private_data->arrow_win[i], widget);
 877         }
 878     }
 879   else
 880     {
 881       for (i = 0; i < 4; i++)
 882         private_data->arrow_win[i] = NULL;
 883     }
 884 }
 885
 886 static void
 887 gtk_calendar_realize_header (GtkWidget *widget)
 888 {
 889   GtkCalendar *calendar;
 890   GtkCalendarPrivateData *private_data;
 891   GdkWindowAttr attributes;
 892   gint attributes_mask;
 893
 894   g_return_if_fail (GTK_IS_CALENDAR (widget));
 895
 896   calendar = GTK_CALENDAR (widget);
 897   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
 898
 899   /* Header window ------------------------------------- */
 900   if (calendar->display_flags & GTK_CALENDAR_SHOW_HEADING)
 901     {
 902       attributes.wclass = GDK_INPUT_OUTPUT;
 903       attributes.window_type = GDK_WINDOW_CHILD;
 904       attributes.visual = gtk_widget_get_visual (widget);
 905       attributes.colormap = gtk_widget_get_colormap (widget);
 906       attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 907       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 908       attributes.x = widget->style->xthickness;
 909       attributes.y = widget->style->ythickness;
 910       attributes.width = widget->allocation.width - 2 * attributes.x;
 911       attributes.height = private_data->header_h - 2 * attributes.y;
 912       private_data->header_win = gdk_window_new (widget->window,
 913                                              &attributes, attributes_mask);
 914
 915       gdk_window_set_background (private_data->header_win,
 916                                  HEADER_BG_COLOR (GTK_WIDGET (calendar)));
 917       gdk_window_show (private_data->header_win);
 918       gdk_window_set_user_data (private_data->header_win, widget);
 919
 920     }
 921   else
 922     {
 923       private_data->header_win = NULL;
 924     }
 925   gtk_calendar_realize_arrows (widget);
 926 }
 927
 928 static void
 929 gtk_calendar_realize_day_names (GtkWidget *widget)
 930 {
 931   GtkCalendar *calendar;
 932   GtkCalendarPrivateData *private_data;
 933   GdkWindowAttr attributes;
 934   gint attributes_mask;
 935
 936   g_return_if_fail (GTK_IS_CALENDAR (widget));
 937
 938   calendar = GTK_CALENDAR (widget);
 939   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
 940
 941   /* Day names  window --------------------------------- */
 942   if ( calendar->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
 943     {
 944       attributes.wclass = GDK_INPUT_OUTPUT;
 945       attributes.window_type = GDK_WINDOW_CHILD;
 946       attributes.visual = gtk_widget_get_visual (widget);
 947       attributes.colormap = gtk_widget_get_colormap (widget);
 948       attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 949       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 950       attributes.x = (widget->style->xthickness + INNER_BORDER);
 951       attributes.y = private_data->header_h + (widget->style->ythickness
 952                                            + INNER_BORDER);
 953       attributes.width = (widget->allocation.width
 954                           - (widget->style->xthickness + INNER_BORDER)
 955                           * 2);
 956       attributes.height = private_data->day_name_h;
 957       private_data->day_name_win = gdk_window_new (widget->window,
 958                                                    &attributes,
 959                                                    attributes_mask);
 960       gdk_window_set_background (private_data->day_name_win,
 961                                  BACKGROUND_COLOR ( GTK_WIDGET ( calendar)));
 962       gdk_window_show (private_data->day_name_win);
 963       gdk_window_set_user_data (private_data->day_name_win, widget);
 964     }
 965   else
 966     {
 967       private_data->day_name_win = NULL;
 968     }
 969 }
 970
 971 static void
 972 gtk_calendar_realize_week_numbers (GtkWidget *widget)
 973 {
 974   GtkCalendar *calendar;
 975   GtkCalendarPrivateData *private_data;
 976   GdkWindowAttr attributes;
 977   gint attributes_mask;
 978
 979   g_return_if_fail (GTK_IS_CALENDAR (widget));
 980
 981   calendar = GTK_CALENDAR (widget);
 982   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
 983
 984   /* Week number window -------------------------------- */
 985   if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
 986     {
 987       attributes.wclass = GDK_INPUT_OUTPUT;
 988       attributes.window_type = GDK_WINDOW_CHILD;
 989       attributes.visual = gtk_widget_get_visual (widget);
 990       attributes.colormap = gtk_widget_get_colormap (widget);
 991       attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 992
 993       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 994       attributes.x = widget->style->xthickness + INNER_BORDER;
 995       attributes.y = (private_data->header_h + private_data->day_name_h
 996                       + (widget->style->ythickness + INNER_BORDER));
 997       attributes.width = private_data->week_width;
 998       attributes.height = private_data->main_h;
 999       private_data->week_win = gdk_window_new (widget->window,
1000                                                &attributes, attributes_mask);
1001       gdk_window_set_background (private_data->week_win,
1002                                  BACKGROUND_COLOR (GTK_WIDGET (calendar)));
1003       gdk_window_show (private_data->week_win);
1004       gdk_window_set_user_data (private_data->week_win, widget);
1005     }
1006   else
1007     {
1008       private_data->week_win = NULL;
1009     }
1010 }
1011
1012 static void
1013 gtk_calendar_realize (GtkWidget *widget)
1014 {
1015   GtkCalendar *calendar;
1016   GtkCalendarPrivateData *private_data;
1017   GdkWindowAttr attributes;
1018   gint attributes_mask;
1019   GdkGCValues values;
1020
1021   calendar = GTK_CALENDAR (widget);
1022   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1023
1024   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1025   gtk_calendar_compute_days (calendar);
1026
1027   attributes.x = widget->allocation.x;
1028   attributes.y = widget->allocation.y;
1029   attributes.width = widget->allocation.width;
1030   attributes.height = widget->allocation.height;
1031   attributes.wclass = GDK_INPUT_OUTPUT;
1032   attributes.window_type = GDK_WINDOW_CHILD;
1033   attributes.event_mask =  (gtk_widget_get_events (widget)
1034                             | GDK_EXPOSURE_MASK |GDK_KEY_PRESS_MASK);
1035   attributes.visual = gtk_widget_get_visual (widget);
1036   attributes.colormap = gtk_widget_get_colormap (widget);
1037
1038   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1039   widget->window = gdk_window_new (widget->parent->window,
1040                                    &attributes, attributes_mask);
1041
1042   widget->style = gtk_style_attach (widget->style, widget->window);
1043
1044   /* Header window ------------------------------------- */
1045   gtk_calendar_realize_header (widget);
1046   /* Day names  window --------------------------------- */
1047   gtk_calendar_realize_day_names (widget);
1048   /* Week number window -------------------------------- */
1049   gtk_calendar_realize_week_numbers (widget);
1050   /* Main Window --------------------------------------  */
1051   attributes.event_mask =  (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK
1052                             | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1053                             | GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
1054
1055   attributes.x = private_data->week_width + (widget->style->ythickness + INNER_BORDER);
1056   attributes.y = (private_data->header_h + private_data->day_name_h
1057                   + (widget->style->ythickness + INNER_BORDER));
1058   attributes.width = (widget->allocation.width - attributes.x
1059                       - (widget->style->xthickness + INNER_BORDER));
1060   attributes.height = private_data->main_h;
1061   private_data->main_win = gdk_window_new (widget->window,
1062                                            &attributes, attributes_mask);
1063   gdk_window_set_background (private_data->main_win,
1064                              BACKGROUND_COLOR ( GTK_WIDGET ( calendar)));
1065   gdk_window_show (private_data->main_win);
1066   gdk_window_set_user_data (private_data->main_win, widget);
1067   gdk_window_set_background (widget->window, BACKGROUND_COLOR (widget));
1068   gdk_window_show (widget->window);
1069   gdk_window_set_user_data (widget->window, widget);
1070
1071   /* Set widgets gc */
1072   calendar->gc = gdk_gc_new (widget->window);
1073
1074   values.foreground = widget->style->white;
1075   values.function = GDK_XOR;
1076   calendar->xor_gc = gdk_gc_new_with_values (widget->window,
1077                                              &values,
1078                                              GDK_GC_FOREGROUND |
1079                                              GDK_GC_FUNCTION);
1080 }
1081
1082 static void
1083 gtk_calendar_unrealize (GtkWidget *widget)
1084 {
1085   GtkCalendar *calendar;
1086   GtkCalendarPrivateData *private_data;
1087   gint i;
1088
1089   calendar = GTK_CALENDAR (widget);
1090   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1091
1092   if (private_data->header_win)
1093     {
1094       for (i = 0; i < 4; i++)
1095         {
1096           if (private_data->arrow_win[i])
1097             {
1098               gdk_window_set_user_data (private_data->arrow_win[i], NULL);
1099               gdk_window_destroy (private_data->arrow_win[i]);
1100               private_data->arrow_win[i] = NULL;
1101             }
1102         }
1103       gdk_window_set_user_data (private_data->header_win, NULL);
1104       gdk_window_destroy (private_data->header_win);
1105       private_data->header_win = NULL;
1106     }
1107
1108   if (private_data->week_win)
1109     {
1110       gdk_window_set_user_data (private_data->week_win, NULL);
1111       gdk_window_destroy (private_data->week_win);
1112       private_data->week_win = NULL;
1113     }
1114
1115   if (private_data->main_win)
1116     {
1117       gdk_window_set_user_data (private_data->main_win, NULL);
1118       gdk_window_destroy (private_data->main_win);
1119       private_data->main_win = NULL;
1120     }
1121   if (private_data->day_name_win)
1122     {
1123       gdk_window_set_user_data (private_data->day_name_win, NULL);
1124       gdk_window_destroy (private_data->day_name_win);
1125       private_data->day_name_win = NULL;
1126     }
1127   if (calendar->xor_gc)
1128     gdk_gc_unref (calendar->xor_gc);
1129   if (calendar->gc)
1130     gdk_gc_unref (calendar->gc);
1131
1132   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
1133     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
1134 }
1135
1136 static void
1137 gtk_calendar_size_request (GtkWidget      *widget,
1138                            GtkRequisition *requisition)
1139 {
1140   GtkCalendar *calendar;
1141   GtkCalendarPrivateData *private_data;
1142   PangoLayout *layout;
1143   PangoRectangle logical_rect;
1144
1145   gint height;
1146   gint i;
1147   gchar buffer[255];
1148   gint calendar_margin = CALENDAR_MARGIN;
1149   gint header_width, main_width;
1150   gint max_header_height = 0;
1151   gint focus_width;
1152   gint focus_padding;
1153
1154   calendar = GTK_CALENDAR (widget);
1155   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1156   gtk_widget_style_get (GTK_WIDGET (widget),
1157                         "focus-line-width", &focus_width,
1158                         "focus-padding", &focus_padding,
1159                         NULL);
1160
1161   layout = gtk_widget_create_pango_layout (widget, NULL);
1162
1163   /*
1164    * Calculate the requisition  width for the widget.
1165    */
1166
1167   /* Header width */
1168
1169   if (calendar->display_flags & GTK_CALENDAR_SHOW_HEADING)
1170     {
1171       private_data->max_month_width = 0;
1172       for (i = 0; i < 12; i++)
1173         {
1174           pango_layout_set_text (layout, default_monthname[i], -1);
1175           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1176           private_data->max_month_width = MAX (private_data->max_month_width,
1177                                                logical_rect.width + 8);
1178           max_header_height = MAX (max_header_height, logical_rect.height);
1179         }
1180       private_data->max_year_width = 0;
1181       for (i=0; i<10; i++)
1182         {
1183           sprintf (buffer, "%d%d%d%d", i,i,i,i);
1184           pango_layout_set_text (layout, buffer, -1);
1185           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1186           private_data->max_year_width = MAX (private_data->max_year_width,
1187                                               logical_rect.width + 8);
1188           max_header_height = MAX (max_header_height, logical_rect.height);
1189         }
1190     }
1191   else
1192     {
1193       private_data->max_month_width = 0;
1194       private_data->max_year_width = 0;
1195     }
1196
1197   if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1198     header_width = (private_data->max_month_width
1199                     + private_data->max_year_width
1200                     + 3 * 3);
1201   else
1202     header_width = (private_data->max_month_width
1203                     + private_data->max_year_width
1204                     + 4 * private_data->arrow_width + 3 * 3);
1205
1206   /* Mainwindow labels width */
1207
1208   private_data->max_day_char_width = 0;
1209   private_data->min_day_width = 0;
1210   private_data->max_label_char_ascent = 0;
1211   private_data->max_label_char_descent = 0;
1212
1213   for (i = 0; i < 9; i++)
1214     {
1215       sprintf (buffer, "%d%d", i, i);
1216       pango_layout_set_text (layout, buffer, -1);
1217       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1218       private_data->min_day_width = MAX (private_data->min_day_width,
1219                                          logical_rect.width);
1220
1221       private_data->max_day_char_ascent = MAX (private_data->max_label_char_ascent,
1222                                                PANGO_ASCENT (logical_rect));
1223       private_data->max_day_char_descent = MAX (private_data->max_label_char_descent,
1224                                                 PANGO_DESCENT (logical_rect));
1225     }
1226   /* We add one to max_day_char_width to be able to make the marked day "bold" */
1227   private_data->max_day_char_width = private_data->min_day_width / 2 + 1;
1228
1229   if (calendar->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
1230     for (i = 0; i < 7; i++)
1231       {
1232         pango_layout_set_text (layout, default_abbreviated_dayname[i], -1);
1233         pango_layout_line_get_pixel_extents (pango_layout_get_lines (layout)->data, NULL, &logical_rect);
1234
1235         private_data->min_day_width = MAX (private_data->min_day_width, logical_rect.width);
1236         private_data->max_label_char_ascent = MAX (private_data->max_label_char_ascent,
1237                                                    PANGO_ASCENT (logical_rect));
1238         private_data->max_label_char_descent = MAX (private_data->max_label_char_descent,
1239                                                     PANGO_DESCENT (logical_rect));
1240       }
1241
1242   private_data->max_week_char_width = 0;
1243   if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
1244     for (i = 0; i < 9; i++)
1245       {
1246         sprintf (buffer, "%d%d", i, i);
1247         pango_layout_set_text (layout, buffer, -1);
1248         pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1249         private_data->max_week_char_width = MAX (private_data->max_week_char_width,
1250                                                  logical_rect.width / 2);
1251       }
1252
1253   main_width = (7 * (private_data->min_day_width + (focus_padding + focus_width) * 2) + (DAY_XSEP * 6) + CALENDAR_MARGIN * 2
1254                 + (private_data->max_week_char_width
1255                    ? private_data->max_week_char_width * 2 + (focus_padding + focus_width) * 2 + CALENDAR_XSEP * 2
1256                    : 0));
1257
1258
1259   requisition->width = MAX (header_width, main_width + INNER_BORDER * 2) + widget->style->xthickness * 2;
1260
1261   /*
1262    * Calculate the requisition height for the widget.
1263    */
1264
1265   if (calendar->display_flags & GTK_CALENDAR_SHOW_HEADING)
1266     {
1267       private_data->header_h = (max_header_height + CALENDAR_YSEP * 2);
1268     }
1269   else
1270     {
1271       private_data->header_h = 0;
1272     }
1273
1274   if (calendar->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
1275     {
1276       private_data->day_name_h = (private_data->max_label_char_ascent
1277                                   + private_data->max_label_char_descent
1278                                   + 2 * (focus_padding + focus_width) + calendar_margin);
1279       calendar_margin = CALENDAR_YSEP;
1280     }
1281   else
1282     {
1283       private_data->day_name_h = 0;
1284     }
1285
1286   private_data->main_h = (CALENDAR_MARGIN + calendar_margin
1287                           + 6 * (private_data->max_day_char_ascent
1288                                  + private_data->max_day_char_descent
1289                                  + 2 * (focus_padding + focus_width))
1290                           + DAY_YSEP * 5);
1291
1292   height = (private_data->header_h + private_data->day_name_h
1293             + private_data->main_h);
1294
1295   requisition->height = height + (widget->style->ythickness + INNER_BORDER) * 2;
1296
1297   g_object_unref (G_OBJECT (layout));
1298 }
1299
1300 static void
1301 gtk_calendar_size_allocate (GtkWidget     *widget,
1302                             GtkAllocation *allocation)
1303 {
1304   GtkCalendar *calendar;
1305   GtkCalendarPrivateData *private_data;
1306   gint xthickness = widget->style->xthickness;
1307   gint ythickness = widget->style->xthickness;
1308
1309   widget->allocation = *allocation;
1310
1311   calendar = GTK_CALENDAR (widget);
1312   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1313
1314   if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
1315     {
1316       private_data->day_width = (private_data->min_day_width
1317                              * ((allocation->width - (xthickness + INNER_BORDER) * 2
1318                                  - (CALENDAR_MARGIN * 2) -  (DAY_XSEP * 6) - CALENDAR_XSEP * 2))
1319                              / (7 * private_data->min_day_width + private_data->max_week_char_width * 2));
1320       private_data->week_width = ((allocation->width - (xthickness + INNER_BORDER) * 2
1321                                - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 6) - CALENDAR_XSEP * 2 )
1322                               - private_data->day_width * 7 + CALENDAR_MARGIN + CALENDAR_XSEP);
1323     }
1324   else
1325     {
1326       private_data->day_width = (allocation->width
1327                              - (xthickness + INNER_BORDER) * 2
1328                              - (CALENDAR_MARGIN * 2)
1329                              - (DAY_XSEP * 6))/7;
1330       private_data->week_width = 0;
1331     }
1332
1333   if (GTK_WIDGET_REALIZED (widget))
1334     {
1335       gdk_window_move_resize (widget->window,
1336                               allocation->x, allocation->y,
1337                               allocation->width, allocation->height);
1338       if (private_data->header_win)
1339         gdk_window_move_resize (private_data->header_win,
1340                                 xthickness, ythickness,
1341                                 allocation->width - 2 * xthickness, private_data->header_h);
1342       if (private_data->arrow_win[ARROW_MONTH_LEFT])
1343         gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_LEFT],
1344                                 3, 3,
1345                                 private_data->arrow_width,
1346                                 private_data->header_h - 7);
1347       if (private_data->arrow_win[ARROW_MONTH_RIGHT])
1348         gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_RIGHT],
1349                                 (private_data->arrow_width
1350                                  + private_data->max_month_width),
1351                                 3,
1352                                 private_data->arrow_width,
1353                                 private_data->header_h - 7);
1354       if (private_data->arrow_win[ARROW_YEAR_LEFT])
1355         gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_LEFT],
1356                                 (allocation->width - 2 * xthickness
1357                                  - (3 + 2*private_data->arrow_width
1358                                     + private_data->max_year_width)),
1359                                 3,
1360                                 private_data->arrow_width,
1361                                 private_data->header_h - 7);
1362       if (private_data->arrow_win[ARROW_YEAR_RIGHT])
1363         gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_RIGHT],
1364                                 (allocation->width - 2 * xthickness
1365                                  - 3 - private_data->arrow_width),
1366                                 3,
1367                                 private_data->arrow_width,
1368                                 private_data->header_h - 7);
1369       if (private_data->day_name_win)
1370         gdk_window_move_resize (private_data->day_name_win,
1371                                 xthickness + INNER_BORDER,
1372                                 private_data->header_h + (widget->style->ythickness + INNER_BORDER),
1373                                 allocation->width - (xthickness + INNER_BORDER) * 2,
1374                                 private_data->day_name_h);
1375       if (private_data->week_win)
1376         gdk_window_move_resize (private_data->week_win,
1377                                 (xthickness + INNER_BORDER),
1378                                 private_data->header_h + private_data->day_name_h
1379                                 + (widget->style->ythickness + INNER_BORDER),
1380                                 private_data->week_width,
1381                                 private_data->main_h);
1382       gdk_window_move_resize (private_data->main_win,
1383                               private_data->week_width + (xthickness + INNER_BORDER),
1384                               private_data->header_h + private_data->day_name_h
1385                               + (widget->style->ythickness + INNER_BORDER),
1386                               allocation->width
1387                               - private_data->week_width
1388                               - (xthickness + INNER_BORDER) * 2,
1389                               private_data->main_h);
1390     }
1391 }
1392
1393 static gboolean
1394 gtk_calendar_expose (GtkWidget      *widget,
1395                      GdkEventExpose *event)
1396 {
1397   GtkCalendar *calendar;
1398   GtkCalendarPrivateData *private_data;
1399
1400   calendar = GTK_CALENDAR (widget);
1401   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1402
1403   if (GTK_WIDGET_DRAWABLE (widget))
1404     {
1405       if (event->window == private_data->main_win)
1406         gtk_calendar_paint_main (widget);
1407
1408       if (event->window == private_data->header_win)
1409         gtk_calendar_paint_header (widget);
1410
1411       if (event->window == private_data->day_name_win)
1412         gtk_calendar_paint_day_names (widget);
1413
1414       if (event->window == private_data->week_win)
1415         gtk_calendar_paint_week_numbers (widget);
1416       if (event->window == widget->window)
1417         {
1418           gtk_paint_shadow (widget->style, widget->window, GTK_WIDGET_STATE (widget),
1419                             GTK_SHADOW_IN, NULL, widget, "calendar",
1420                             0, 0, widget->allocation.width, widget->allocation.height);
1421         }
1422     }
1423
1424   return FALSE;
1425 }
1426
1427 static void
1428 gtk_calendar_paint_header (GtkWidget *widget)
1429 {
1430   GtkCalendar *calendar;
1431   GdkGC *gc;
1432   char buffer[255];
1433   int x, y;
1434   gint header_width, cal_height;
1435   gint max_month_width;
1436   gint max_year_width;
1437   GtkCalendarPrivateData *private_data;
1438   PangoLayout *layout;
1439   PangoRectangle logical_rect;
1440
1441   calendar = GTK_CALENDAR (widget);
1442   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1443
1444   if (private_data->freeze_count)
1445     {
1446       private_data->dirty_header = 1;
1447       return;
1448     }
1449   private_data->dirty_header = 0;
1450   gc = calendar->gc;
1451
1452   /* Clear window */
1453   gdk_window_clear (private_data->header_win);
1454
1455   header_width = widget->allocation.width - 2 * widget->style->xthickness;
1456   cal_height = widget->allocation.height;
1457
1458   max_month_width = private_data->max_month_width;
1459   max_year_width = private_data->max_year_width;
1460
1461   gdk_gc_set_foreground (gc, BACKGROUND_COLOR (GTK_WIDGET (calendar)));
1462   gtk_draw_shadow (widget->style, private_data->header_win,
1463                    GTK_STATE_NORMAL, GTK_SHADOW_OUT,
1464                    0, 0, header_width, private_data->header_h);
1465
1466
1467   sprintf (buffer, "%d", calendar->year);
1468   layout = gtk_widget_create_pango_layout (widget, buffer);
1469   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1470
1471   /* Draw title */
1472   y = (private_data->header_h - logical_rect.height) / 2;
1473
1474   /* Draw year and its arrows */
1475
1476   if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1477     x = header_width - (3 + max_year_width
1478                         - (max_year_width - logical_rect.width)/2);
1479   else
1480     x = header_width - (3 + private_data->arrow_width + max_year_width
1481                         - (max_year_width - logical_rect.width)/2);
1482
1483
1484   gdk_gc_set_foreground (gc, HEADER_FG_COLOR (GTK_WIDGET (calendar)));
1485   gdk_draw_layout (private_data->header_win, gc, x, y, layout);
1486
1487   /* Draw month */
1488   sprintf (buffer, "%s", default_monthname[calendar->month]);
1489   pango_layout_set_text (layout, buffer, -1);
1490   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1491
1492   if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1493     x = 3 + (max_month_width - logical_rect.width) / 2;
1494   else
1495     x = 3 + private_data->arrow_width + (max_month_width - logical_rect.width)/2;
1496
1497   gdk_draw_layout (private_data->header_win, gc, x, y, layout);
1498
1499   gdk_gc_set_foreground (gc, BACKGROUND_COLOR (GTK_WIDGET (calendar)));
1500
1501   gtk_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
1502   gtk_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
1503   gtk_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
1504   gtk_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
1505
1506   g_object_unref (G_OBJECT (layout));
1507 }
1508
1509 static void
1510 gtk_calendar_paint_day_names (GtkWidget *widget)
1511 {
1512   GtkCalendar *calendar;
1513   GdkGC *gc;
1514   char buffer[255];
1515   int day,i;
1516   int day_width, cal_width;
1517   gint cal_height;
1518   int day_wid_sep;
1519   PangoLayout *layout;
1520   PangoRectangle logical_rect;
1521   GtkCalendarPrivateData *private_data;
1522   gint focus_padding;
1523   gint focus_width;
1524
1525   g_return_if_fail (GTK_IS_CALENDAR (widget));
1526   calendar = GTK_CALENDAR (widget);
1527   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1528   gc = calendar->gc;
1529
1530   gtk_widget_style_get (GTK_WIDGET (widget),
1531                         "focus-line-width", &focus_width,
1532                         "focus-padding", &focus_padding,
1533                         NULL);
1534   /*
1535    * Handle freeze/thaw functionality
1536    */
1537
1538   if (private_data->freeze_count)
1539     {
1540       private_data->dirty_day_names = 1;
1541       return;
1542     }
1543   private_data->dirty_day_names = 0;
1544
1545   /*
1546    * Clear the window
1547    */
1548
1549   gdk_window_clear (private_data->day_name_win);
1550
1551   day_width = private_data->day_width;
1552   cal_width = widget->allocation.width;
1553   cal_height = widget->allocation.height;
1554   day_wid_sep = day_width + DAY_XSEP;
1555
1556   /*
1557    * Draw rectangles as inverted background for the labels.
1558    */
1559
1560   gdk_gc_set_foreground (gc, &widget->style->base[GTK_STATE_SELECTED]);
1561   gdk_draw_rectangle (private_data->day_name_win, gc, TRUE,
1562                       CALENDAR_MARGIN, CALENDAR_MARGIN,
1563                       cal_width-CALENDAR_MARGIN * 2,
1564                       private_data->day_name_h - CALENDAR_MARGIN);
1565
1566   if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
1567     gdk_draw_rectangle (private_data->day_name_win, gc, TRUE,
1568                         CALENDAR_MARGIN,
1569                         private_data->day_name_h - CALENDAR_YSEP,
1570                         private_data->week_width - CALENDAR_YSEP - CALENDAR_MARGIN,
1571                         CALENDAR_YSEP);
1572
1573   /*
1574    * Write the labels
1575    */
1576
1577   layout = gtk_widget_create_pango_layout (widget, NULL);
1578
1579   gdk_gc_set_foreground (gc, &widget->style->text[GTK_STATE_SELECTED]);
1580   for (i = 0; i < 7; i++)
1581     {
1582       if (gtk_widget_get_direction (GTK_WIDGET (calendar)) == GTK_TEXT_DIR_RTL)
1583         day = 6 - i;
1584       else
1585         day = i;
1586       if (calendar->display_flags & GTK_CALENDAR_WEEK_START_MONDAY)
1587         day= (day+1)%7;
1588       sprintf (buffer, "%s", default_abbreviated_dayname[day]);
1589
1590       pango_layout_set_text (layout, buffer, -1);
1591       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1592
1593       gdk_draw_layout (private_data->day_name_win, gc,
1594                        (CALENDAR_MARGIN +
1595                         + private_data->week_width
1596                         + (private_data->week_width ? CALENDAR_XSEP : 0)
1597                         + day_wid_sep * i
1598                         + (day_width - logical_rect.width)/2),
1599                        CALENDAR_MARGIN + focus_width + focus_padding + logical_rect.y,
1600                        layout);
1601     }
1602
1603   g_object_unref (G_OBJECT (layout));
1604 }
1605
1606 static void
1607 gtk_calendar_paint_week_numbers (GtkWidget *widget)
1608 {
1609   GtkCalendar *calendar;
1610   GdkGC *gc;
1611   gint row, week = 0, year;
1612   gint x_loc;
1613   char buffer[3];
1614   gint y_loc, day_height;
1615   GtkCalendarPrivateData *private_data;
1616   PangoLayout *layout;
1617   PangoRectangle logical_rect;
1618   gint focus_padding;
1619   gint focus_width;
1620
1621   g_return_if_fail (GTK_IS_CALENDAR (widget));
1622   g_return_if_fail (widget->window != NULL);
1623   calendar = GTK_CALENDAR (widget);
1624   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1625   gc = calendar->gc;
1626
1627   /*
1628    * Handle freeze/thaw functionality
1629    */
1630
1631   if (private_data->freeze_count)
1632     {
1633       private_data->dirty_week = 1;
1634       return;
1635     }
1636   private_data->dirty_week = 0;
1637
1638   gtk_widget_style_get (GTK_WIDGET (widget),
1639                         "focus-line-width", &focus_width,
1640                         "focus-padding", &focus_padding,
1641                         NULL);
1642
1643   /*
1644    * Clear the window
1645    */
1646
1647   gdk_window_clear (private_data->week_win);
1648
1649   /*
1650    * Draw a rectangle as inverted background for the labels.
1651    */
1652
1653   gdk_gc_set_foreground (gc, &widget->style->base[GTK_STATE_SELECTED]);
1654   if (private_data->day_name_win)
1655     gdk_draw_rectangle (private_data->week_win, gc, TRUE,
1656                         CALENDAR_MARGIN,
1657                         0,
1658                         private_data->week_width - CALENDAR_MARGIN,
1659                         private_data->main_h - CALENDAR_MARGIN);
1660   else
1661     gdk_draw_rectangle (private_data->week_win, gc, TRUE,
1662                         CALENDAR_MARGIN,
1663                         CALENDAR_MARGIN,
1664                         private_data->week_width - CALENDAR_MARGIN,
1665                         private_data->main_h - 2 * CALENDAR_MARGIN);
1666
1667   /*
1668    * Write the labels
1669    */
1670
1671   layout = gtk_widget_create_pango_layout (widget, NULL);
1672
1673   gdk_gc_set_foreground (gc, &widget->style->text[GTK_STATE_SELECTED]);
1674   day_height = row_height (calendar);
1675   for (row = 0; row < 6; row++)
1676     {
1677       year = calendar->year;
1678       if (calendar->day[row][6] < 15 && row > 3 && calendar->month == 11)
1679         year++;
1680
1681       g_return_if_fail (week_of_year (&week, &year,
1682                                       ((calendar->day[row][6] < 15 && row > 3 ? 1 : 0)
1683                                        + calendar->month) % 12 + 1, calendar->day[row][6]));
1684
1685       sprintf (buffer, "%d", week);
1686       pango_layout_set_text (layout, buffer, -1);
1687       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1688
1689       y_loc = top_y_for_row (calendar, row) + (day_height - logical_rect.height) / 2;
1690
1691       x_loc = (private_data->week_width
1692                - logical_rect.width
1693                - CALENDAR_XSEP - focus_padding - focus_width);
1694
1695       gdk_draw_layout (private_data->week_win, gc, x_loc, y_loc, layout);
1696     }
1697
1698   g_object_unref (G_OBJECT (layout));
1699 }
1700
1701 static void
1702 gtk_calendar_paint_day_num (GtkWidget *widget,
1703                             gint       day)
1704 {
1705   GtkCalendar *calendar;
1706   gint r, c, row, col;
1707
1708   g_return_if_fail (GTK_IS_CALENDAR (widget));
1709
1710   calendar = GTK_CALENDAR (widget);
1711
1712   row = -1;
1713   col = -1;
1714   for (r = 0; r < 6; r++)
1715     for (c = 0; c < 7; c++)
1716       if (calendar->day_month[r][c] == MONTH_CURRENT &&
1717           calendar->day[r][c] == day)
1718         {
1719           row = r;
1720           col = c;
1721         }
1722
1723   g_return_if_fail (row != -1);
1724   g_return_if_fail (col != -1);
1725
1726   gtk_calendar_paint_day (widget, row, col);
1727 }
1728
1729 static void
1730 gtk_calendar_paint_day (GtkWidget *widget,
1731                         gint       row,
1732                         gint       col)
1733 {
1734   GtkCalendar *calendar;
1735   GdkGC *gc;
1736   gchar buffer[255];
1737   gint day;
1738   gint day_height;
1739   gint x_left;
1740   gint x_loc;
1741   gint y_top;
1742   gint y_loc;
1743   gint day_xspace;
1744   gint focus_width;
1745
1746   GtkCalendarPrivateData *private_data;
1747   PangoLayout *layout;
1748   PangoRectangle logical_rect;
1749
1750   g_return_if_fail (GTK_IS_CALENDAR (widget));
1751   g_return_if_fail (row < 6);
1752   g_return_if_fail (col < 7);
1753   calendar = GTK_CALENDAR (widget);
1754   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1755
1756   /*
1757    * Handle freeze/thaw functionality
1758    */
1759
1760   if (private_data->freeze_count)
1761     {
1762       private_data->dirty_main = 1;
1763       return;
1764     }
1765
1766   gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
1767
1768   day_height = row_height (calendar);
1769
1770   day_xspace = private_data->day_width - private_data->max_day_char_width*2;
1771
1772   day = calendar->day[row][col];
1773
1774   x_left = left_x_for_column (calendar, col);
1775   x_loc = x_left + private_data->day_width / 2 + private_data->max_day_char_width;
1776
1777   y_top = top_y_for_row (calendar, row);
1778
1779   gdk_window_clear_area (private_data->main_win, x_left, y_top,
1780                          private_data->day_width, day_height);
1781
1782   gc = calendar->gc;
1783
1784   if (calendar->day_month[row][col] == MONTH_PREV)
1785     {
1786       gdk_gc_set_foreground (gc, PREV_MONTH_COLOR (GTK_WIDGET (calendar)));
1787     }
1788   else if (calendar->day_month[row][col] == MONTH_NEXT)
1789     {
1790       gdk_gc_set_foreground (gc, NEXT_MONTH_COLOR (GTK_WIDGET (calendar)));
1791     }
1792   else
1793     {
1794       /*
1795       if (calendar->highlight_row == row && calendar->highlight_col == col)
1796         {
1797           gdk_gc_set_foreground (gc, HIGHLIGHT_BACK_COLOR (GTK_WIDGET (calendar)));
1798           gdk_draw_rectangle (private_data->main_win, gc, TRUE, x_left, y_top,
1799                               private_data->day_width, day_height);
1800         }
1801       */
1802       if (calendar->selected_day == day)
1803         {
1804           gdk_gc_set_foreground (gc, & (GTK_WIDGET (calendar)->style->base[GTK_STATE_SELECTED]));
1805           gdk_draw_rectangle (private_data->main_win, gc, TRUE, x_left, y_top,
1806                               private_data->day_width, day_height);
1807         }
1808
1809       if (calendar->marked_date[day-1])
1810         gdk_gc_set_foreground (gc, MARKED_COLOR  (GTK_WIDGET (calendar)));
1811       else
1812         gdk_gc_set_foreground (gc, NORMAL_DAY_COLOR (GTK_WIDGET (calendar)));
1813
1814       if (calendar->selected_day == day)
1815         gdk_gc_set_foreground (gc, & (GTK_WIDGET (calendar)->style->text[GTK_STATE_SELECTED]));
1816       else
1817         gdk_gc_set_foreground (gc, & (GTK_WIDGET (calendar)->style->fg[GTK_WIDGET_STATE (calendar)]));
1818     }
1819
1820
1821   sprintf (buffer, "%d", day);
1822   layout = gtk_widget_create_pango_layout (widget, buffer);
1823   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1824
1825   x_loc -= logical_rect.width;
1826
1827   y_loc = y_top + (day_height - logical_rect.height) / 2;
1828   gdk_draw_layout (private_data->main_win, gc,
1829                    x_loc, y_loc, layout);
1830   if (calendar->marked_date[day-1]
1831       && calendar->day_month[row][col] == MONTH_CURRENT)
1832     gdk_draw_layout (private_data->main_win, gc,
1833                      x_loc-1, y_loc, layout);
1834
1835   if (GTK_WIDGET_HAS_FOCUS (calendar)
1836       && calendar->focus_row == row && calendar->focus_col == col)
1837     {
1838       gtk_paint_focus (widget->style,
1839                        private_data->main_win,
1840                        (calendar->selected_day == day)
1841                           ? GTK_STATE_SELECTED : GTK_STATE_NORMAL,
1842                        NULL, widget, "calendar-day",
1843                        x_left, y_top,
1844                        private_data->day_width,
1845                        day_height);
1846     }
1847
1848   g_object_unref (G_OBJECT (layout));
1849 }
1850
1851
1852 static void
1853 gtk_calendar_paint_main (GtkWidget *widget)
1854 {
1855   GtkCalendar *calendar;
1856   GtkCalendarPrivateData *private_data;
1857   gint row, col;
1858
1859   g_return_if_fail (GTK_IS_CALENDAR (widget));
1860   g_return_if_fail (widget->window != NULL);
1861
1862   calendar = GTK_CALENDAR (widget);
1863   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
1864
1865   if (private_data->freeze_count)
1866     {
1867       private_data->dirty_main = 1;
1868       return;
1869     }
1870   private_data->dirty_main = 0;
1871   gdk_window_clear (private_data->main_win);
1872
1873   /* gtk_calendar_compute_days (calendar); */ /* REMOVE later */
1874
1875   for (col = 0; col < 7; col++)
1876     for (row = 0; row < 6; row++)
1877       gtk_calendar_paint_day (widget, row, col);
1878 }
1879
1880 static void
1881 gtk_calendar_compute_days (GtkCalendar *calendar)
1882 {
1883   gint month;
1884   gint year;
1885   gint ndays_in_month;
1886   gint ndays_in_prev_month;
1887   gint first_day;
1888   gint row;
1889   gint col;
1890   gint day;
1891
1892   g_return_if_fail (GTK_IS_CALENDAR (calendar));
1893
1894   year = calendar->year;
1895   month = calendar->month + 1;
1896
1897   ndays_in_month = month_length[leap (year)][month];
1898
1899   first_day = day_of_week (year, month, 1);
1900
1901   if (calendar->display_flags & GTK_CALENDAR_WEEK_START_MONDAY)
1902     first_day--;
1903   else
1904     first_day %= 7;
1905
1906
1907   /* Compute days of previous month */
1908   if (month > 1)
1909     ndays_in_prev_month = month_length[leap (year)][month-1];
1910   else
1911     ndays_in_prev_month = month_length[leap (year)][12];
1912   day = ndays_in_prev_month - first_day + 1;
1913
1914   row = 0;
1915   if (first_day > 0)
1916     {
1917       for (col = 0; col < first_day; col++)
1918         {
1919           calendar->day[row][col] = day;
1920           calendar->day_month[row][col] = MONTH_PREV;
1921           day++;
1922         }
1923     }
1924
1925   /* Compute days of current month */
1926   col = first_day;
1927   for (day = 1; day <= ndays_in_month; day++)
1928     {
1929       calendar->day[row][col] = day;
1930       calendar->day_month[row][col] = MONTH_CURRENT;
1931
1932       col++;
1933       if (col == 7)
1934         {
1935           row++;
1936           col = 0;
1937         }
1938     }
1939
1940   /* Compute days of next month */
1941   day = 1;
1942   for (; row <= 5; row++)
1943     {
1944       for (; col <= 6; col++)
1945         {
1946           calendar->day[row][col] = day;
1947           calendar->day_month[row][col] = MONTH_NEXT;
1948           day++;
1949         }
1950       col = 0;
1951     }
1952 }
1953
1954 /* ----------------------------------------------------------------------
1955    NAME:        gtk_calendar_display_options
1956    DESCRIPTION: Set display options (whether to display the
1957    heading and the month headings)
1958
1959    flags is can be an XOR of:
1960    GTK_CALENDAR_SHOW_HEADING
1961    GTK_CALENDAR_SHOW_DAY_NAMES
1962    GTK_CALENDAR_NO_MONTH_CHANGE
1963    GTK_CALENDAR_SHOW_WEEK_NUMBERS
1964    GTK_CALENDAR_WEEK_START_MONDAY
1965    ---------------------------------------------------------------------- */
1966
1967 void
1968 gtk_calendar_display_options (GtkCalendar              *calendar,
1969                               GtkCalendarDisplayOptions flags)
1970 {
1971   GtkCalendarPrivateData *private_data;
1972   gint resize = 0;
1973   GtkWidget *widget;
1974   gint i;
1975
1976   g_return_if_fail (GTK_IS_CALENDAR (calendar));
1977
1978   widget = GTK_WIDGET (calendar);
1979   private_data = GTK_CALENDAR_PRIVATE_DATA (calendar);
1980
1981   if (GTK_WIDGET_REALIZED (widget))
1982     {
1983       if ((flags ^ calendar->display_flags) & GTK_CALENDAR_NO_MONTH_CHANGE)
1984         {
1985           resize ++;
1986           if (! (flags & GTK_CALENDAR_NO_MONTH_CHANGE)
1987               && (private_data->header_win))
1988             {
1989               calendar->display_flags &= ~GTK_CALENDAR_NO_MONTH_CHANGE;
1990               gtk_calendar_realize_arrows (widget);
1991             }
1992           else
1993             {
1994               for (i = 0; i < 4; i++)
1995                 {
1996                   if (private_data->arrow_win[i])
1997                     {
1998                       gdk_window_set_user_data (private_data->arrow_win[i],
1999                                                 NULL);
2000                       gdk_window_destroy (private_data->arrow_win[i]);
2001                       private_data->arrow_win[i] = NULL;
2002                     }
2003                 }
2004             }
2005         }
2006
2007       if ((flags ^ calendar->display_flags) & GTK_CALENDAR_SHOW_HEADING)
2008         {
2009           resize++;
2010
2011           if (flags & GTK_CALENDAR_SHOW_HEADING)
2012             {
2013               calendar->display_flags |= GTK_CALENDAR_SHOW_HEADING;
2014               gtk_calendar_realize_header (widget);
2015             }
2016           else
2017             {
2018               for (i = 0; i < 4; i++)
2019                 {
2020                   if (private_data->arrow_win[i])
2021                     {
2022                       gdk_window_set_user_data (private_data->arrow_win[i],
2023                                                 NULL);
2024                       gdk_window_destroy (private_data->arrow_win[i]);
2025                       private_data->arrow_win[i] = NULL;
2026                     }
2027                 }
2028               gdk_window_set_user_data (private_data->header_win, NULL);
2029               gdk_window_destroy (private_data->header_win);
2030               private_data->header_win = NULL;
2031             }
2032         }
2033
2034
2035       if ((flags ^ calendar->display_flags) & GTK_CALENDAR_SHOW_DAY_NAMES)
2036         {
2037           resize++;
2038
2039           if (flags & GTK_CALENDAR_SHOW_DAY_NAMES)
2040             {
2041               calendar->display_flags |= GTK_CALENDAR_SHOW_DAY_NAMES;
2042               gtk_calendar_realize_day_names (widget);
2043             }
2044           else
2045             {
2046               gdk_window_set_user_data (private_data->day_name_win, NULL);
2047               gdk_window_destroy (private_data->day_name_win);
2048               private_data->day_name_win = NULL;
2049             }
2050         }
2051
2052       if ((flags ^ calendar->display_flags) & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
2053         {
2054           resize++;
2055
2056           if (flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
2057             {
2058               calendar->display_flags |= GTK_CALENDAR_SHOW_WEEK_NUMBERS;
2059               gtk_calendar_realize_week_numbers (widget);
2060             }
2061           else
2062             {
2063               gdk_window_set_user_data (private_data->week_win, NULL);
2064               gdk_window_destroy (private_data->week_win);
2065               private_data->week_win = NULL;
2066             }
2067         }
2068
2069       if ((flags ^ calendar->display_flags) & GTK_CALENDAR_WEEK_START_MONDAY)
2070         {
2071           if (calendar->display_flags & GTK_CALENDAR_WEEK_START_MONDAY)
2072             calendar->display_flags &= ~GTK_CALENDAR_WEEK_START_MONDAY;
2073           else
2074             calendar->display_flags |= GTK_CALENDAR_WEEK_START_MONDAY;
2075
2076           gtk_calendar_compute_days (calendar);
2077           gtk_calendar_paint_main (GTK_WIDGET (calendar));
2078           if (private_data->day_name_win)
2079             gtk_calendar_paint_day_names (GTK_WIDGET (calendar));
2080         }
2081
2082       calendar->display_flags = flags;
2083       if (resize)
2084         gtk_widget_queue_resize (GTK_WIDGET (calendar));
2085
2086     }
2087   else
2088     calendar->display_flags = flags;
2089
2090 }
2091
2092 gboolean
2093 gtk_calendar_select_month (GtkCalendar *calendar,
2094                            guint        month,
2095                            guint        year)
2096 {
2097   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), FALSE);
2098   g_return_val_if_fail (month <= 11, FALSE);
2099
2100   calendar->month = month;
2101   calendar->year  = year;
2102
2103   gtk_calendar_compute_days (calendar);
2104
2105   gtk_widget_queue_draw (GTK_WIDGET (calendar));
2106   gtk_signal_emit (GTK_OBJECT (calendar),
2107                    gtk_calendar_signals[MONTH_CHANGED_SIGNAL]);
2108   return TRUE;
2109 }
2110
2111 void
2112 gtk_calendar_select_day (GtkCalendar *calendar,
2113                          guint        day)
2114 {
2115   g_return_if_fail (GTK_IS_CALENDAR (calendar));
2116   g_return_if_fail (day <= 31);
2117
2118   /* gtk_calendar_compute_days (calendar); */
2119
2120   /* Deselect the old day */
2121   if (calendar->selected_day > 0)
2122     {
2123       gint selected_day;
2124
2125       selected_day = calendar->selected_day;
2126       calendar->selected_day = 0;
2127       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2128         gtk_calendar_paint_day_num (GTK_WIDGET (calendar), selected_day);
2129     }
2130
2131   calendar->selected_day = day;
2132
2133   /* Select the new day */
2134   if (day != 0)
2135     {
2136       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2137         gtk_calendar_paint_day_num (GTK_WIDGET (calendar), day);
2138     }
2139
2140   gtk_signal_emit (GTK_OBJECT (calendar),
2141                    gtk_calendar_signals[DAY_SELECTED_SIGNAL]);
2142 }
2143
2144 void
2145 gtk_calendar_clear_marks (GtkCalendar *calendar)
2146 {
2147   guint day;
2148
2149   g_return_if_fail (GTK_IS_CALENDAR (calendar));
2150
2151   for (day = 0; day < 31; day++)
2152     {
2153       calendar->marked_date[day] = FALSE;
2154     }
2155
2156   calendar->num_marked_dates = 0;
2157
2158   if (GTK_WIDGET_DRAWABLE (calendar))
2159     {
2160       gtk_calendar_paint_main (GTK_WIDGET (calendar));
2161     }
2162 }
2163
2164 gboolean
2165 gtk_calendar_mark_day (GtkCalendar *calendar,
2166                        guint        day)
2167 {
2168   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), FALSE);
2169
2170   if (day >= 1 && day <= 31 && calendar->marked_date[day-1] == FALSE)
2171     {
2172       calendar->marked_date[day - 1] = TRUE;
2173       calendar->num_marked_dates++;
2174     }
2175   if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2176     {
2177       gtk_calendar_paint_main (GTK_WIDGET (calendar));
2178     }
2179
2180   return TRUE;
2181 }
2182
2183 gboolean
2184 gtk_calendar_unmark_day (GtkCalendar *calendar,
2185                          guint        day)
2186 {
2187   g_return_val_if_fail (GTK_IS_CALENDAR (calendar), FALSE);
2188
2189   if (day >= 1 && day <= 31 && calendar->marked_date[day-1] == TRUE)
2190     {
2191       calendar->marked_date[day - 1] = FALSE;
2192       calendar->num_marked_dates--;
2193     }
2194
2195   if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (calendar)))
2196     {
2197       gtk_calendar_paint_main (GTK_WIDGET (calendar));
2198     }
2199
2200   return TRUE;
2201 }
2202
2203 void
2204 gtk_calendar_get_date (GtkCalendar *calendar,
2205                        guint       *year,
2206                        guint       *month,
2207                        guint       *day)
2208 {
2209   g_return_if_fail (GTK_IS_CALENDAR (calendar));
2210
2211   if (year)
2212     *year = calendar->year;
2213
2214   if (month)
2215     *month = calendar->month;
2216
2217   if (day)
2218     *day = calendar->selected_day;
2219 }
2220
2221 static gboolean
2222 gtk_calendar_button_press (GtkWidget      *widget,
2223                            GdkEventButton *event)
2224 {
2225   GtkCalendar *calendar;
2226   GtkCalendarPrivateData *private_data;
2227   gint x, y;
2228   void (* action_func) (GtkCalendar *);
2229
2230   calendar = GTK_CALENDAR (widget);
2231   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
2232
2233   x = (gint) (event->x);
2234   y = (gint) (event->y);
2235
2236   if (event->window == private_data->main_win)
2237     gtk_calendar_main_button (widget, event);
2238
2239   action_func = NULL;
2240
2241   if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
2242     action_func = gtk_calendar_set_month_prev;
2243   else if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
2244     action_func = gtk_calendar_set_month_next;
2245   else if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
2246     action_func = gtk_calendar_set_year_prev;
2247   else if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
2248     action_func = gtk_calendar_set_year_next;
2249
2250   /* only call the action on single click, not double */
2251   if (action_func && event->type == GDK_BUTTON_PRESS)
2252     (* action_func) (calendar);
2253
2254   return action_func != NULL;
2255 }
2256
2257 static gboolean
2258 gtk_calendar_motion_notify (GtkWidget      *widget,
2259                             GdkEventMotion *event)
2260 {
2261   GtkCalendar *calendar;
2262   GtkCalendarPrivateData *private_data;
2263   gint event_x, event_y;
2264   gint row, col;
2265   gint old_row, old_col;
2266
2267   calendar = GTK_CALENDAR (widget);
2268   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
2269   event_x = (gint) (event->x);
2270   event_y = (gint) (event->y);
2271
2272   if (event->window == private_data->main_win)
2273     {
2274
2275       row = row_from_y (calendar, event_y);
2276       col = column_from_x (calendar, event_x);
2277
2278       if (row != calendar->highlight_row || calendar->highlight_col != col)
2279         {
2280           old_row = calendar->highlight_row;
2281           old_col = calendar->highlight_col;
2282           if (old_row > -1 && old_col > -1)
2283             {
2284               calendar->highlight_row = -1;
2285               calendar->highlight_col = -1;
2286               gtk_calendar_paint_day (widget, old_row, old_col);
2287             }
2288
2289           calendar->highlight_row = row;
2290           calendar->highlight_col = col;
2291
2292           if (row > -1 && col > -1)
2293             gtk_calendar_paint_day (widget, row, col);
2294         }
2295     }
2296   return TRUE;
2297 }
2298
2299 static gboolean
2300 gtk_calendar_enter_notify (GtkWidget        *widget,
2301                            GdkEventCrossing *event)
2302 {
2303   GtkCalendar *calendar;
2304   GtkCalendarPrivateData *private_data;
2305
2306   calendar = GTK_CALENDAR (widget);
2307   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
2308
2309   if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
2310     {
2311       private_data->arrow_state[ARROW_MONTH_LEFT] = GTK_STATE_PRELIGHT;
2312       gtk_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
2313     }
2314
2315   if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
2316     {
2317       private_data->arrow_state[ARROW_MONTH_RIGHT] = GTK_STATE_PRELIGHT;
2318       gtk_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
2319     }
2320
2321   if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
2322     {
2323       private_data->arrow_state[ARROW_YEAR_LEFT] = GTK_STATE_PRELIGHT;
2324       gtk_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
2325     }
2326
2327   if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
2328     {
2329       private_data->arrow_state[ARROW_YEAR_RIGHT] = GTK_STATE_PRELIGHT;
2330       gtk_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
2331     }
2332
2333   return TRUE;
2334 }
2335
2336 static gboolean
2337 gtk_calendar_leave_notify (GtkWidget        *widget,
2338                            GdkEventCrossing *event)
2339 {
2340   GtkCalendar *calendar;
2341   GtkCalendarPrivateData *private_data;
2342   gint row;
2343   gint col;
2344
2345   calendar = GTK_CALENDAR (widget);
2346   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
2347
2348   if (event->window == private_data->main_win)
2349     {
2350       row = calendar->highlight_row;
2351       col = calendar->highlight_col;
2352       calendar->highlight_row = -1;
2353       calendar->highlight_col = -1;
2354       if (row > -1 && col > -1)
2355         gtk_calendar_paint_day (widget, row, col);
2356     }
2357
2358   if (event->window == private_data->arrow_win[ARROW_MONTH_LEFT])
2359     {
2360       private_data->arrow_state[ARROW_MONTH_LEFT] = GTK_STATE_NORMAL;
2361       gtk_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
2362     }
2363
2364   if (event->window == private_data->arrow_win[ARROW_MONTH_RIGHT])
2365     {
2366       private_data->arrow_state[ARROW_MONTH_RIGHT] = GTK_STATE_NORMAL;
2367       gtk_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
2368     }
2369
2370   if (event->window == private_data->arrow_win[ARROW_YEAR_LEFT])
2371     {
2372       private_data->arrow_state[ARROW_YEAR_LEFT] = GTK_STATE_NORMAL;
2373       gtk_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
2374     }
2375
2376   if (event->window == private_data->arrow_win[ARROW_YEAR_RIGHT])
2377     {
2378       private_data->arrow_state[ARROW_YEAR_RIGHT] = GTK_STATE_NORMAL;
2379       gtk_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
2380     }
2381
2382   return TRUE;
2383 }
2384
2385 static void
2386 gtk_calendar_paint_arrow (GtkWidget *widget,
2387                           guint      arrow)
2388 {
2389   GtkCalendarPrivateData *private_data;
2390   GdkWindow *window;
2391   GdkGC *gc;
2392   GtkCalendar *calendar;
2393   gint state;
2394   gint width, height;
2395
2396   calendar = GTK_CALENDAR (widget);
2397   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
2398
2399   if (private_data->freeze_count)
2400     {
2401       private_data->dirty_header = 1;
2402       return;
2403     }
2404   window = private_data->arrow_win[arrow];
2405   if (window)
2406     {
2407       state = private_data->arrow_state[arrow];
2408       gc = calendar->gc;
2409
2410       gdk_window_clear (window);
2411       gdk_window_set_background (window, &(widget)->style->bg[state]);
2412       gdk_window_get_size (window, &width, &height);
2413       gdk_window_clear_area (window,
2414                              0,0,
2415                              width,height);
2416
2417       gdk_gc_set_foreground (gc, & (widget)->style->fg[state]);
2418
2419       if (arrow == ARROW_MONTH_LEFT || arrow == ARROW_YEAR_LEFT)
2420         draw_arrow_left (window, gc, width/2 - 3, height/2 - 4, 8);
2421       else
2422         draw_arrow_right (window, gc, width/2 - 2, height/2 - 4, 8);
2423       return;
2424     }
2425 }
2426
2427 void
2428 gtk_calendar_freeze (GtkCalendar *calendar)
2429 {
2430   g_return_if_fail (GTK_IS_CALENDAR (calendar));
2431
2432   GTK_CALENDAR_PRIVATE_DATA (calendar)->freeze_count++;
2433 }
2434
2435 void
2436 gtk_calendar_thaw (GtkCalendar *calendar)
2437 {
2438   GtkCalendarPrivateData *private_data;
2439
2440   g_return_if_fail (GTK_IS_CALENDAR (calendar));
2441
2442   private_data = GTK_CALENDAR_PRIVATE_DATA (calendar);
2443
2444   if (private_data->freeze_count)
2445     if (!(--private_data->freeze_count))
2446       {
2447         if (private_data->dirty_header)
2448           if (GTK_WIDGET_DRAWABLE (calendar))
2449             gtk_calendar_paint_header (GTK_WIDGET (calendar));
2450
2451         if (private_data->dirty_day_names)
2452           if (GTK_WIDGET_DRAWABLE (calendar))
2453             gtk_calendar_paint_day_names (GTK_WIDGET (calendar));
2454
2455         if (private_data->dirty_week)
2456           if (GTK_WIDGET_DRAWABLE (calendar))
2457             gtk_calendar_paint_week_numbers (GTK_WIDGET (calendar));
2458
2459         if (private_data->dirty_main)
2460           if (GTK_WIDGET_DRAWABLE (calendar))
2461             gtk_calendar_paint_main (GTK_WIDGET (calendar));
2462       }
2463 }
2464
2465 static void
2466 gtk_calendar_set_background (GtkWidget *widget)
2467 {
2468   GtkCalendar *calendar;
2469   GtkCalendarPrivateData *private_data;
2470   gint i;
2471
2472   calendar = GTK_CALENDAR (widget);
2473   private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
2474
2475   if (GTK_WIDGET_REALIZED (widget))
2476     {
2477       for (i = 0; i < 4; i++)
2478         {
2479           if (private_data->arrow_win[i])
2480             gdk_window_set_background (private_data->arrow_win[i],
2481                                        HEADER_BG_COLOR (widget));
2482         }
2483       if (private_data->header_win)
2484         gdk_window_set_background (private_data->header_win,
2485                                    HEADER_BG_COLOR (widget));
2486       if (private_data->day_name_win)
2487         gdk_window_set_background (private_data->day_name_win,
2488                                    BACKGROUND_COLOR (widget));
2489       if (private_data->week_win)
2490         gdk_window_set_background (private_data->week_win,
2491                                    BACKGROUND_COLOR (widget));
2492       if (private_data->main_win)
2493         gdk_window_set_background (private_data->main_win,
2494                                    BACKGROUND_COLOR (widget));
2495       if (widget->window)
2496         gdk_window_set_background (widget->window,
2497                                    BACKGROUND_COLOR (widget));
2498     }
2499 }
2500
2501 static void
2502 gtk_calendar_style_set (GtkWidget *widget,
2503                         GtkStyle  *previous_style)
2504 {
2505   if (previous_style && GTK_WIDGET_REALIZED (widget))
2506     gtk_calendar_set_background(widget);
2507 }
2508
2509 static void
2510 gtk_calendar_state_changed (GtkWidget      *widget,
2511                             GtkStateType    previous_state)
2512 {
2513   gtk_calendar_set_background (widget);
2514 }
2515
2516 static void
2517 gtk_calendar_finalize (GObject *object)
2518 {
2519   GtkCalendarPrivateData *private_data;
2520   private_data = GTK_CALENDAR_PRIVATE_DATA (object);
2521
2522   g_free (private_data);
2523
2524   if (G_OBJECT_CLASS (parent_class)->finalize)
2525     (* G_OBJECT_CLASS (parent_class)->finalize) (object);
2526 }
2527
2528 static gboolean
2529 gtk_calendar_key_press (GtkWidget   *widget,
2530                         GdkEventKey *event)
2531 {
2532   GtkCalendar *calendar;
2533   gint return_val;
2534   gint old_focus_row;
2535   gint old_focus_col;
2536   gint row, col, day;
2537
2538   calendar = GTK_CALENDAR (widget);
2539   return_val = FALSE;
2540
2541   old_focus_row = calendar->focus_row;
2542   old_focus_col = calendar->focus_col;
2543
2544   switch (event->keyval)
2545     {
2546     case GDK_KP_Left:
2547     case GDK_Left:
2548       return_val = TRUE;
2549       if (event->state & GDK_CONTROL_MASK)
2550         {
2551           gtk_calendar_set_month_prev (calendar);
2552         }
2553       else
2554         {
2555           if (calendar->focus_col > 0)
2556             {
2557               calendar->focus_col--;
2558             }
2559           else if (calendar->focus_row > 0)
2560             {
2561               calendar->focus_col = 6;
2562               calendar->focus_row--;
2563             }
2564           gtk_calendar_paint_day (widget, old_focus_row, old_focus_col);
2565           gtk_calendar_paint_day (widget, calendar->focus_row,
2566                                   calendar->focus_col);
2567         }
2568       break;
2569     case GDK_KP_Right:
2570     case GDK_Right:
2571       return_val = TRUE;
2572       if (event->state & GDK_CONTROL_MASK)
2573         {
2574         gtk_calendar_set_month_next (calendar);
2575         }
2576       else
2577         {
2578           if (calendar->focus_col < 6)
2579             {
2580               calendar->focus_col++;
2581             }
2582           else if (calendar->focus_row < 5)
2583             {
2584               calendar->focus_col = 0;
2585               calendar->focus_row++;
2586             }
2587           gtk_calendar_paint_day (widget, old_focus_row, old_focus_col);
2588           gtk_calendar_paint_day (widget, calendar->focus_row,
2589                                   calendar->focus_col);
2590         }
2591       break;
2592     case GDK_KP_Up:
2593     case GDK_Up:
2594       return_val = TRUE;
2595       if (event->state & GDK_CONTROL_MASK)
2596         {
2597           gtk_calendar_set_year_prev (calendar);
2598         }
2599       else
2600         {
2601           if (calendar->focus_row > 0)
2602             {
2603               calendar->focus_row--;
2604             }
2605           gtk_calendar_paint_day (widget, old_focus_row, old_focus_col);
2606           gtk_calendar_paint_day (widget, calendar->focus_row,
2607                                   calendar->focus_col);
2608         }
2609       break;
2610     case GDK_KP_Down:
2611     case GDK_Down:
2612       return_val = TRUE;
2613       if (event->state & GDK_CONTROL_MASK)
2614         {
2615           gtk_calendar_set_year_next (calendar);
2616         }
2617       else
2618         {
2619           if (calendar->focus_row < 5)
2620             {
2621               calendar->focus_row++;
2622             }
2623           gtk_calendar_paint_day (widget, old_focus_row, old_focus_col);
2624           gtk_calendar_paint_day (widget, calendar->focus_row,
2625                                   calendar->focus_col);
2626         }
2627       break;
2628     case GDK_KP_Space:
2629     case GDK_space:
2630       row = calendar->focus_row;
2631       col = calendar->focus_col;
2632       day = calendar->day[row][col];
2633
2634       if (row > -1 && col > -1)
2635         {
2636           return_val = TRUE;
2637           gtk_calendar_freeze (calendar);
2638
2639           if (calendar->day_month[row][col] == MONTH_PREV)
2640             {
2641               gtk_calendar_set_month_prev (calendar);
2642             }
2643           else if (calendar->day_month[row][col] == MONTH_NEXT)
2644             {
2645               gtk_calendar_set_month_next (calendar);
2646             }
2647
2648           gtk_calendar_select_day (calendar, day);
2649
2650           for (row = 0; row < 6; row ++)
2651             for (col = 0; col < 7; col++)
2652               {
2653                 if (calendar->day_month[row][col] == MONTH_CURRENT
2654                     && calendar->day[row][col] == day)
2655                   {
2656                     calendar->focus_row = row;
2657                     calendar->focus_col = col;
2658                   }
2659               }
2660           gtk_calendar_thaw (calendar);
2661         }
2662     }
2663
2664   return return_val;
2665 }