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));
}
