自学教程：C++ GTK_CALENDAR函数代码示例

/*** store the calendar date to GDate, update our gtkentry*/static void gtk_dateentry_calendar_getfrom(GtkWidget * calendar, GtkDateEntry * dateentry){guint year, month, day;	DB( g_print(" (dateentry) get from calendar/n") );	gtk_calendar_get_date (GTK_CALENDAR (dateentry->calendar), &year, &month, &day);	g_date_set_dmy (dateentry->date, day, month + 1, year);	gtk_dateentry_datetoentry(dateentry);}

static voidupdate_calendar (TpawCalendarButton *self){  if (self->priv->calendar == NULL)    return;  gtk_calendar_clear_marks (GTK_CALENDAR (self->priv->calendar));  if (self->priv->date == NULL)    return;  gtk_calendar_select_day (GTK_CALENDAR (self->priv->calendar),      g_date_get_day (self->priv->date));  gtk_calendar_select_month (GTK_CALENDAR (self->priv->calendar),      g_date_get_month (self->priv->date) - 1,      g_date_get_year (self->priv->date));  gtk_calendar_mark_day (GTK_CALENDAR (self->priv->calendar),      g_date_get_day (self->priv->date));}

voidseahorse_gpgme_expires_new (SeahorseGpgmeSubkey *subkey, GtkWindow *parent){	SeahorseWidget *swidget;	GtkWidget *date, *expire;	gulong expires;	gchar *title;	const gchar *label;		g_return_if_fail (subkey != NULL && SEAHORSE_IS_GPGME_SUBKEY (subkey));	swidget = seahorse_widget_new_allow_multiple ("expires", parent);	g_return_if_fail (swidget != NULL);	g_object_set_data_full (G_OBJECT (swidget), "subkey", 	                        g_object_ref (subkey), g_object_unref);		date = GTK_WIDGET (seahorse_widget_get_widget (swidget, "calendar"));	g_return_if_fail (date != NULL);	expire = GTK_WIDGET (seahorse_widget_get_widget (swidget, "expire"));	expires = seahorse_pgp_subkey_get_expires (SEAHORSE_PGP_SUBKEY (subkey)); 	if (!expires) {		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expire), TRUE);		gtk_widget_set_sensitive (date, FALSE);	} else {		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expire), FALSE);		gtk_widget_set_sensitive (date, TRUE);	}    	if (expires) {		struct tm t;		time_t time = (time_t)expires;		if (gmtime_r (&time, &t)) {			gtk_calendar_select_month (GTK_CALENDAR (date), t.tm_mon, t.tm_year + 1900);			gtk_calendar_select_day (GTK_CALENDAR (date), t.tm_mday);		}	}		label = seahorse_pgp_subkey_get_description (SEAHORSE_PGP_SUBKEY (subkey));	title = g_strdup_printf (_("Expiry: %s"), label);	gtk_window_set_title (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)), title);	g_free (title);}

static	voidGetCalendar(	GtkWidget			*widget,	_Calendar			*data){ENTER_FUNC;	gtk_calendar_get_date(GTK_CALENDAR(widget), 		&(data->year),&(data->month),&(data->day));LEAVE_FUNC;}

void on_calendar1_day_selected( GtkWidget *widget, struct _properties *properties ){  g_print("on_calendar1_day_selected()/n");  guint day, month, year;  gtk_calendar_get_date (GTK_CALENDAR(properties->GtkInfo.calendar1), &year, &month, &day);  int daysaway = date_to_days_away(day,month+1,year-2000);  g_print("daysaway = %d, day = %d, month = %d, year = %d/n", daysaway, day, month, year);  if(daysaway < 0)  {    properties->data.t[properties->calendarSelected] = 0;    gtk_label_set_text(GTK_LABEL(properties->GtkInfo.labelCalendar),"Please select date greater than current");  } else  {    time(&properties->starttime);    int dummy;    int hour;    int minute;    int seconds;    switch(properties->calendarSelected)    {    case 0:      decimal_date_to_real_dates(properties->data.t[properties->calendarSelected] - properties->data.te, &dummy, &dummy, &dummy, &hour, &minute, &seconds);      break;    case 1:      decimal_date_to_real_dates(properties->data.t[properties->calendarSelected] - properties->data.te2, &dummy, &dummy, &dummy, &hour, &minute, &seconds);      break;    case 2:      decimal_date_to_real_dates(properties->data.t[properties->calendarSelected] - properties->data.te3, &dummy, &dummy, &dummy, &hour, &minute, &seconds);      break;    default:      g_print("on_calendar1_day_selected(): Bad calendarSelected switch/n");      break;    }    properties->data.t[properties->calendarSelected] = adjust_to_current_time_forward( (double) --daysaway / (double) 365, 0.0 );    double k = (double) (                 ( (double)(hour)*(double)60*(double)60) +                 (double)(minute*60) + (double)seconds);    properties->data.t[properties->calendarSelected] += (double) ( (k) /(double)86400)/(double)365;    gtk_label_set_text(GTK_LABEL(properties->GtkInfo.labelCalendar),"");  }}

