gtkcalendar.c

gtk是linux一款强大的夸平台的图形化开发工具

			      allocation->x, allocation->y,
			      allocation->width, allocation->height);
      if (private_data->header_win)
	gdk_window_move_resize (private_data->header_win,
				2, 2,
				allocation->width-4, private_data->header_h);
      if (private_data->arrow_win[ARROW_MONTH_LEFT])
	gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_LEFT],
				3, 3,
				private_data->arrow_width,
				private_data->header_h - 7);
      if (private_data->arrow_win[ARROW_MONTH_RIGHT])
	gdk_window_move_resize (private_data->arrow_win[ARROW_MONTH_RIGHT],
				(private_data->arrow_width 
				 + private_data->max_month_width), 
				3,
				private_data->arrow_width,
				private_data->header_h - 7);
      if (private_data->arrow_win[ARROW_YEAR_LEFT])
	gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_LEFT],
				(allocation->width - 4
				 - (3 + 2*private_data->arrow_width 
				    + private_data->max_year_width)),
				3,
				private_data->arrow_width,
				private_data->header_h - 7);
      if (private_data->arrow_win[ARROW_YEAR_RIGHT])
	gdk_window_move_resize (private_data->arrow_win[ARROW_YEAR_RIGHT],
				(allocation->width - 4 
				 - 3 - private_data->arrow_width), 
				3,
				private_data->arrow_width,
				private_data->header_h - 7);
      if (private_data->day_name_win)
	gdk_window_move_resize (private_data->day_name_win,
				widget->style->klass->xthickness + INNER_BORDER,
				private_data->header_h + (widget->style->klass->ythickness + INNER_BORDER),
				allocation->width - (widget->style->klass->xthickness + INNER_BORDER) * 2,
				private_data->day_name_h);
      if (private_data->week_win)
	gdk_window_move_resize (private_data->week_win,
				(widget->style->klass->xthickness + INNER_BORDER),
				private_data->header_h + private_data->day_name_h
				+ (widget->style->klass->ythickness + INNER_BORDER),
				private_data->week_width,
				private_data->main_h);
      gdk_window_move_resize (private_data->main_win,
			      (private_data->week_width ? private_data->week_width + CALENDAR_XSEP :0) 
			      + (widget->style->klass->xthickness + INNER_BORDER),
			      private_data->header_h + private_data->day_name_h
			      + (widget->style->klass->ythickness + INNER_BORDER),
			      allocation->width 
			      - (private_data->week_width ? private_data->week_width + CALENDAR_XSEP :0) 
			      - (widget->style->klass->xthickness + INNER_BORDER) * 2,
			      private_data->main_h);
    }
}

static void
gtk_calendar_draw_focus (GtkWidget *widget)
{
  GtkCalendar *calendar;
  GtkCalendarPrivateData *private_data;
  gint width, height;
  gint x, y;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_CALENDAR (widget));

  calendar = GTK_CALENDAR (widget);
  private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
  
  if (GTK_WIDGET_DRAWABLE (widget))
    {
      x = 0;
      y = 0;
      gdk_window_get_size (widget->window, &width, &height);
      gdk_window_clear (widget->window);
      
      gdk_draw_rectangle (widget->window, 
			  widget->style->base_gc[GTK_WIDGET_STATE (widget)],
			  FALSE, x + 2, y + 2, width - 5, height - 5);
      
      gtk_draw_shadow (widget->style, widget->window,
		       GTK_STATE_NORMAL, GTK_SHADOW_IN,
		       x, y, width, height);
      
    }
}

static gint
gtk_calendar_expose (GtkWidget	    *widget,
		     GdkEventExpose *event)
{
  GtkCalendar *calendar;
  GtkCalendarPrivateData *private_data;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_CALENDAR (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);
  
  calendar = GTK_CALENDAR (widget);
  private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
  
  if (GTK_WIDGET_DRAWABLE (widget))
    {
      if (event->window == private_data->main_win)
	gtk_calendar_paint_main (widget);
      
      if (event->window == private_data->header_win)
	gtk_calendar_paint_header (widget);
      
      if (event->window == private_data->day_name_win)
	gtk_calendar_paint_day_names (widget);
      
      if (event->window == private_data->week_win)
	gtk_calendar_paint_week_numbers (widget);
      if (event->window == widget->window)
	gtk_widget_draw_focus (widget);
    }
  
  return FALSE;
}

static void
gtk_calendar_draw (GtkWidget	*widget,
		   GdkRectangle *area)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_CALENDAR (widget));
  g_return_if_fail (area != NULL);
  
  if (GTK_WIDGET_DRAWABLE (widget))
    gtk_calendar_paint (widget, area);
  
}

