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