void selecionadata(GtkWidget *widget,gpointer *entry){gint ano,mes,dia;char data[11];gtk_calendar_get_date(GTK_CALENDAR(calendar),&ano,&mes,&dia);mes ++;//g_print("%d/%d/%d",dia,mes,ano);//gtk_entry_set_textsprintf(data,"%d/%d/%d",dia,mes,ano);gtk_entry_set_text(GTK_ENTRY(entry),data);}

static voidday_selected(GtkWidget *cal, calendar_data *cdata) {	/* don't close it when the day change was caused by a month change! */	if (!cdata->closehack) {		guint *date = cdata->date;		gtk_calendar_get_date(GTK_CALENDAR(cal), &date[0], &date[1], &date[2]);		date[1]++; /* month was zero-based. */		gtk_widget_destroy(cdata->win);	}	cdata->closehack = FALSE;}

/* Defrosts a calendar; all the changes made since * the last gtk_calendar_freeze() are displayed. */intclip_GTK_CALENDARTHAW(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   CHECKCWID(ccal, GTK_IS_CALENDAR);   gtk_calendar_thaw(GTK_CALENDAR(ccal->widget));   return 0; err:   return 1;}

void calendar_day_selected_double_click( GtkWidget    *widget,                                         CalendarData *data ){  struct tm tm;  char buffer[256] = "day_selected_double_click: ";  calendar_date_to_string (data, buffer+27, 256-27);  calendar_set_signal_strings (buffer, data);  memset (&tm, 0, sizeof (tm));  gtk_calendar_get_date (GTK_CALENDAR(data->window),			 &tm.tm_year, &tm.tm_mon, &tm.tm_mday);  tm.tm_year -= TM_YEAR_BASE;  if(GTK_CALENDAR(data->window)->marked_date[tm.tm_mday-1] == 0) {    gtk_calendar_mark_day(GTK_CALENDAR(data->window),tm.tm_mday);  } else {     gtk_calendar_unmark_day(GTK_CALENDAR(data->window),tm.tm_mday);  }}

int main(int argc, char** argv){    GtkWidget *window;    GtkWidget *calendar;    gtk_init(&argc, &argv);    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);    g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);    calendar = gtk_calendar_new();    gtk_calendar_display_options(GTK_CALENDAR(calendar), GTK_CALENDAR_SHOW_HEADING|GTK_CALENDAR_SHOW_DAY_NAMES|	    GTK_CALENDAR_SHOW_WEEK_NUMBERS|GTK_CALENDAR_WEEK_START_MONDAY);    gtk_calendar_select_month(GTK_CALENDAR(calendar),8,1985);    gtk_calendar_select_day(GTK_CALENDAR(calendar),8);    gtk_container_add(GTK_CONTAINER(window), calendar);    gtk_widget_show_all(window);    gtk_main();}

intclip_GTK_CALENDARCLEARMARKS(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   CHECKCWID(ccal, GTK_IS_CALENDAR);   gtk_calendar_clear_marks(GTK_CALENDAR(ccal->widget));   return 0; err:   return 1;}

static GtkWidget* create_simple_calendar_item(GtkWidget** calendar_out){    GtkWidget* menu_item = gtk_menu_item_new();    GtkWidget* calendar = *calendar_out = gtk_calendar_new();    gtk_calendar_set_display_options(GTK_CALENDAR(calendar),                                     GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_NO_MONTH_CHANGE |                                     GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_DETAILS);    gtk_widget_set_sensitive(menu_item, FALSE);    gtk_container_add(GTK_CONTAINER(menu_item), calendar);    return menu_item;}

