tcal.c

一个功能全面的电子邮件客户端

	day_width =width / 7;
	
	month->window=new_window (widget, x, y, width, height, 
	                          GDK_EXPOSURE_MASK       |
				                    GDK_BUTTON_PRESS_MASK   |
													  GDK_BUTTON_RELEASE_MASK |
													  GDK_LEAVE_NOTIFY_MASK   |
													  GDK_ENTER_NOTIFY_MASK, GTK_STATE_NORMAL);
	if (mon != -1)
		month->name=months[mon];
	month->month=mon;
	memset (&tm_s, 0, sizeof (struct tm));
	tm_s.tm_mon=mon;
	tm_s.tm_year=year-1900;
	tm_s.tm_isdst=-1;
	time=mktime (&tm_s);
	tm_s=*(localtime (&time));
	for (cy=0;cy<6;cy++) {
		for (cx=0;cx<7;cx++) {
			GtkTCalDay *day=(GtkTCalDay *)calloc (1, sizeof (GtkTCalDay));
			day->window=new_window (widget, cx * day_width, (cy * day_height) + 20, 
			                        day_width, day_height, 
	                          GDK_EXPOSURE_MASK       |
				                    GDK_BUTTON_PRESS_MASK   |
													  GDK_BUTTON_RELEASE_MASK |
													  GDK_LEAVE_NOTIFY_MASK   |
													  GDK_ENTER_NOTIFY_MASK, GTK_STATE_PRELIGHT);
			day->width=day_width;
			day->height=day_height;
			day->x=cx;
			day->y=cy;
			if (count > tm_s.tm_wday) {
				day->date=date;
				date++;
			} else {
				day->date=-1;
			}
			day->month=mon;
			if (year % 4 == 0) {
				if (day->date > leap[mon])
					day->date=-1;
			} else {
				if (day->date > non_leap[mon])
					day->date=-1;
			}
			count++;
			month->days=g_list_append (month->days, day);
		}
	}
	return month;
}

static void gtk_tcal_realize (GtkWidget *widget) {
	GdkWindowAttr attributes;
	GtkTCalMonth *month;
	GtkTCal *tcal=GTK_TCAL (widget);
	gint attr_mask;
	int cx, cy, w, h;
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (widget));
	
	GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
	attributes.window_type=GDK_WINDOW_CHILD;
	attributes.x=widget->allocation.x;
	attributes.y=widget->allocation.y;
	attributes.width = widget->allocation.width;
	attributes.height = widget->allocation.height;
	attributes.wclass = GDK_INPUT_OUTPUT;
	attributes.visual = gtk_widget_get_visual (widget);
	attributes.colormap = gtk_widget_get_colormap (widget);
	attributes.event_mask = (GDK_EXPOSURE_MASK
				                   | GDK_BUTTON_PRESS_MASK
													 | GDK_BUTTON_RELEASE_MASK |
													  GDK_LEAVE_NOTIFY_MASK   |
													  GDK_ENTER_NOTIFY_MASK);
													 
	attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

	widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attr_mask);
	gdk_window_set_user_data (widget->window, widget);

	widget->style = gtk_style_attach (widget->style, widget->window);
	gdk_window_set_background (widget->window, &widget->style->bg[GTK_STATE_PRELIGHT]);

	switch (tcal->type) {
		case GTK_TCAL_MONTH:
			month=gtk_tcal_create_month (widget, 0, 0, 
			     tcal->width, tcal->height, tcal->year, tcal->month);
			tcal->months=g_list_append (tcal->months, month);
			break;
		case GTK_TCAL_YEAR:
			w=tcal->width  / 3;
			h=tcal->height / 4;
			for (cy=0;cy<4;cy++) {
				for (cx=0;cx<3;cx++) {
					month=gtk_tcal_create_month (widget, cx * w, cy * h, w, h, 
					                                  tcal->year, cy * 3 + cx);
					month->rx=cx;
					month->ry=cy;
					tcal->months=g_list_append (tcal->months, month);			
				}
			}
			break;
	}
	GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
}

static void gtk_tcal_unrealize (GtkWidget *widget) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (widget));
	if (GTK_WIDGET_CLASS (parent_class)->unrealize)
		(*GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}

