/*
** 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 void
update_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));
}
void
seahorse_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 void
GetCalendar(
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_text
sprintf(data,"%d/%d/%d",dia,mes,ano);
gtk_entry_set_text(GTK_ENTRY(entry),data);
}
static void
day_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. */
int
clip_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();
}
int
clip_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;
}
int
clip_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 void
calendar_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 void
on_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));
}
int
clip_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;
}
int
clip_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);
}
int
clip_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 void
gnc_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 void
calendar_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 void
calendar_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);
}
