/*******************************************************
* get_filter_times
*
* get the start and end times from the dialog
*******************************************************/
static void
get_filter_times (CsvExportInfo *info)
{
time64 time_val;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(info->csvd.start_date_choose)))
{
time_val = gnc_date_edit_get_date (GNC_DATE_EDIT(info->csvd.start_date));
time_val = gnc_time64_get_day_start (time_val);
info->csvd.start_time = time_val;
}
else
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(info->csvd.start_date_today)))
info->csvd.start_time = gnc_time64_get_today_start();
else
info->csvd.start_time = 0;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(info->csvd.end_date_choose)))
{
time_val = gnc_date_edit_get_date (GNC_DATE_EDIT(info->csvd.end_date));
time_val = gnc_time64_get_day_end (time_val);
info->csvd.end_time = time_val;
}
else
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(info->csvd.end_date_today)))
info->csvd.end_time = gnc_time64_get_today_end();
else
info->csvd.end_time = gnc_time (NULL);
}
}
static size_t
init_from_time(void)
{
size_t total;
time64 time;
#ifdef HAVE_SYS_TIMES_H
clock_t clocks;
struct tms tms_buf;
#endif
ENTER("");
total = 0;
time = gnc_time (NULL);
md5_process_bytes(&time, sizeof(time), &guid_context);
total += sizeof(time);
#ifdef HAVE_SYS_TIMES_H
clocks = times(&tms_buf);
md5_process_bytes(&clocks, sizeof(clocks), &guid_context);
md5_process_bytes(&tms_buf, sizeof(tms_buf), &guid_context);
total += sizeof(clocks) + sizeof(tms_buf);
#endif
LEAVE("");
return total;
}
Timespec
timespec_now()
{
Timespec ts;
ts.tv_sec = gnc_time(NULL);
ts.tv_nsec = 0;
return ts;
}
static void
gcrd_init (GncCellRendererDate *date)
{
GncCellRendererPopup *popup;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *bbox;
GtkWidget *button;
popup = GNC_CELL_RENDERER_POPUP (date);
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (popup->popup_window), frame);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
date->calendar = gtk_calendar_new ();
popup->focus_window = date->calendar;
gtk_box_pack_start (GTK_BOX (vbox), date->calendar, TRUE, TRUE, 0);
date->button_box = gtk_hbutton_box_new ();
gtk_box_set_spacing (GTK_BOX (date->button_box), 6);
gtk_box_pack_start (GTK_BOX (vbox), date->button_box, FALSE, FALSE, 0);
button = gtk_button_new_with_label (_("Cancel"));
gtk_container_add (GTK_CONTAINER (date->button_box), button);
g_signal_connect (button, "clicked",
G_CALLBACK (gcrd_cancel_clicked),
date);
date->today_button = gtk_button_new_with_label (_("Today"));
gtk_container_add (GTK_CONTAINER (date->button_box), date->today_button);
g_signal_connect (date->today_button, "clicked",
G_CALLBACK (gcrd_today_clicked),
date);
button = gtk_button_new_with_label (_("Select"));
gtk_container_add (GTK_CONTAINER (date->button_box), button);
g_signal_connect (button, "clicked",
G_CALLBACK (gcrd_ok_clicked),
date);
g_signal_connect (date->calendar, "day-selected",
G_CALLBACK (gcrd_day_selected),
date);
g_signal_connect (date->calendar, "day-selected-double-click",
G_CALLBACK (gcrd_selected_double_click),
date);
//Set calendar to show current date when displayed
date->time = gnc_time (NULL);
gtk_widget_show_all (frame);
}
static void
gnc_recurrence_init( GncRecurrence *gr )
{
GtkVBox *vb;
GtkHBox *hb;
GtkWidget *w;
GtkBuilder *builder;
recurrenceSet(&gr->recurrence, 1, PERIOD_MONTH, NULL, WEEKEND_ADJ_NONE);
/* Open up the builder file */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "gnc-recurrence.glade", "GCB_PeriodType_liststore");
gnc_builder_add_from_file (builder, "gnc-recurrence.glade", "GSB_Mult_Adj");
gnc_builder_add_from_file (builder, "gnc-recurrence.glade", "RecurrenceEntryVBox");
vb = GTK_VBOX(gtk_builder_get_object (builder, "RecurrenceEntryVBox"));
hb = GTK_HBOX(gtk_builder_get_object (builder, "Startdate_hbox"));
w = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
gr->gde_start = w;
gtk_box_pack_start (GTK_BOX (hb), w, TRUE, TRUE, 0);
gtk_widget_show (w);
gtk_widget_set_no_show_all(GTK_WIDGET(gr->gde_start), TRUE);
gr->gcb_period = GTK_COMBO_BOX(gtk_builder_get_object (builder, "GCB_PeriodType"));
gr->gsb_mult = GTK_SPIN_BUTTON(gtk_builder_get_object (builder, "GSB_Mult"));
gr->gcb_eom = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, "GCB_EndOfMonth"));
gr->nth_weekday = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, "GCB_NthWeekday"));
gtk_widget_set_no_show_all(GTK_WIDGET(gr->gcb_eom), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(gr->nth_weekday), TRUE);
gtk_container_add( GTK_CONTAINER(&gr->widget), GTK_WIDGET(vb) );
gnc_recurrence_set(gr, &gr->recurrence);
something_changed( GTK_WIDGET(gr), gr);
/* Setup the signals */
g_signal_connect( G_OBJECT(gr->gde_start), "date_changed",
G_CALLBACK(something_changed), gr );
g_signal_connect( G_OBJECT(gr->gcb_period), "changed",
G_CALLBACK(something_changed), gr );
g_signal_connect( G_OBJECT(gr->gsb_mult), "value-changed",
G_CALLBACK(something_changed), gr );
g_signal_connect( G_OBJECT(gr->gcb_eom), "toggled",
G_CALLBACK(something_changed), gr );
g_signal_connect( G_OBJECT(gr->nth_weekday), "toggled",
G_CALLBACK(something_changed), gr );
gtk_widget_show_all( GTK_WIDGET(&gr->widget) );
gtk_builder_connect_signals(builder, gr);
g_object_unref(G_OBJECT(builder));
}
void qof_book_mark_session_dirty (QofBook *book)
{
if (!book) return;
if (!book->session_dirty)
{
/* Set the session dirty upfront, because the callback will check. */
book->session_dirty = TRUE;
book->dirty_time = gnc_time (NULL);
if (book->dirty_cb)
book->dirty_cb(book, TRUE, book->dirty_data);
}
}
static void
starting_balance_helper (Account *account, hierarchy_data *data)
{
gnc_numeric balance;
balance = get_final_balance (data->balance_hash, account);
if (gnc_reverse_balance(account))
balance = gnc_numeric_neg(balance);
if (!gnc_numeric_zero_p (balance))
gnc_account_create_opening_balance (account, balance, gnc_time (NULL),
gnc_get_current_book ());
}
void
ap_assistant_finish (GtkAssistant *assistant, gpointer user_data)
{
AcctPeriodInfo *info = user_data;
GtkTextBuffer * buffer;
GtkTextIter startiter, enditer;
gint len;
const char *btitle;
char *bnotes;
Timespec closing_date;
ENTER("info=%p", info);
btitle = gtk_entry_get_text (GTK_ENTRY(info->book_title));
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info->book_notes));
len = gtk_text_buffer_get_char_count (buffer);
gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0);
gtk_text_buffer_get_iter_at_offset(buffer, &enditer, len);
bnotes = gtk_text_buffer_get_text(buffer, &startiter, &enditer , 0);
PINFO("Book title is - %s\n", btitle);
timespecFromTime64 (&closing_date,
gnc_time64_get_day_end_gdate (&info->closing_date));
g_free(bnotes);
/* Report the status back to the user. */
info->close_status = 0; /* XXX fixme success or failure? */
/* Find the next closing date ... */
info->prev_closing_date = info->closing_date;
recurrenceListNextInstance (info->period, &info->prev_closing_date,
&info->closing_date);
/* FIXME Test for valid closing date, not sure why it won't be!!! */
if (g_date_valid(&info->closing_date) == TRUE)
{
/* If the next closing date is in the future, then we are done. */
if (gnc_time (NULL) >
gnc_time64_get_day_end_gdate (&info->closing_date))
{
/* Load up the GUI for the next closing period. */
gnc_frequency_setup_recurrence (info->period_menu, NULL,
&info->closing_date);
/* Jump back to the Close Book page. */
gtk_assistant_set_current_page (GTK_ASSISTANT(info->window), 1);
}
}
}
static void
gcrd_today_clicked (GtkWidget *button, GncCellRendererDate *cell)
{
time64 today;
gint year, month, day;
today = gnc_time (NULL);
gcrd_time2dmy ( today, &day, &month, &year);
gtk_calendar_clear_marks (GTK_CALENDAR (cell->calendar));
gtk_calendar_select_month (GTK_CALENDAR (cell->calendar), month - 1, year);
gtk_calendar_select_day (GTK_CALENDAR (cell->calendar), day);
gtk_calendar_mark_day (GTK_CALENDAR (cell->calendar), day);
}
void
xaccSchedXactionSetTemplateTrans(SchedXaction *sx, GList *t_t_list,
QofBook *book)
{
Transaction *new_trans;
TTInfo *tti;
TTSplitInfo *s_info;
Split *new_split;
GList *split_list;
g_return_if_fail (book);
/* delete any old transactions, if there are any */
delete_template_trans( sx );
for (; t_t_list != NULL; t_t_list = t_t_list->next)
{
tti = t_t_list->data;
new_trans = xaccMallocTransaction(book);
xaccTransBeginEdit(new_trans);
xaccTransSetDescription(new_trans,
gnc_ttinfo_get_description(tti));
xaccTransSetDatePostedSecsNormalized(new_trans, gnc_time (NULL));
/* Set tran-num with gnc_set_num_action which is the same as
* xaccTransSetNum with these arguments */
gnc_set_num_action(new_trans, NULL,
gnc_ttinfo_get_num(tti), NULL);
xaccTransSetNotes (new_trans, gnc_ttinfo_get_notes (tti));
xaccTransSetCurrency( new_trans,
gnc_ttinfo_get_currency(tti) );
for (split_list = gnc_ttinfo_get_template_splits(tti);
split_list;
split_list = split_list->next)
{
s_info = split_list->data;
new_split = pack_split_info(s_info, sx->template_acct,
new_trans, book);
xaccTransAppendSplit(new_trans, new_split);
}
xaccTransCommitEdit(new_trans);
}
}
static void
test_entry_basics ( Fixture *fixture, gconstpointer pData )
{
time64 ts1 = gnc_time(NULL), ts2;
const char *desc = "Test description with éà unicode chars";
const char *action = "Test action with éà unicode chars";
const char *note = "Test note with éà unicode chars";
gnc_numeric quantity = {500000, 100};
gboolean is_cn = FALSE;
GncEntry *entry = gncEntryCreate(fixture->book);
g_assert(entry);
g_test_message( "Test basic setters/getters" );
g_test_message( " Date" );
gncEntrySetDate (entry, ts1);
ts2 = gncEntryGetDate (entry);
g_assert(ts2 == ts1);
g_test_message( " DateEntered" );
gncEntrySetDateEntered (entry, ts1);
ts2 = gncEntryGetDateEntered (entry);
g_assert(ts2 == ts1);
g_test_message( " Description" );
gncEntrySetDescription (entry, desc);
g_assert(g_strcmp0 (gncEntryGetDescription (entry), desc) == 0);
g_test_message( " Action" );
gncEntrySetAction (entry, action);
g_assert(g_strcmp0 (gncEntryGetAction (entry), action) == 0);
g_test_message( " Notes" );
gncEntrySetNotes (entry, note);
g_assert(g_strcmp0 (gncEntryGetNotes (entry), note) == 0);
g_test_message( " Quantity" );
gncEntrySetQuantity (entry, quantity);
g_assert(gnc_numeric_eq (gncEntryGetQuantity (entry), quantity));
g_test_message( " DocQuantity (with is_cn = FALSE)" );
gncEntrySetDocQuantity (entry, quantity, is_cn);
g_assert(gnc_numeric_eq (gncEntryGetDocQuantity (entry, is_cn), quantity));
g_assert(gnc_numeric_eq (gncEntryGetQuantity (entry), quantity));
g_test_message( " DocQuantity (with is_cn = TRUE)");
is_cn = TRUE;
gncEntrySetDocQuantity (entry, quantity, is_cn);
g_assert(gnc_numeric_eq (gncEntryGetDocQuantity (entry, is_cn), quantity));
g_assert(gnc_numeric_eq (gncEntryGetQuantity (entry), gnc_numeric_neg (quantity)));
g_test_message( " InvAccount" );
gncEntrySetInvAccount (entry, fixture->account);
g_assert(gncEntryGetInvAccount (entry) == fixture->account);
}
static void
fill_time_combo (GtkWidget *widget, GNCDateEdit *gde)
{
GtkTreeModel *model;
GtkTreeIter hour_iter, min_iter;
struct tm *tm_returned;
struct tm mtm;
time64 current_time;
int i, j;
if (gde->lower_hour > gde->upper_hour)
return;
model = gtk_combo_box_get_model (GTK_COMBO_BOX(gde->time_combo));
gnc_time (¤t_time);
tm_returned = gnc_localtime_r (¤t_time, &mtm);
g_return_if_fail(tm_returned != NULL);
for (i = gde->lower_hour; i <= gde->upper_hour; i++)
{
char buffer [40];
mtm.tm_hour = i;
mtm.tm_min = 0;
if (gde->flags & GNC_DATE_EDIT_24_HR)
qof_strftime (buffer, sizeof (buffer), "%H:00", &mtm);
else
qof_strftime (buffer, sizeof (buffer), "%I:00 %p ", &mtm);
gtk_tree_store_append (GTK_TREE_STORE(model), &hour_iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE(model), &hour_iter, 0, buffer, -1);
for (j = 0; j < 60; j += 15)
{
mtm.tm_min = j;
if (gde->flags & GNC_DATE_EDIT_24_HR)
qof_strftime (buffer, sizeof (buffer), "%H:%M", &mtm);
else
qof_strftime (buffer, sizeof (buffer), "%I:%M %p", &mtm);
gtk_tree_store_append(GTK_TREE_STORE(model), &min_iter, &hour_iter );
gtk_tree_store_set (GTK_TREE_STORE(model), &min_iter, 0, buffer, -1);
}
}
}
static void
gcrd_show (GncCellRendererPopup *cell,
const gchar *path,
gint x1,
gint y1,
gint x2,
gint y2)
{
GncCellRendererDate *date;
gint year;
gint month;
gint day;
gint index;
const gchar *text;
if (parent_class->show_popup) {
parent_class->show_popup (cell,
path,
x1, y1,
x2, y2);
}
date = GNC_CELL_RENDERER_DATE (cell);
text = gnc_popup_entry_get_text (GNC_POPUP_ENTRY (GNC_CELL_RENDERER_POPUP (cell)->editable));
if (!(g_strcmp0(text, "")))
{
date->time = gnc_time (NULL);
gcrd_time2dmy ( date->time, &day, &month, &year);
}
else
{
date->time = gcrd_string_dmy2time (text);
gcrd_time2dmy ( date->time, &day, &month, &year);
}
gtk_calendar_clear_marks (GTK_CALENDAR (date->calendar));
gtk_calendar_select_month (GTK_CALENDAR (date->calendar), month - 1, year);
gtk_calendar_select_day (GTK_CALENDAR (date->calendar), day);
gtk_calendar_mark_day (GTK_CALENDAR (date->calendar), day);
}
/* Set the "show date" setting on a GncPeriodSelect widget. If set
* to TRUE then a GtkLabel will be used to show the date
* corresponding to the selected time period.
*/
void
gnc_period_select_set_show_date (GncPeriodSelect *period, const gboolean show_date)
{
GDate date;
g_return_if_fail(period != NULL);
g_return_if_fail(GNC_IS_PERIOD_SELECT(period));
if (show_date)
{
g_date_clear(&date, 1);
gnc_gdate_set_time64(&date, gnc_time (NULL));
gnc_period_select_set_date_common(period, &date);
}
else
{
gnc_period_select_set_date_common(period, NULL);
}
}
int
main(void)
{
int y, m, d;
time64 bin_time;
struct tm br_time;
gnc_time (&bin_time);
gnc_localtime_r (&bin_time, &br_time);
gregorian_to_jalali(&y, &m, &d,
1900 + br_time.tm_year,
1 + br_time.tm_mon,
br_time.tm_mday);
printf("Current Jalali date: %d %s %d\n", d, j_month_name[m-1], y);
return 0;
}
/* 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);
}
}
/* Return the field separator for the current date format
return date character
*/
char dateSeparator (void)
{
static char locale_separator = '\0';
switch (dateFormat)
{
case QOF_DATE_FORMAT_CE:
return '.';
case QOF_DATE_FORMAT_ISO:
case QOF_DATE_FORMAT_UTC:
return '-';
case QOF_DATE_FORMAT_US:
case QOF_DATE_FORMAT_UK:
default:
return '/';
case QOF_DATE_FORMAT_LOCALE:
if (locale_separator != '\0')
return locale_separator;
else
{
/* Make a guess */
gchar string[256];
struct tm tm;
time64 secs;
gchar *s;
secs = gnc_time (NULL);
gnc_localtime_r(&secs, &tm);
auto normalized_fmt =
normalize_format(qof_date_format_get_string(dateFormat));
qof_strftime(string, sizeof(string), normalized_fmt.c_str(), &tm);
for (s = string; *s != '\0'; s++)
if (!isdigit(*s))
return (locale_separator = *s);
}
break;
}
return '\0';
}
static void
gnc_date_cell_init (DateCell *cell)
{
PopBox *box;
time64 secs;
char buff[DATE_BUF];
gnc_basic_cell_init (&(cell->cell));
cell->cell.is_popup = TRUE;
cell->cell.destroy = gnc_date_cell_destroy;
cell->cell.gui_realize = gnc_date_cell_realize;
cell->cell.gui_destroy = gnc_date_cell_gui_destroy;
cell->cell.modify_verify = gnc_date_cell_modify_verify;
cell->cell.direct_update = gnc_date_cell_direct_update;
cell->cell.set_value = gnc_date_cell_set_value_internal;
box = g_new0 (PopBox, 1);
box->sheet = NULL;
box->item_edit = NULL;
box->date_picker = NULL;
box->signals_connected = FALSE;
box->calendar_popped = FALSE;
box->in_date_select = FALSE;
cell->cell.gui_private = box;
/* default value is today's date */
gnc_time (&secs);
gnc_localtime_r (&secs, &(box->date));
gnc_date_cell_print_date (cell, buff);
gnc_basic_cell_set_value_internal (&cell->cell, buff);
}
/*******************************************************************
* get_earliest_in_book
*
* Find the earliest date occuring in the book. Do this by making
* a query and sorting by date. Since the truncated sort returns
* only the *last* search results, sort in decreasing order.
*******************************************************************/
static time64
get_earliest_in_book (QofBook *book)
{
QofQuery *q;
GSList *p1, *p2;
GList *res;
time64 earliest;
q = qof_query_create_for (GNC_ID_SPLIT);
qof_query_set_max_results (q, 1);
qof_query_set_book (q, book);
/* Sort by transaction date */
p1 = g_slist_prepend (NULL, TRANS_DATE_POSTED);
p1 = g_slist_prepend (p1, SPLIT_TRANS);
p2 = g_slist_prepend (NULL, QUERY_DEFAULT_SORT);
qof_query_set_sort_order (q, p1, p2, NULL);
/* Reverse the sort order */
qof_query_set_sort_increasing (q, FALSE, FALSE, FALSE);
/* Run the query, find the earliest transaction date */
res = qof_query_run (q);
if (res)
{
earliest = xaccQueryGetEarliestDateFound (q);
}
else
{
/* If no results, we don't want to bomb totally */
earliest = gnc_time (0);
}
qof_query_destroy (q);
return earliest;
}
static gint
sxftd_init( SXFromTransInfo *sxfti )
{
GtkWidget *w;
const char *transName;
gint pos;
GList *schedule = NULL;
time64 start_tt;
struct tm *tmpTm;
GDate date, nextDate;
if ( ! sxfti->sx )
{
return -1;
}
if ( ! sxfti->trans )
{
return -2;
}
if ( xaccTransIsOpen( sxfti->trans ) )
{
return SXFTD_ERRNO_OPEN_XACTION;
}
/* Setup Widgets */
{
sxfti->ne_but = GTK_TOGGLE_BUTTON(gtk_builder_get_object(sxfti->builder, "never_end_button"));
sxfti->ed_but = GTK_TOGGLE_BUTTON(gtk_builder_get_object(sxfti->builder, "end_on_date_button"));
sxfti->oc_but = GTK_TOGGLE_BUTTON(gtk_builder_get_object(sxfti->builder, "n_occurrences_button"));
sxfti->n_occurences = GTK_ENTRY(gtk_builder_get_object(sxfti->builder, "n_occurrences_entry"));
}
/* Get the name from the transaction, try that as the initial SX name. */
transName = xaccTransGetDescription( sxfti->trans );
xaccSchedXactionSetName( sxfti->sx, transName );
sxfti->name = GTK_ENTRY(gtk_builder_get_object(sxfti->builder, "name_entry" ));
pos = 0;
gtk_editable_insert_text( GTK_EDITABLE(sxfti->name), transName,
(strlen(transName) * sizeof(char)), &pos );
sxfti_attach_callbacks(sxfti);
/* Setup the example calendar and related data structures. */
{
int num_marks = SXFTD_EXCAL_NUM_MONTHS * 31;
w = GTK_WIDGET(gtk_builder_get_object(sxfti->builder, "ex_cal_frame" ));
sxfti->dense_cal_model = gnc_dense_cal_store_new(num_marks);
sxfti->example_cal = GNC_DENSE_CAL(gnc_dense_cal_new_with_model(GNC_DENSE_CAL_MODEL(sxfti->dense_cal_model)));
g_object_ref_sink(sxfti->example_cal);
g_assert(sxfti->example_cal);
gnc_dense_cal_set_num_months( sxfti->example_cal, SXFTD_EXCAL_NUM_MONTHS );
gnc_dense_cal_set_months_per_col( sxfti->example_cal, SXFTD_EXCAL_MONTHS_PER_COL );
gtk_container_add( GTK_CONTAINER(w), GTK_WIDGET(sxfti->example_cal) );
}
/* Setup the start and end dates as GNCDateEdits */
{
GtkWidget *paramTable = GTK_WIDGET(gtk_builder_get_object(sxfti->builder, "param_table" ));
sxfti->startDateGDE =
GNC_DATE_EDIT( gnc_date_edit_new (gnc_time (NULL),
FALSE, FALSE));
gtk_table_attach( GTK_TABLE(paramTable),
GTK_WIDGET( sxfti->startDateGDE ),
1, 2, 2, 3,
(GTK_EXPAND | GTK_FILL),
GTK_FILL,
0, 0 );
g_signal_connect( sxfti->startDateGDE, "date-changed",
G_CALLBACK( sxftd_update_excal_adapt ),
sxfti );
}
{
GtkWidget *endDateBox = GTK_WIDGET(gtk_builder_get_object(sxfti->builder, "end_date_hbox" ));
sxfti->endDateGDE =
GNC_DATE_EDIT( gnc_date_edit_new (gnc_time (NULL),
FALSE, FALSE));
gtk_box_pack_start( GTK_BOX( endDateBox ),
GTK_WIDGET( sxfti->endDateGDE ),
TRUE, TRUE, 0 );
g_signal_connect( sxfti->endDateGDE, "date-changed",
G_CALLBACK( sxftd_update_excal_adapt ),
sxfti );
}
/* Setup the initial start date for user display/confirmation */
/* compute good initial date. */
start_tt = xaccTransGetDate( sxfti->trans );
gnc_gdate_set_time64( &date, start_tt );
sxfti->freq_combo = GTK_COMBO_BOX(gtk_builder_get_object(sxfti->builder, "freq_combo_box"));
gtk_combo_box_set_active(GTK_COMBO_BOX(sxfti->freq_combo), 0);
g_signal_connect( sxfti->freq_combo, "changed",
G_CALLBACK(sxftd_freq_combo_changed),
sxfti );
sxftd_update_schedule( sxfti, &date, &schedule);
recurrenceListNextInstance(schedule, &date, &nextDate);
recurrenceListFree(&schedule);
start_tt = gnc_time64_get_day_start_gdate (&nextDate);
gnc_date_edit_set_time( sxfti->startDateGDE, start_tt );
g_signal_connect( G_OBJECT(sxfti->name), "destroy",
G_CALLBACK(sxftd_destroy),
sxfti );
sxftd_update_example_cal( sxfti );
return 0;
}
/** 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;
}
}
/* Convert a string into day, month and year integers
Convert a string into day / month / year integers according to
the current dateFormat value.
This function will always parse a single number as the day of
the month, regardless of the ordering of the dateFormat value.
Two numbers will always be parsed as the day and the month, in
the same order that they appear in the dateFormat value. Three
numbers are parsed exactly as specified in the dateFormat field.
Fully formatted UTC timestamp strings are converted separately.
param buff - pointer to date string
param day - will store day of the month as 1 ... 31
param month - will store month of the year as 1 ... 12
param year - will store the year (4-digit)
return TRUE if date appeared to be valid.
Globals: global dateFormat value
*/
static gboolean
qof_scan_date_internal (const char *buff, int *day, int *month, int *year,
QofDateFormat which_format)
{
char *dupe, *tmp, *first_field, *second_field, *third_field;
int iday, imonth, iyear;
int now_day, now_month, now_year;
struct tm *now, utc;
time64 secs;
if (!buff) return(FALSE);
if (which_format == QOF_DATE_FORMAT_UTC)
{
if (strptime(buff, QOF_UTC_DATE_FORMAT, &utc)
|| strptime (buff, "%Y-%m-%d", &utc))
{
*day = utc.tm_mday;
*month = utc.tm_mon + 1;
*year = utc.tm_year + 1900;
return TRUE;
}
else
{
return FALSE;
}
}
dupe = g_strdup (buff);
tmp = dupe;
first_field = NULL;
second_field = NULL;
third_field = NULL;
/* Use strtok to find delimiters */
if (tmp)
{
static const char *delims = ".,-+/\\()년월年月 ";
first_field = strtok (tmp, delims);
if (first_field)
{
second_field = strtok (NULL, delims);
if (second_field)
{
third_field = strtok (NULL, delims);
}
}
}
/* today's date */
gnc_time (&secs);
now = gnc_localtime (&secs);
now_day = now->tm_mday;
now_month = now->tm_mon + 1;
now_year = now->tm_year + 1900;
gnc_tm_free (now);
/* set defaults: if day or month appear to be blank, use today's date */
iday = now_day;
imonth = now_month;
iyear = -1;
/* get numeric values */
switch (which_format)
{
case QOF_DATE_FORMAT_LOCALE:
if (buff[0] != '\0')
{
struct tm thetime;
gchar *format = g_strdup (GNC_D_FMT);
gchar *stripped_format = g_strdup (GNC_D_FMT);
gint counter = 0, stripped_counter = 0;
/* strptime can't handle the - format modifier
* let's strip it out of the format before using it
*/
while (format[counter] != '\0')
{
stripped_format[stripped_counter] = format[counter];
if ((format[counter] == '%') && (format[counter+1] == '-'))
counter++; // skip - format modifier
counter++;
stripped_counter++;
}
stripped_format[stripped_counter] = '\0';
g_free (format);
/* Parse time string. */
memset(&thetime, -1, sizeof(struct tm));
strptime (buff, stripped_format, &thetime);
g_free (stripped_format);
if (third_field)
{
/* Easy. All three values were parsed. */
iyear = thetime.tm_year + 1900;
iday = thetime.tm_mday;
imonth = thetime.tm_mon + 1;
}
else if (second_field)
{
/* Hard. Two values parsed. Figure out the ordering. */
if (thetime.tm_year == -1)
{
/* %m-%d or %d-%m. Don't care. Already parsed correctly. */
iday = thetime.tm_mday;
imonth = thetime.tm_mon + 1;
}
else if (thetime.tm_mon != -1)
{
/* Must be %Y-%m-%d. Reparse as %m-%d.*/
imonth = atoi(first_field);
iday = atoi(second_field);
}
else
{
/* Must be %Y-%d-%m. Reparse as %d-%m. */
iday = atoi(first_field);
imonth = atoi(second_field);
}
}
else if (first_field)
{
iday = atoi(first_field);
}
}
break;
case QOF_DATE_FORMAT_UK:
case QOF_DATE_FORMAT_CE:
if (third_field)
{
iday = atoi(first_field);
imonth = atoi(second_field);
iyear = atoi(third_field);
}
else if (second_field)
{
iday = atoi(first_field);
imonth = atoi(second_field);
}
else if (first_field)
{
iday = atoi(first_field);
}
break;
case QOF_DATE_FORMAT_ISO:
if (third_field)
{
iyear = atoi(first_field);
imonth = atoi(second_field);
iday = atoi(third_field);
}
else if (second_field)
{
imonth = atoi(first_field);
iday = atoi(second_field);
}
else if (first_field)
{
iday = atoi(first_field);
}
break;
case QOF_DATE_FORMAT_US:
default:
if (third_field)
{
imonth = atoi(first_field);
iday = atoi(second_field);
iyear = atoi(third_field);
}
else if (second_field)
{
imonth = atoi(first_field);
iday = atoi(second_field);
}
else if (first_field)
{
iday = atoi(first_field);
}
break;
}
g_free (dupe);
if ((12 < imonth) || (31 < iday))
{
/*
* Ack! Thppfft! Someone just fed this routine a string in the
* wrong date format. This is known to happen if a register
* window is open when changing the date format. Try the
* previous date format. If that doesn't work, see if we can
* exchange month and day. If that still doesn't work,
* bail and give the caller what they asked for (garbage)
* parsed in the new format.
*
* Note: This test cannot detect any format change that only
* swaps month and day field, if the day is 12 or less. This is
* deemed acceptable given the obscurity of this bug.
*/
if ((which_format != prevQofDateFormat) &&
qof_scan_date_internal(buff, day, month, year, prevQofDateFormat))
{
return(TRUE);
}
if ((12 < imonth) && (12 >= iday))
{
int tmp = imonth;
imonth = iday;
iday = tmp;
}
else
{
return FALSE;
}
}
/* if no year was entered, choose a year according to the
dateCompletion preference. If it is
QOF_DATE_COMPLETION_THISYEAR, use the current year, else if it
is QOF_DATE_COMPLETION_SLIDING, use a sliding window that
starts dateCompletionBackMonths before the current month.
We go by whole months, rather than days, because presumably
this is less confusing.
*/
if (iyear == -1)
{
if (dateCompletion == QOF_DATE_COMPLETION_THISYEAR)
{
iyear = now_year; /* use the current year */
}
else
{
iyear = now_year - floordiv(imonth - now_month +
dateCompletionBackMonths, 12);
}
}
/* If the year entered is smaller than 100, assume we mean the current
century (and are not revising some roman emperor's books) */
if (iyear < 100)
iyear += ((int) ((now_year + 50 - iyear) / 100)) * 100;
if (year) *year = iyear;
if (month) *month = imonth;
if (day) *day = iday;
return(TRUE);
}
gchar *
gnc_date_timestamp (void)
{
return gnc_print_time64(gnc_time(nullptr), "%Y%m%d%H%M%S");
}
/** Create the preferences dialog. This function first reads the
* dialog-preferences.glade file to obtain the content and then
* the dialog is created with a set of common preferences. It then
* runs the list of add-ins, calling a helper function to add each full/partial
* page to this dialog, Finally it builds the "interesting widgets"
* table that is used for connecting the widgets up to callback functions.
*
* @internal
*
* @return A pointer to the newly created dialog.
*/
static GtkWidget *
gnc_preferences_dialog_create(void)
{
GtkBuilder *builder;
GtkWidget *dialog, *notebook, *label, *image;
GtkWidget *box, *date, *period, *currency;
GHashTable *prefs_table;
GDate* gdate = NULL;
gchar buf[128];
GtkListStore *store;
GtkTreePath *path;
GtkTreeIter iter;
gnc_commodity *locale_currency;
const gchar *currency_name;
QofBook *book;
KvpFrame *book_frame;
gint64 month, day;
GDate fy_end;
gboolean date_is_valid = FALSE;
ENTER("");
DEBUG("Opening dialog-preferences.glade:");
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "auto_decimal_places_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "autosave_interval_minutes_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "save_on_close_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "date_backmonth_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "max_transactions_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "key_length_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "new_search_limit_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "retain_days_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "tab_width_adj");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "date_formats");
gnc_builder_add_from_file (builder, "dialog-preferences.glade", "GnuCash Preferences");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "GnuCash Preferences"));
#ifndef REGISTER2_ENABLED
/* Hide preferences that are related to register2 */
box = GTK_WIDGET (gtk_builder_get_object (builder, "label14"));
gtk_widget_hide (box);
box = GTK_WIDGET (gtk_builder_get_object (builder, "pref/general.register/key-length"));
gtk_widget_hide (box);
box = GTK_WIDGET (gtk_builder_get_object (builder, "pref/general.register/show-extra-dates"));
gtk_widget_hide (box);
box = GTK_WIDGET (gtk_builder_get_object (builder, "pref/general.register/show-calendar-buttons"));
gtk_widget_hide (box);
box = GTK_WIDGET (gtk_builder_get_object (builder, "pref/general.register/selection-to-blank-on-expand"));
gtk_widget_hide (box);
box = GTK_WIDGET (gtk_builder_get_object (builder, "pref/general.register/show-extra-dates-on-selection"));
gtk_widget_hide (box);
#endif
label = GTK_WIDGET(gtk_builder_get_object (builder, "sample_account"));
g_object_set_data(G_OBJECT(dialog), "sample_account", label);
image = GTK_WIDGET(gtk_builder_get_object (builder, "separator_error"));
g_object_set_data(G_OBJECT(dialog), "separator_error", image);
DEBUG("autoconnect");
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, dialog);
DEBUG("done");
notebook = GTK_WIDGET(gtk_builder_get_object (builder, "notebook1"));
prefs_table = g_hash_table_new(g_str_hash, g_str_equal);
g_object_set_data(G_OBJECT(dialog), NOTEBOOK, notebook);
g_object_set_data_full(G_OBJECT(dialog), PREFS_WIDGET_HASH,
prefs_table, (GDestroyNotify)g_hash_table_destroy);
book = gnc_get_current_book();
g_date_clear (&fy_end, 1);
qof_instance_get (QOF_INSTANCE (book),
"fy-end", &fy_end,
NULL);
box = GTK_WIDGET(gtk_builder_get_object (builder,
"pref/" GNC_PREFS_GROUP_ACCT_SUMMARY "/" GNC_PREF_START_PERIOD));
period = gnc_period_select_new(TRUE);
gtk_widget_show (period);
gtk_box_pack_start (GTK_BOX (box), period, TRUE, TRUE, 0);
if (date_is_valid)
gnc_period_select_set_fy_end(GNC_PERIOD_SELECT (period), &fy_end);
box = GTK_WIDGET(gtk_builder_get_object (builder,
"pref/" GNC_PREFS_GROUP_ACCT_SUMMARY "/" GNC_PREF_END_PERIOD));
period = gnc_period_select_new(FALSE);
gtk_widget_show (period);
gtk_box_pack_start (GTK_BOX (box), period, TRUE, TRUE, 0);
if (date_is_valid)
gnc_period_select_set_fy_end(GNC_PERIOD_SELECT (period), &fy_end);
box = GTK_WIDGET(gtk_builder_get_object (builder,
"pref/" GNC_PREFS_GROUP_ACCT_SUMMARY "/" GNC_PREF_START_DATE));
date = gnc_date_edit_new(gnc_time (NULL), FALSE, FALSE);
gtk_widget_show (date);
gtk_box_pack_start (GTK_BOX (box), date, TRUE, TRUE, 0);
box = GTK_WIDGET(gtk_builder_get_object (builder,
"pref/" GNC_PREFS_GROUP_ACCT_SUMMARY "/" GNC_PREF_END_DATE));
date = gnc_date_edit_new(gnc_time (NULL), FALSE, FALSE);
gtk_widget_show (date);
gtk_box_pack_start (GTK_BOX (box), date, TRUE, TRUE, 0);
box = GTK_WIDGET(gtk_builder_get_object (builder,
"pref/" GNC_PREFS_GROUP_GENERAL "/" GNC_PREF_CURRENCY_OTHER));
currency = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(currency), gnc_default_currency());
gtk_widget_show (currency);
gtk_box_pack_start(GTK_BOX (box), currency, TRUE, TRUE, 0);
box = GTK_WIDGET(gtk_builder_get_object (builder,
"pref/" GNC_PREFS_GROUP_GENERAL_REPORT "/" GNC_PREF_CURRENCY_OTHER));
currency = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(currency), gnc_default_currency());
gtk_widget_show (currency);
gtk_box_pack_start(GTK_BOX (box), currency, TRUE, TRUE, 0);
/* Add to the list of interesting widgets */
gnc_prefs_build_widget_table(builder, dialog);
g_slist_foreach(add_ins, gnc_preferences_build_page, dialog);
/* Sort tabs alphabetically */
gnc_prefs_sort_pages(GTK_NOTEBOOK(notebook));
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
DEBUG("We have the following interesting widgets:");
g_hash_table_foreach(prefs_table, (GHFunc)gnc_prefs_connect_one, dialog);
DEBUG("Done with interesting widgets.");
/* Other stuff */
gdate = g_date_new_dmy(31, G_DATE_JULY, 2013);
g_date_strftime(buf, sizeof(buf), "%x", gdate);
store = GTK_LIST_STORE(gtk_builder_get_object (builder, "date_formats"));
path = gtk_tree_path_new_from_indices (QOF_DATE_FORMAT_LOCALE, -1);
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path))
gtk_list_store_set (store, &iter, 1, buf, -1);
g_date_free(gdate);
locale_currency = gnc_locale_default_currency ();
currency_name = gnc_commodity_get_printname(locale_currency);
label = GTK_WIDGET(gtk_builder_get_object (builder, "locale_currency"));
gtk_label_set_label(GTK_LABEL(label), currency_name);
label = GTK_WIDGET(gtk_builder_get_object (builder, "locale_currency2"));
gtk_label_set_label(GTK_LABEL(label), currency_name);
g_object_unref(G_OBJECT(builder));
LEAVE("dialog %p", dialog);
return dialog;
}
/*******************************************************
* Create the Assistant
*******************************************************/
static GtkWidget *
csv_export_assistant_create (CsvExportInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *box, *h_box;
GtkWidget *button;
GtkWidget *table, *hbox;
time64 start_time, end_time;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder , "assistant-csv-export.glade", "CSV Export Assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "CSV Export Assistant"));
info->window = window;
/* Set the assistant colors */
gnc_assistant_set_colors (GTK_ASSISTANT (info->window));
/* Load default settings */
load_settings (info);
/* Start Page */
info->start_page = GTK_WIDGET(gtk_builder_get_object(builder, "start_page"));
info->start_label = GTK_WIDGET(gtk_builder_get_object(builder, "start_label"));
info->custom_entry = GTK_WIDGET(gtk_builder_get_object(builder, "custom_entry"));
gtk_widget_set_sensitive (info->custom_entry, FALSE);
/* Account Page */
info->account_page = GTK_WIDGET(gtk_builder_get_object(builder, "account_page"));
if (info->export_type == XML_EXPORT_TREE)
gtk_widget_destroy (info->account_page);
else
{
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkWidget *box, *label;
info->csva.acct_info = GTK_WIDGET(gtk_builder_get_object (builder, "acct_info_vbox"));
info->csva.num_acct_label = GTK_WIDGET(gtk_builder_get_object (builder, "num_accounts_label"));
tree_view = gnc_tree_view_account_new (FALSE);
info->csva.account_treeview = GTK_WIDGET(tree_view);
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_EXTENDED);
g_signal_connect (G_OBJECT(selection), "changed",
G_CALLBACK(csv_export_account_changed_cb), info);
gtk_widget_show (info->csva.account_treeview);
box = GTK_WIDGET(gtk_builder_get_object (builder, "account_scroll"));
gtk_container_add (GTK_CONTAINER(box), info->csva.account_treeview);
label = GTK_WIDGET(gtk_builder_get_object (builder, "accounts_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), GTK_WIDGET(tree_view));
/* select subaccounts button */
button = GTK_WIDGET(gtk_builder_get_object (builder, "select_subaccounts_button"));
info->csva.select_button = button;
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK(csv_export_select_subaccounts_clicked_cb), info);
g_signal_connect (G_OBJECT(info->csva.account_treeview), "cursor_changed",
G_CALLBACK(csv_export_cursor_changed_cb), info);
/* Set the date info */
button = GTK_WIDGET(gtk_builder_get_object (builder, "show_range"));
/* Earliest and Latest in Book */
start_time = get_earliest_in_book (gnc_get_current_book());
end_time = gnc_time (NULL);
info->csvd.start_time = start_time;
info->csvd.end_time = end_time;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(button), FALSE);
table = GTK_WIDGET(gtk_builder_get_object (builder, "select_range_table"));
info->csvd.table = table;
gtk_widget_set_sensitive (GTK_WIDGET(table), FALSE);
info->csvd.start_date_choose = GTK_WIDGET(gtk_builder_get_object (builder, "start_date_choose"));
info->csvd.start_date_today = GTK_WIDGET(gtk_builder_get_object (builder, "start_date_today"));
info->csvd.end_date_choose = GTK_WIDGET(gtk_builder_get_object (builder, "end_date_choose"));
info->csvd.end_date_today = GTK_WIDGET(gtk_builder_get_object (builder, "end_date_today"));
/* Start date info */
info->csvd.start_date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "start_date_hbox"));
gtk_box_pack_start (GTK_BOX(hbox), info->csvd.start_date, TRUE, TRUE, 0);
gtk_widget_show (info->csvd.start_date);
gnc_date_edit_set_time (GNC_DATE_EDIT(info->csvd.start_date), start_time);
g_signal_connect (G_OBJECT(info->csvd.start_date), "date-changed",
G_CALLBACK(csv_export_date_changed_cb), info);
/* End date info */
info->csvd.end_date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "end_date_hbox"));
gtk_box_pack_start (GTK_BOX(hbox), info->csvd.end_date, TRUE, TRUE, 0);
gtk_widget_show (info->csvd.end_date);
gnc_date_edit_set_time (GNC_DATE_EDIT(info->csvd.end_date), end_time);
g_signal_connect (G_OBJECT (info->csvd.end_date), "date-changed",
G_CALLBACK (csv_export_date_changed_cb), info);
/* Load Accounts */
show_acct_type_accounts (info);
update_accounts_tree (info);
}
/* File chooser Page */
info->file_page = GTK_WIDGET(gtk_builder_get_object(builder, "file_page"));
info->file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_SAVE);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_widget_set_size_request (button, 100, -1);
gtk_widget_show (button);
h_box = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start(GTK_BOX(h_box), button, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(info->file_chooser), h_box);
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK(csv_export_file_chooser_confirm_cb), info);
box = GTK_WIDGET(gtk_builder_get_object (builder, "file_page"));
gtk_box_pack_start (GTK_BOX (box), info->file_chooser, TRUE, TRUE, 6);
gtk_widget_show (info->file_chooser);
/* Finish Page */
info->finish_label = GTK_WIDGET(gtk_builder_get_object (builder, "end_page"));
/* Summary Page */
info->summary_label = GTK_WIDGET(gtk_builder_get_object (builder, "summary_page"));
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK(csv_export_assistant_destroy_cb), info);
gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(info->window));
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
{
GObject *object = gtk_builder_get_object (builder, "paned");
gnc_prefs_bind (GNC_PREFS_GROUP, GNC_PREF_PANED_POS, object, "position");
}
gtk_builder_connect_signals (builder, info);
g_object_unref (G_OBJECT(builder));
return window;
}
/***********************************************************************
* @todo Maybe invoice checking should be done in gnc_bi_import_fix_bis (...)
* rather than in here? But that is more concerned with ensuring the csv is consistent.
* @param GtkListStore *store
* @param guint *n_invoices_created
* @param guint *n_invoices_updated
* @return void
***********************************************************************/
void
gnc_bi_import_create_bis (GtkListStore * store, QofBook * book,
guint * n_invoices_created,
guint * n_invoices_updated,
gchar * type, gchar * open_mode, GString * info)
{
gboolean valid;
GtkTreeIter iter;
gchar *id, *date_opened, *owner_id, *billing_id, *notes;
gchar *date, *desc, *action, *account, *quantity, *price, *disc_type,
*disc_how, *discount, *taxable, *taxincluded, *tax_table;
gchar *date_posted, *due_date, *account_posted, *memo_posted,
*accumulatesplits;
guint dummy;
GncInvoice *invoice;
GncEntry *entry;
gint day, month, year;
gnc_numeric value;
GncOwner *owner;
Account *acc;
enum update {YES = GTK_RESPONSE_YES, NO = GTK_RESPONSE_NO} update;
GtkWidget *dialog;
Timespec today;
InvoiceWindow *iw;
gchar *new_id = NULL;
gint64 denom = 0;
gnc_commodity *currency;
// these arguments are needed
g_return_if_fail (store && book);
// logic of this function only works for bills or invoices
g_return_if_fail ((g_ascii_strcasecmp (type, "INVOICE") == 0) ||
(g_ascii_strcasecmp (type, "BILL") == 0));
// allow to call this function without statistics
if (!n_invoices_created)
n_invoices_created = &dummy;
if (!n_invoices_updated)
n_invoices_updated = &dummy;
*n_invoices_created = 0;
*n_invoices_updated = 0;
invoice = NULL;
update = NO;
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
while (valid)
{
// Walk through the list, reading each row
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
ID, &id,
DATE_OPENED, &date_opened,
DATE_POSTED, &date_posted, // if autoposting requested
DUE_DATE, &due_date, // if autoposting requested
ACCOUNT_POSTED, &account_posted, // if autoposting requested
MEMO_POSTED, &memo_posted, // if autoposting requested
ACCU_SPLITS, &accumulatesplits, // if autoposting requested
OWNER_ID, &owner_id,
BILLING_ID, &billing_id,
NOTES, ¬es,
DATE, &date,
DESC, &desc,
ACTION, &action,
ACCOUNT, &account,
QUANTITY, &quantity,
PRICE, &price,
DISC_TYPE, &disc_type,
DISC_HOW, &disc_how,
DISCOUNT, &discount,
TAXABLE, &taxable,
TAXINCLUDED, &taxincluded,
TAX_TABLE, &tax_table, -1);
// TODO: Assign a new invoice number if one is absent. BUT we don't want to assign a new invoice for every line!!
// so we'd have to flag this up somehow or add an option in the import GUI. The former implies that we make
// an assumption about what the importer (person) wants to do. It seems reasonable that a CSV file full of items with
// If an invoice exists then we add to it in this current schema.
// no predefined invoice number is a new invoice that's in need of a new number.
// This was not designed to satisfy the need for repeat invoices however, so maybe we need a another method for this, after all
// It should be easier to copy an invoice with a new ID than to go through all this malarky.
if (g_ascii_strcasecmp (type, "BILL") == 0)
invoice = gnc_search_bill_on_id (book, id);
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
invoice = gnc_search_invoice_on_id (book, id);
DEBUG( "Existing %s ID: %s\n", type, gncInvoiceGetID(invoice));
// If the search is empty then there is no existing invoice so make a new one
if (invoice == NULL)
{
DEBUG( "Creating a new : %s\n", type );
// new invoice
invoice = gncInvoiceCreate (book);
/* Protect against thrashing the DB and trying to write the invoice
* record prematurely */
gncInvoiceBeginEdit (invoice);
gncInvoiceSetID (invoice, id);
owner = gncOwnerNew ();
if (g_ascii_strcasecmp (type, "BILL") == 0)
gncOwnerInitVendor (owner,
gnc_search_vendor_on_id (book, owner_id));
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
gncOwnerInitCustomer (owner,
gnc_search_customer_on_id (book, owner_id));
gncInvoiceSetOwner (invoice, owner);
gncInvoiceSetCurrency (invoice, gncOwnerGetCurrency (owner)); // Set the invoice currency based on the owner
if (strlen (date_opened) != 0) // If a date is specified in CSV
{
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date_opened, &day, &month, &year);
gncInvoiceSetDateOpened (invoice,
gnc_dmy2timespec (day, month, year));
}
else // If no date in CSV
{
time64 now = gnc_time (NULL);
Timespec now_timespec;
timespecFromTime64 (&now_timespec, now);
gncInvoiceSetDateOpened (invoice, now_timespec);
}
gncInvoiceSetBillingID (invoice, billing_id ? billing_id : "");
gncInvoiceSetNotes (invoice, notes ? notes : "");
gncInvoiceSetActive (invoice, TRUE);
//if (g_ascii_strcasecmp(type,"INVOICE"))gncInvoiceSetBillTo( invoice, billto );
(*n_invoices_created)++;
update = YES;
// open new bill / invoice in a tab, if requested
if (g_ascii_strcasecmp(open_mode, "ALL") == 0
|| (g_ascii_strcasecmp(open_mode, "NOT_POSTED") == 0
&& strlen(date_posted) == 0))
{
iw = gnc_ui_invoice_edit (invoice);
gnc_plugin_page_invoice_new (iw);
}
gncInvoiceCommitEdit (invoice);
}
// I want to warn the user that an existing billvoice exists, but not every
// time.
// An import can contain many lines usually referring to the same invoice.
// NB: Posted invoices are NEVER updated.
else // if invoice exists
{
if (gncInvoiceIsPosted (invoice)) // Is it already posted?
{
valid =
gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
continue; // If already posted then never import
}
if (update != YES) // Pop up a dialog to ask if updates are the expected action
{
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_YES_NO,
"%s",
_("Are you sure you have bills/invoices to update?"));
update = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (update == NO)
{
// Cleanup and leave
g_free (id);
g_free (date_opened);
g_free (owner_id);
g_free (billing_id);
g_free (notes);
g_free (date);
g_free (desc);
g_free (action);
g_free (account);
g_free (quantity);
g_free (price);
g_free (disc_type);
g_free (disc_how);
g_free (discount);
g_free (taxable);
g_free (taxincluded);
g_free (tax_table);
g_free (date_posted);
g_free (due_date);
g_free (account_posted);
g_free (memo_posted);
g_free (accumulatesplits);
return;
}
}
(*n_invoices_updated)++;
}
// add entry to invoice/bill
entry = gncEntryCreate (book);
gncEntryBeginEdit(entry);
currency = gncInvoiceGetCurrency(invoice);
if (currency) denom = gnc_commodity_get_fraction(currency);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date, &day, &month, &year);
{
GDate *date = g_date_new_dmy(day, month, year);
gncEntrySetDateGDate (entry, date);
g_date_free (date);
}
timespecFromTime64 (&today, gnc_time (NULL)); // set today to the current date
gncEntrySetDateEntered (entry, today);
gncEntrySetDescription (entry, desc);
gncEntrySetAction (entry, action);
value = gnc_numeric_zero();
gnc_exp_parser_parse (quantity, &value, NULL);
gncEntrySetQuantity (entry, value);
acc = gnc_account_lookup_for_register (gnc_get_current_root_account (),
account);
if (g_ascii_strcasecmp (type, "BILL") == 0)
{
gncEntrySetBillAccount (entry, acc);
value = gnc_numeric_zero();
gnc_exp_parser_parse (price, &value, NULL);
gncEntrySetBillPrice (entry, value);
gncEntrySetBillTaxable (entry, text2bool (taxable));
gncEntrySetBillTaxIncluded (entry, text2bool (taxincluded));
gncEntrySetBillTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
gncEntryCommitEdit(entry);
gncBillAddEntry (invoice, entry);
}
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
{
gncEntrySetNotes (entry, notes);
gncEntrySetInvAccount (entry, acc);
value = gnc_numeric_zero();
gnc_exp_parser_parse (price, &value, NULL);
gncEntrySetInvPrice (entry, value);
gncEntrySetInvTaxable (entry, text2bool (taxable));
gncEntrySetInvTaxIncluded (entry, text2bool (taxincluded));
gncEntrySetInvTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
value = gnc_numeric_zero();
gnc_exp_parser_parse (discount, &value, NULL);
gncEntrySetInvDiscount (entry, value);
gncEntrySetInvDiscountType (entry, text2disc_type (disc_type));
gncEntrySetInvDiscountHow (entry, text2disc_how (disc_how));
gncEntryCommitEdit(entry);
gncInvoiceAddEntry (invoice, entry);
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
// handle auto posting of invoices
if (valid)
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &new_id, -1);
if (g_strcmp0 (id, new_id) != 0)
{
// the next invoice id is different => try to autopost this invoice
if (qof_scan_date (date_posted, &day, &month, &year))
{
// autopost this invoice
gboolean auto_pay;
Timespec d1, d2;
if (g_ascii_strcasecmp (type, "INVOICE") == 0)
auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_AUTO_PAY);
else
auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_BILL, GNC_PREF_AUTO_PAY);
d1 = gnc_dmy2timespec (day, month, year);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (due_date, &day, &month, &year); // obtains the due date, or leaves it at date_posted
d2 = gnc_dmy2timespec (day, month, year);
acc = gnc_account_lookup_for_register
(gnc_get_current_root_account (), account_posted);
gncInvoicePostToAccount (invoice, acc, &d1, &d2,
memo_posted,
text2bool (accumulatesplits),
auto_pay);
}
}
}
// cleanup
g_free (new_id);
g_free (id);
g_free (date_opened);
g_free (owner_id);
g_free (billing_id);
g_free (notes);
g_free (date);
g_free (desc);
g_free (action);
g_free (account);
g_free (quantity);
g_free (price);
g_free (disc_type);
g_free (disc_how);
g_free (discount);
g_free (taxable);
g_free (taxincluded);
g_free (tax_table);
g_free (date_posted);
g_free (due_date);
g_free (account_posted);
g_free (memo_posted);
g_free (accumulatesplits);
}
Transaction *
gnc_ab_trans_to_gnc(const AB_TRANSACTION *ab_trans, Account *gnc_acc)
{
QofBook *book;
Transaction *gnc_trans;
const gchar *fitid;
const GWEN_TIME *valuta_date;
time64 current_time;
const char *custref;
gchar *description;
Split *split;
gchar *memo;
g_return_val_if_fail(ab_trans && gnc_acc, NULL);
/* Create new GnuCash transaction for the given AqBanking one */
book = gnc_account_get_book(gnc_acc);
gnc_trans = xaccMallocTransaction(book);
xaccTransBeginEdit(gnc_trans);
/* Date / Time */
valuta_date = AB_Transaction_GetValutaDate(ab_trans);
if (!valuta_date)
{
const GWEN_TIME *normal_date = AB_Transaction_GetDate(ab_trans);
if (normal_date)
valuta_date = normal_date;
}
if (valuta_date)
xaccTransSetDatePostedSecsNormalized(gnc_trans, GWEN_Time_toTime_t(valuta_date));
else
g_warning("transaction_cb: Oops, date 'valuta_date' was NULL");
xaccTransSetDateEnteredSecs(gnc_trans, gnc_time (NULL));
/* Currency. We take simply the default currency of the gnucash account */
xaccTransSetCurrency(gnc_trans, xaccAccountGetCommodity(gnc_acc));
/* Trans-Num or Split-Action set with gnc_set_num_action below per book
* option */
/* Description */
description = gnc_ab_description_to_gnc(ab_trans);
xaccTransSetDescription(gnc_trans, description);
g_free(description);
/* Notes. */
/* xaccTransSetNotes(gnc_trans, g_notes); */
/* But Nobody ever uses the Notes field? */
/* Add one split */
split = xaccMallocSplit(book);
xaccSplitSetParent(split, gnc_trans);
xaccSplitSetAccount(split, gnc_acc);
/* Set the transaction number or split action field based on book option.
* We use the "customer reference", if there is one. */
custref = AB_Transaction_GetCustomerReference(ab_trans);
if (custref && *custref
&& g_ascii_strncasecmp(custref, "NONREF", 6) != 0)
gnc_set_num_action (gnc_trans, split, custref, NULL);
/* Set OFX unique transaction ID */
fitid = AB_Transaction_GetFiId(ab_trans);
if (fitid && *fitid)
gnc_import_set_split_online_id(split, fitid);
{
/* Amount into the split */
const AB_VALUE *ab_value = AB_Transaction_GetValue(ab_trans);
double d_value = ab_value ? AB_Value_GetValueAsDouble (ab_value) : 0.0;
AB_TRANSACTION_TYPE ab_type = AB_Transaction_GetType (ab_trans);
gnc_numeric gnc_amount;
/*printf("Transaction with value %f has type %d\n", d_value, ab_type);*/
/* If the value is positive, but the transaction type says the
money is transferred away from our account (Transfer instead of
DebitNote), we switch the value to negative. */
if (d_value > 0.0 && ab_type == AB_Transaction_TypeTransfer)
d_value = -d_value;
gnc_amount = double_to_gnc_numeric(
d_value,
xaccAccountGetCommoditySCU(gnc_acc),
GNC_HOW_RND_ROUND_HALF_UP);
if (!ab_value)
g_warning("transaction_cb: Oops, value was NULL. Using 0");
xaccSplitSetBaseValue(split, gnc_amount, xaccAccountGetCommodity(gnc_acc));
}
/* Memo in the Split. */
memo = gnc_ab_memo_to_gnc(ab_trans);
xaccSplitSetMemo(split, memo);
g_free(memo);
return gnc_trans;
}
void
gnc_date_format_refresh (GNCDateFormat *gdf)
{
GNCDateFormatPriv *priv;
int sel_option;
gboolean enable_year, enable_month, enable_custom, check_modifiers;
static gchar *format, *c;
gchar date_string[MAX_DATE_LEN];
time64 secs_now;
struct tm today;
g_return_if_fail(gdf);
g_return_if_fail(GNC_IS_DATE_FORMAT(gdf));
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
sel_option =
gtk_combo_box_get_active(GTK_COMBO_BOX(priv->format_combobox));
switch (sel_option)
{
case QOF_DATE_FORMAT_CUSTOM:
format = g_strdup(gtk_entry_get_text(GTK_ENTRY(priv->custom_entry)));
enable_year = enable_month = check_modifiers = FALSE;
enable_custom = TRUE;
break;
case QOF_DATE_FORMAT_LOCALE:
case QOF_DATE_FORMAT_UTC:
format = g_strdup(qof_date_format_get_string(sel_option));
enable_year = enable_month = check_modifiers = enable_custom = FALSE;
break;
case QOF_DATE_FORMAT_ISO:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->months_number), TRUE);
enable_year = check_modifiers = TRUE;
enable_month = enable_custom = FALSE;
break;
default:
enable_year = enable_month = check_modifiers = TRUE;
enable_custom = FALSE;
break;
}
/* Tweak widget sensitivities, as appropriate. */
gnc_date_format_enable_year(gdf, enable_year);
gnc_date_format_enable_month(gdf, enable_month);
gnc_date_format_enable_format(gdf, enable_custom);
/* Update the format string based upon the user's preferences */
if (check_modifiers)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_number)))
{
format = g_strdup(qof_date_format_get_string(sel_option));
}
else
{
format = g_strdup(qof_date_text_format_get_string(sel_option));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_name)))
{
c = strchr(format, 'b');
if (c)
*c = 'B';
}
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->years_button)))
{
c = strchr(format, 'y');
if (c)
*c = 'Y';
}
}
/*
* Give feedback on the format string so users can see how it works
* without having to read the strftime man page. Prevent recursive
* signals.
*/
g_signal_handlers_block_matched(priv->custom_entry, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, gdf);
gtk_entry_set_text(GTK_ENTRY(priv->custom_entry), format);
g_signal_handlers_unblock_matched(priv->custom_entry, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, gdf);
/* Visual feedback on what the date will look like. */
secs_now = gnc_time (NULL);
gnc_localtime_r (&secs_now, &today);
qof_strftime(date_string, MAX_DATE_LEN, format, &today);
gtk_label_set_text(GTK_LABEL(priv->sample_label), date_string);
g_free(format);
}
static AB_IMEXPORTER_ACCOUNTINFO *
bal_accountinfo_cb(AB_IMEXPORTER_ACCOUNTINFO *element, gpointer user_data)
{
GncABImExContextImport *data = user_data;
Account *gnc_acc;
AB_ACCOUNT_STATUS *item, *best = NULL;
const GWEN_TIME *best_time = NULL;
const AB_BALANCE *booked_bal, *noted_bal;
const AB_VALUE *booked_val = NULL, *noted_val = NULL;
gdouble booked_value, noted_value;
gnc_numeric value;
time64 booked_tt = 0;
GtkWidget *dialog;
gboolean show_recn_window = FALSE;
g_return_val_if_fail(element && data, NULL);
if (data->awaiting & IGNORE_BALANCES)
/* Ignore them */
return NULL;
if (!AB_ImExporterAccountInfo_GetFirstAccountStatus(element))
/* No balance found */
return NULL;
else
data->awaiting |= FOUND_BALANCES;
/* Lookup the most recent ACCOUNT_STATUS available */
item = AB_ImExporterAccountInfo_GetFirstAccountStatus(element);
while (item)
{
const GWEN_TIME *item_time = AB_AccountStatus_GetTime(item);
if (!best || GWEN_Time_Diff(best_time, item_time) < 0.0)
{
best = item;
best_time = item_time;
}
item = AB_ImExporterAccountInfo_GetNextAccountStatus(element);
}
booked_bal = AB_AccountStatus_GetBookedBalance(best);
if (!(data->awaiting & AWAIT_BALANCES))
{
/* Ignore zero balances if we don't await a balance */
if (!booked_bal || AB_Value_IsZero(AB_Balance_GetValue(booked_bal)))
return NULL;
/* Ask the user whether to import unawaited non-zero balance */
if (gnc_verify_dialog(data->parent, TRUE, "%s",
_("The bank has sent balance information "
"in its response."
"\n"
"Do you want to import it?")))
{
data->awaiting |= AWAIT_BALANCES;
}
else
{
data->awaiting |= IGNORE_BALANCES;
return NULL;
}
}
/* Lookup the corresponding gnucash account */
gnc_acc = gnc_ab_accinfo_to_gnc_acc(element);
if (!gnc_acc) return NULL;
data->gnc_acc = gnc_acc;
/* Lookup booked balance and time */
if (booked_bal)
{
const GWEN_TIME *ti = AB_Balance_GetTime(booked_bal);
if (ti)
{
booked_tt = GWEN_Time_toTime_t(ti);
}
else
{
/* No time found? Use today because the HBCI query asked for today's
* balance. */
booked_tt = gnc_time64_get_day_start(gnc_time(NULL));
}
booked_val = AB_Balance_GetValue(booked_bal);
if (booked_val)
{
booked_value = AB_Value_GetValueAsDouble(booked_val);
}
else
{
g_warning("bal_accountinfo_cb: booked_val == NULL. Assuming 0");
booked_value = 0.0;
}
}
else
{
g_warning("bal_accountinfo_cb: booked_bal == NULL. Assuming 0");
booked_tt = 0;
booked_value = 0.0;
}
/* Lookup noted balance */
noted_bal = AB_AccountStatus_GetNotedBalance(best);
if (noted_bal)
{
noted_val = AB_Balance_GetValue(noted_bal);
if (noted_val)
noted_value = AB_Value_GetValueAsDouble(noted_val);
else
{
g_warning("bal_accountinfo_cb: noted_val == NULL. Assuming 0");
noted_value = 0.0;
}
}
else
{
g_warning("bal_accountinfo_cb: noted_bal == NULL. Assuming 0");
noted_value = 0.0;
}
value = double_to_gnc_numeric(booked_value,
xaccAccountGetCommoditySCU(gnc_acc),
GNC_HOW_RND_ROUND_HALF_UP);
if (noted_value == 0.0 && booked_value == 0.0)
{
dialog = gtk_message_dialog_new(
GTK_WINDOW(data->parent),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s",
/* Translators: Strings from this file are needed only in
* countries that have one of aqbanking's Online Banking
* techniques available. This is 'OFX DirectConnect'
* (U.S. and others), 'HBCI' (in Germany), or 'YellowNet'
* (Switzerland). If none of these techniques are available
* in your country, you may safely ignore strings from the
* import-export/hbci subdirectory. */
_("The downloaded Online Banking Balance was zero.\n\n"
"Either this is the correct balance, or your bank does not "
"support Balance download in this Online Banking version. "
"In the latter case you should choose a different "
"Online Banking version number in the Online Banking "
"(AqBanking or HBCI) Setup. After that, try again to "
"download the Online Banking Balance."));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else
{
gnc_numeric reconc_balance = xaccAccountGetReconciledBalance(gnc_acc);
gchar *booked_str = gnc_AB_VALUE_to_readable_string(booked_val);
gchar *message1 = g_strdup_printf(
_("Result of Online Banking job: \n"
"Account booked balance is %s"),
booked_str);
gchar *message2 =
(noted_value == 0.0) ?
g_strdup("") :
g_strdup_printf(_("For your information: This account also "
"has a noted balance of %s\n"),
gnc_AB_VALUE_to_readable_string(noted_val));
if (gnc_numeric_equal(value, reconc_balance))
{
const gchar *message3 =
_("The booked balance is identical to the current "
"reconciled balance of the account.");
dialog = gtk_message_dialog_new(
GTK_WINDOW(data->parent),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s\n%s\n%s",
message1, message2, message3);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(GTK_WIDGET(dialog));
}
else
{
const char *message3 = _("Reconcile account now?");
show_recn_window = gnc_verify_dialog(data->parent, TRUE, "%s\n%s\n%s",
message1, message2, message3);
}
g_free(booked_str);
g_free(message1);
g_free(message2);
}
/* Show reconciliation window */
if (show_recn_window)
recnWindowWithBalance(data->parent, gnc_acc, value, booked_tt);
return NULL;
}
static GtkWidget *
gnc_stock_split_assistant_create (StockSplitInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder , "assistant-stock-split.glade", "stock_split_assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "stock_split_assistant"));
info->window = window;
// Set the style context for this assistant so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(window), "GncAssistStockSplit");
/* Enable buttons on first, second, fourth and last page. */
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "intro_page_label")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "stock_account_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "stock_cash_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "finish_page_label")),
TRUE);
/* Account page Widgets */
{
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
info->account_view = GTK_WIDGET(gtk_builder_get_object(builder, "account_view"));
view = GTK_TREE_VIEW(info->account_view);
// Set grid lines option to preference
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(view), gnc_tree_view_get_grid_lines_pref ());
store = gtk_list_store_new(NUM_SPLIT_COLS, G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(view, GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Account"), renderer,
"text", SPLIT_COL_FULLNAME,
NULL);
gtk_tree_view_append_column(view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Symbol"), renderer,
"text", SPLIT_COL_MNEMONIC,
NULL);
gtk_tree_view_append_column(view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Shares"), renderer,
"text", SPLIT_COL_SHARES,
NULL);
gtk_tree_view_append_column(view, column);
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed_cb), info);
}
/* Details Page Widgets */
{
GtkWidget *table;
GtkWidget *amount;
GtkWidget *date;
GtkWidget *label;
table = GTK_WIDGET(gtk_builder_get_object(builder, "stock_details_table"));
info->description_entry = GTK_WIDGET(gtk_builder_get_object(builder, "description_entry"));
date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
gtk_grid_attach (GTK_GRID(table), date, 1, 0, 1, 1);
gtk_widget_show (date);
info->date_edit = date;
label = GTK_WIDGET(gtk_builder_get_object(builder, "date_label"));
gnc_date_make_mnemonic_target (GNC_DATE_EDIT(date), label);
amount = gnc_amount_edit_new ();
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_details_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_grid_attach (GTK_GRID(table), amount, 1, 1, 1, 1);
gtk_widget_show (amount);
info->distribution_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "distribution_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
amount = gnc_amount_edit_new ();
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (amount),
gnc_default_price_print_info ());
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_details_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_grid_attach (GTK_GRID(table), amount, 1, 5, 1, 1);
gtk_widget_show (amount);
info->price_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "price_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
info->price_currency_edit = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(info->price_currency_edit), gnc_default_currency());
gtk_widget_show (info->price_currency_edit);
gtk_grid_attach (GTK_GRID(table), info->price_currency_edit, 1, 6, 1, 1);
}
/* Cash page Widgets */
{
GtkWidget *box;
GtkWidget *tree;
GtkWidget *amount;
GtkWidget *label;
GtkWidget *scroll;
GtkTreeSelection *selection;
box = GTK_WIDGET(gtk_builder_get_object(builder, "cash_box"));
amount = gnc_amount_edit_new ();
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_box_pack_start (GTK_BOX (box), amount, TRUE, TRUE, 0);
info->cash_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "cash_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
info->memo_entry = GTK_WIDGET(gtk_builder_get_object(builder, "memo_entry"));
/* income tree */
tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
info->income_tree = tree;
gnc_tree_view_account_set_filter (GNC_TREE_VIEW_ACCOUNT (tree),
gnc_stock_split_assistant_view_filter_income,
NULL, /* user data */
NULL /* destroy callback */);
gtk_widget_show (tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW(tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_unselect_all (selection);
g_signal_connect (selection, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
label = GTK_WIDGET(gtk_builder_get_object(builder, "income_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), tree);
scroll = GTK_WIDGET(gtk_builder_get_object(builder, "income_scroll"));
gtk_container_add (GTK_CONTAINER (scroll), tree);
/* asset tree */
tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
info->asset_tree = tree;
gnc_tree_view_account_set_filter (GNC_TREE_VIEW_ACCOUNT (tree),
gnc_stock_split_assistant_view_filter_asset,
NULL /* user data */,
NULL /* destroy callback */);
gtk_widget_show (tree);
label = GTK_WIDGET(gtk_builder_get_object(builder, "asset_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), tree);
scroll = GTK_WIDGET(gtk_builder_get_object(builder, "asset_scroll"));
gtk_container_add (GTK_CONTAINER (scroll), tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW(tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_unselect_all (selection);
g_signal_connect (selection, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
}
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK (gnc_stock_split_assistant_window_destroy_cb), info);
gtk_builder_connect_signals(builder, info);
g_object_unref(G_OBJECT(builder));
return window;
}