static void gtk_tcal_size_request (GtkWidget *widget, GtkRequisition *requisition) {
	GtkAllocation alloc;
	if (GTK_TCAL (widget)->type==GTK_TCAL_YEAR) {
		GTK_TCAL (widget)->width    =
			requisition->width        = 500;
		GTK_TCAL (widget)->height   =
			requisition->height       = 600;
	} else {
		GTK_TCAL (widget)->width    =
			requisition->width        = 
			alloc.width               = 
			widget->parent->allocation.width-4;
		GTK_TCAL (widget)->height   =
			requisition->height       = 
			alloc.height              = 
			widget->parent->allocation.height-4;
	}
	alloc.x=0;
	alloc.y=0;
}

static void gtk_tcal_size_allocate (GtkWidget *widget, GtkAllocation *allocation) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (widget));
	g_return_if_fail (allocation != NULL);
		GTK_TCAL (widget)->width=allocation->width;
		GTK_TCAL (widget)->height=allocation->height;
		if (GTK_WIDGET_REALIZED (widget)) {
			if (widget->window)
				gdk_window_move_resize (widget->window, allocation->x, allocation->y,
				                        allocation->width, allocation->height);
			gtk_tcal_resize_children (GTK_TCAL (widget));
		}
}

static char *days[]={"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

void gtk_tcal_paint_month (GtkWidget *widget, GtkTCalMonth *month) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (widget->style != NULL);
	{
		int width;
		int i;
		GdkGC	*black=widget->style->black_gc,
		      *light_grey=widget->style->bg_gc[GTK_STATE_NORMAL];
		gdk_draw_rectangle (month->window, light_grey, TRUE, 0, 0,
		                    month->width, month->height);		
		gtk_draw_shadow (widget->style, month->window, GTK_STATE_NORMAL, 
		                 GTK_SHADOW_IN, 0, 0, month->width, month->height);	
		width=month->width / 7;
		for (i=0;i<7;i++) {
			if (black)
				gdk_draw_string (month->window, GTK_TCAL (widget)->small->font, black, 
				                 i * width + 2, 27, days[i]);
		}
		if (month->name) {
			width=gdk_string_width (GTK_TCAL (widget)->bold->font, month->name);
			gdk_draw_string (month->window, GTK_TCAL (widget)->bold->font, black, 
				               (month->width / 2 ) - (width / 2), 15, month->name);
		}
	}
}

void gtk_tcal_paint_day (GtkWidget *widget, GtkTCalDay *day) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (widget->style != NULL);
	{
		GdkGC *black=widget->style->black_gc,
		      *dark_grey=widget->style->bg_gc[GTK_STATE_NORMAL],
					*light_grey=widget->style->bg_gc[GTK_STATE_PRELIGHT];
		if (day->x == 0 || day->x == 6) {
			gdk_draw_rectangle (day->window, dark_grey, TRUE, 0, 0,
			                    day->width, day->height);
		} else {
			gdk_draw_rectangle (day->window, light_grey, TRUE, 0, 0,
			                    day->width, day->height);
		}
		gtk_draw_shadow (widget->style, day->window, GTK_STATE_NORMAL, 
		                 GTK_SHADOW_OUT, 0, 0, day->width, day->height);
		if (day->date!=-1) {
			char *tmp=(char *)calloc (25, sizeof (char));
			int width;
			snprintf (tmp, 24, "%d", day->date);
			if (day->evnt==GTK_TCAL_DONT_KNOW) {
				GList *list;
				if ((list=find_events (GTK_TCAL (widget), GTK_TCAL (widget)->year, day->month, day->date))) {
					day->evnt=GTK_TCAL_HAS_EVENTS;
					g_list_free (list);
				} else {
					day->evnt=GTK_TCAL_HAS_NOT_EVENTS;
				}
			}
			if (day->evnt==GTK_TCAL_HAS_EVENTS) {
				width=gdk_string_width (GTK_TCAL (widget)->bold->font, tmp);
				gdk_draw_string (day->window, GTK_TCAL (widget)->bold->font, black, 
				                 (day->width / 2) - (width / 2), 13, tmp);
			} else {
				width=gdk_string_width (widget->style->font, tmp);
				gtk_draw_string (widget->style, day->window, GTK_STATE_NORMAL,
				                 (day->width / 2) - (width / 2), 13, tmp);
			}
			free (tmp);
		}
	}
}

