calender-callbacks.c

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

  event_store_add (event);
  calendar_event_destroy (widget, data);
  calendar_save ();
  calendar_update_all_uis ();
  calendar_event_loop();
}

void calendar_event_categories (GtkWidget *widget, gpointer data) {
	GtkWidget *window=event_master_category_create (lookup_widget (widget, "event_editor"), 
	           gtk_entry_get_text (GTK_ENTRY (lookup_widget (widget, "entry9"))));
	gtk_widget_show (window);
}

void calendar_event_categories2 (GtkWidget *widget, gpointer data) {
        GtkWidget *window=event_master_category_create (lookup_widget (widget, "new_message_window"),
                   gtk_entry_get_text (GTK_ENTRY (lookup_widget (widget, "entry9"))));
        gtk_widget_show (window);
}

void calendar_renotify (GtkWidget *widget, CalendarEvent *event) {
	gtk_widget_destroy (lw (widget, "yesno"));
}

void calendar_child_changed (Schedule *schedule, char *text, CalendarEvent *event) {
	if (!event) 
		return;
	if (event->information && text) {
		time_t start, end;
		schedule_child_get_time (schedule, event, &start, &end);
		/* Notification doesn't need to exist in base TradeClient code */
		free (event->start);
		event->start=time_t_to_event_time (start);
		event_time_dump (event->start);
		free (event->stop);
		event->stop=time_t_to_event_time (end);
		event_time_dump (event->stop);
		event->subject=text;
		event_store_delete (event);
		event_store_add (event);
	}
	calendar_display_event (event);
	calendar_update_all_uis ();
}

void calendar_clear_event () {
	if (calendar_window) {
	GtkCList *clist=GTK_CLIST (lookup_widget (calendar_window, "attendee_clist"));
	gtk_clist_freeze (clist);gtk_clist_clear (clist);gtk_clist_thaw (clist);
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (calendar_window, "location")), "");
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (calendar_window, "location")), "");
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (calendar_window, "subject_entry")), "");
	gtk_text_set_point (GTK_TEXT (lookup_widget (calendar_window, "information_text")), 0);
	gtk_text_forward_delete (GTK_TEXT (lookup_widget (calendar_window, "information_text")), 
	    gtk_text_get_length (GTK_TEXT (lookup_widget (calendar_window, "information_text"))));
	}
}

void calendar_display_event (CalendarEvent *event) {
	GtkCList *clist=GTK_CLIST (lookup_widget (calendar_window, "attendee_clist"));
	GtkCList *cats=GTK_CLIST (lookup_widget (calendar_window, "category_clist"));
	EventAttendee *attend;
	char *cl_data[2], *tmp1, *tmp2;
	Llist *seek;
	if (event->location)
		gtk_entry_set_text (GTK_ENTRY (lookup_widget (calendar_window, "location")),
	                      event->location);
	if (event->subject) 
		gtk_entry_set_text (GTK_ENTRY (lookup_widget (calendar_window, "subject_entry")),
	                      event->subject);
	gtk_text_set_point (GTK_TEXT (lookup_widget (calendar_window, "information_text")), 0);
	gtk_text_forward_delete (GTK_TEXT (lookup_widget (calendar_window, "information_text")), 
	    gtk_text_get_length (GTK_TEXT (lookup_widget (calendar_window, "information_text"))));
	if (event->information) 
		gtk_text_insert (GTK_TEXT (lookup_widget (calendar_window, "information_text")),
	                   NULL, NULL, NULL, event->information, -1);
	gtk_clist_freeze (clist);
	gtk_clist_clear (clist);
	tmp1=strdup (ctime (&event->start->time));
	tmp1[24]='\0';
	gtk_label_set_text (GTK_LABEL (lookup_widget (calendar_window, "start_time")), tmp1);
	tmp2=strdup (ctime (&event->stop->time));
	tmp2[24]='\0';
	gtk_label_set_text (GTK_LABEL (lookup_widget (calendar_window, "end_time")), tmp2);
	free (tmp1);free (tmp2);
	seek=event->attendees;
	while (seek) {
		attend=seek->data;
		if (attend) {
			cl_data[0]=attend->name;
			switch (attend->priority) {
				case PRIORITY_NONE:
				case PRIORITY_MANDATORY:
					cl_data[1]=strdup (_("Required"));
					break;
				case PRIORITY_OPTIONAL:
					cl_data[1]=strdup (_("Optional"));
					break;
				case PRIORITY_RESOURCE:
					cl_data[1]=strdup (_("Resource"));
					break;
			  case PRIORITY_ORGANIZER:
			    cl_data[1]=strdup (_("Organizer"));
			    break;
			}
			gtk_clist_append (clist, cl_data);
			free (cl_data[1]);
		}
		seek=seek->next;
	}
	gtk_clist_thaw (clist);
	gtk_clist_freeze (cats);
	gtk_clist_clear (cats);
	for (seek=event->categories;seek;seek=seek->next) {
		cl_data[0]=seek->data;
		gtk_clist_append (cats, cl_data);
	}
	gtk_clist_thaw (cats);
}

