calender-callbacks.c

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

			}
		}
		gtk_clist_sort (clist);
		gtk_clist_thaw (clist);
	}
}

static char *clist2_names[7]={NULL, "monday_clist1", "tuesday_clist1", 
                             "wednesday_clist1", "thursday_clist1", "friday_clist1", NULL };

void calendar_workweekly_populate (EventTime *time) {
	GtkCList *clist;
	int day;
	time_t t=event_time_to_time_t (time);
	struct tm *t2=localtime (&t);
	event_time_dump (time);
	t-=(t2->tm_wday-1) * 24 * 60 * 60;	
	time=time_t_to_event_time (t);
	event_time_dump (time);
	for (day=1;day<6;day++) {
		CalendarEvent *event;
		char *cl_data[1];
		Llist *seek;
		int row;
		clist=GTK_CLIST (lw (calendar_window, clist2_names[day]));
		gtk_clist_set_compare_func (clist, (GtkCListCompareFunc)calendar_week_custom_sorter);
		gtk_clist_freeze (clist);
		gtk_clist_clear (clist);
		
		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);
			}
		}
		gtk_clist_sort (clist);
		gtk_clist_thaw (clist);
		time->date++;
	}
}

void calendar_weekcal_day_selected (GtkCalendar *cal) {
	EventTime time;
	memset (&time, 0, sizeof (EventTime));
	time.year=cal->year;
	time.month=cal->month;
	time.date=cal->selected_day;
	calendar_weekly_populate (&time);
}

void calendar_workweekcal_day_selected (GtkCalendar *cal) {
	EventTime time;
	memset (&time, 0, sizeof (EventTime));
	time.year=cal->year;
	time.month=cal->month;
	time.date=cal->selected_day;
	calendar_workweekly_populate (&time);
}

void calendar_weekly_event_selected (GtkCList *clist, gint row, gint column, GdkEventButton *event, gpointer data) {
	CalendarEvent *cevent=gtk_clist_get_row_data (clist, row);
	cur_event=cevent;
	calendar_display_event (cevent);
}

void calendar_monthly_changed (GtkEditable *editable, gpointer data) {
	char *month=gtk_entry_get_text (GTK_ENTRY (editable));
	int mon=month_string_to_int (month);
	gtk_tcal_set (GTK_TCAL (lw (GTK_WIDGET (editable), "monthly")), 
	              gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (
								   lw (GTK_WIDGET (editable), "monthly_year"))), mon);
}

void calendar_monthly_year_changed (GtkEditable *spin, gpointer data) {
	char *month=gtk_entry_get_text (GTK_ENTRY (lw (GTK_WIDGET (spin), "monthly_month")));
	int mon=month_string_to_int (month);
	int year=gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
	gtk_tcal_set (GTK_TCAL (lw (GTK_WIDGET (spin), "monthly")), 
	              year, mon);
}

void calendar_yearly_year_changed (GtkEditable *spin, gpointer data) {
	int year=gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
	gtk_tcal_set (GTK_TCAL (lw (GTK_WIDGET (spin), "yearly")), 
	              year, -1);
}

void calendar_yearly_event_selected (GtkTCal *tcal, CalendarEvent *event) {
	if (event) {
		calendar_display_event (event);
	}
}

GtkWidget *todo_child=NULL;

void calendar_todo_rehash () {	
	GtkTree *tree=GTK_TREE (lw (calendar_window, "todo_tree"));
	GList *seek;
	gtk_tree_clear_items (tree, 0, g_list_length (tree->children));
	for (seek=todo_first ();seek;seek=seek->next) {
		Todo *todo=seek->data;
		todo->treeitem=calendar_todo_add (tree, todo->text, todo->due, todo->complete);
	}
}

void calendar_todo_activated (GtkEntry *entry) {
	char *text=gtk_entry_get_text (entry);
	char *due=gtk_entry_get_text (GTK_ENTRY (lw (calendar_window, "todo_due")));
	GtkWidget *widget=calendar_todo_add (GTK_TREE (lw (calendar_window, "todo_tree")), text, due, FALSE);
	Todo *todo=todo_new ();
	todo->text=strdup (text);
	todo->due=strdup (due);
	todo->treeitem=widget;
	gtk_entry_set_text (entry, "");
	gtk_entry_set_text (GTK_ENTRY (lw (calendar_window, "todo_due")), "");
}

void calendar_todo_activated2 (GtkEntry *entry) {
        char *text=gtk_entry_get_text (GTK_ENTRY (lw (calendar_window, "todo_entry")));
        char *due=gtk_entry_get_text (GTK_ENTRY (lw (calendar_window, "todo_due")));
        GtkWidget *widget=calendar_todo_add (GTK_TREE (lw (calendar_window, "todo_tree")), text, due, FALSE);
        Todo *todo=todo_new ();
        todo->text=strdup (text);
        todo->due=strdup (due);
        todo->treeitem=widget;
        gtk_entry_set_text (entry, "");
        gtk_entry_set_text (GTK_ENTRY (lw (calendar_window, "todo_due")), "");
}

