void gnc_date_cell_set_value (DateCell *cell, int day, int mon, int year) { PopBox *box = cell->cell.gui_private; struct tm dada; char buff[DATE_BUF]; dada.tm_mday = day; dada.tm_mon = mon - 1; dada.tm_year = year - 1900; gnc_tm_set_day_start(&dada); gnc_mktime (&dada); box->date.tm_mday = dada.tm_mday; box->date.tm_mon = dada.tm_mon; box->date.tm_year = dada.tm_year; qof_print_date_dmy_buff (buff, MAX_DATE_LENGTH, dada.tm_mday, dada.tm_mon + 1, dada.tm_year + 1900); gnc_basic_cell_set_value_internal (&cell->cell, buff); if (!box->date_picker) return; block_picker_signals (cell); gnc_date_picker_set_date (box->date_picker, day, mon - 1, year); unblock_picker_signals (cell); }
static Timespec gnc_dmy2timespec_internal (int day, int month, int year, gboolean start_of_day) { Timespec result; struct tm date; long long secs = 0; long long era = 0; date.tm_year = year - 1900; date.tm_mon = month - 1; date.tm_mday = day; if (start_of_day) gnc_tm_set_day_start(&date); else gnc_tm_set_day_end(&date); /* compute number of seconds */ secs = gnc_mktime (&date); result.tv_sec = secs; result.tv_nsec = 0; return result; }
static void gnc_parse_date (struct tm *parsed, const char * datestr) { int day, month, year; gboolean use_autoreadonly = qof_book_uses_autoreadonly(gnc_get_current_book()); if (!parsed) return; if (!datestr) return; if (!qof_scan_date (datestr, &day, &month, &year)) { // Couldn't parse date, use today struct tm tm_today; memset (&tm_today, 0, sizeof (struct tm)); gnc_tm_get_today_start (&tm_today); day = tm_today.tm_mday; month = tm_today.tm_mon + 1; year = tm_today.tm_year + 1900; } // If we have an auto-read-only threshold, do not accept a date that is // older than the threshold. if (use_autoreadonly) { GDate *d = g_date_new_dmy(day, month, year); if (check_readonly_threshold (datestr, d)) { day = g_date_get_day (d); month = g_date_get_month (d); year = g_date_get_year (d); } g_date_free (d); } parsed->tm_mday = day; parsed->tm_mon = month - 1; parsed->tm_year = year - 1900; gnc_tm_set_day_start(parsed); /* Using gnc_mktime purely for its side effect of filling in the * rest of parsed and to check that it's valid. */ if (gnc_mktime (parsed) == -1) gnc_tm_get_today_start (parsed); gnc_mktime (parsed); }
time64 time64CanonicalDayTime (time64 t) { struct tm tm; gnc_localtime_r(&t, &tm); gnc_tm_set_day_middle(&tm); return gnc_mktime (&tm); }
time64 gnc_time64_get_today_end (void) { struct tm tm; gnc_tm_get_day_end(&tm, time(NULL)); return gnc_mktime(&tm); }
time64 gnc_time64_get_day_end (time64 time_val) { struct tm tm; time64 new_time; gnc_tm_get_day_end(&tm, time_val); new_time = gnc_mktime(&tm); return new_time; }
void gnc_date_edit_set_gdate (GNCDateEdit *gde, const GDate *date) { struct tm mytm; time64 t; g_return_if_fail(gde && GNC_IS_DATE_EDIT(gde) && date && g_date_valid(date)); g_date_to_struct_tm(date, &mytm); t = gnc_mktime(&mytm); gnc_date_edit_set_time(gde, t); }
/* This function converts separate entities to a time64 value */ static time64 gcrd_dmy2time (gint day, gint month, gint year) { struct tm when; memset (&when, 0, sizeof (when)); when.tm_year = year - 1900; when.tm_mon = month - 1 ; when.tm_mday = day; return gnc_mktime (&when); }
/* Converts any time on a day to midday that day. * given a timepair contains any time on a certain day (local time) * converts it to be midday that day. */ Timespec timespecCanonicalDayTime(Timespec t) { struct tm tm; Timespec retval; time64 t_secs = t.tv_sec + (t.tv_nsec / NANOS_PER_SECOND); gnc_localtime_r(&t_secs, &tm); gnc_tm_set_day_middle(&tm); retval.tv_sec = gnc_mktime(&tm); retval.tv_nsec = 0; return retval; }
time64 gnc_parse_time_to_time64 (const gchar *s, const gchar *format) { struct tm tm; g_return_val_if_fail(s && format, -1); if (!strptime(s, format, &tm)) return -1; return gnc_mktime(&tm); }
/** * gnc_date_edit_get_date: * @gde: The GNCDateEdit widget * * Returns the time entered in the GNCDateEdit widget */ time64 gnc_date_edit_get_date (GNCDateEdit *gde) { struct tm tm; g_return_val_if_fail (gde != NULL, 0); g_return_val_if_fail (GNC_IS_DATE_EDIT (gde), 0); tm = gnc_date_edit_get_date_internal (gde); return gnc_mktime (&tm); }
/* Convert day, month and year values to a date string Convert a date as day / month / year integers into a localized string representation param buff - pointer to previously allocated character array; its size must be at lease MAX_DATE_LENTH bytes. param day - value to be set with the day of the month as 1 ... 31 param month - value to be set with the month of the year as 1 ... 12 param year - value to be set with the year (4-digit) return length of string created in buff. Globals: global dateFormat value */ size_t qof_print_date_dmy_buff (char * buff, size_t len, int day, int month, int year) { int flen; if (!buff) return 0; /* Note that when printing year, we use %-4d in format string; * this causes a one, two or three-digit year to be left-adjusted * when printed (i.e. padded with blanks on the right). This is * important while the user is editing the year, since erasing a * digit can temporarily cause a three-digit year, and having the * blank on the left is a real pain for the user. So pad on the * right. */ switch (dateFormat) { case QOF_DATE_FORMAT_UK: flen = g_snprintf (buff, len, "%02d/%02d/%-4d", day, month, year); break; case QOF_DATE_FORMAT_CE: flen = g_snprintf (buff, len, "%02d.%02d.%-4d", day, month, year); break; case QOF_DATE_FORMAT_LOCALE: { struct tm tm_str; time64 t; tm_str.tm_mday = day; tm_str.tm_mon = month - 1; /* tm_mon = 0 through 11 */ tm_str.tm_year = year - 1900; /* this is what the standard says, it's not a Y2K thing */ gnc_tm_set_day_start (&tm_str); t = gnc_mktime (&tm_str); gnc_localtime_r (&t, &tm_str); flen = qof_strftime (buff, len, GNC_D_FMT, &tm_str); if (flen != 0) break; } /* FALL THROUGH */ case QOF_DATE_FORMAT_ISO: case QOF_DATE_FORMAT_UTC: flen = g_snprintf (buff, len, "%04d-%02d-%02d", year, month, day); break; case QOF_DATE_FORMAT_US: default: flen = g_snprintf (buff, len, "%02d/%02d/%-4d", month, day, year); break; } return flen; }
void gnc_date_cell_get_date (DateCell *cell, Timespec *ts) { PopBox *box = cell->cell.gui_private; if (!cell || !ts) return; gnc_parse_date (&(box->date), cell->cell.value); ts->tv_sec = gnc_mktime (&box->date); ts->tv_nsec = 0; }
time64 gnc_time64_get_day_start_gdate (const GDate *date) { struct tm stm; time64 secs; /* First convert to a 'struct tm' */ g_date_to_struct_tm (date, &stm); /* Then convert to number of seconds */ secs = gnc_mktime (&stm); return secs; }
/* Opens up a general journal window. */ GNCLedgerDisplay * gnc_ledger_display_gl (void) { Query *query; time64 start; struct tm tm; GNCLedgerDisplay *ld; ENTER(" "); query = qof_query_create_for(GNC_ID_SPLIT); qof_query_set_book (query, gnc_get_current_book()); /* In lieu of not "mis-using" some portion of the infrastructure by writing * a bunch of new code, we just filter out the accounts of the template * transactions. While these are in a seperate Account trees just for this * reason, the query engine makes no distinction between Account trees. * See Gnome Bug 86302. * -- jsled */ { Account *tRoot; GList *al; tRoot = gnc_book_get_template_root( gnc_get_current_book() ); al = gnc_account_get_descendants( tRoot ); if (g_list_length(al) != 0) xaccQueryAddAccountMatch( query, al, QOF_GUID_MATCH_NONE, QOF_QUERY_AND ); g_list_free (al); al = NULL; tRoot = NULL; } gnc_tm_get_today_start(&tm); tm.tm_mon--; /* Default the register to the last month's worth of transactions. */ start = gnc_mktime (&tm); xaccQueryAddDateMatchTT (query, TRUE, start, FALSE, 0, QOF_QUERY_AND); ld = gnc_ledger_display_internal (NULL, query, LD_GL, GENERAL_JOURNAL, REG_STYLE_JOURNAL, FALSE, FALSE); LEAVE("%p", ld); return ld; }
static int date_focus_out_event(GtkWidget *widget, GdkEventKey *event, gpointer data) { GNCDateEdit *gde = data; struct tm tm; /* Get the date entered and attempt to use it. */ tm = gnc_date_edit_get_date_internal (gde); gnc_date_edit_set_time (gde, gnc_mktime (&tm)); /* Get the date again in case it was invalid the first time. */ tm = gnc_date_edit_get_date_internal (gde); g_signal_emit (gde, date_edit_signals [DATE_CHANGED], 0); g_signal_emit (gde, date_edit_signals [TIME_CHANGED], 0); return FALSE; }
/* This code should be kept in sync with src/register/datecell.c */ static int date_accel_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) { GNCDateEdit *gde = data; const char *string; struct tm tm; string = gtk_entry_get_text (GTK_ENTRY (widget)); tm = gnc_date_edit_get_date_internal (gde); if (!gnc_handle_date_accelerator (event, &tm, string)) return FALSE; gnc_date_edit_set_time (gde, gnc_mktime (&tm)); g_signal_emit (G_OBJECT (gde), date_edit_signals [TIME_CHANGED], 0); return TRUE; }
time64 gnc_time64_get_day_end_gdate (const GDate *date) { struct tm stm; time64 secs; /* First convert to a 'struct tm' */ g_date_to_struct_tm(date, &stm); /* Force to th last second of the day */ stm.tm_hour = 23; stm.tm_min = 59; stm.tm_sec = 59; stm.tm_isdst = -1; /* Then convert to number of seconds */ secs = gnc_mktime (&stm); return secs; }
/* This function converts a string date to a time64 value */ static time64 gcrd_string_dmy2time (const gchar *date_string) { gint year = 0, month = 0, day = 0; if(qof_scan_date (date_string, &day, &month, &year)) { struct tm when; memset (&when, 0, sizeof (when)); when.tm_year = year - 1900; when.tm_mon = month - 1 ; when.tm_mday = day; return gnc_mktime (&when); } else { return gnc_time (NULL); } }
static gboolean gtk_cell_editable_key_press_event (GtkEntry *entry, GdkEventKey *key_event, GncPopupEntry *widget) { const char *date_string; gint year = 0, month = 0, day = 0; struct tm when; if (key_event->keyval == GDK_KEY_Escape) { widget->editing_canceled = TRUE; gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget)); gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (widget)); return TRUE; } date_string = gtk_entry_get_text (entry); memset (&when, 0, sizeof (when)); if (qof_scan_date (date_string, &day, &month, &year)) { when.tm_year = year - 1900; when.tm_mon = month - 1 ; when.tm_mday = day; if (!gnc_handle_date_accelerator (key_event, &when, date_string)) return FALSE; gtk_entry_set_text (entry, qof_print_date (gnc_mktime (&when))); gtk_widget_grab_focus (GTK_WIDGET (entry)); return TRUE; } return FALSE; }
/** Parses a string into a date, given a format. The format must * include the year. This function should only be called by * parse_date. * @param date_str The string containing a date being parsed * @param format An index specifying a format in date_format_user * @return The parsed value of date_str on success or -1 on failure */ static time64 parse_date_with_year (const char* date_str, int format) { time64 rawtime; /* The integer time */ struct tm retvalue, test_retvalue; /* The time in a broken-down structure */ int i, j, mem_length, orig_year = -1, orig_month = -1, orig_day = -1; /* Buffer for containing individual parts (e.g. year, month, day) of a date */ char date_segment[5]; /* The compiled regular expression */ regex_t preg = {0}; /* An array containing indices specifying the matched substrings in date_str */ regmatch_t pmatch[4] = { {0}, {0}, {0}, {0} }; /* The regular expression for parsing dates */ const char* regex = "^ *([0-9]+) *[-/.'] *([0-9]+) *[-/.'] *([0-9]+).*$|^ *([0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]).*$"; /* We get our matches using the regular expression. */ regcomp (&preg, regex, REG_EXTENDED); regexec (&preg, date_str, 4, pmatch, 0); regfree (&preg); /* If there wasn't a match, there was an error. */ if (pmatch[0].rm_eo == 0) return -1; /* If this is a string without separators ... */ if (pmatch[1].rm_so == -1) { /* ... we will fill in the indices based on the user's selection. */ int k = 0; /* k traverses date_str by keeping track of where separators "should" be. */ j = 1; /* j traverses pmatch. */ for (i = 0; date_format_user[format][i]; i++) { char segment_type = date_format_user[format][i]; /* Only do something if this is a meaningful character */ if (segment_type == 'y' || segment_type == 'm' || segment_type == 'd') { pmatch[j].rm_so = k; switch (segment_type) { case 'm': case 'd': k += 2; break; case 'y': k += 4; break; } pmatch[j].rm_eo = k; j++; } } } /* Put some sane values in retvalue by using the current time for * the non-year-month-day parts of the date. */ gnc_time (&rawtime); gnc_localtime_r (&rawtime, &retvalue); /* j traverses pmatch (index 0 contains the entire string, so we * start at index 1 for the first meaningful match). */ j = 1; /* Go through the date format and interpret the matches in order of * the sections in the date format. */ for (i = 0; date_format_user[format][i]; i++) { char segment_type = date_format_user[format][i]; /* Only do something if this is a meaningful character */ if (segment_type == 'y' || segment_type == 'm' || segment_type == 'd') { /* Copy the matching substring into date_segment so that we can * convert it into an integer. */ mem_length = pmatch[j].rm_eo - pmatch[j].rm_so; memcpy (date_segment, date_str + pmatch[j].rm_so, mem_length); date_segment[mem_length] = '\0'; /* Set the appropriate member of retvalue. Save the original * values so that we can check if the change when we use gnc_mktime * below. */ switch (segment_type) { case 'y': retvalue.tm_year = atoi (date_segment); /* Handle two-digit years. */ if (retvalue.tm_year < 100) { /* We allow two-digit years in the range 1969 - 2068. */ if (retvalue.tm_year < 69) retvalue.tm_year += 100; } else retvalue.tm_year -= 1900; orig_year = retvalue.tm_year; break; case 'm': orig_month = retvalue.tm_mon = atoi (date_segment) - 1; break; case 'd': orig_day = retvalue.tm_mday = atoi (date_segment); break; } j++; } } /* Convert back to an integer. If gnc_mktime leaves retvalue unchanged, * everything is okay; otherwise, an error has occurred. */ /* We have to use a "test" date value to account for changes in * daylight savings time, which can cause a date change with gnc_mktime * near midnight, causing the code to incorrectly think a date is * incorrect. */ test_retvalue = retvalue; gnc_mktime (&test_retvalue); retvalue.tm_isdst = test_retvalue.tm_isdst; rawtime = gnc_mktime (&retvalue); if (retvalue.tm_mday == orig_day && retvalue.tm_mon == orig_month && retvalue.tm_year == orig_year) { return rawtime; } else { return -1; } }
size_t qof_print_date_tm_buff (char * buff, size_t len, struct tm date) { return gnc_print_date_time_buff (buff, len, gnc_mktime(& date)); }