void gtk_tcal_paint_day_focus (GtkWidget *widget, GtkTCalDay *day) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (widget->style != NULL);
	{
		GdkGC *black=widget->style->black_gc,
		      *dark_grey=widget->style->bg_gc[GTK_STATE_NORMAL],
					*light_grey=widget->style->bg_gc[GTK_STATE_PRELIGHT];
		if (day->x == 0 || day->x == 6) {
			gdk_draw_rectangle (day->window, dark_grey, TRUE, 0, 0,
			                    day->width, day->height);
		} else {
			gdk_draw_rectangle (day->window, light_grey, TRUE, 0, 0,
			                    day->width, day->height);
		}
		gtk_draw_shadow (widget->style, day->window, GTK_STATE_NORMAL, 
		                 GTK_SHADOW_ETCHED_IN, 0, 0, day->width, day->height);
		if (day->date!=-1) {
			char *tmp=(char *)calloc (25, sizeof (char));
			int width;
			snprintf (tmp, 24, "%d", day->date);
			if (day->evnt==GTK_TCAL_DONT_KNOW) {
				GList *list;
				if ((list=find_events (GTK_TCAL (widget), GTK_TCAL (widget)->year, day->month, day->date))) {
					g_list_free (list);
					day->evnt=GTK_TCAL_HAS_EVENTS;
				} else {
					day->evnt=GTK_TCAL_HAS_NOT_EVENTS;
				}
			}
			if (day->evnt==GTK_TCAL_HAS_EVENTS) {
				width=gdk_string_width (GTK_TCAL (widget)->bold->font, tmp);
				gdk_draw_string (day->window, GTK_TCAL (widget)->bold->font, black, 
				                 (day->width / 2) - (width / 2), 13, tmp);
			} else {
				width=gdk_string_width (widget->style->font, tmp);
				gtk_draw_string (widget->style, day->window, GTK_STATE_NORMAL,
				                 (day->width / 2) - (width / 2), 13, tmp);
			}		
			free (tmp);
		}
	}
}

void gtk_tcal_paint_day_pressed (GtkWidget *widget, GtkTCalDay *day) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (widget->style != NULL);
	{
		GdkGC *black=widget->style->black_gc,
		      *dark_grey=widget->style->bg_gc[GTK_STATE_SELECTED],
					*light_grey=widget->style->bg_gc[GTK_STATE_SELECTED];
		if (day->x == 0 || day->x == 6) {
			gdk_draw_rectangle (day->window, dark_grey, TRUE, 0, 0,
			                    day->width, day->height);
		} else {
			gdk_draw_rectangle (day->window, light_grey, TRUE, 0, 0,
			                    day->width, day->height);
		}
		gtk_draw_shadow (widget->style, day->window, GTK_STATE_NORMAL, 
		                 GTK_SHADOW_IN, 0, 0, day->width, day->height);
		if (day->date!=-1) {
			char *tmp=(char *)calloc (25, sizeof (char));
			int width;
			snprintf (tmp, 24, "%d", day->date);
			if (day->evnt==GTK_TCAL_DONT_KNOW) {
				GList *list;
				if ((list=find_events (GTK_TCAL (widget), GTK_TCAL (widget)->year, day->month, day->date))) {
					day->evnt=GTK_TCAL_HAS_EVENTS;
					g_list_free (list);
				} else {
					day->evnt=GTK_TCAL_HAS_NOT_EVENTS;
				}
			}
			if (day->evnt==GTK_TCAL_HAS_EVENTS) {
				width=gdk_string_width (GTK_TCAL (widget)->bold->font, tmp);
				gdk_draw_string (day->window, GTK_TCAL (widget)->bold->font, black, 
				                 (day->width / 2) - (width / 2), 13, tmp);
			} else {
				width=gdk_string_width (widget->style->font, tmp);
				gtk_draw_string (widget->style, day->window, GTK_STATE_NORMAL,
				                 (day->width / 2) - (width / 2), 13, tmp);
			}
			free (tmp);
		}
	}
}