void calendar_todo_changed (GtkEditable *editable) {
	GtkWidget *widget=GTK_WIDGET (editable);
	char *text=gtk_entry_get_text (GTK_ENTRY (editable));
	widget=widget->parent->parent; 
	if (GTK_IS_TREE_ITEM (widget)) {
		Todo *todo=todo_find_from_tree (widget);
		if (todo) {
			if (todo->text) free (todo->text);
			todo->text=strdup (text);
		}
	}
}

void calendar_todo_due_changed (GtkEditable *editable) {
	GtkWidget *widget=GTK_WIDGET (editable);
	char *text=gtk_entry_get_text (GTK_ENTRY (editable));
	widget=widget->parent->parent->parent; 
	if (GTK_IS_TREE_ITEM (widget)) {
		Todo *todo=todo_find_from_tree (widget);
		if (todo) {
			if (todo->due) free (todo->due);
			todo->due=strdup (text);
		}
	}
}

void calendar_todo_delete (GtkWidget *widget, gpointer data) {
	Todo *todo=data;

	todo_delete (todo);
	calendar_todo_rehash();
	todo_child=NULL;
}

void calendar_todo_select (GtkWidget *widget, gpointer data) {
	GtkWidget *window = lookup_widget (widget, "main_calendar");
	create_calendar (3, window);
}

void calendar_todo_child_selected (GtkTree *tree, GtkWidget *child) {
	todo_child=child;
	gtk_tree_unselect_child (tree, child);
}

void calendar_todo_completion_toggled (GtkToggleButton *toggle, GtkTree *tree) {
	GtkWidget *widget=GTK_WIDGET (toggle);
	GtkBox *hbox=GTK_BOX (widget->parent);
	
	GtkBoxChild *child=hbox->children->next->data;
	GtkWidget *entry=child->widget;
	GtkWidget *combo;
	GtkWidget *treeitem=GTK_WIDGET (hbox)->parent;
	Todo *todo=todo_find_from_tree (treeitem);
	child=hbox->children->data;
	toggle=GTK_TOGGLE_BUTTON (child->widget);
	child=hbox->children->next->next->data;
	combo=child->widget;
	if (toggle->active) {
		todo->complete=TRUE;
		gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE);
		gtk_widget_set_sensitive (combo, FALSE);
	} else {
		todo->complete=FALSE;
		gtk_widget_set_sensitive (GTK_WIDGET (entry), TRUE);
		gtk_widget_set_sensitive (combo, TRUE);
	}
}

void calendar_switch_page (GtkNotebook *notebook, GtkNotebookPage *page,
                           guint page_num) {

  /* Force an update, just in case */
  calendar_update_all_uis() ;

  switch (page_num)
    {
    case 0:
      current_view=CALENDAR_VIEW_TODO;
      break;

    case 1:  
      current_view=CALENDAR_VIEW_DAILY;
      break;

    case 2:
      current_view=CALENDAR_VIEW_WORK;
      break;

    case 3:
      current_view=CALENDAR_VIEW_WEEK;
      break;

    case 4:
      current_view=CALENDAR_VIEW_MONTH;
      break;

    case 5: 
      current_view=CALENDAR_VIEW_YEAR;
      break;

    }
					
  /*	if (page_num == 1) 
		current_view=CALENDAR_VIEW_DAILY;
	
	if (page_num == 2) 

		current_view=CALENDAR_VIEW_WORK;

	if (page_num == 3) 
		current_view=CALENDAR_VIEW_WEEK;
	 Function has been deprecated due to fix supplied by George Mason for
	 * tcal redraw problem.  Thanks George!
	 */
  if (page_num==1) {
#if 0
    GtkWidget *daily=lw (calendar_window, "schedule");
    GdkRectangle rect;
    if (!daily)
      return;
    rect.height=SCHEDULE (daily)->height;
    rect.width=SCHEDULE (daily)->width;
    rect.x=0;
    rect.y=0;
    schedule_paint (daily, &rect);
#endif
  }
  if (page_num==4) {
    GtkWidget *monthly=lw (calendar_window, "monthly");
    if (!monthly)
      return;
    gtk_tcal_paint (monthly, NULL);
  }
  if (page_num==5) {
    GtkWidget *yearly=lw (calendar_window, "yearly");
    if (!yearly)
      return;
    gtk_tcal_paint (yearly, NULL);
  }
}