/** * a_dialog_get_date: * * Returns: a date as a string - always in ISO8601 format (YYYY-MM-DD) *  This string can be NULL (especially when the dialog is cancelled) *  Free the string after use */gchar *a_dialog_get_date ( GtkWindow *parent, const gchar *title ){  GtkWidget *dialog = gtk_dialog_new_with_buttons ( title,                                                    parent,                                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,                                                    GTK_STOCK_CANCEL,                                                    GTK_RESPONSE_REJECT,                                                    GTK_STOCK_OK,                                                    GTK_RESPONSE_ACCEPT,                                                    NULL);  GtkWidget *cal = gtk_calendar_new ();  GtkWidget *today = gtk_button_new_with_label ( _("Today") );  static guint year = 0;  static guint month = 0;  static guint day = 0;  if ( year != 0 ) {    // restore the last selected date    gtk_calendar_select_month ( GTK_CALENDAR(cal), month, year );    gtk_calendar_select_day ( GTK_CALENDAR(cal), day );  }  gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), today, FALSE, FALSE, 0);  gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), cal, FALSE, FALSE, 0);  g_signal_connect_swapped ( G_OBJECT(today), "clicked", G_CALLBACK(today_clicked), cal );  gtk_widget_show_all ( dialog );  gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );  gchar *date_str = NULL;  if ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT )  {    gtk_calendar_get_date ( GTK_CALENDAR(cal), &year, &month, &day );    date_str = g_strdup_printf ( "%d-%02d-%02d", year, month+1, day );  }  gtk_widget_destroy ( dialog );  return date_str;}

void calendar_set_flags( CalendarData *calendar ){  gint i;  gint options=0;  for (i=0;i<5;i++)     if (calendar->settings[i])      {	options=options + (1<<i);      }  if (calendar->window)    gtk_calendar_display_options (GTK_CALENDAR (calendar->window), options);}

static gboolean on_visibility_notify(GtkWidget* widget,                                     GdkEvent* event,                                     gpointer data){    GDateTime* datetime = g_date_time_new_now_local();    if(!datetime)    {        gtk_menu_item_set_label(GTK_MENU_ITEM(greeter.ui.clock.date_widget), "[date]");        g_signal_handler_disconnect(greeter.ui.clock.date_widget, visibility_notify_id);        return TRUE;    }    gchar* str = g_date_time_format(datetime, config.clock.date_format);    gtk_menu_item_set_label(GTK_MENU_ITEM(greeter.ui.clock.date_widget), str);    gtk_calendar_select_month(GTK_CALENDAR(greeter.ui.clock.calendar_widget),                              g_date_time_get_month(datetime) - 1,                              g_date_time_get_year(datetime));    gtk_calendar_select_day(GTK_CALENDAR(greeter.ui.clock.calendar_widget), g_date_time_get_day_of_month(datetime));    g_free(str);    g_date_time_unref(datetime);    return TRUE;}

intclip_GTK_CALENDARGETDISPLAYOPTIONS(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   CHECKCWID(ccal, GTK_IS_CALENDAR);   _clip_retni(ClipMachineMemory, gtk_calendar_get_display_options(GTK_CALENDAR(ccal->widget)));   return 0; err:   return 1;}

static voidcalendar_set_flags (CalendarData *calendar){  gint options = 0, i;  for (i = 0; i < G_N_ELEMENTS (calendar->settings); i++)    if (calendar->settings[i])      options=options + (1 << i);  if (calendar->window)    gtk_calendar_set_display_options (GTK_CALENDAR (calendar->window), options);}

/** * update the calendar of the scheduled transactions * * /param * * /return FALSE * */gboolean gsb_calendar_update ( void ){    time_t temps;    GSList *tmp_list;    gint calendar_month;	gint calendar_year;    gtk_calendar_clear_marks ( GTK_CALENDAR ( scheduled_calendar ));    /* select the current day */    time ( &temps );    if ( ( localtime ( &temps ) -> tm_mon == GTK_CALENDAR ( scheduled_calendar ) -> month )	 &&	 ( ( localtime ( &temps ) -> tm_year + 1900 ) == GTK_CALENDAR ( scheduled_calendar ) -> year ) )	gtk_calendar_select_day ( GTK_CALENDAR ( scheduled_calendar ),				  localtime ( &temps ) -> tm_mday );    else	gtk_calendar_select_day ( GTK_CALENDAR ( scheduled_calendar ),				  FALSE );    calendar_month = GTK_CALENDAR ( scheduled_calendar ) -> month + 1;	calendar_year = GTK_CALENDAR ( scheduled_calendar ) -> year + 25;    /* check the scheduled transactions and bold them in the calendar */    tmp_list = gsb_data_scheduled_get_scheduled_list ();    while ( tmp_list )    {	GDate *tmp_date;	gint scheduled_number;	scheduled_number = gsb_data_scheduled_get_scheduled_number (tmp_list -> data);	tmp_date = gsb_date_copy (gsb_data_scheduled_get_date (scheduled_number));	while (tmp_date && g_date_get_month (tmp_date) == calendar_month && g_date_get_year (tmp_date) < calendar_year)	{	    GDate *new_date;	    gtk_calendar_mark_day ( GTK_CALENDAR ( scheduled_calendar ),				    g_date_get_day (tmp_date));	    new_date = gsb_scheduler_get_next_date (scheduled_number, tmp_date);	    g_free (tmp_date);	    tmp_date = new_date;	}	tmp_list = tmp_list -> next;    }    return FALSE;}

static voidon_calendar_entry_activated(GtkWidget *widget, GtkWidget *calendar){    GDate *date;    const gchar *text;    date = g_date_new();    text = gtk_entry_get_text(GTK_ENTRY(widget));    g_date_set_parse(date, text);    if (g_date_valid(date)) {	gtk_calendar_freeze(GTK_CALENDAR(calendar));	gtk_calendar_select_month(GTK_CALENDAR(calendar),				  g_date_get_month(date) - 1,				  g_date_get_year(date));	gtk_calendar_select_day(GTK_CALENDAR(calendar),				g_date_get_day(date));	gtk_calendar_thaw(GTK_CALENDAR(calendar));    }    g_date_free(date);}

void calendar_date_to_string( CalendarData *data,			      char         *buffer,			      gint          buff_len ){  struct tm tm;  time_t time;  memset (&tm, 0, sizeof (tm));  gtk_calendar_get_date (GTK_CALENDAR(data->window),			 &tm.tm_year, &tm.tm_mon, &tm.tm_mday);  tm.tm_year -= TM_YEAR_BASE;  time = mktime(&tm);  strftime (buffer, buff_len-1, "%x", gmtime(&time));}

void on_buttonCalendar_clicked( GtkWidget *widget, struct _properties *properties ){  g_print ("on_buttonCalendar_clicked():/n");  gtk_window_set_title(GTK_WINDOW(properties->GtkInfo.dialogCalendar), "Select Date for Expr");  gtk_window_set_icon(GTK_WINDOW(properties->GtkInfo.dialogCalendar), create_pixbuf("images/2.png"));  int year;  int month;  int day;  int hour;  int minute;  int seconds;  properties->calendarSelected = 0;  decimal_date_to_real_dates(properties->data.t[properties->calendarSelected], &year, &month, &day, &hour, &minute, &seconds);  gtk_calendar_select_month(GTK_CALENDAR(properties->GtkInfo.calendar1), month, year);  gtk_calendar_select_day(GTK_CALENDAR(properties->GtkInfo.calendar1), day);  gtk_dialog_run(GTK_DIALOG(properties->GtkInfo.dialogCalendar));}

intclip_GTK_CALENDARGETDATE(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   guint     year, month, day;   CHECKCWID(ccal, GTK_IS_CALENDAR);   gtk_calendar_get_date(GTK_CALENDAR(ccal->widget), &year, &month, &day);   _clip_retdc(ClipMachineMemory, year, month + 1, day);   return 0; err:   return 1;}

intclip_GTK_CALENDARDISPLAYOPTIONS(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   GtkCalendarDisplayOptions flags = _clip_parni(ClipMachineMemory, 2);   CHECKCWID(ccal, GTK_IS_CALENDAR);   CHECKARG(2, NUMERIC_type_of_ClipVarType);   gtk_calendar_display_options(GTK_CALENDAR(ccal->widget), flags);   return 0; err:   return 1;}

static void gtk_dateentry_calendar_year(GtkWidget *calendar, GtkDateEntry *dateentry){guint year, month, day;	DB( g_print(" (dateentry) year changed/n") );	gtk_calendar_get_date (GTK_CALENDAR (dateentry->calendar), &year, &month, &day);	if( year < 1900)		g_object_set(calendar, "year", 1900, NULL);	if( year > 2200)		g_object_set(calendar, "year", 2200, NULL);	}

intclip_GTK_CALENDARUNMARKDAY(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   guint     day = _clip_parni(ClipMachineMemory, 2);   CHECKCWID(ccal, GTK_IS_CALENDAR);   CHECKOPT(2, NUMERIC_type_of_ClipVarType);   gtk_calendar_unmark_day(GTK_CALENDAR(ccal->widget), day);   return 0; err:   return 1;}

/** /brief Update Time controller widgets *  /param mod Pointer to the GtkSatModule widget */void tmg_update_widgets (GtkSatModule *mod){    struct tm tim;    time_t    t;    /* update time widgets */    t = (mod->tmgCdnum - 2440587.5)*86400.;    if (sat_cfg_get_bool (SAT_CFG_BOOL_USE_LOCAL_TIME)) {        tim = *localtime (&t);    }    else {        tim = *gmtime (&t);    }    /* hour */    gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgHour),                               tim.tm_hour);    /* min */    gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMin),                               tim.tm_min);    /* sec */    gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgSec),                               tim.tm_sec);    /* msec: alway 0 in RT and SRT modes */    gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMsec), 0);    /* calendar */    gtk_calendar_select_month (GTK_CALENDAR (mod->tmgCal),                               tim.tm_mon, tim.tm_year+1900);    gtk_calendar_select_day (GTK_CALENDAR (mod->tmgCal), tim.tm_mday);}

