/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * GTK Calendar Widget

 * Copyright (C) 1998 Cesar Miquel, Shawn T. Amundson and Mattias Groenlund

 * 

 * lib_date routines

 * Copyright (c) 1995, 1996, 1997, 1998 by Steffen Beyer

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free

 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE__NL_TIME_FIRST_WEEKDAY

#include <langinfo.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <time.h>

#include <glib.h>

#ifdef G_OS_WIN32

#include <windows.h>

#endif

#include "gtkcalendar.h"

#include "gtkdnd.h"

#include "gtkintl.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtktooltip.h"

#include "gtkprivate.h"

#include "gdk/gdkkeysyms.h"

#include "gtkalias.h"

/***************************************************************************/

/* The following date routines are taken from the lib_date package. 

 * They have been minimally edited to avoid conflict with types defined

 * in win32 headers.

 */

static const guint month_length[2][13] =

{

  { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },

  { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

};

static const guint days_in_months[2][14] =

{

  { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },

  { 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }

};

static glong  calc_days(guint year, guint mm, guint dd);

static guint  day_of_week(guint year, guint mm, guint dd);

static glong  dates_difference(guint year1, guint mm1, guint dd1,

			       guint year2, guint mm2, guint dd2);

static guint  weeks_in_year(guint year);

static gboolean 

leap (guint year)

{

  return((((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0));

}

static guint 

day_of_week (guint year, guint mm, guint dd)

{

  glong  days;

  days = calc_days(year, mm, dd);

  if (days > 0L)

    {

      days--;

      days %= 7L;

      days++;

    }

  return( (guint) days );

}

static guint weeks_in_year(guint year)

{

  return(52 + ((day_of_week(year,1,1)==4) || (day_of_week(year,12,31)==4)));

}

static gboolean 

check_date(guint year, guint mm, guint dd)

{

  if (year < 1) return FALSE;

  if ((mm < 1) || (mm > 12)) return FALSE;

  if ((dd < 1) || (dd > month_length[leap(year)][mm])) return FALSE;

  return TRUE;

}

static guint 

week_number(guint year, guint mm, guint dd)

{

  guint first;

  first = day_of_week(year,1,1) - 1;

  return( (guint) ( (dates_difference(year,1,1, year,mm,dd) + first) / 7L ) +

	  (first < 4) );

}

static glong 

year_to_days(guint year)

{

  return( year * 365L + (year / 4) - (year / 100) + (year / 400) );

}

static glong 

calc_days(guint year, guint mm, guint dd)

{

  gboolean lp;

  if (year < 1) return(0L);

  if ((mm < 1) || (mm > 12)) return(0L);

  if ((dd < 1) || (dd > month_length[(lp = leap(year))][mm])) return(0L);

  return( year_to_days(--year) + days_in_months[lp][mm] + dd );

}

static gboolean 

week_of_year(guint *week, guint *year, guint mm, guint dd)

{

  if (check_date(*year,mm,dd))

    {

      *week = week_number(*year,mm,dd);

      if (*week == 0) 

	*week = weeks_in_year(--(*year));

      else if (*week > weeks_in_year(*year))

	{

	  *week = 1;

	  (*year)++;

	}

      return TRUE;

    }

  return FALSE;

}

static glong 

dates_difference(guint year1, guint mm1, guint dd1,

		 guint year2, guint mm2, guint dd2)

{

  return( calc_days(year2, mm2, dd2) - calc_days(year1, mm1, dd1) );

}

/*** END OF lib_date routines ********************************************/

/* Spacing around day/week headers and main area, inside those windows */

#define CALENDAR_MARGIN		 0

#define DAY_XSEP		 0 /* not really good for small calendar */

#define DAY_YSEP		 0 /* not really good for small calendar */

#define SCROLL_DELAY_FACTOR      5

/* Color usage */

#define HEADER_FG_COLOR(widget)		 (& (widget)->style->fg[gtk_widget_get_state (widget)])

#define HEADER_BG_COLOR(widget)		 (& (widget)->style->bg[gtk_widget_get_state (widget)])

#define SELECTED_BG_COLOR(widget)	 (& (widget)->style->base[gtk_widget_has_focus (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE])

#define SELECTED_FG_COLOR(widget)	 (& (widget)->style->text[gtk_widget_has_focus (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE])

#define NORMAL_DAY_COLOR(widget)	 (& (widget)->style->text[gtk_widget_get_state (widget)])

#define PREV_MONTH_COLOR(widget)	 (& (widget)->style->mid[gtk_widget_get_state (widget)])

#define NEXT_MONTH_COLOR(widget)	 (& (widget)->style->mid[gtk_widget_get_state (widget)])

#define MARKED_COLOR(widget)		 (& (widget)->style->text[gtk_widget_get_state (widget)])

#define BACKGROUND_COLOR(widget)	 (& (widget)->style->base[gtk_widget_get_state (widget)])

#define HIGHLIGHT_BACK_COLOR(widget)	 (& (widget)->style->mid[gtk_widget_get_state (widget)])

enum {

  ARROW_YEAR_LEFT,

  ARROW_YEAR_RIGHT,

  ARROW_MONTH_LEFT,

  ARROW_MONTH_RIGHT

};

enum {

  MONTH_PREV,

  MONTH_CURRENT,

  MONTH_NEXT

};

enum {

  MONTH_CHANGED_SIGNAL,

  DAY_SELECTED_SIGNAL,

  DAY_SELECTED_DOUBLE_CLICK_SIGNAL,

  PREV_MONTH_SIGNAL,

  NEXT_MONTH_SIGNAL,

  PREV_YEAR_SIGNAL,

  NEXT_YEAR_SIGNAL,

  LAST_SIGNAL

};

enum

{

  PROP_0,

  PROP_YEAR,

  PROP_MONTH,

  PROP_DAY,

  PROP_SHOW_HEADING,

  PROP_SHOW_DAY_NAMES,

  PROP_NO_MONTH_CHANGE,

  PROP_SHOW_WEEK_NUMBERS,

  PROP_SHOW_DETAILS,

  PROP_DETAIL_WIDTH_CHARS,

  PROP_DETAIL_HEIGHT_ROWS

};

static guint gtk_calendar_signals[LAST_SIGNAL] = { 0 };

struct _GtkCalendarPrivate

{

  GdkWindow *header_win;

  GdkWindow *day_name_win;

  GdkWindow *main_win;

  GdkWindow *week_win;

  GdkWindow *arrow_win[4];

  guint header_h;

  guint day_name_h;

  guint main_h;

  guint	     arrow_state[4];

  guint	     arrow_width;

  guint	     max_month_width;

  guint	     max_year_width;

  guint day_width;

  guint week_width;

  guint min_day_width;

  guint max_day_char_width;

  guint max_day_char_ascent;

  guint max_day_char_descent;

  guint max_label_char_ascent;

  guint max_label_char_descent;

  guint max_week_char_width;

  /* flags */

  guint year_before : 1;

  guint need_timer  : 1;

  guint in_drag : 1;

  guint drag_highlight : 1;

  guint32 timer;

  gint click_child;

  gint week_start;

  gint drag_start_x;

  gint drag_start_y;

  /* Optional callback, used to display extra information for each day. */

  GtkCalendarDetailFunc detail_func;

  gpointer              detail_func_user_data;

  GDestroyNotify        detail_func_destroy;

  /* Size requistion for details provided by the hook. */

  gint detail_height_rows;

  gint detail_width_chars;

  gint detail_overflow[6];

};

#define GTK_CALENDAR_GET_PRIVATE(widget)  (GTK_CALENDAR (widget)->priv)

static void gtk_calendar_finalize     (GObject      *calendar);

static void gtk_calendar_destroy      (GtkObject    *calendar);

static void gtk_calendar_set_property (GObject      *object,

				       guint         prop_id,

				       const GValue *value,

				       GParamSpec   *pspec);

static void gtk_calendar_get_property (GObject      *object,

				       guint         prop_id,

				       GValue       *value,

				       GParamSpec   *pspec);

static void     gtk_calendar_realize        (GtkWidget        *widget);

static void     gtk_calendar_unrealize      (GtkWidget        *widget);

static void     gtk_calendar_size_request   (GtkWidget        *widget,

					     GtkRequisition   *requisition);

static void     gtk_calendar_size_allocate  (GtkWidget        *widget,

					     GtkAllocation    *allocation);

static gboolean gtk_calendar_expose         (GtkWidget        *widget,

					     GdkEventExpose   *event);

static gboolean gtk_calendar_button_press   (GtkWidget        *widget,

					     GdkEventButton   *event);

static gboolean gtk_calendar_button_release (GtkWidget        *widget,

					     GdkEventButton   *event);

static gboolean gtk_calendar_motion_notify  (GtkWidget        *widget,

					     GdkEventMotion   *event);

static gboolean gtk_calendar_enter_notify   (GtkWidget        *widget,

					     GdkEventCrossing *event);

static gboolean gtk_calendar_leave_notify   (GtkWidget        *widget,

					     GdkEventCrossing *event);

static gboolean gtk_calendar_scroll         (GtkWidget        *widget,

					     GdkEventScroll   *event);

static gboolean gtk_calendar_key_press      (GtkWidget        *widget,

					     GdkEventKey      *event);

static gboolean gtk_calendar_focus_out      (GtkWidget        *widget,

					     GdkEventFocus    *event);

static void     gtk_calendar_grab_notify    (GtkWidget        *widget,

					     gboolean          was_grabbed);

static void     gtk_calendar_state_changed  (GtkWidget        *widget,

					     GtkStateType      previous_state);

static void     gtk_calendar_style_set      (GtkWidget        *widget,

					     GtkStyle         *previous_style);

static gboolean gtk_calendar_query_tooltip  (GtkWidget        *widget,

					     gint              x,

					     gint              y,

					     gboolean          keyboard_mode,

					     GtkTooltip       *tooltip);

static void     gtk_calendar_drag_data_get      (GtkWidget        *widget,

						 GdkDragContext   *context,

						 GtkSelectionData *selection_data,

						 guint             info,

						 guint             time);

static void     gtk_calendar_drag_data_received (GtkWidget        *widget,

						 GdkDragContext   *context,

						 gint              x,

						 gint              y,

						 GtkSelectionData *selection_data,

						 guint             info,

						 guint             time);

static gboolean gtk_calendar_drag_motion        (GtkWidget        *widget,

						 GdkDragContext   *context,

						 gint              x,

						 gint              y,

						 guint             time);

static void     gtk_calendar_drag_leave         (GtkWidget        *widget,

						 GdkDragContext   *context,

						 guint             time);

static gboolean gtk_calendar_drag_drop          (GtkWidget        *widget,

						 GdkDragContext   *context,

						 gint              x,

						 gint              y,

						 guint             time);

static void calendar_start_spinning (GtkCalendar *calendar,

				     gint         click_child);

static void calendar_stop_spinning  (GtkCalendar *calendar);

static void calendar_invalidate_day     (GtkCalendar *widget,

					 gint       row,

					 gint       col);

static void calendar_invalidate_day_num (GtkCalendar *widget,

					 gint       day);

static void calendar_invalidate_arrow   (GtkCalendar *widget,

					 guint      arrow);

static void calendar_compute_days      (GtkCalendar *calendar);

static gint calendar_get_xsep          (GtkCalendar *calendar);

static gint calendar_get_ysep          (GtkCalendar *calendar);

static char    *default_abbreviated_dayname[7];

static char    *default_monthname[12];

G_DEFINE_TYPE (GtkCalendar, gtk_calendar, GTK_TYPE_WIDGET)

static void

gtk_calendar_class_init (GtkCalendarClass *class)

{

  GObjectClass   *gobject_class;

  GtkObjectClass   *object_class;

  GtkWidgetClass *widget_class;

  gobject_class = (GObjectClass*)  class;

  object_class = (GtkObjectClass*)  class;

  widget_class = (GtkWidgetClass*) class;

  gobject_class->set_property = gtk_calendar_set_property;

  gobject_class->get_property = gtk_calendar_get_property;

  gobject_class->finalize = gtk_calendar_finalize;

  object_class->destroy = gtk_calendar_destroy;

  widget_class->realize = gtk_calendar_realize;

  widget_class->unrealize = gtk_calendar_unrealize;

  widget_class->expose_event = gtk_calendar_expose;

  widget_class->size_request = gtk_calendar_size_request;

  widget_class->size_allocate = gtk_calendar_size_allocate;

  widget_class->button_press_event = gtk_calendar_button_press;

  widget_class->button_release_event = gtk_calendar_button_release;

  widget_class->motion_notify_event = gtk_calendar_motion_notify;

  widget_class->enter_notify_event = gtk_calendar_enter_notify;

  widget_class->leave_notify_event = gtk_calendar_leave_notify;

  widget_class->key_press_event = gtk_calendar_key_press;

  widget_class->scroll_event = gtk_calendar_scroll;

  widget_class->style_set = gtk_calendar_style_set;

  widget_class->state_changed = gtk_calendar_state_changed;

  widget_class->grab_notify = gtk_calendar_grab_notify;

  widget_class->focus_out_event = gtk_calendar_focus_out;

  widget_class->query_tooltip = gtk_calendar_query_tooltip;

  widget_class->drag_data_get = gtk_calendar_drag_data_get;

  widget_class->drag_motion = gtk_calendar_drag_motion;

  widget_class->drag_leave = gtk_calendar_drag_leave;

  widget_class->drag_drop = gtk_calendar_drag_drop;

  widget_class->drag_data_received = gtk_calendar_drag_data_received;

  /**

   * GtkCalendar:year:

   *

   * The selected year. 

   * This property gets initially set to the current year.

   */  

  g_object_class_install_property (gobject_class,

                                   PROP_YEAR,

                                   g_param_spec_int ("year",

						     P_("Year"),

						     P_("The selected year"),

						     0, G_MAXINT >> 9, 0,

						     GTK_PARAM_READWRITE));

  /**

   * GtkCalendar:month:

   *

   * The selected month (as a number between 0 and 11). 

   * This property gets initially set to the current month.

   */

  g_object_class_install_property (gobject_class,

                                   PROP_MONTH,

                                   g_param_spec_int ("month",

						     P_("Month"),

						     P_("The selected month (as a number between 0 and 11)"),

						     0, 11, 0,

						     GTK_PARAM_READWRITE));

  /**

   * GtkCalendar:day:

   *

   * The selected day (as a number between 1 and 31, or 0 

   * to unselect the currently selected day).

   * This property gets initially set to the current day.

   */

  g_object_class_install_property (gobject_class,

                                   PROP_DAY,

                                   g_param_spec_int ("day",

						     P_("Day"),

						     P_("The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day)"),

						     0, 31, 0,

						     GTK_PARAM_READWRITE));

/**

 * GtkCalendar:show-heading:

 *

 * Determines whether a heading is displayed.

 *

 * Since: 2.4

 */

  g_object_class_install_property (gobject_class,

                                   PROP_SHOW_HEADING,

                                   g_param_spec_boolean ("show-heading",

							 P_("Show Heading"),

							 P_("If TRUE, a heading is displayed"),

							 TRUE,

							 GTK_PARAM_READWRITE));

/**

 * GtkCalendar:show-day-names:

 *

 * Determines whether day names are displayed.

 *

 * Since: 2.4

 */

  g_object_class_install_property (gobject_class,

                                   PROP_SHOW_DAY_NAMES,

                                   g_param_spec_boolean ("show-day-names",

							 P_("Show Day Names"),

							 P_("If TRUE, day names are displayed"),

							 TRUE,

							 GTK_PARAM_READWRITE));

/**

 * GtkCalendar:no-month-change:

 *

 * Determines whether the selected month can be changed.

 *

 * Since: 2.4

 */

  g_object_class_install_property (gobject_class,

                                   PROP_NO_MONTH_CHANGE,

                                   g_param_spec_boolean ("no-month-change",

							 P_("No Month Change"),

							 P_("If TRUE, the selected month cannot be changed"),

							 FALSE,

							 GTK_PARAM_READWRITE));

/**

 * GtkCalendar:show-week-numbers:

 *

 * Determines whether week numbers are displayed.

 *

 * Since: 2.4

 */

  g_object_class_install_property (gobject_class,

                                   PROP_SHOW_WEEK_NUMBERS,

                                   g_param_spec_boolean ("show-week-numbers",

							 P_("Show Week Numbers"),

							 P_("If TRUE, week numbers are displayed"),

							 FALSE,

							 GTK_PARAM_READWRITE));

/**

 * GtkCalendar:detail-width-chars:

 *

 * Width of a detail cell, in characters.

 * A value of 0 allows any width. See gtk_calendar_set_detail_func().

 *

 * Since: 2.14

 */

  g_object_class_install_property (gobject_class,

                                   PROP_DETAIL_WIDTH_CHARS,

                                   g_param_spec_int ("detail-width-chars",

						     P_("Details Width"),

						     P_("Details width in characters"),

						     0, 127, 0,

						     GTK_PARAM_READWRITE));

/**

 * GtkCalendar:detail-height-rows:

 *

 * Height of a detail cell, in rows.

 * A value of 0 allows any width. See gtk_calendar_set_detail_func().

 *

 * Since: 2.14

 */

  g_object_class_install_property (gobject_class,

                                   PROP_DETAIL_HEIGHT_ROWS,

                                   g_param_spec_int ("detail-height-rows",

						     P_("Details Height"),

						     P_("Details height in rows"),

						     0, 127, 0,

						     GTK_PARAM_READWRITE));

/**

 * GtkCalendar:show-details:

 *

 * Determines whether details are shown directly in the widget, or if they are

 * available only as tooltip. When this property is set days with details are

 * marked.

 *

 * Since: 2.14

 */

  g_object_class_install_property (gobject_class,

                                   PROP_SHOW_DETAILS,

                                   g_param_spec_boolean ("show-details",

							 P_("Show Details"),

							 P_("If TRUE, details are shown"),

							 TRUE,

							 GTK_PARAM_READWRITE));

  /**

   * GtkCalendar:inner-border

   *

   * The spacing around the day/week headers and main area.

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_int ("inner-border",

                                                             P_("Inner border"),

                                                             P_("Inner border space"),

                                                             0, G_MAXINT, 4,

                                                             GTK_PARAM_READABLE));

  /**

   * GtkCalndar:vertical-separation

   *

   * Separation between day headers and main area.

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_int ("vertical-separation",

                                                             P_("Vertical separation"),

                                                             P_("Space between day headers and main area"),

                                                             0, G_MAXINT, 4,

                                                             GTK_PARAM_READABLE));

  /**

   * GtkCalendar:horizontal-separation

   *

   * Separation between week headers and main area.

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_int ("horizontal-separation",

                                                             P_("Horizontal separation"),

                                                             P_("Space between week headers and main area"),

                                                             0, G_MAXINT, 4,

                                                             GTK_PARAM_READABLE));

  /**

   * GtkCalendar::month-changed:

   * @calendar: the object which received the signal.

   *

   * Emitted when the user clicks a button to change the selected month on a

   * calendar.

   */

  gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =

    g_signal_new (I_("month-changed"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, month_changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  gtk_calendar_signals[DAY_SELECTED_SIGNAL] =

    g_signal_new (I_("day-selected"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, day_selected),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =

    g_signal_new (I_("day-selected-double-click"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, day_selected_double_click),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  gtk_calendar_signals[PREV_MONTH_SIGNAL] =

    g_signal_new (I_("prev-month"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, prev_month),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  gtk_calendar_signals[NEXT_MONTH_SIGNAL] =

    g_signal_new (I_("next-month"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, next_month),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  gtk_calendar_signals[PREV_YEAR_SIGNAL] =

    g_signal_new (I_("prev-year"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, prev_year),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  gtk_calendar_signals[NEXT_YEAR_SIGNAL] =

    g_signal_new (I_("next-year"),

		  G_OBJECT_CLASS_TYPE (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkCalendarClass, next_year),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  g_type_class_add_private (gobject_class, sizeof (GtkCalendarPrivate));

}

static void

gtk_calendar_init (GtkCalendar *calendar)

{

  GtkWidget *widget = GTK_WIDGET (calendar);

  time_t secs;

  struct tm *tm;

  gint i;

#ifdef G_OS_WIN32

  wchar_t wbuffer[100];

#else

  char buffer[255];

  time_t tmp_time;

#endif

  GtkCalendarPrivate *priv;

  gchar *year_before;

#ifdef HAVE__NL_TIME_FIRST_WEEKDAY

  union { unsigned int word; char *string; } langinfo;

  gint week_1stday = 0;

  gint first_weekday = 1;

  guint week_origin;

#else

  gchar *week_start;

#endif

  priv = calendar->priv = G_TYPE_INSTANCE_GET_PRIVATE (calendar,

						       GTK_TYPE_CALENDAR,

						       GtkCalendarPrivate);

  gtk_widget_set_can_focus (widget, TRUE);

  if (!default_abbreviated_dayname[0])

    for (i=0; i<7; i++)

      {

#ifndef G_OS_WIN32

	tmp_time= (i+3)*86400;

	strftime ( buffer, sizeof (buffer), "%a", gmtime (&tmp_time));

	default_abbreviated_dayname[i] = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);

#else

	if (!GetLocaleInfoW (GetThreadLocale (), LOCALE_SABBREVDAYNAME1 + (i+6)%7,

			     wbuffer, G_N_ELEMENTS (wbuffer)))

	  default_abbreviated_dayname[i] = g_strdup_printf ("(%d)", i);

	else

	  default_abbreviated_dayname[i] = g_utf16_to_utf8 (wbuffer, -1, NULL, NULL, NULL);

#endif

      }

  if (!default_monthname[0])

    for (i=0; i<12; i++)

      {

#ifndef G_OS_WIN32

	tmp_time=i*2764800;

	strftime ( buffer, sizeof (buffer), "%B", gmtime (&tmp_time));

	default_monthname[i] = g_locale_to_utf8 (buffer, -1, NULL, NULL, NULL);

#else

	if (!GetLocaleInfoW (GetThreadLocale (), LOCALE_SMONTHNAME1 + i,

			     wbuffer, G_N_ELEMENTS (wbuffer)))

	  default_monthname[i] = g_strdup_printf ("(%d)", i);

	else

	  default_monthname[i] = g_utf16_to_utf8 (wbuffer, -1, NULL, NULL, NULL);

#endif

      }

  /* Set defaults */

  secs = time (NULL);

  tm = localtime (&secs;;

  calendar->month = tm->tm_mon;

  calendar->year  = 1900 + tm->tm_year;

  for (i=0;i<31;i++)

    calendar->marked_date[i] = FALSE;

  calendar->num_marked_dates = 0;

  calendar->selected_day = tm->tm_mday;

  calendar->display_flags = (GTK_CALENDAR_SHOW_HEADING |

			     GTK_CALENDAR_SHOW_DAY_NAMES |

			     GTK_CALENDAR_SHOW_DETAILS);

  calendar->highlight_row = -1;

  calendar->highlight_col = -1;

  calendar->focus_row = -1;

  calendar->focus_col = -1;

  priv->max_year_width = 0;

  priv->max_month_width = 0;

  priv->max_day_char_width = 0;

  priv->max_week_char_width = 0;

  priv->max_day_char_ascent = 0;

  priv->max_day_char_descent = 0;

  priv->max_label_char_ascent = 0;

  priv->max_label_char_descent = 0;

  priv->arrow_width = 10;

  priv->need_timer = 0;

  priv->timer = 0;

  priv->click_child = -1;

  priv->in_drag = 0;

  priv->drag_highlight = 0;

  gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_COPY);

  gtk_drag_dest_add_text_targets (widget);

  priv->year_before = 0;

  /* Translate to calendar:YM if you want years to be displayed

   * before months; otherwise translate to calendar:MY.

   * Do *not* translate it to anything else, if it

   * it isn't calendar:YM or calendar:MY it will not work.

   *

   * Note that the ordering described here is logical order, which is

   * further influenced by BIDI ordering. Thus, if you have a default

   * text direction of RTL and specify "calendar:YM", then the year

   * will appear to the right of the month.

   */

  year_before = _("calendar:MY");

  if (strcmp (year_before, "calendar:YM") == 0)

    priv->year_before = 1;

  else if (strcmp (year_before, "calendar:MY") != 0)

    g_warning ("Whoever translated calendar:MY did so wrongly.\n");

#ifdef G_OS_WIN32

  priv->week_start = 0;

  week_start = NULL;

  if (GetLocaleInfoW (GetThreadLocale (), LOCALE_IFIRSTDAYOFWEEK,

		      wbuffer, G_N_ELEMENTS (wbuffer)))

    week_start = g_utf16_to_utf8 (wbuffer, -1, NULL, NULL, NULL);

  if (week_start != NULL)

    {

      priv->week_start = (week_start[0] - '0' + 1) % 7;

      g_free(week_start);

    }

#else

#ifdef HAVE__NL_TIME_FIRST_WEEKDAY

  langinfo.string = nl_langinfo (_NL_TIME_FIRST_WEEKDAY);

  first_weekday = langinfo.string[0];

  langinfo.string = nl_langinfo (_NL_TIME_WEEK_1STDAY);

  week_origin = langinfo.word;

  if (week_origin == 19971130) /* Sunday */

    week_1stday = 0;

  else if (week_origin == 19971201) /* Monday */

    week_1stday = 1;

  else

    g_warning ("Unknown value of _NL_TIME_WEEK_1STDAY.\n");

  priv->week_start = (week_1stday + first_weekday - 1) % 7;

#else

  /* Translate to calendar:week_start:0 if you want Sunday to be the

   * first day of the week to calendar:week_start:1 if you want Monday

   * to be the first day of the week, and so on.

   */  

  week_start = _("calendar:week_start:0");

  if (strncmp (week_start, "calendar:week_start:", 20) == 0)

    priv->week_start = *(week_start + 20) - '0';

  else 

    priv->week_start = -1;

  if (priv->week_start < 0 || priv->week_start > 6)

    {

      g_warning ("Whoever translated calendar:week_start:0 did so wrongly.\n");

      priv->week_start = 0;

    }

#endif

#endif

  calendar_compute_days (calendar);

}

/****************************************

 *          Utility Functions           *

 ****************************************/

static void

calendar_queue_refresh (GtkCalendar *calendar)

{

  GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);

  if (!(priv->detail_func) ||

      !(calendar->display_flags & GTK_CALENDAR_SHOW_DETAILS) ||

       (priv->detail_width_chars && priv->detail_height_rows))

    gtk_widget_queue_draw (GTK_WIDGET (calendar));

  else

    gtk_widget_queue_resize (GTK_WIDGET (calendar));

}

static void

calendar_set_month_next (GtkCalendar *calendar)

{

  gint month_len;

  if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)

    return;