void calendar_update_all_uis () {
	if (!calendar_window)
		return;
	event_store_updated ();

	calendar_daycal_day_selected (GTK_CALENDAR (lw (calendar_window, "daily_calendar")));
	calendar_weekcal_day_selected (GTK_CALENDAR (lw (calendar_window, "weekly_calendar")));
	calendar_workweekcal_day_selected (GTK_CALENDAR (lw (calendar_window, "calendar2")));
	calendar_daycal_month_changed (GTK_CALENDAR (lw (calendar_window, "daily_calendar")));	
	return ;
}

void mail_todo_callback (GtkWidget *widget, gpointer userdata)
{
	Todo *todo = userdata;
	char *subject_line;
	GtkWidget *window = make_new_message_window (NULL, NULL);
	GtkWidget *subject = lookup_widget (window, "subject_entry");
	GtkWidget *body = lookup_widget (window, "body_textbox");

	subject_line = (char *)calloc (strlen (todo->due) + 7, sizeof (char));
	sprintf (subject_line, "TODO: %s", todo->due);

	gtk_entry_set_text (GTK_ENTRY (subject), subject_line);
	gtk_text_insert (GTK_TEXT (body), NULL, NULL, NULL, todo->text, -1);

	if (subject_line) free (subject_line);
}

GtkWidget *todo_popup ()
{
	GtkWidget *menu;
	GtkWidget *title, *sep, *mail, *delete;

	menu = gtk_menu_new();
	gtk_object_set_data (GTK_OBJECT (menu), "menu", menu);

	title= gtk_menu_item_new_with_label ("Todo Actions");
        gtk_widget_ref (title);
        gtk_object_set_data_full (GTK_OBJECT (menu), "title", title,
                                        (GtkDestroyNotify) gtk_widget_unref);
	gtk_widget_show(title);
        gtk_container_add (GTK_CONTAINER (menu), title);

	sep = gtk_menu_item_new();
	gtk_widget_show(sep);
	gtk_container_add (GTK_CONTAINER (menu), sep);

	mail = gtk_menu_item_new_with_label ("Mail Item");
	gtk_widget_ref (mail);
	gtk_object_set_data_full (GTK_OBJECT (menu), "mail", mail,
					(GtkDestroyNotify) gtk_widget_unref);
	gtk_container_add (GTK_CONTAINER (menu), mail);
	gtk_widget_show(mail);

        delete = gtk_menu_item_new_with_label ("Delete Item");
        gtk_widget_ref (delete);
        gtk_object_set_data_full (GTK_OBJECT (menu), "delete", delete,
                                        (GtkDestroyNotify) gtk_widget_unref);
        gtk_container_add (GTK_CONTAINER (menu), delete);
        gtk_widget_show(delete);

	return menu;
}

void todo_button_press_event (GtkWidget *widget, GdkEventButton *event, gpointer userdata)
{
	Todo *todo = todo_find_from_tree (widget);
	GtkWidget *menu = todo_popup();

        gtk_signal_connect (GTK_OBJECT (lookup_widget (menu,"mail")),
		"activate", GTK_SIGNAL_FUNC (mail_todo_callback), todo);
        gtk_signal_connect (GTK_OBJECT (lookup_widget (menu,"delete")),
		"activate", GTK_SIGNAL_FUNC (calendar_todo_delete), todo);

	if (event->button == 3)
		gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 1, 0);
}



/*
 * Warning, this function is directly accessing some GTK
 * attributes.  This may break in future releases of GTK.
 * On the other hand, there isn't a way to otherwise do this
 * because GTK, being lame, doesn't properly expose an interface
 * to common sense attributes.
 */
void
new_event_subject_changed( GtkWidget *widget, gpointer data )
{
  GtkWidget *window ;
  char *text ;
  char *newText ;
  char *subject ;
  int length ;
  char compText[] = ": " ;


  window = lookup_widget (widget, "event_editor" ) ;
  text = gtk_entry_get_text (GTK_ENTRY (widget));

  if ( (text) && (length = strlen( text )) )
    {
      subject = GTK_WINDOW(window) -> title ;
      length = strlen( subject ) + strlen( compText ) + strlen( text ) ;
      subject = strstr( GTK_WINDOW(window) -> title, compText ) ;
      if( subject ) *subject = (char)0x00 ;
      subject = GTK_WINDOW(window) -> title ;
      newText = (char *)calloc( length+10, sizeof (char) ) ;
      sprintf( newText, "%s%s%s", subject, compText, text ) ;
      gtk_window_set_title (GTK_WINDOW (window), newText);
      free( newText ) ;
    }
  else
    {
      text = strstr( GTK_WINDOW(window) -> title, compText ) ;
      if( text )
	{
	  *text = (char)0x00 ;
	  newText = strdup( GTK_WINDOW(window) -> title ) ;
	  gtk_window_set_title (GTK_WINDOW (window), newText ) ;
	  free( newText ) ;
	}
    }

  return ;
}