static gint gtk_tcal_button_press_event (GtkWidget *widget, GdkEventButton *event) {
	if (event->window != widget->window) {
		GtkTCalDay *day=find_day (GTK_TCAL (widget), event->window);
		if (day) {
			if (day->date != -1) {
				GList *events=find_events (GTK_TCAL (widget), GTK_TCAL (widget)->year,
				                           day->month, day->date);
				if (GTK_IS_WIDGET (GTK_TCAL (widget)->popup)) {
					gtk_widget_destroy (GTK_TCAL (widget)->popup);
				}
				gtk_tcal_create_popup (GTK_TCAL (widget), events);
				g_list_free (events);
				gtk_tcal_paint_day_pressed (widget, day);
				if (event->button == 1) 
					gtk_menu_popup (GTK_MENU (GTK_TCAL (widget)->popup), NULL, NULL, NULL, NULL, 1, 0);
			}
		}
	}
	return TRUE;
}

static gint gtk_tcal_button_release_event (GtkWidget *widget, GdkEventButton *event) {
	if (event->window != widget->window) {
		GtkTCalDay *day=find_day (GTK_TCAL (widget), event->window);
		if (day) {
			if (day->date != -1) 
				gtk_tcal_paint_day_focus (widget, day);
		}
	}
	return TRUE;
}

void gtk_tcal_paint (GtkWidget *widget, GdkRectangle *area) {
	GtkTCal *tcal;
	GList *seek;
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (widget));
	tcal=GTK_TCAL (widget);
	for (seek=tcal->months;seek;seek=seek->next) {
		GList *dseek;
		GtkTCalMonth *month=seek->data;
		gtk_tcal_paint_month (widget, month);
		for (dseek=month->days;dseek;dseek=dseek->next) {
			GtkTCalDay *day=dseek->data;
			gtk_tcal_paint_day (widget, day);
		}
	}
	gtk_draw_shadow (widget->style, widget->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT, 
	                 0, 0, GTK_TCAL (widget)->width, GTK_TCAL (widget)->height);
}


static gint gtk_tcal_expose_event (GtkWidget *widget, GdkEventExpose *event) {
	GtkTCalMonth *month;
	GtkTCalDay *day;
	g_return_val_if_fail (GTK_TCAL_IS_TCAL (widget), FALSE);
	if (event->window != widget->window) {
		month=find_month (GTK_TCAL (widget), event->window);
		if (!month) {
			day=find_day (GTK_TCAL (widget), event->window);
			gtk_tcal_paint_day (widget, day);
		} else {
			gtk_tcal_paint_month (widget, month);
		}
	}
	return TRUE;
}

static gint gtk_tcal_leave_notify (GtkWidget *widget, GdkEventCrossing *event) {
	GtkTCal *tcal=GTK_TCAL (widget);
	if (event->window != widget->window) {
		GtkTCalDay *day=find_day (tcal, event->window);
		if (day) {
			if (day->date != -1) 
				gtk_tcal_paint_day (widget, day);
		}
	}	
	return TRUE;
}

static gint gtk_tcal_enter_notify (GtkWidget *widget, GdkEventCrossing *event) {
	GtkTCal *tcal=GTK_TCAL (widget);
	if (event->window != widget->window) {
		GtkTCalDay *day=find_day (tcal, event->window);
		if (day) {
			if (day->date != -1) 
				gtk_tcal_paint_day_focus (widget, day);
		}
	}	
	return TRUE;
}


static void event_selected (GtkTCal *tcal, gpointer data) {}

void gtk_tcal_event_store_updated (GtkTCal *tcal) {
	GList *seek;
	g_return_if_fail (tcal != NULL);
	for (seek=g_list_first (tcal->months);seek;seek=seek->next) {
		GtkTCalMonth *month=seek->data;
		GList *dseek;
		for (dseek=month->days;dseek;dseek=dseek->next) {
			GtkTCalDay *day=dseek->data;
			day->evnt=GTK_TCAL_DONT_KNOW;
		}
	}
}

static void gtk_tcal_draw (GtkWidget *widget, GdkRectangle *rect) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL(widget));

	gtk_tcal_paint (widget, rect);
}