tcal.c

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

/* TradeClient <http://tradeclient.sourceforge.net>
 * $Id: tcal.c,v 1.7 2001/03/20 22:19:33 ttabner Exp $
 *
 * Copyright (C) 1999-2000 Bynari Inc.
 * Copyright (C) 2001 Project TradeClient
 *
 * LGPL
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program 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 Library
 * General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */


#include "tcal.h"

#ifdef DMALLOC
#include <dmalloc.h>
#endif

typedef enum GtkTCalSignals {
	EVENT_SELECTED,
	LAST_SIGNAL
} GtkTCalSignals;

int suspend_paint;

GtkWidgetClass *parent_class;
static int gtk_tcal_signals[LAST_SIGNAL] = { 0 };

static void gtk_tcal_class_init (GtkTCalClass *gtk_tcal_class);
static void gtk_tcal_init (GtkTCal *gtk_tcal);

static void gtk_tcal_destroy (GtkObject *object);
static void gtk_tcal_map (GtkWidget *widget);
static void gtk_tcal_unmap (GtkWidget *widget);
static void gtk_tcal_realize (GtkWidget *widget);
static void gtk_tcal_unrealize (GtkWidget *widget);
static void gtk_tcal_size_request (GtkWidget *widget, GtkRequisition *requisition);
static void gtk_tcal_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
static gint gtk_tcal_button_press_event (GtkWidget *widget, GdkEventButton *event);
static gint gtk_tcal_button_release_event (GtkWidget *widget, GdkEventButton *event);
static gint gtk_tcal_expose_event (GtkWidget *widget, GdkEventExpose *event);
static gint gtk_tcal_leave_notify (GtkWidget *widget, GdkEventCrossing *event);
static gint gtk_tcal_enter_notify (GtkWidget *widget, GdkEventCrossing *event);
static void gtk_tcal_draw (GtkWidget *widget, GdkRectangle *rect);

static void event_selected (GtkTCal *tcal, gpointer data);
void gtk_tcal_month_set_days (GtkTCalMonth *month, guint year, guint mon);

void gtk_tcal_paint (GtkWidget *widget, GdkRectangle *area);


guint gtk_tcal_get_type () {
	static guint gtk_tcal_type=0;
	if (!gtk_tcal_type) {
		GtkTypeInfo gtk_tcal_info = {
			"GtkTCal",
			sizeof (GtkTCal),
			sizeof (GtkTCalClass),
			(GtkClassInitFunc) gtk_tcal_class_init,
			(GtkObjectInitFunc) gtk_tcal_init,
			(GtkArgSetFunc) NULL,
			(GtkArgGetFunc) NULL
		};
		gtk_tcal_type=gtk_type_unique (gtk_widget_get_type (), &gtk_tcal_info);
	}
	return gtk_tcal_type;
}

GList *find_events (GtkTCal *tcal, guint year, guint month, guint date) {
	GList *list=NULL;
	GList *seek;
	g_return_val_if_fail (tcal != NULL, NULL);
	for (seek=tcal->event_store;seek;seek=seek->next) {
		GtkTCalEvent *event=seek->data;
		if (event->year == year && event->month == month && event->date == date) {
			list=g_list_append (list, event);
		}
	}
	return list;
}

static void gtk_tcal_class_init (GtkTCalClass *gtk_tcal_class) {
	GtkObjectClass *object_class=(GtkObjectClass *)gtk_tcal_class;
	GtkWidgetClass *widget_class=(GtkWidgetClass *)gtk_tcal_class;
	parent_class=gtk_type_class (gtk_widget_get_type ());

	gtk_tcal_signals[EVENT_SELECTED]=	
		gtk_signal_new ("event_selected", GTK_RUN_FIRST, object_class->type, 
		                GTK_SIGNAL_OFFSET (GtkTCalClass, event_selected),
										gtk_marshal_NONE__POINTER, GTK_TYPE_NONE, 
										1, GTK_TYPE_POINTER);
	
	gtk_object_class_add_signals (object_class, gtk_tcal_signals, LAST_SIGNAL);

	object_class->destroy=gtk_tcal_destroy;
	
	widget_class->map=gtk_tcal_map;
	widget_class->unmap=gtk_tcal_unmap;
	widget_class->realize=gtk_tcal_realize;
	widget_class->unrealize=gtk_tcal_unrealize;
	widget_class->draw=gtk_tcal_draw;
	
	widget_class->size_request=gtk_tcal_size_request;
	widget_class->size_allocate=gtk_tcal_size_allocate;
	widget_class->button_press_event=gtk_tcal_button_press_event;
	widget_class->button_release_event=gtk_tcal_button_release_event;
	widget_class->expose_event=gtk_tcal_expose_event;	
	widget_class->leave_notify_event=gtk_tcal_leave_notify;
	widget_class->enter_notify_event=gtk_tcal_enter_notify;

	gtk_tcal_class->event_selected=event_selected;
}

void gtk_tcal_event_selected_callback (GtkMenuItem *menuitem, GtkTCalEventCombo *combo) {
	gtk_signal_emit (GTK_OBJECT (combo->tcal), gtk_tcal_signals[EVENT_SELECTED],
	                 combo->event->user_data);
}