void calendar_child_selected (Schedule *schedule, char *text, gpointer data, time_t start, time_t end) {
	CalendarEvent *event=(CalendarEvent *)data;
	if (!data) 
		return;
	cur_event=event;
	calendar_display_event (event);
}

void calendar_add_recipient (GtkWidget *widget, gpointer data) {
	calendar_event_create_tree_item (GTK_TREE (lookup_widget (widget, "attendee_tree")), NULL, PRIORITY_NONE);
}

void calendar_attendee_selected (GtkTree *tree, GtkWidget *child) {
	GtkWidget *widget=GTK_BIN (child)->child;
	GtkBoxChild *bchild;
	GList *seek;
	gtk_tree_unselect_child (tree, child);
	if (GTK_IS_HBOX (widget)) {
		seek= GTK_BOX (widget)->children->next;
		bchild=seek->data;
		if (GTK_IS_ENTRY (bchild->widget)) {
			gtk_widget_grab_focus (bchild->widget);
		}
	}
}

void calendar_event_edit (GtkWidget *w, gpointer data) {
	GtkWidget *widget;
	EventAttendee *attend;
	Llist *seek;
	char *tmp;
	if (!cur_event) 
		return;	
	widget=create_event_editor ();
	if (cur_event->flags & EVENT_APPOINTMENT) {
		gtk_window_set_title (GTK_WINDOW (widget), _("Appointment") );
	} else {
		gtk_window_set_title (GTK_WINDOW (widget), _("Meeting Request") );
	}
	for (seek=cur_event->attendees;seek;seek=seek->next) {
		attend=seek->data;
		calendar_event_create_tree_item (GTK_TREE (lookup_widget (widget, "attendee_tree")),
  	                                 attend->name, attend->priority);
	}
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "location")), 
	                    cur_event->location);
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "subject")), 
	                    cur_event->subject);

	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "startyear")), 
	                    event_int_to_year(cur_event->start->year));
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "endyear")), 
	                    event_int_to_year(cur_event->stop->year));
	
	tmp=event_int_to_month(cur_event->start->month);
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "startmonth")), tmp);
	free (tmp);
	tmp=event_int_to_month(cur_event->stop->month);
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "endmonth")), tmp);
	free (tmp);
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "startdate")), 
	                    event_int_to_day(cur_event->start->date));
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "enddate")), 
	                    event_int_to_day(cur_event->stop->date));
		
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "starttime")), 
	                    event_time_to_char(cur_event->start->hour, cur_event->start->minute));
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "endtime")), 
	                    event_time_to_char(cur_event->stop->hour, cur_event->stop->minute));
	tmp=event_categories_to_char (cur_event->categories);
	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "entry9")), tmp);
	free (tmp);

	gtk_text_insert (GTK_TEXT (lookup_widget (widget, "information")), NULL, NULL, NULL, cur_event->information, -1);
	
	clip_handle_editable (lw (widget, "subject"));
	clip_handle_editable (lw (widget, "startyear"));
	clip_handle_editable (lw (widget, "endyear"));
	clip_handle_editable (lw (widget, "entry9"));
	clip_handle_editable (lw (widget, "information"));
	clip_handle_editable (lw (widget, "location"));
	gtk_signal_connect (GTK_OBJECT (widget), "delete_event",
	                    GTK_SIGNAL_FUNC (calendar_event_destroy), NULL);
	gtk_signal_connect (GTK_OBJECT (lookup_widget (widget, "add_attendee_row")), "clicked",
	                    GTK_SIGNAL_FUNC (calendar_add_recipient), NULL);
	gtk_signal_connect (GTK_OBJECT (lookup_widget (widget, "cancel_button")), "clicked",
	                    GTK_SIGNAL_FUNC (calendar_event_destroy), NULL);
	gtk_signal_connect (GTK_OBJECT (lookup_widget (widget, "ok_button")), "clicked",
	                    GTK_SIGNAL_FUNC (calendar_event_accept), cur_event);
	gtk_signal_connect (GTK_OBJECT (lookup_widget (widget, "attendee_tree")), "select_child",
	                    GTK_SIGNAL_FUNC (calendar_attendee_selected), NULL);		
	gtk_signal_connect (GTK_OBJECT (lookup_widget (widget, "select_categories")), "clicked",
	                    GTK_SIGNAL_FUNC (calendar_event_categories), NULL);
	gtk_signal_connect (GTK_OBJECT (lookup_widget (widget, "subject")), "focus-out-event",
	                    GTK_SIGNAL_FUNC (new_event_subject_changed), NULL);

	if ((cur_event->reminder)>0) {
	tmp=(char *)calloc (80, sizeof(char));
	snprintf(tmp, sizeof(tmp), "%d", cur_event->reminder);
	gtk_entry_set_text(GTK_ENTRY(lookup_widget(widget,"remind_duration")),tmp);
	free (tmp);
	} else {
		gtk_entry_set_text(GTK_ENTRY(lookup_widget(widget,"remind_duration")),"");
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (lookup_widget (widget, "remind_me")),FALSE);
	}

	if (strlen(cur_event->program)>0){
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (lookup_widget(widget, "spawn_button")),TRUE);
		gtk_entry_set_text(GTK_ENTRY(lookup_widget(widget,"spawn_entry")),cur_event->program);
	}

	if (cur_event->status){
		switch (cur_event->status)
		{
			case STATUS_BUSY:
				gtk_entry_set_text (GTK_ENTRY(lookup_widget(widget,"mark_me_as")), _("Busy"));
				break;
			case STATUS_FREE:
				gtk_entry_set_text (GTK_ENTRY(lookup_widget(widget,"mark_me_as")), _("Free"));
				break;
			case STATUS_TENTATIVE:
				gtk_entry_set_text (GTK_ENTRY(lookup_widget(widget,"mark_me_as")), _("Tentative"));
				break;
			case STATUS_OUT_OF_OFFICE:
				gtk_entry_set_text (GTK_ENTRY(lookup_widget(widget,"mark_me_as")), _("Out of Office"));
				break;
		}
	}

	if (cur_event->flags & EVENT_INVITE_RECIP)
	{
		tba (widget, "send_invitations");
	} else {
		tbn (widget, "send_invitations");
	}

	if (cur_event->flags & EVENT_RECUR)
        {
                tba (widget, "recur_event");
        } else {
                tbn (widget, "recur_event");
        }

	if (cur_event->flags & EVENT_ALL_DAY)
	{
		tba (widget, "all_day_event");
	} else {
		tbn (widget, "all_day_event");
	}


	/* Now, force the title bar update!! */
	new_event_subject_changed( lookup_widget( widget, "subject" ), NULL ) ;

	/* Now, show the populated widget along with the updated title bar! */
	gtk_widget_show (widget);
}