static voidgnc_date_edit_set_time_internal (GNCDateEdit *gde, time64 the_time){    char buffer [40];    struct tm *mytm = gnc_localtime (&the_time);    g_return_if_fail(mytm != NULL);    /* Update the date text. */    qof_print_date_dmy_buff(buffer, 40,                            mytm->tm_mday,                            mytm->tm_mon + 1,                            1900 + mytm->tm_year);    gtk_entry_set_text(GTK_ENTRY(gde->date_entry), buffer);    /* Update the calendar. */    if (!gde->in_selected_handler)    {	gtk_calendar_select_day(GTK_CALENDAR (gde->calendar), 1);	gtk_calendar_select_month(GTK_CALENDAR (gde->calendar),				  mytm->tm_mon, 1900 + mytm->tm_year);	gtk_calendar_select_day(GTK_CALENDAR (gde->calendar), mytm->tm_mday);    }    /* Set the time of day. */    if (gde->flags & GNC_DATE_EDIT_24_HR)        qof_strftime (buffer, sizeof (buffer), "%H:%M", mytm);    else        qof_strftime (buffer, sizeof (buffer), "%I:%M %p", mytm);    gtk_entry_set_text(GTK_ENTRY(gde->time_entry), buffer);    gnc_tm_free (mytm);    g_signal_emit (gde, date_edit_signals [DATE_CHANGED], 0);    g_signal_emit (gde, date_edit_signals [TIME_CHANGED], 0);}