static void
gtk_calendar_paint (GtkWidget	 *widget,
		    GdkRectangle *area)
{
  GtkCalendar *calendar;
  GtkCalendarPrivateData *private_data;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (widget->window != NULL);
  g_return_if_fail (GTK_IS_CALENDAR (widget));
  
  calendar = GTK_CALENDAR (widget);
  private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
  
  if (private_data->main_win != NULL)
    gtk_calendar_paint_main (widget);
  
  if (private_data->header_win != NULL)
    gtk_calendar_paint_header (widget);
  
  if (private_data->day_name_win != NULL)
    gtk_calendar_paint_day_names (widget);
  
  if (private_data->week_win != NULL)
    gtk_calendar_paint_week_numbers (widget);
  
  gtk_widget_draw_focus (widget);
}

static void
gtk_calendar_paint_header (GtkWidget *widget)
{
  GtkCalendar *calendar;
  GdkGC *gc;
  char buffer[255];
  int y, y_arrow;
  gint header_width, cal_height;
  gint str_width;
  gint max_month_width;
  gint max_year_width;
  GtkCalendarPrivateData *private_data;

  calendar = GTK_CALENDAR (widget);
  private_data = GTK_CALENDAR_PRIVATE_DATA (widget);

  if (private_data->freeze_count)
    {
      private_data->dirty_header = 1;
      return;
    }
  private_data->dirty_header = 0;
  gc = calendar->gc;
  
  /* Clear window */
  gdk_window_clear (private_data->header_win);
  
  header_width = widget->allocation.width - 4;
  cal_height = widget->allocation.height;
  
  max_month_width = private_data->max_month_width;
  max_year_width = private_data->max_year_width;
  
  gdk_gc_set_foreground (gc, BACKGROUND_COLOR (GTK_WIDGET (calendar)));
  gtk_draw_shadow (widget->style, private_data->header_win,
		   GTK_STATE_NORMAL, GTK_SHADOW_OUT,
		   0, 0, header_width, private_data->header_h);
  
  
  /* Draw title */
  y = private_data->header_h - (private_data->header_h 
				- HEADER_FONT (widget)->ascent
				+ HEADER_FONT (widget)->descent) / 2;
  y_arrow = (private_data->header_h - 9) / 2;
  
  /* Draw year and its arrows */
  sprintf (buffer, "%d", calendar->year);
  str_width = gdk_string_measure (HEADER_FONT (widget), buffer);
  gdk_gc_set_foreground (gc, HEADER_FG_COLOR (GTK_WIDGET (calendar)));
  if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
    gdk_draw_string (private_data->header_win, HEADER_FONT (widget), gc,
		     header_width - (3 + max_year_width
				     - (max_year_width - str_width)/2),
		     y, buffer);
  else
    gdk_draw_string (private_data->header_win, HEADER_FONT (widget), gc,
		     header_width - (3 + private_data->arrow_width + max_year_width
				     - (max_year_width - str_width)/2),
		     y, buffer);
  
  /* Draw month */
  sprintf (buffer, "%s", default_monthname[calendar->month]);
  str_width = gdk_string_measure (HEADER_FONT (widget), buffer);
  if (calendar->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
    gdk_draw_string (private_data->header_win, HEADER_FONT (widget), gc,
		     3 + (max_month_width - str_width) / 2,
		     y, buffer);
  else
    gdk_draw_string (private_data->header_win, HEADER_FONT (widget), gc,
		     3 + private_data->arrow_width + (max_month_width - str_width)/2,
		     y, buffer);
  
  y += CALENDAR_YSEP + HEADER_FONT (widget)->descent;
  
  gdk_gc_set_foreground (gc, BACKGROUND_COLOR (GTK_WIDGET (calendar)));
  
  gtk_calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
  gtk_calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
  gtk_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
  gtk_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
  
}

static void
gtk_calendar_paint_day_names (GtkWidget *widget)
{
  GtkCalendar *calendar;
  GdkGC *gc;
  char buffer[255];
  int day,i;
  int day_width, cal_width;
  gint cal_height;
  int day_wid_sep;
  int str_width;
  GtkCalendarPrivateData *private_data;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_CALENDAR (widget));
  calendar = GTK_CALENDAR (widget);
  private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
  gc = calendar->gc;
  
  /*
   * Handle freeze/thaw functionality
   */
  
  if (private_data->freeze_count)
    {
      private_data->dirty_day_names = 1;
      return;
    }
  private_data->dirty_day_names = 0;
  
  /*
   * Clear the window
   */
  
  gdk_window_clear (private_data->day_name_win);
  
  day_width = private_data->day_width;
  cal_width = widget->allocation.width;
  cal_height = widget->allocation.height;
  day_wid_sep = day_width + DAY_XSEP;
  
  /*
   * Draw rectangles as inverted background for the labels.
   */
  
  gdk_gc_set_foreground (gc, &widget->style->bg[GTK_STATE_SELECTED]);
  gdk_draw_rectangle (private_data->day_name_win, gc, TRUE,
		      CALENDAR_MARGIN, CALENDAR_MARGIN,
		      cal_width-CALENDAR_MARGIN * 2,
		      private_data->day_name_h - CALENDAR_MARGIN);
  
  if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
    gdk_draw_rectangle (private_data->day_name_win, gc, TRUE,
			CALENDAR_MARGIN,
			private_data->day_name_h - CALENDAR_YSEP,
			private_data->week_width - CALENDAR_YSEP - CALENDAR_MARGIN,
			CALENDAR_YSEP);
  
  /*
   * Write the labels
   */
  gdk_gc_set_foreground (gc, &widget->style->fg[GTK_STATE_SELECTED]);
  for (i = 0; i < 7; i++)
    {
      day=i;
      if (calendar->display_flags & GTK_CALENDAR_WEEK_START_MONDAY)
	day= (day+1)%7;
      sprintf (buffer, "%s", default_abbreviated_dayname[day]);
      str_width = gdk_string_measure (LABEL_FONT (widget), buffer);
      gdk_draw_string (private_data->day_name_win, LABEL_FONT (widget),
		       gc,
		       ((private_data->week_width ? CALENDAR_XSEP : CALENDAR_MARGIN)
			+ day_wid_sep * i
			+ private_data->week_width
			+ (day_width - str_width)/2),
		       CALENDAR_MARGIN + DAY_YPAD
		       + private_data->max_label_char_ascent, buffer);
    }
}