void canceled_event (GtkWidget *widget, CalendarEvent *event) {
	gtk_widget_destroy (lookup_widget (widget, "yesno"));

	event_store_delete (event);
	event_destroy (event);
	if (calendar_window) {
		calendar_update_all_uis ();		
		calendar_rehash ();
		calendar_clear_event ();        
	}
	calendar_save ();
	calendar_event_loop ();
}

void calendar_event_delete_accept (GtkWidget *widget, CalendarEvent *event) {
	event_store_delete (event);
	event_destroy (event);
	calendar_update_all_uis ();		

	calendar_rehash ();
	cur_event=NULL;
	calendar_save ();
	calendar_clear_event ();	
	gtk_widget_destroy (lw (widget, "yesno"));
	calendar_event_loop();
}



void 
calendar_event_delete (GtkWidget *widget, gpointer data) {
	if (cur_event) {	
		event_store_delete (cur_event);
		event_destroy (cur_event);
		calendar_update_all_uis ();		

		calendar_rehash ();
		cur_event=NULL;
	}
	calendar_save ();
	calendar_clear_event ();

  return ;
}

void calendar_category_accept (GtkWidget *widget, gpointer data) {
	GtkWidget *parent=(GtkWidget *)data;
	GtkTree *tree=GTK_TREE (lookup_widget (widget, "master_category_tree"));
	GtkWidget *scratch;
	GtkBoxChild *child;
	GList *seek, *cats=NULL;
	char *tmpc;
	int len;
	for (seek=tree->children;seek;seek=seek->next) {
		scratch=(GtkWidget *)seek->data;
		if (!scratch) break;
		scratch=GTK_BIN (scratch)->child;
		if (!scratch) break;
		child=GTK_BOX (scratch)->children->data;
		if (!child) break;
		if (GTK_TOGGLE_BUTTON (GTK_WIDGET (child->widget))->active) {
			child=GTK_BOX (scratch)->children->next->data;
			tmpc=(char *)calloc (1024, sizeof (char));
			gtk_label_get (GTK_LABEL (child->widget), &tmpc);
			cats=g_list_append (cats, tmpc);
		}
	}
	len=0;
	for (seek=cats;seek;seek=seek->next) {
		len+=strlen ((char *)seek->data)+2;
	}
	len+=5;
	tmpc=(char *)calloc (len, sizeof (char));
	
	for (seek=cats;seek;seek=seek->next) {
		if (seek->prev)
			sprintf (tmpc, "%s; %s", tmpc, (char *)seek->data);
		else
			sprintf (tmpc, "%s", (char *)seek->data);
	}
	if (cats) g_list_free (cats);	
	if (tmpc) gtk_entry_set_text (GTK_ENTRY (lookup_widget (parent, "entry9")), tmpc);
	if (tmpc) free (tmpc);
	gtk_widget_destroy (lookup_widget (widget, "master_category"));
}
 