static voidcalendar_date_to_string (CalendarData *data,			      char         *buffer,			      gint          buff_len){  GDate *date;  guint year, month, day;  gtk_calendar_get_date (GTK_CALENDAR(data->window),			 &year, &month, &day);  date = g_date_new_dmy (day, month + 1, year);  g_date_strftime (buffer, buff_len-1, "%x", date);  g_date_free (date);}

bool wxGtkCalendarCtrl::SetDate(const wxDateTime& date){    if ( date.IsValid() && !IsInValidRange(date) )        return false;    g_signal_handlers_block_by_func(m_widget,        (gpointer) gtk_day_selected_callback, this);    g_signal_handlers_block_by_func(m_widget,        (gpointer) gtk_month_changed_callback, this);    m_selectedDate = date;    int year = date.GetYear();    int month = date.GetMonth();    int day = date.GetDay();    gtk_calendar_select_month(GTK_CALENDAR(m_widget), month, year);    gtk_calendar_select_day(GTK_CALENDAR(m_widget), day);    g_signal_handlers_unblock_by_func( m_widget,        (gpointer) gtk_month_changed_callback, this);    g_signal_handlers_unblock_by_func( m_widget,        (gpointer) gtk_day_selected_callback, this);    return true;}

static voidcalendar_update_details (CalendarData *data){  guint year, month, day;  gchar *detail;  gtk_calendar_get_date (GTK_CALENDAR (data->calendar_widget), &year, &month, &day);  detail = calendar_get_detail (data, year, month, day);  g_signal_handler_block (data->details_buffer, data->details_changed);  gtk_text_buffer_set_text (data->details_buffer, detail ? detail : "", -1);  g_signal_handler_unblock (data->details_buffer, data->details_changed);  g_free (detail);}