void
range_widget_get_bounds(GtkWidget *dialog, time_t *start, time_t *end)
{
guint year, month, day;
struct tm start_tm, end_tm;
memset(&start_tm, 0, sizeof(struct tm));
memset(&end_tm, 0, sizeof(struct tm));
gtk_calendar_get_date(GTK_CALENDAR(start_calendar), &year, &month, &day);
start_tm.tm_year = year - 1900;
start_tm.tm_mon = month;
start_tm.tm_mday = day;
start_tm.tm_hour = gtk_spin_button_get_value(GTK_SPIN_BUTTON(start_hours));
start_tm.tm_min = gtk_spin_button_get_value(GTK_SPIN_BUTTON(start_minutes));
start_tm.tm_sec = gtk_spin_button_get_value(GTK_SPIN_BUTTON(start_seconds));
gtk_calendar_get_date(GTK_CALENDAR(end_calendar), &year, &month, &day);
end_tm.tm_year = year - 1900;
end_tm.tm_mon = month;
end_tm.tm_mday = day;
end_tm.tm_hour = gtk_spin_button_get_value(GTK_SPIN_BUTTON(end_hours));
end_tm.tm_min = gtk_spin_button_get_value(GTK_SPIN_BUTTON(end_minutes));
end_tm.tm_sec = gtk_spin_button_get_value(GTK_SPIN_BUTTON(end_seconds));
*start = mktime(&start_tm);
*end = mktime(&end_tm);
}
static void
log_window_calendar_chats_day_selected_cb (GtkWidget *calendar,
EmpathyLogWindow *window)
{
guint year;
guint month;
guint day;
GDate *date;
gtk_calendar_get_date (GTK_CALENDAR (calendar), &year, &month, &day);
if (day == 0)
/* No date selected */
return;
/* We need this hear because it appears that the months start from 0 */
month++;
date = g_date_new_dmy (day, month, year);
DEBUG ("Currently selected date is: %04u-%02u-%02u", year, month, day);
log_window_chats_get_messages (window, date);
g_date_free (date);
}
void FormAccount_CalendarDateDaySelected(GtkCalendar* calendar, gpointer user_data)
{
FormAccount* fa = (gpointer) user_data;
GtkTreeModel* model;
GtkTreePath* path;
GtkTreeIter iter;
guint year;
guint month;
guint day;
gchar DateStr[100];
if (fa->CalendarDateOnSelectEnabled == FALSE)
{
return ;
}
gtk_calendar_get_date(calendar, &year, &month, &day);
++month;
if (FormAccount_GetCursor(fa, &model, &path, &iter) == FALSE)
{
return ;
}
g_sprintf(DateStr, "%04u-%02u-%02u 00:00:00", year, month, day);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_ID_DATE, DateStr, -1);
FormAccount_UpdateModifiedRecordState(fa, &model, &iter);
gtk_tree_path_free(path);
}
static void
log_window_chats_get_messages (EmpathyLogWindow *window,
const gchar *date_to_show)
{
TpAccount *account;
gchar *chat_id;
gboolean is_chatroom;
const gchar *date;
guint year_selected;
guint year;
guint month;
guint month_selected;
guint day;
if (!log_window_chats_get_selected (window, &account,
&chat_id, &is_chatroom)) {
return;
}
g_signal_handlers_block_by_func (window->calendar_chats,
log_window_calendar_chats_day_selected_cb,
window);
/* Either use the supplied date or get the last */
date = date_to_show;
if (!date) {
/* Get a list of dates and show them on the calendar */
tpl_log_manager_get_dates_async (window->log_manager,
account, chat_id,
is_chatroom,
log_manager_got_dates_cb, (gpointer) window);
/* signal unblocked at the end of the CB flow */
} else {
sscanf (date, "%4d%2d%2d", &year, &month, &day);
gtk_calendar_get_date (GTK_CALENDAR (window->calendar_chats),
&year_selected,
&month_selected,
NULL);
month_selected++;
if (year != year_selected && month != month_selected) {
day = 0;
}
gtk_calendar_select_day (GTK_CALENDAR (window->calendar_chats), day);
g_signal_handlers_unblock_by_func (window->calendar_chats,
log_window_calendar_chats_day_selected_cb,
window);
}
if (date) {
log_window_get_messages_for_date (window, date);
}
g_object_unref (account);
g_free (chat_id);
}
bool Calendar::runExternalViewer()
{
Config* config = Config::getInstance();
size_t len = config->external_viewer.length();
if (len > 0) {
int year, month, day;
gtk_calendar_get_date((GtkCalendar*)widget,
(guint*)&year, (guint*)&month, (guint*)&day);
struct tm date;
date.tm_year = year - 1900;
date.tm_mon = month;
date.tm_mday = day;
date.tm_sec = date.tm_min = date.tm_hour = date.tm_wday
= date.tm_yday = date.tm_isdst = 0;
size_t buf_size = len + 64;
char* cmd = new char[buf_size];
strftime(cmd, buf_size, config->external_viewer.c_str(), &date);
fork_and_run(cmd);
delete[] cmd;
return true;
} else {
return false;
}
}
static void
gcrd_day_selected (GtkWidget *popup_window, GncCellRendererDate *cell)
{
guint year;
guint month;
guint day;
time64 t;
gchar *str;
gtk_calendar_get_date (GTK_CALENDAR (cell->calendar),
&year,
&month,
&day);
t = gcrd_dmy2time ( day, month + 1, year);
cell->time = t;
str = gcrd_time2dmy_string (t);
gnc_popup_entry_set_text (
GNC_POPUP_ENTRY (GNC_CELL_RENDERER_POPUP (cell)->editable), str);
g_free (str);
}
static void dt_date_ok_callback(GtkWidget *button, cbdata *cbd)
{
GtkWidget *editwindow = cbd->editwindow;
GtkWidget *w;
guint y, m, d;
int sign;
char buffer[10];
time_t t = 0;
struct tm tm;
w = gtk_object_get_data(GTK_OBJECT(editwindow), "calendar");
if (w) {
gtk_calendar_get_date(GTK_CALENDAR(w), &y, &m, &d);
memset(&tm, 0, sizeof(struct tm));
tm.tm_year = y - 1900;
tm.tm_mon = m;
tm.tm_mday = d;
t = mktime(&tm);
t /= 24*60*60;
}
snprintf(buffer, sizeof(buffer), "%ld", t);
w = gtk_object_get_data(GTK_OBJECT(cbd->hbox), "inputbox");
gtk_entry_set_text(GTK_ENTRY(w), buffer);
gtk_widget_destroy(editwindow);
}
void Calendar::_change(int year_offset, int month_offset, int day_offset)
{
int year, month, day;
gtk_calendar_get_date((GtkCalendar*)widget,
(guint*)&year, (guint*)&month, (guint*)&day);
unsigned int n_days = _n_days(year, month);
day += day_offset;
if (day < 1) {
day += _n_days(year, month - 1);
month_offset--;
} else if (day > n_days) {
day -= n_days;
month_offset++;
}
month += month_offset;
if (month > 11) {
month = 0;
year_offset++;
} else if (month < 0) {
month = 11;
year_offset--;
}
year += year_offset;
gtk_calendar_select_month((GtkCalendar*)widget, (guint)month, (guint)year);
gtk_calendar_select_day((GtkCalendar*)widget, day);
}
/**
* Print the selected date on a calendar.
* @param calendar calendar to print information about
*/
void mk_print_GtkCalendar_info(GtkCalendar* calendar)
{
guint year;
guint month;
guint day;
gtk_calendar_get_date(calendar, &year, &month, &day);
g_printf("\t%d-%02d-%02d", year, month+1, day); // YYYY-MM-DD
}
void button_event(GtkWidget *widget, gpointer data)
{
guint year;
guint month;
guint day;
gtk_calendar_get_date(GTK_CALENDAR(calendar), &year, &month, &day);
g_print("Year: %d, Month: %d, Day: %d\n", year, month, day);
}
void
popcalendar_run(GtkWidget *parent, guint date[], int markfirstyear, guint32 marks[]) {
GtkWidget *win;
GtkWidget *frame, *box;
GtkWidget *cal;
calendar_data cdata_actual = {0}, *cdata = &cdata_actual;
win = gtk_window_new(GTK_WINDOW_POPUP);
cdata->win = win;
cdata->date = date;
cdata->marks = marks;
cdata->markfirstyear = markfirstyear;
gtk_window_set_transient_for(GTK_WINDOW(win), GTK_WINDOW(parent));
gtk_window_set_modal(GTK_WINDOW(win), TRUE);
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_MOUSE);
g_signal_connect(G_OBJECT(win), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
box = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(box), 5);
/*hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new("Select day:"),
FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_button_new_with_label("x"),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);*/
cal = gtk_calendar_new();
if (date[0] != 0) {
gtk_calendar_select_month(GTK_CALENDAR(cal), date[1]-1, date[0]);
gtk_calendar_select_day(GTK_CALENDAR(cal), date[2]);
} else {
gtk_calendar_get_date(GTK_CALENDAR(cal), &date[0], &date[1], &date[2]);
}
g_signal_connect(G_OBJECT(cal), "day-selected",
G_CALLBACK(day_selected), cdata);
g_signal_connect(G_OBJECT(cal), "month-changed",
G_CALLBACK(month_changed), cdata);
gtk_calendar_display_options(GTK_CALENDAR(cal),
GTK_CALENDAR_SHOW_HEADING |
GTK_CALENDAR_SHOW_DAY_NAMES);
popcalendar_set_marks(GTK_CALENDAR(cal),
marks[(date[0]-markfirstyear)*12 + date[1]-1]);
gtk_box_pack_start(GTK_BOX(box), cal, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), box);
gtk_container_add(GTK_CONTAINER(win), frame);
gtk_widget_show_all(frame);
gtk_widget_show(win);
gtk_main();
}
static void
GetCalendar(
GtkWidget *widget,
_Calendar *data)
{
ENTER_FUNC;
gtk_calendar_get_date(GTK_CALENDAR(widget),
&(data->year),&(data->month),&(data->day));
LEAVE_FUNC;
}
/*
** 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);
}
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);
}
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),"");
}
}
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;
}
static void
day_selected (GtkCalendar *calendar, GNCDateEdit *gde)
{
Timespec t;
guint year, month, day;
gde->in_selected_handler = TRUE;
gtk_calendar_get_date (calendar, &year, &month, &day);
/* GtkCalendar returns a 0-based month */
t = gnc_dmy2timespec (day, month + 1, year);
gnc_date_edit_set_time_ts (gde, t);
gde->in_selected_handler = FALSE;
}
bool Calendar::markToday()
{
guint year, month;
gtk_calendar_get_date((GtkCalendar*)widget, &year, &month, NULL);
if (year == today_year && month == today_month) {
gtk_calendar_mark_day((GtkCalendar*)widget, today_day);
return true;
} else {
gtk_calendar_unmark_day((GtkCalendar*)widget, today_day);
return false;
}
}
static void
month_changed(GtkWidget *cal, calendar_data *cdata) {
guint year, mon, day;
cdata->closehack = TRUE;
gtk_calendar_get_date(GTK_CALENDAR(cal), &year, &mon, &day);
if (year < cdata->markfirstyear)
popcalendar_set_marks(GTK_CALENDAR(cal), 0);
else
popcalendar_set_marks(GTK_CALENDAR(cal),
cdata->marks[(year-cdata->markfirstyear)*12 + mon]);
}
CAMLprim value ml_gtk_calendar_get_date (value w)
{
guint year, month, day;
value ret;
gtk_calendar_get_date (GtkCalendar_val(w), &year, &month, &day);
ret = alloc_small (3, 0);
Field(ret,0) = Val_int(year);
Field(ret,1) = Val_int(month);
Field(ret,2) = Val_int(day);
return ret;
}
static void lunar_calendar_day_selected(GtkCalendar *gcalendar)
{
guint year, month, day;
GError *error = NULL;
LunarCalendar *calendar;
gchar *holiday, *format, *strtime, *color;
calendar = LUNAR_CALENDAR(gcalendar);
if (getenv("LUNAR_CALENDAR_IGNORE_NON_CHINESE") != NULL)
{
const gchar* const * langs = g_get_language_names();
if (langs[0] && langs[0][0] != '\0')
if (!g_str_has_prefix(langs[0], "zh_")) {
g_object_set (gcalendar, "show-details", FALSE, NULL);
return;
}
}
gtk_calendar_get_date(gcalendar, &year, &month, &day);
lunar_date_set_solar_date(calendar->date, year, month + 1, day, 3, &error);
if (error != NULL) {
g_clear_error (&error);
return;
}
color = rgba_to_string(calendar->rgba);
holiday = lunar_date_get_holiday(calendar->date, "\n");
if (holiday != NULL) {
format = g_strdup_printf("%s\n%s\n%s\n%s\n<span color=\"%s\">%s</span>",
_("%(year)-%(month)-%(day)"),
_("%(YUE)yue%(RI)"),
_("%(Y60)nian%(M60)yue%(D60)ri"),
_("shengxiao: %(shengxiao)"),
color,
holiday);
} else {
format = g_strdup_printf("%s\n%s\n%s\n%s",
_("%(year)-%(month)-%(day)"),
_("%(YUE)yue%(RI)"),
_("%(Y60)nian%(M60)yue%(D60)ri"),
_("shengxiao: %(shengxiao)"));
}
strtime = lunar_date_strftime(calendar->date, format);
g_free(color);
g_free(holiday);
g_free(format);
gtk_widget_set_tooltip_markup(GTK_WIDGET(gcalendar), strtime);
g_free(strtime);
}
static VALUE
rg_date(VALUE self)
{
VALUE ret;
guint year, month, day;
gtk_calendar_get_date(_SELF(self), &year, &month, &day);
ret = rb_ary_new();
rb_ary_push(ret, INT2FIX(year));
rb_ary_push(ret, INT2FIX(month+1));
rb_ary_push(ret, INT2FIX(day));
return ret;
}
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 get_date(GtkWidget *t, isoDate_t *date)
{
GtkWidget *w;
GtkWindow *win;
GtkWidget *thiswin;
gint x,x_off;
gint y,y_off;
guint year;
guint month;
guint day;
isoDate_t odate=*date;
got_date=0;
win=GTK_WINDOW(gtk_builder_get_object (builder, "CalendarWindow"));
if(win==NULL) {
fprintf(stderr,"Could not locate Calendar window\n");
return(-1);
}
thiswin = gtk_widget_get_toplevel(t);
if(thiswin==NULL) {
fprintf(stderr,"Could not locate main window\n");
return(-1);
}
if(!(gtk_widget_translate_coordinates(GTK_WIDGET(t)
,GTK_WIDGET(thiswin), 0, 0, &x_off, &y_off))) {
fprintf(stderr,"Could not get position of button in window");
}
gtk_window_get_position(GTK_WINDOW(thiswin), &x, &y);
gtk_window_move(GTK_WINDOW(win), x+x_off, y+y_off);
w=GTK_WIDGET(gtk_builder_get_object (builder, "Calendar"));
if(w==NULL) {
fprintf(stderr,"Could not locate Calendar widget\n");
return(-1);
}
gtk_calendar_select_month(GTK_CALENDAR(w), isoDate_month(*date)-1, isoDate_year(*date));
gtk_calendar_select_day(GTK_CALENDAR(w), isoDate_day(*date));
gtk_window_present(GTK_WINDOW(win));
/* Wait for window to close... */
gtk_main();
w=GTK_WIDGET(gtk_builder_get_object (builder, "Calendar"));
if(w==NULL)
return(-1);
gtk_calendar_get_date(GTK_CALENDAR(w), &year, &month, &day);
gtk_widget_hide_on_delete(GTK_WIDGET(gtk_widget_get_toplevel(GTK_WIDGET(w))));
*date=isoDate_create(year, month+1, day);
return(odate!=*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));
}
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);
}
void Calendar::_change(int year_offset, int month_offset)
{
int year, month;
gtk_calendar_get_date((GtkCalendar*)widget, (guint*)&year, (guint*)&month, NULL);
month += month_offset;
if (month > 11) {
month = 0;
year_offset++;
} else if (month < 0) {
month = 11;
year_offset--;
}
year += year_offset;
gtk_calendar_select_month((GtkCalendar*)widget, (guint)month, (guint)year);
}
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);
}
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);
}
static void
date_selected_cb (GNCDatePicker *gdp, gpointer data)
{
DateCell *cell = data;
PopBox *box = cell->cell.gui_private;
guint day, month, year;
char buffer[DATE_BUF];
gtk_calendar_get_date (gdp->calendar, &year, &month, &day);
qof_print_date_dmy_buff (buffer, MAX_DATE_LENGTH, day, month + 1, year);
box->in_date_select = TRUE;
gnucash_sheet_modify_current_cell (box->sheet, buffer);
box->in_date_select = FALSE;
}