void calendar_category_cancel (GtkWidget *widget, gpointer data) {
	gtk_widget_destroy (lookup_widget (widget, "master_category"));
}

static char *clist_names[8]={"sunday_clist", "monday_clist", "tuesday_clist", 
                             "wednesday_clist", "thursday_clist", "friday_clist", 
			     "saturday_clist", NULL };

														
void calendar_weekly_populate (EventTime *time) {
	GtkCList *clist;
	int day;
	char *tmp=event_date_to_char (time);
	time_t t=event_time_to_time_t (time);
	struct tm *t2=localtime (&t);
	t-=(t2->tm_wday+1) * 24 * 60 * 60;
	time=time_t_to_event_time (t);
	event_time_dump (time);
	tmp=event_date_to_char (time);
	g_return_if_fail (time!=NULL);

	gtk_label_set_text (GTK_LABEL (lw (calendar_window, "label118")), tmp);

	for (day=0;day<7;day++) {
		CalendarEvent *event;
		char *cl_data[1];
		Llist *seek;
		int row;
		clist=GTK_CLIST (lw (calendar_window, clist_names[day]));
		gtk_clist_set_compare_func (clist, (GtkCListCompareFunc)calendar_week_custom_sorter);
		gtk_clist_freeze (clist);
		gtk_clist_clear (clist);
		time->date++;

		for (seek=event_first();seek;seek=seek->next) {	
			event=seek->data;
			if (event->start->month==time->month &&
			    event->start->year==time->year &&
					event->start->date==time->date) {
				cl_data[0]=event->subject;
				row=gtk_clist_append (clist, cl_data);
				gtk_clist_set_row_data (clist, row, (gpointer)event);