static void gtk_tcal_init (GtkTCal *tcal) {
	GTK_WIDGET_UNSET_FLAGS (tcal, GTK_NO_WINDOW);
	GTK_WIDGET_SET_FLAGS (tcal, GTK_CAN_FOCUS);
	tcal->event_store=NULL;
	tcal->bold=gtk_style_copy (GTK_WIDGET (tcal)->style);
	tcal->bold->font=gdk_font_load ("-*-helvetica-bold-r-*--*-*-*-*-*-*-*-1");
	tcal->small=gtk_style_copy (GTK_WIDGET (tcal)->style);
	tcal->small->font=gdk_font_load ("-adobe-helvetica-medium-r-normal-*-*-80-*-*-p-*-iso8859-1");
}

void gtk_tcal_set (GtkTCal *tcal, guint year, guint month) {
	GList *seek;
	int count=0;
	g_return_if_fail (tcal != NULL);
	tcal->year=year;
	tcal->month=month;
	if (tcal->months) {
		switch (tcal->type) {
			case GTK_TCAL_MONTH:
				gtk_tcal_month_set_days (tcal->months->data, year, month);	
				break;
			case GTK_TCAL_YEAR:
				for (seek=tcal->months;seek;seek=seek->next) {
					gtk_tcal_month_set_days (seek->data, year, count);
					count++;
				}
				break;
		}
		gtk_tcal_paint (GTK_WIDGET (tcal), NULL);
	}
}

void gtk_tcal_set_event_store (GtkTCal *tcal, GList *event_store) {
	g_return_if_fail (tcal != NULL);
	tcal->event_store=event_store;
}

GtkWidget *gtk_tcal_new (GtkTCalType type, guint year, guint month) {
	GtkTCal *tcal=gtk_type_new (gtk_tcal_get_type ());
	g_return_val_if_fail (tcal != NULL, NULL);
	tcal->type=type;
	tcal->year=year;
	tcal->month=month;
	return GTK_WIDGET (tcal);
}

static void gtk_tcal_destroy (GtkObject *object) {
	g_return_if_fail (object != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (object));
	if (GTK_OBJECT_CLASS (parent_class)->destroy) 
		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}

static void gtk_tcal_map (GtkWidget *widget) {
	GdkRectangle rect;
	GList *seek, *dseek;
	GtkTCal *tcal=GTK_TCAL (widget);
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (widget));
	GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
	
	gdk_window_show (widget->window);

	rect.x=0;rect.y=0;
	rect.width=GTK_TCAL (widget)->width;
	rect.height=GTK_TCAL (widget)->height;
	
	for (seek=tcal->months;seek;seek=seek->next) {
		GtkTCalMonth *month=seek->data;
		gdk_window_show (month->window);
		for (dseek=month->days;dseek;dseek=dseek->next) {
			GtkTCalDay *day=dseek->data;
			gdk_window_show (day->window);
		}
	}
	
	gtk_tcal_paint (widget, &rect);
}



static void gtk_tcal_unmap (GtkWidget *widget) {
	g_return_if_fail (widget != NULL);
	g_return_if_fail (GTK_TCAL_IS_TCAL (widget));
	GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
	
	gdk_window_hide (widget->window);
}

GList *combos=NULL;

void gtk_tcal_create_popup (GtkTCal *tcal, GList *events) {
	GtkWidget *menuitem;
	GList *seek;
	g_return_if_fail (tcal != NULL);
	if (GTK_IS_WIDGET (tcal->popup))
		gtk_widget_destroy (tcal->popup);
	for (seek=combos;seek;seek=seek->next) {
		free (seek->data);
	}
	g_list_free (combos); combos=NULL;
	tcal->popup=gtk_menu_new ();
	if (!events) {
		menuitem=gtk_menu_item_new_with_label ("No events to show");
		gtk_widget_show (menuitem);		
		gtk_container_add (GTK_CONTAINER (tcal->popup), menuitem);
		gtk_widget_set_sensitive (menuitem, FALSE);
	} else {
		menuitem=gtk_menu_item_new_with_label ("Events on This Day");
		gtk_widget_show (menuitem);		
		gtk_container_add (GTK_CONTAINER (tcal->popup), menuitem);
		gtk_widget_set_sensitive (menuitem, TRUE);

		menuitem=gtk_menu_item_new ();
		gtk_widget_show (menuitem);		
		gtk_container_add (GTK_CONTAINER (tcal->popup), menuitem);
		gtk_widget_set_sensitive (menuitem, FALSE);		
	}
	for (seek=events;seek;seek=seek->next) {
		GtkTCalEvent *event=seek->data;
		GtkTCalEventCombo *combo=(GtkTCalEventCombo *)calloc (1, sizeof (GtkTCalEventCombo));
		combos=g_list_append (combos, combo);
		combo->tcal=tcal;
		combo->event=event;
		menuitem=gtk_menu_item_new_with_label (event->subject);
		gtk_container_add (GTK_CONTAINER (tcal->popup), menuitem);
		gtk_widget_show (menuitem);
		gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
		                    GTK_SIGNAL_FUNC (gtk_tcal_event_selected_callback), combo);
	}
}