static void
gtk_calendar_paint_week_numbers (GtkWidget *widget)
{
  GtkCalendar *calendar;
  GdkGC *gc;
  gint row, week = 0, year;
  gint x_loc;
  char buffer[3];
  gint y_baseline, day_height;
  GtkCalendarPrivateData *private_data;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (widget->window != NULL);
  g_return_if_fail (GTK_IS_CALENDAR (widget));
  calendar = GTK_CALENDAR (widget);
  private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
  gc = calendar->gc;
  
  /*
   * Handle freeze/thaw functionality
   */
  
  if (private_data->freeze_count)
    {
      private_data->dirty_week = 1;
      return;
    }
  private_data->dirty_week = 0;
  
  /*
   * Clear the window
   */
  
  gdk_window_clear (private_data->week_win);
  
  /*
   * Draw a rectangle as inverted background for the labels.
   */
  
  gdk_gc_set_foreground (gc, &widget->style->bg[GTK_STATE_SELECTED]);
  if (private_data->day_name_win)
    gdk_draw_rectangle (private_data->week_win, gc, TRUE,
			CALENDAR_MARGIN,
			0,
			private_data->week_width - CALENDAR_MARGIN - CALENDAR_XSEP,
			private_data->main_h - CALENDAR_MARGIN);
  else
    gdk_draw_rectangle (private_data->week_win, gc, TRUE,
			CALENDAR_MARGIN,
			CALENDAR_MARGIN,
			private_data->week_width - CALENDAR_MARGIN - CALENDAR_XSEP,
			private_data->main_h - 2 * CALENDAR_MARGIN);
  
  /*
   * Write the labels
   */
  
  gdk_gc_set_foreground (gc, &widget->style->fg[GTK_STATE_SELECTED]);
  day_height = row_height (calendar);
  for (row = 0; row < 6; row++)
    {
      year = calendar->year;
      if (calendar->day[row][6] < 15 && row > 3 && calendar->month == 11)
	year++;
      y_baseline = (top_y_for_row (calendar, row)
		    + (day_height + LABEL_FONT (widget)->ascent
		       - LABEL_FONT (widget)->descent)/2);
      g_return_if_fail (week_of_year (&week, &year,		
				      ((calendar->day[row][6] < 15 && row > 3 ? 1 : 0)
				       + calendar->month) % 12 + 1, calendar->day[row][6]));
      x_loc= (private_data->week_width - (private_data->week_width - CALENDAR_XSEP
				      - DAY_XPAD * 2 - CALENDAR_MARGIN ) / 2
	      - private_data->max_week_char_width
	      - CALENDAR_XSEP - DAY_XPAD);
      
      if (week > 9)
	{
	  sprintf (buffer, "%d", week/10);
	  gdk_draw_string (private_data->week_win, LABEL_FONT (widget), gc,
			   x_loc, y_baseline , buffer);
	}
      
      sprintf (buffer, "%d", week%10);
      gdk_draw_string (private_data->week_win, LABEL_FONT (widget), gc,
		       x_loc + private_data->max_week_char_width, y_baseline , buffer);
    }
}

static void
gtk_calendar_paint_day_num (GtkWidget *widget,
			    gint       day)
{
  GtkCalendar *calendar;
  gint r, c, row, col;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_CALENDAR (widget));
  
  calendar = GTK_CALENDAR (widget);
  
  row = -1;
  col = -1;
  for (r = 0; r < 6; r++)
    for (c = 0; c < 7; c++)
      if (calendar->day_month[r][c] == MONTH_CURRENT &&
	  calendar->day[r][c] == day)
	{
	  row = r;
	  col = c;
	}
  
  g_return_if_fail (row != -1);
  g_return_if_fail (col != -1);
  
  gtk_calendar_paint_day (widget, row, col);
}

static void
gtk_calendar_paint_day (GtkWidget *widget,
			gint	   row,
			gint	   col)