calendar.c

一个linux下的时钟软件

				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
calendar_draw_focus (GtkWidget *widget)
{
  Calendar *calendar;
  CalendarPrivateData *private_data;
  gint width, height;
  gint x, y;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (IS_CALENDAR (widget));

  calendar = CALENDAR (widget);
  private_data = 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
calendar_expose (GtkWidget	    *widget,
		     GdkEventExpose *event)
{
  Calendar *calendar;
  CalendarPrivateData *private_data;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (IS_CALENDAR (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);
  
  calendar = CALENDAR (widget);
  private_data = CALENDAR_PRIVATE_DATA (widget);
  
  if (GTK_WIDGET_DRAWABLE (widget))
    {
      if (event->window == private_data->main_win)
		calendar_paint_main (widget);
      if (event->window == private_data->header_win)
		calendar_paint_header (widget);
      if (event->window == private_data->day_name_win)
		calendar_paint_day_names (widget);
      if (event->window == private_data->week_win)
		calendar_paint_week_numbers (widget);
      if (event->window == widget->window)
		gtk_widget_draw_focus (widget);
    }
  
  return FALSE;
}

static void
calendar_draw (GtkWidget	*widget,
		   GdkRectangle *area)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (IS_CALENDAR (widget));
  g_return_if_fail (area != NULL);
  
  if (GTK_WIDGET_DRAWABLE (widget))
    calendar_paint (widget, area);
  
}

static void
calendar_paint (GtkWidget	 *widget,
		    GdkRectangle *area)
{
  Calendar *calendar;
  CalendarPrivateData *private_data;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (widget->window != NULL);
  g_return_if_fail (IS_CALENDAR (widget));
  
  calendar = CALENDAR (widget);
  private_data = CALENDAR_PRIVATE_DATA (widget);
  
  if (private_data->main_win != NULL)
    calendar_paint_main (widget);
  
  if (private_data->header_win != NULL)
    calendar_paint_header (widget);
  
  if (private_data->day_name_win != NULL)
    calendar_paint_day_names (widget);
  
  if (private_data->week_win != NULL)
    calendar_paint_week_numbers (widget);
  
  gtk_widget_draw_focus (widget);
}

static void
calendar_paint_header (GtkWidget *widget)
{
  Calendar *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;
  CalendarPrivateData *private_data;

  calendar = CALENDAR (widget);
  private_data = 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 & 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 & 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)));
  
  calendar_paint_arrow (widget, ARROW_MONTH_LEFT);
  calendar_paint_arrow (widget, ARROW_MONTH_RIGHT);
  calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
  calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
}

static void
calendar_paint_day_names (GtkWidget *widget)
{
  Calendar *calendar;
  GdkGC *gc;
  char buffer[255];
  int day,i;
  int day_width, cal_width;
  int cal_height;
  int day_wid_sep;
  int str_width;
  CalendarPrivateData *private_data;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (IS_CALENDAR (widget));
  calendar = CALENDAR (widget);
  private_data = 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 & 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 & 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
calendar_paint_week_numbers (GtkWidget *widget)
{
  Calendar *calendar;
  GdkGC *gc;
  gint row, week = 0, year;
  gint x_loc;
  char buffer[3];
  gint y_baseline, day_height;
  CalendarPrivateData *private_data;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (widget->window != NULL);
  g_return_if_fail (IS_CALENDAR (widget));
  calendar = CALENDAR (widget);
  private_data = 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
calendar_paint_day_num (GtkWidget *widget,
			    gint       day)
{
  Calendar *calendar;
  gint r, c, row, col;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (IS_CALENDAR (widget));
  
  calendar = 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);
  
  calendar_paint_day (widget, row, col);
}

static void
calendar_paint_day (GtkWidget *widget,
			gint	   row,
			gint	   col)
{
  GdkGC *gc;
  gchar buffer[255];
  gint day;
  gint day_height;
  gint x_left;
  gint x_loc;
  gint y_top;
  gint y_baseline;
  gint day_xspace;
  Calendar *calendar;
  GdkColor  color;
  static GdkColormap *colormap = NULL;
  static GdkGC *mgc;

  CalendarPrivateData *private_data;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (IS_CALENDAR (widget));
  g_return_if_fail (row < 6);
  g_return_if_fail (col < 7);
  calendar = CALENDAR (widget);
  private_data = CALENDAR_PRIVATE_DATA (widget);

  /*
   * Handle freeze/thaw functionality
   */
  
  if (private_data->freeze_count)
    {
      private_data->dirty_main = 1;
      return;
    }
  
  day_height = row_height (calendar);
  
  day_xspace = private_data->day_width - private_data->max_day_char_width*2;
  
  day = calendar->day[row][col];
  
  x_left = left_x_for_column (calendar, col);
  x_loc = x_left + private_data->day_width / 2 + private_data->max_day_char_width;
  
  y_top = top_y_for_row (calendar, row);
  y_baseline = y_top + (day_height + private_data->max_day_char_ascent)/2;
  
  gdk_window_clear_area (private_data->main_win, x_left, y_top,
			 private_data->day_width, day_height);
  
  gc = calendar->gc;
  
  if (calendar->day_month[row][col] == MONTH_PREV)