GtkTCalMonth *find_month(GtkTCal *tcal, GdkWindow *window) {
	GList *seek;
	g_return_val_if_fail (tcal != NULL, NULL);
	for (seek=tcal->months;seek;seek=seek->next) {
		GtkTCalMonth *month=seek->data;
		if (month->window == window)
			return month;
	}
	return NULL;
}

GtkTCalDay *find_day (GtkTCal *tcal, GdkWindow *window) {
	GList *seek;
	g_return_val_if_fail (tcal != NULL, NULL);
	for (seek=tcal->months;seek;seek=seek->next) {
		GtkTCalMonth *month=seek->data;
		GList *dseek;
		for (dseek=month->days;dseek;dseek=dseek->next) {
			GtkTCalDay *day=dseek->data;
			if (day->window == window)
				return day;
		}
	}
	return NULL;
}


GdkWindow *new_window (GtkWidget *widget, gint x, gint y, guint width, 
                      guint height, gulong mask, guint state) {
	GdkWindow *window;
	GdkWindowAttr attributes;
	gint attributes_mask;
	
	attributes.window_type = GDK_WINDOW_CHILD;
	attributes.x = x;
	attributes.y = y;
	attributes.width = width;
	attributes.height = height;
	attributes.wclass = GDK_INPUT_OUTPUT;
	attributes.visual = gtk_widget_get_visual (widget);
	attributes.colormap = gtk_widget_get_colormap (widget);
	attributes.cursor = NULL;
	attributes.event_mask = mask;
	attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR;

	window = gdk_window_new (widget->window, &attributes, attributes_mask);

	gtk_style_set_background (widget->style, window, state);
	gdk_window_set_user_data (window, widget);
	
	return window;
}

void gtk_tcal_resize_children (GtkTCal *tcal) {
	GList *seek;
	int th, tw, tx, ty;
	g_return_if_fail (tcal != NULL);
	suspend_paint=TRUE;
	for (seek=tcal->months;seek;seek=seek->next) {
		GtkTCalMonth *month=seek->data;
		GList *dseek;
		switch (tcal->type) {
			case GTK_TCAL_MONTH:
				if (month->width != tcal->width || month->height != tcal->height) {
					gdk_window_resize (month->window, tcal->width, tcal->height);
					month->width=tcal->width;
					month->height=tcal->height;
				}
				break;
			case GTK_TCAL_YEAR:
				tw=tcal->width / 3;
				th=tcal->height  / 4;
				tw= tw / 7;
				tw=tw*7;
				tx=month->rx * tw;
				ty=month->ry * th;
				if (month->width != tw-7 || month->height != th || 
				    month->x != tx || month->y != ty) {
					month->width=tw-7;
					month->height=th;
					month->x=tx;
					month->y=ty;
					gdk_window_move_resize (month->window, month->x, month->y, 
					                        month->width, month->height);
				}
				break;
		}
		for (dseek=month->days;dseek;dseek=dseek->next) {
			int day_height=(month->height-30) / 6;
			int day_width =month->width / 7;
			GtkTCalDay *day=dseek->data;
			int t=month->height - (day_height * 6);
			tx=day->x * day_width + month->x;
			ty=day->y * day_height + t + month->y;
			if (day->rx != tx || day->ry != ty || day->width != day_width || day->height != day_height) {
				gdk_window_move_resize (day->window, tx, 
				     ty, day_width, day_height);
				day->height=day_height;
				day->width=day_width;
				day->rx=tx;
				day->ry=ty;
			}
		}
	}
	suspend_paint=FALSE;
}

static char *months[]={"January",   "February", "March",    "April", 
                         "May",       "June",     "July",     "August",
												 "September", "October",  "November", "December"};

static int non_leap[]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
static int leap[]    ={31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

typedef struct tm mytm;

void gtk_tcal_month_set_days (GtkTCalMonth *month, guint year, guint mon) {
	GList *seek;
	mytm tm_s;
	time_t time;
	int count=0, date=1;
	g_return_if_fail (month != NULL);
	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 (seek=month->days;seek;seek=seek->next) {
		GtkTCalDay *day=seek->data;
		day->month=mon;
		day->evnt=GTK_TCAL_DONT_KNOW;
		if (count > tm_s.tm_wday) {
			day->date=date;
			date++;
		} else {
			day->date=-1;
		}
		if (year % 4 == 0) {
			if (day->date > leap[mon])
				day->date=-1;
		} else {
			if (day->date > non_leap[mon])
				day->date=-1;
		}		
		count++;
	}
}

GtkTCalMonth *gtk_tcal_create_month (GtkWidget *widget, gint x, gint y,
                                     guint height, guint width, guint year, guint mon) {
	int day_height, day_width;
	int cx, cy;
	mytm tm_s;
	time_t time;
	int count=0, date=1;
	GtkTCalMonth *month=(GtkTCalMonth *)calloc (1, sizeof (GtkTCalMonth));
	day_height=(height-20) / 6;