/* Constructor */
GNCImportSettings *
gnc_import_Settings_new (void)
{
GNCImportSettings * settings;
settings = g_new0 ( GNCImportSettings, 1);
settings->action_skip_enabled =
gnc_prefs_get_bool (GNC_PREFS_GROUP_IMPORT, GNC_PREF_ENABLE_SKIP);
settings->action_update_enabled =
gnc_prefs_get_bool (GNC_PREFS_GROUP_IMPORT, GNC_PREF_ENABLE_UPDATE);
settings->action_add_enabled = DEFAULT_ACTION_ADD_ENABLED;
settings->action_clear_enabled = DEFAULT_ACTION_CLEAR_ENABLED;
settings->clear_threshold =
(int)gnc_prefs_get_float (GNC_PREFS_GROUP_IMPORT, GNC_PREF_AUTO_CLEAR_THRESHOLD);
settings->add_threshold =
(int)gnc_prefs_get_float (GNC_PREFS_GROUP_IMPORT, GNC_PREF_AUTO_ADD_THRESHOLD);
settings->display_threshold =
(int)gnc_prefs_get_float (GNC_PREFS_GROUP_IMPORT, GNC_PREF_MATCH_THRESHOLD);
settings->fuzzy_amount =
gnc_prefs_get_float (GNC_PREFS_GROUP_IMPORT, GNC_PREF_ATM_FEE_THRESHOLD);
settings->match_date_hardlimit = 42; /* 6 weeks */
return settings;
}
static SplitRegisterStyle
gnc_get_default_register_style (GNCAccountType type)
{
SplitRegisterStyle new_style = REG_STYLE_LEDGER;
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
GNC_PREF_DEFAULT_STYLE_JOURNAL))
new_style = REG_STYLE_JOURNAL;
else if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
GNC_PREF_DEFAULT_STYLE_AUTOLEDGER))
new_style = REG_STYLE_AUTO_LEDGER;
return new_style;
}
static void
gnc_plugin_page_invoice_init (GncPluginPageInvoice *plugin_page)
{
GncPluginPage *parent;
GtkActionGroup *action_group;
gboolean use_new;
/* Init parent declared variables */
parent = GNC_PLUGIN_PAGE(plugin_page);
use_new = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_USE_NEW);
g_object_set(G_OBJECT(plugin_page),
"page-name", _("Invoice"),
"page-uri", "default:",
"ui-description", "gnc-plugin-page-invoice-ui.xml",
"use-new-window", use_new,
(char *)NULL);
/* change me when the system supports multiple books */
gnc_plugin_page_add_book(parent, gnc_get_current_book());
/* Create menu and toolbar information */
action_group =
gnc_plugin_page_create_action_group(parent,
"GncPluginPageInvoiceActions");
gtk_action_group_add_actions (action_group, gnc_plugin_page_invoice_actions,
gnc_plugin_page_invoice_n_actions, plugin_page);
gtk_action_group_add_radio_actions (action_group,
radio_entries, n_radio_entries,
REG_STYLE_LEDGER,
G_CALLBACK(gnc_plugin_page_invoice_cmd_sort_changed),
plugin_page);
gnc_plugin_init_short_names (action_group, toolbar_labels);
}
void
gnc_GWEN_Init(void)
{
gchar* gwen_logging = g_strdup(g_getenv("GWEN_LOGLEVEL"));
gchar* aqb_logging = g_strdup(g_getenv("AQBANKING_LOGLEVEL"));
/* Initialize gwen library */
GWEN_Init();
/* Initialize gwen logging */
if (gnc_prefs_get_bool(GNC_PREFS_GROUP_AQBANKING, GNC_PREF_VERBOSE_DEBUG))
{
if (!gwen_logging)
{
GWEN_Logger_SetLevel(NULL, GWEN_LoggerLevel_Info);
GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, GWEN_LoggerLevel_Info);
}
if (!aqb_logging)
GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, GWEN_LoggerLevel_Debug);
}
else
{
if (!gwen_logging)
{
GWEN_Logger_SetLevel(NULL, GWEN_LoggerLevel_Error);
GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, GWEN_LoggerLevel_Error);
}
if (!aqb_logging)
GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, GWEN_LoggerLevel_Warning);
}
g_free(gwen_logging);
g_free(aqb_logging);
gnc_GWEN_Gui_log_init();
}
/********************************************************************\
* gnc_restore_window_size *
* restores the position and size of the given window, if these *
* these parameters have been saved earlier. Does nothing if no *
* saved values are found. *
* *
* Args: group - the preferences group to look in for saved coords *
* window - the window for which the coords are to be *
* restored *
* Returns: nothing *
\*******************************************************************/
void
gnc_restore_window_size(const char *group, GtkWindow *window)
{
gint wpos[2], wsize[2];
GVariant *geometry;
ENTER("");
g_return_if_fail(group != NULL);
g_return_if_fail(window != NULL);
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
return;
geometry = gnc_prefs_get_value (group, GNC_PREF_LAST_GEOMETRY);
if (g_variant_is_of_type (geometry, (const GVariantType *) "(iiii)") )
{
gint screen_width;
gint screen_height;
#if GTK_CHECK_VERSION(3,22,0)
GdkWindow *win = gdk_screen_get_root_window (gtk_window_get_screen (window));
GdkMonitor *mon = gdk_display_get_monitor_at_window (gtk_widget_get_display (GTK_WIDGET(window)), win);
GdkRectangle monitor_size;
gdk_monitor_get_geometry (mon, &monitor_size);
screen_width = monitor_size.width;
screen_height = monitor_size.height;
#else
screen_width = gdk_screen_width(); //default screen
screen_height = gdk_screen_height(); //default screen
#endif
g_variant_get (geometry, "(iiii)",
&wpos[0], &wpos[1],
&wsize[0], &wsize[1]);
DEBUG("geometry from preferences - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
/* (-1, -1) means no geometry was saved (default preferences value) */
if ((wpos[0] != -1) && (wpos[1] != -1))
{
/* Keep the window on screen if possible */
if (screen_width != 0)
wpos[0] = wpos[0] % screen_width;
if (screen_height != 0)
wpos[1] = wpos[1] % screen_height;
DEBUG("geometry after screen adaption - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
gtk_window_move(window, wpos[0], wpos[1]);
}
/* Don't attempt to restore invalid sizes */
if ((wsize[0] > 0) && (wsize[1] > 0))
gtk_window_resize(window, wsize[0], wsize[1]);
}
g_variant_unref (geometry);
LEAVE("");
}
/********************************************************************\
* gnc_set_label_color *
* sets the color of the label given the value *
* *
* Args: label - gtk label widget *
* value - value to use to set color *
* Returns: none *
\*******************************************************************/
void
gnc_set_label_color(GtkWidget *label, gnc_numeric value)
{
gboolean deficit;
GdkColormap *cm;
GtkStyle *style;
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_NEGATIVE_IN_RED))
return;
cm = gtk_widget_get_colormap(GTK_WIDGET(label));
gtk_widget_ensure_style(GTK_WIDGET(label));
style = gtk_widget_get_style(GTK_WIDGET(label));
style = gtk_style_copy(style);
deficit = gnc_numeric_negative_p (value);
if (deficit)
{
gnc_get_deficit_color(&style->fg[GTK_STATE_NORMAL]);
gdk_colormap_alloc_color(cm, &style->fg[GTK_STATE_NORMAL], FALSE, TRUE);
}
else
style->fg[GTK_STATE_NORMAL] = style->black;
gtk_widget_set_style(label, style);
g_object_unref(style);
}
static void
gnc_tree_model_owner_init (GncTreeModelOwner *model)
{
GncTreeModelOwnerPrivate *priv;
gboolean red;
ENTER("model %p", model);
while (model->stamp == 0)
{
model->stamp = g_random_int ();
}
red = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_NEGATIVE_IN_RED);
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
priv->book = NULL;
priv->owner_list = NULL;
priv->owner_type = GNC_OWNER_NONE;
priv->negative_color = red ? "red" : NULL;
gnc_prefs_register_cb(GNC_PREFS_GROUP_GENERAL, GNC_PREF_NEGATIVE_IN_RED,
gnc_tree_model_owner_update_color,
model);
LEAVE(" ");
}
void
gnc_sx_sxsincelast_book_opened(void)
{
GList *auto_created_txns = NULL;
GncSxInstanceModel *inst_model;
GncSxSummary summary;
if (!gnc_prefs_get_bool (GNC_PREFS_GROUP_STARTUP, GNC_PREF_RUN_AT_FOPEN))
return;
if (qof_book_is_readonly(gnc_get_current_book()))
{
/* Is the book read-only? Then don't change anything here. */
return;
}
inst_model = gnc_sx_get_current_instances();
gnc_sx_instance_model_summarize(inst_model, &summary);
gnc_sx_summary_print(&summary);
gnc_sx_instance_model_effect_change(inst_model, TRUE, &auto_created_txns, NULL);
if (summary.need_dialog)
{
gnc_ui_sx_since_last_run_dialog(inst_model, auto_created_txns);
auto_created_txns = NULL;
}
else
{
if (summary.num_auto_create_no_notify_instances != 0)
{
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_STARTUP, GNC_PREF_SHOW_AT_FOPEN))
return;
gnc_info_dialog
(NULL,
ngettext
("There are no Scheduled Transactions to be entered at this time. "
"(One transaction automatically created)",
"There are no Scheduled Transactions to be entered at this time. "
"(%d transactions automatically created)",
summary.num_auto_create_no_notify_instances),
summary.num_auto_create_no_notify_instances);
}
}
g_list_free(auto_created_txns);
g_object_unref(G_OBJECT(inst_model));
}
void
gnc_totd_dialog (GtkWindow *parent, gboolean startup)
{
TotdDialog *totd_dialog;
GtkBuilder *builder;
GtkWidget *dialog, *button;
GtkTextView *textview;
gboolean show_tips;
totd_dialog = g_new0 (TotdDialog, 1);
show_tips = gnc_prefs_get_bool(GNC_PREFS_GROUP, GNC_PREF_SHOW_TIPS);
if (startup && !show_tips)
return;
if (tip_count == -1)
{
if (!gnc_totd_initialize())
return;
current_tip_number = gnc_prefs_get_int(GNC_PREFS_GROUP, GNC_PREF_CURRENT_TIP);
}
if (gnc_forall_gui_components(DIALOG_TOTD_CM_CLASS, show_handler, NULL))
{
return;
}
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-totd.glade", "totd_dialog");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "totd_dialog"));
gtk_window_set_transient_for(GTK_WINDOW (dialog), parent);
totd_dialog->dialog = dialog;
ENTER("totd_dialog %p, dialog %p", totd_dialog, dialog);
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, totd_dialog);
button = GTK_WIDGET(gtk_builder_get_object (builder, "show_checkbutton"));
totd_dialog->showcheck_button = button;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), show_tips);
textview = GTK_TEXT_VIEW(gtk_builder_get_object (builder, "tip_textview"));
totd_dialog->textview = textview;
gnc_new_tip_number(totd_dialog, 1);
gnc_restore_window_size(GNC_PREFS_GROUP, GTK_WINDOW(totd_dialog->dialog));
gtk_widget_show(GTK_WIDGET (totd_dialog->dialog));
gnc_register_gui_component(DIALOG_TOTD_CM_CLASS,
NULL, close_handler, totd_dialog);
g_object_unref(G_OBJECT(builder));
LEAVE("");
}
static void
file_retain_type_changed_cb(gpointer gsettings, gchar *key, gpointer user_data)
{
XMLFileRetentionType type = XML_RETAIN_ALL;
if (gnc_prefs_is_set_up())
{
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_RETAIN_TYPE_NEVER))
type = XML_RETAIN_NONE;
else if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_RETAIN_TYPE_DAYS))
type = XML_RETAIN_DAYS;
else if (!gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_RETAIN_TYPE_FOREVER))
PWARN("no file retention policy was set, assuming conservative policy 'forever'");
gnc_prefs_set_file_retention_policy (type);
}
}
static void
gnc_ui_hierarchy_assistant_hook (void)
{
if (gnc_prefs_get_bool(GNC_PREFS_GROUP, GNC_PREF_SHOW_ON_NEW_FILE))
{
gnc_ui_hierarchy_assistant_with_callback(TRUE, after_assistant);
}
}
static void
gnc_commodities_dialog_create (GtkWidget * parent, CommoditiesDialog *cd)
{
GtkWidget *button;
GtkWidget *scrolled_window;
GtkBuilder *builder;
GtkTreeView *view;
GtkTreeSelection *selection;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-commodities.glade", "securities_dialog");
cd->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "securities_dialog"));
cd->session = gnc_get_current_session();
cd->book = qof_session_get_book(cd->session);
cd->show_currencies = gnc_prefs_get_bool(GNC_PREFS_GROUP, GNC_PREF_INCL_ISO);
// Set the style context for this dialog so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(cd->dialog), "GncCommoditiesDialog");
gtk_builder_connect_signals(builder, cd);
/* parent */
if (parent != NULL)
gtk_window_set_transient_for (GTK_WINDOW (cd->dialog), GTK_WINDOW (parent));
/* buttons */
cd->remove_button = GTK_WIDGET(gtk_builder_get_object (builder, "remove_button"));
cd->edit_button = GTK_WIDGET(gtk_builder_get_object (builder, "edit_button"));
/* commodity tree */
scrolled_window = GTK_WIDGET(gtk_builder_get_object (builder, "commodity_list_window"));
view = gnc_tree_view_commodity_new(cd->book,
"state-section", STATE_SECTION,
"show-column-menu", TRUE,
NULL);
cd->commodity_tree = GNC_TREE_VIEW_COMMODITY(view);
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET(view));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(cd->commodity_tree), TRUE);
gnc_tree_view_commodity_set_filter (cd->commodity_tree,
gnc_commodities_dialog_filter_ns_func,
gnc_commodities_dialog_filter_cm_func,
cd, NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (gnc_commodities_dialog_selection_changed), cd);
g_signal_connect (G_OBJECT (cd->commodity_tree), "row-activated",
G_CALLBACK (row_activated_cb), cd);
/* Show currency button */
button = GTK_WIDGET(gtk_builder_get_object (builder, "show_currencies_button"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(button), cd->show_currencies);
g_object_unref(G_OBJECT(builder));
gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(cd->dialog), GTK_WINDOW(parent));
}
static void
file_compression_changed_cb(gpointer gsettings, gchar *key, gpointer user_data)
{
if (gnc_prefs_is_set_up())
{
gboolean file_compression = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_FILE_COMPRESSION);
gnc_prefs_set_file_save_compressed (file_compression);
}
}
/********************************************************************\
* Get the preference for showing tree view grid lines *
* *
* Args: none *
* Returns: GtkTreeViewGridLines setting *
\********************************************************************/
GtkTreeViewGridLines
gnc_tree_view_get_grid_lines_pref (void)
{
GtkTreeViewGridLines grid_lines;
gboolean h_lines = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, "grid-lines-horizontal");
gboolean v_lines = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, "grid-lines-vertical");
if (h_lines)
{
if (v_lines)
grid_lines = GTK_TREE_VIEW_GRID_LINES_BOTH;
else
grid_lines = GTK_TREE_VIEW_GRID_LINES_HORIZONTAL;
}
else if (v_lines)
grid_lines = GTK_TREE_VIEW_GRID_LINES_VERTICAL;
else
grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
return grid_lines;
}
/** Tell the GncTreeModelOwner code to update the color that it will
* use for negative numbers. This function will iterate over all
* existing models and update their setting.
*
* @internal
*/
static void
gnc_tree_model_owner_update_color (gpointer gsettings, gchar *key, gpointer user_data)
{
GncTreeModelOwnerPrivate *priv;
GncTreeModelOwner *model;
gboolean use_red;
g_return_if_fail(GNC_IS_TREE_MODEL_OWNER(user_data));
model = user_data;
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
use_red = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_NEGATIVE_IN_RED);
priv->negative_color = use_red ? "red" : NULL;
}
/********************************************************************\
* gnc_set_label_color *
* sets the color of the label given the value *
* *
* Args: label - gtk label widget *
* value - value to use to set color *
* Returns: none *
\*******************************************************************/
void
gnc_set_label_color(GtkWidget *label, gnc_numeric value)
{
gboolean deficit;
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_NEGATIVE_IN_RED))
return;
deficit = gnc_numeric_negative_p (value);
if (deficit)
gnc_widget_set_style_context (GTK_WIDGET(label), "negative-numbers");
else
gnc_widget_set_style_context (GTK_WIDGET(label), "default-color");
}
/********************************************************************\
* gnc_restore_window_size *
* restores the position and size of the given window, if these *
* these parameters have been saved earlier. Does nothing if no *
* saved values are found. *
* *
* Args: group - the preferences group to look in for saved coords *
* window - the window for which the coords are to be *
* restored *
* Returns: nothing *
\*******************************************************************/
void
gnc_restore_window_size(const char *group, GtkWindow *window)
{
gint wpos[2], wsize[2];
GVariant *geometry;
ENTER("");
g_return_if_fail(group != NULL);
g_return_if_fail(window != NULL);
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
return;
geometry = gnc_prefs_get_value (group, GNC_PREF_LAST_GEOMETRY);
if (g_variant_is_of_type (geometry, (const GVariantType *) "(iiii)") )
{
gint screen_width = gdk_screen_width();
gint screen_height = gdk_screen_height();
g_variant_get (geometry, "(iiii)",
&wpos[0], &wpos[1],
&wsize[0], &wsize[1]);
DEBUG("geometry from preferences - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
/* (-1, -1) means no geometry was saved (default preferences value) */
if ((wpos[0] != -1) && (wpos[1] != -1))
{
/* Keep the window on screen if possible */
if (screen_width != 0)
wpos[0] = wpos[0] % screen_width;
if (screen_height != 0)
wpos[1] = wpos[1] % screen_height;
DEBUG("geometry after screen adaption - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
gtk_window_move(window, wpos[0], wpos[1]);
}
/* Don't attempt to restore invalid sizes */
if ((wsize[0] > 0) && (wsize[1] > 0))
gtk_window_resize(window, wsize[0], wsize[1]);
}
g_variant_unref (geometry);
LEAVE("");
}
static time64
lookup_end_date_option(GDate *fy_end)
{
time64 time;
int which;
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_ACCT_SUMMARY, GNC_PREF_END_CHOICE_ABS))
time = gnc_prefs_get_int64 (GNC_PREFS_GROUP_ACCT_SUMMARY, GNC_PREF_END_DATE);
else
{
which = gnc_prefs_get_int(GNC_PREFS_GROUP_ACCT_SUMMARY, GNC_PREF_END_PERIOD);
time = gnc_accounting_period_end_time64(which, fy_end, NULL);
}
if (time == 0)
time = -1;
return time;
}
/* gnc_configure_date_completion
* sets dateCompletion to the current value on the scheme side.
* QOF_DATE_COMPLETION_THISYEAR: use current year
* QOF_DATE_COMPLETION_SLIDING: use a sliding 12-month window
* backmonths 0-11: windows starts this many months before current month
*
* Args: Nothing
* Returns: Nothing
*/
static void
gnc_configure_date_completion (void)
{
QofDateCompletion dc = QOF_DATE_COMPLETION_THISYEAR;
int backmonths = gnc_prefs_get_float(GNC_PREFS_GROUP_GENERAL,
GNC_PREF_DATE_BACKMONTHS);
if (backmonths < 0)
backmonths = 0;
else if (backmonths > 11)
backmonths = 11;
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_DATE_COMPL_SLIDING))
dc = QOF_DATE_COMPLETION_SLIDING;
qof_date_completion_set(dc, backmonths);
}
void
gnc_table_save_state (Table *table, gchar * state_key)
{
GnucashSheet *sheet;
GNCHeaderWidths widths;
GList *node;
gchar *key;
if (!table)
return;
if (table->ui_data == NULL)
return;
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
return;
sheet = GNUCASH_SHEET (table->ui_data);
widths = gnc_header_widths_new ();
gnucash_sheet_get_header_widths (sheet, widths);
node = gnc_table_layout_get_cells (table->layout);
for (; node; node = node->next)
{
BasicCell *cell = node->data;
int width;
width = gnc_header_widths_get_width (widths, cell->cell_name);
if (width <= 0)
continue;
if (cell->expandable)
continue;
/* Remember whether the column is visible */
key = g_strdup_printf("%s_width", cell->cell_name);
// FIXME the actual state saving is currently not implemented
g_free(key);
}
gnc_header_widths_destroy (widths);
}
/********************************************************************\
* gnc_save_window_size *
* save the window position and size into options whose names are *
* prefixed by the group name. *
* *
* Args: group - preferences group to save the options in *
* window - the window for which current position and size *
* are to be saved *
* Returns: nothing *
\********************************************************************/
void
gnc_save_window_size(const char *group, GtkWindow *window)
{
gint wpos[2], wsize[2];
GVariant *geometry;
g_return_if_fail(group != NULL);
g_return_if_fail(window != NULL);
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
return;
gtk_window_get_position(GTK_WINDOW(window), &wpos[0], &wpos[1]);
gtk_window_get_size(GTK_WINDOW(window), &wsize[0], &wsize[1]);
geometry = g_variant_new ("(iiii)", wpos[0], wpos[1],
wsize[0], wsize[1]);
gnc_prefs_set_value (group, GNC_PREF_LAST_GEOMETRY, geometry);
/* Don't unref geometry here, it is consumed by gnc_prefs_set_value */
}
static void
gnc_plugin_page_invoice_summarybar_position_changed(gpointer prefs, gchar *pref, gpointer user_data)
{
GncPluginPage *plugin_page;
GncPluginPageInvoice *page;
GncPluginPageInvoicePrivate *priv;
GtkPositionType position = GTK_POS_BOTTOM;
g_return_if_fail(user_data != NULL);
plugin_page = GNC_PLUGIN_PAGE(user_data);
page = GNC_PLUGIN_PAGE_INVOICE (user_data);
priv = GNC_PLUGIN_PAGE_INVOICE_GET_PRIVATE(page);
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SUMMARYBAR_POSITION_TOP))
position = GTK_POS_TOP;
gtk_box_reorder_child(GTK_BOX(priv->widget),
plugin_page->summarybar,
(position == GTK_POS_TOP ? 0 : -1) );
}
static time64
lookup_start_date_option(GDate *fy_end)
{
gchar *choice;
time64 time;
int which;
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_ACCT_SUMMARY, GNC_PREF_START_CHOICE_ABS))
time = gnc_prefs_get_int64 (GNC_PREFS_GROUP_ACCT_SUMMARY, GNC_PREF_START_DATE);
else
{
which = gnc_prefs_get_int(GNC_PREFS_GROUP_ACCT_SUMMARY, GNC_PREF_START_PERIOD);
time = gnc_accounting_period_start_time64(which, fy_end, NULL);
}
/* we will need the balance of the last transaction before the start
date, so subtract 1 from start date */
/* CAS: we don't actually do what this comment says. I think that's
because a bug in the engine has been fixed. */
return time;
}
/************************************************************************\
* gnc_get_credit_string *
* return a credit string for a given account type *
* *
* Args: account_type - type of account to get credit string for *
* Return: g_malloc'd credit string or NULL, must be freed with g_free *
\************************************************************************/
char *
gnc_get_credit_string(GNCAccountType account_type)
{
SCM result;
SCM arg;
initialize_scm_functions();
if (gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_ACCOUNTING_LABELS))
return g_strdup(_("Credit"));
if ((account_type < ACCT_TYPE_NONE) || (account_type >= NUM_ACCOUNT_TYPES))
account_type = ACCT_TYPE_NONE;
arg = scm_from_long (account_type);
result = scm_call_1(getters.credit_string, arg);
if (!scm_is_string(result))
return NULL;
return gnc_scm_to_utf8_string(result);
}
void
gnc_options_dialog_set_new_book_option_values (GNCOptionDB *odb)
{
GNCOption *num_source_option;
GtkWidget *num_source_is_split_action_button;
gboolean num_source_is_split_action;
if (!odb) return;
num_source_is_split_action = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL,
GNC_PREF_NUM_SOURCE);
if (num_source_is_split_action)
{
num_source_option = gnc_option_db_get_option_by_name(odb,
OPTION_SECTION_ACCOUNTS,
OPTION_NAME_NUM_FIELD_SOURCE);
num_source_is_split_action_button =
gnc_option_get_gtk_widget (num_source_option);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (num_source_is_split_action_button),
num_source_is_split_action);
}
}
/* XXX This code is a cut-n-paste job from the SplitRegister code;
* the split-register should be generalized to the point where a cut-n-paste
* like this isn't required, and this should be trashed.
*/
void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
{
GncEntry *blank_entry, *find_entry;
CursorBuffer *cursor_buffer;
Table *table;
GList *node;
CellBlock *cursor_header, *cursor;
VirtualCellLocation vcell_loc;
VirtualLocation save_loc;
gboolean start_primary_color = TRUE;
int new_entry_row = -1;
if (!ledger) return;
/* Load up cells */
load_discount_type_cells (ledger);
load_discount_how_cells (ledger);
gnc_entry_ledger_load_xfer_cells (ledger);
blank_entry = gnc_entry_ledger_get_blank_entry (ledger);
if (blank_entry == NULL && ledger->invoice == NULL && entry_list == NULL)
return;
if (blank_entry == NULL && ledger->invoice)
{
switch (ledger->type)
{
case GNCENTRY_ORDER_ENTRY:
case GNCENTRY_INVOICE_ENTRY:
case GNCENTRY_BILL_ENTRY:
case GNCENTRY_EXPVOUCHER_ENTRY:
case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
gnc_suspend_gui_refresh ();
blank_entry = gncEntryCreate (ledger->book);
gncEntrySetDateGDate (blank_entry, &ledger->last_date_entered);
ledger->blank_entry_guid = *gncEntryGetGUID (blank_entry);
gnc_resume_gui_refresh ();
/* The rest of this does not apply to expense vouchers */
if (ledger->type != GNCENTRY_EXPVOUCHER_ENTRY)
{
const GncOwner *owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (ledger->invoice));
GncTaxTable *table = NULL;
GncTaxIncluded taxincluded_p = GNC_TAXINCLUDED_USEGLOBAL;
gboolean taxincluded = FALSE;
gnc_numeric discount = gnc_numeric_zero ();
gnc_numeric price = gnc_numeric_zero ();
/* Determine the Price from Customer's or Vendor's Job */
switch (gncOwnerGetType (gncInvoiceGetOwner (ledger->invoice)))
{
case GNC_OWNER_JOB:
price = gncJobGetRate( gncOwnerGetJob (gncInvoiceGetOwner (ledger->invoice)));
break;
default:
break;
}
/* Determine the TaxIncluded and Discount values */
switch (gncOwnerGetType (owner))
{
case GNC_OWNER_CUSTOMER:
taxincluded_p = gncCustomerGetTaxIncluded (owner->owner.customer);
discount = gncCustomerGetDiscount (owner->owner.customer);
break;
case GNC_OWNER_VENDOR:
taxincluded_p = gncVendorGetTaxIncluded (owner->owner.vendor);
break;
default:
break;
}
/* Compute the default taxincluded */
switch (taxincluded_p)
{
case GNC_TAXINCLUDED_YES:
taxincluded = TRUE;
break;
case GNC_TAXINCLUDED_NO:
taxincluded = FALSE;
break;
case GNC_TAXINCLUDED_USEGLOBAL:
if (ledger->prefs_group)
{
taxincluded = gnc_prefs_get_bool (ledger->prefs_group, GNC_PREF_TAX_INCL);
}
else
{
taxincluded = FALSE;
}
break;
}
/* Compute the proper taxtable */
switch (gncOwnerGetType (owner))
{
case GNC_OWNER_CUSTOMER:
table = gnc_business_get_default_tax_table (ledger->book,
GNC_OWNER_CUSTOMER);
if (gncCustomerGetTaxTableOverride (owner->owner.customer))
table = gncCustomerGetTaxTable (owner->owner.customer);
break;
case GNC_OWNER_VENDOR:
table = gnc_business_get_default_tax_table (ledger->book,
GNC_OWNER_VENDOR);
if (gncVendorGetTaxTableOverride (owner->owner.vendor))
table = gncVendorGetTaxTable (owner->owner.vendor);
break;
default:
break;
}
if (ledger->is_cust_doc)
{
gncEntrySetInvTaxTable (blank_entry, table);
gncEntrySetInvTaxIncluded (blank_entry, taxincluded);
gncEntrySetInvDiscount (blank_entry, discount);
gncEntrySetInvPrice (blank_entry, price);
}
else
{
gncEntrySetBillTaxTable (blank_entry, table);
gncEntrySetBillTaxIncluded (blank_entry, taxincluded);
gncEntrySetBillPrice (blank_entry, price);
}
}
break;
default:
ledger->blank_entry_guid = *guid_null ();
break;
}
ledger->blank_entry_edited = FALSE;
}
table = ledger->table;
gnc_table_leave_update (table, table->current_cursor_loc);
save_loc = table->current_cursor_loc;
/* Figure out where we are going to */
if (ledger->traverse_to_new)
{
find_entry = blank_entry;
}
else if (ledger->hint_entry)
{
find_entry = ledger->hint_entry;
}
else
{
find_entry = gnc_entry_ledger_get_current_entry(ledger);
/* XXX: get current entry (cursor_hint_xxx) */
}
/* If the current cursor has changed we save the values for later
* possible restoration. */
if (gnc_table_current_cursor_changed (table, TRUE) &&
(find_entry == gnc_entry_ledger_get_current_entry (ledger)))
{
cursor_buffer = gnc_cursor_buffer_new ();
gnc_table_save_current_cursor (table, cursor_buffer);
}
else
cursor_buffer = NULL;
/* disable move callback -- we don't want the cascade of
* callbacks while we are fiddling with loading the register */
gnc_table_control_allow_move (table->control, FALSE);
/* invalidate the cursor */
{
VirtualLocation virt_loc;
virt_loc.vcell_loc.virt_row = -1;
virt_loc.vcell_loc.virt_col = -1;
virt_loc.phys_row_offset = -1;
virt_loc.phys_col_offset = -1;
gnc_table_move_cursor_gui (table, virt_loc);
}
/* make sure that the header is loaded */
vcell_loc.virt_row = 0;
vcell_loc.virt_col = 0;
cursor_header = gnc_table_layout_get_cursor (table->layout, CURSOR_HEADER);
gnc_table_set_vcell (table, cursor_header, NULL, TRUE, TRUE, vcell_loc);
vcell_loc.virt_row++;
/* get the current time and reset the dividing row */
table->model->dividing_row_upper = -1;
table->model->dividing_row = -1;
table->model->dividing_row_lower = -1;
cursor = gnc_table_layout_get_cursor (table->layout, "cursor");
/* Populate the table */
for (node = entry_list; node; node = node->next)
{
GncEntry *entry = node->data;
/* Don't load the blank entry */
if (entry == blank_entry)
continue;
/* If this is the first load of the ledger, fill the quickfill cells */
{
/* XXX */
}
if (entry == find_entry)
new_entry_row = vcell_loc.virt_row;
gnc_table_set_vcell (table, cursor, gncEntryGetGUID (entry),
TRUE, start_primary_color, vcell_loc);
vcell_loc.virt_row++;
/* Flip color for the next guy */
start_primary_color = !start_primary_color;
}
/* Add the blank entry at the end. */
if (blank_entry)
{
gnc_table_set_vcell (table, cursor, gncEntryGetGUID (blank_entry),
TRUE, start_primary_color, vcell_loc);
if (find_entry == blank_entry)
new_entry_row = vcell_loc.virt_row;
vcell_loc.virt_row++;
}
/* Resize the table */
gnc_table_set_size (table, vcell_loc.virt_row, 1);
/* Restore the cursor to its rightful position */
if (new_entry_row > 0)
save_loc.vcell_loc.virt_row = new_entry_row;
if (gnc_table_find_close_valid_cell (table, &save_loc, FALSE))
{
gnc_table_move_cursor_gui (table, save_loc);
if (find_entry == gnc_entry_ledger_get_current_entry (ledger))
gnc_table_restore_current_cursor (table, cursor_buffer);
}
gnc_cursor_buffer_destroy (cursor_buffer);
cursor_buffer = NULL;
/* Reset the ledger */
ledger->traverse_to_new = FALSE;
ledger->hint_entry = NULL;
/* Set the cell fractions */
gnc_table_refresh_gui (table, TRUE);
gnc_entry_ledger_show_entry (ledger, table->current_cursor_loc.vcell_loc);
/* Set completion character */
gnc_combo_cell_set_complete_char
((ComboCell *)
gnc_table_layout_get_cell (table->layout, ENTRY_IACCT_CELL),
gnc_get_account_separator ());
gnc_combo_cell_set_complete_char
((ComboCell *)
gnc_table_layout_get_cell (table->layout, ENTRY_BACCT_CELL),
gnc_get_account_separator ());
/* enable callback for cursor user-driven moves */
gnc_table_control_allow_move (table->control, TRUE);
}
GtkWidget *
gnc_reconcile_view_new (Account *account, GNCReconcileViewType type,
time64 statement_date)
{
GNCReconcileView *view;
GtkListStore *liststore;
gboolean include_children, auto_check;
GList *accounts = NULL;
GList *splits;
Query *query;
g_return_val_if_fail (account, NULL);
g_return_val_if_fail ((type == RECLIST_DEBIT) ||
(type == RECLIST_CREDIT), NULL);
view = g_object_new (GNC_TYPE_RECONCILE_VIEW, NULL);
/* Create the list store with 6 columns and add to treeview,
column 0 will be a pointer to the entry */
liststore = gtk_list_store_new (6, G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (liststore));
g_object_unref (liststore);
view->account = account;
view->view_type = type;
view->statement_date = statement_date;
query = qof_query_create_for (GNC_ID_SPLIT);
qof_query_set_book (query, gnc_get_current_book ());
include_children = xaccAccountGetReconcileChildrenStatus (account);
if (include_children)
accounts = gnc_account_get_descendants (account);
/* match the account */
accounts = g_list_prepend (accounts, account);
xaccQueryAddAccountMatch (query, accounts, QOF_GUID_MATCH_ANY, QOF_QUERY_AND);
g_list_free (accounts);
/* limit the matches to CREDITs and DEBITs only, depending on the type */
if (type == RECLIST_CREDIT)
xaccQueryAddValueMatch(query, gnc_numeric_zero (),
QOF_NUMERIC_MATCH_CREDIT,
QOF_COMPARE_GTE, QOF_QUERY_AND);
else
xaccQueryAddValueMatch(query, gnc_numeric_zero (),
QOF_NUMERIC_MATCH_DEBIT,
QOF_COMPARE_GTE, QOF_QUERY_AND);
/* limit the matches only to Cleared and Non-reconciled splits */
xaccQueryAddClearedMatch (query, CLEARED_NO | CLEARED_CLEARED, QOF_QUERY_AND);
/* Initialize the QueryList */
gnc_reconcile_view_construct (view, query);
/* find the list of splits to auto-reconcile */
auto_check = gnc_prefs_get_bool (GNC_PREFS_GROUP_RECONCILE, GNC_PREF_CHECK_CLEARED);
if (auto_check)
{
time64 statement_date_day_end = gnc_time64_get_day_end(statement_date);
for (splits = qof_query_run (query); splits; splits = splits->next)
{
Split *split = splits->data;
char recn = xaccSplitGetReconcile (split);
time64 trans_date = xaccTransGetDate (xaccSplitGetParent (split));
/* Just an extra verification that our query is correct ;) */
g_assert (recn == NREC || recn == CREC);
if (recn == CREC &&
gnc_difftime (trans_date, statement_date_day_end) <= 0)
g_hash_table_insert (view->reconciled, split, split);
}
}
/* Free the query -- we don't need it anymore */
qof_query_destroy (query);
return GTK_WIDGET (view);
}
/*******************************************************
* 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);
}
static guint
sxftd_compute_sx(SXFromTransInfo *sxfti)
{
gchar *name;
GDate date;
GList *schedule = NULL;
getEndTuple end_info;
guint sxftd_errno = 0; /* 0 == OK, > 0 means dialog needs to be run again */
SchedXaction *sx = sxfti->sx;
/* get the name */
name = gtk_editable_get_chars(GTK_EDITABLE(sxfti->name), 0, -1);
xaccSchedXactionSetName(sx, name);
g_free(name);
gnc_gdate_set_time64( &date, gnc_date_edit_get_date( sxfti->startDateGDE ) );
sxftd_update_schedule(sxfti, &date, &schedule);
if (sxftd_errno == 0)
{
gnc_sx_set_schedule(sx, schedule);
xaccSchedXactionSetStartDate( sx, &date );
}
end_info = sxftd_get_end_info(sxfti);
switch (end_info.type)
{
case NEVER_END:
break;
case END_ON_DATE:
xaccSchedXactionSetEndDate(sx, &(end_info.end_date));
break;
case END_AFTER_N_OCCS:
xaccSchedXactionSetNumOccur(sx, end_info.n_occurrences);
break;
default:
sxftd_errno = 2;
break;
}
gnc_sx_set_instance_count( sx, 1 );
/* Set the autocreate, days-in-advance and remind-in-advance values from
* options. */
{
gboolean autoCreateState, notifyState;
gint daysInAdvance;
autoCreateState =
gnc_prefs_get_bool (GNC_PREFS_GROUP_SXED, GNC_PREF_CREATE_AUTO);
notifyState =
gnc_prefs_get_bool (GNC_PREFS_GROUP_SXED, GNC_PREF_NOTIFY);
xaccSchedXactionSetAutoCreate( sx,
autoCreateState,
(autoCreateState & notifyState) );
daysInAdvance =
gnc_prefs_get_float (GNC_PREFS_GROUP_SXED, GNC_PREF_CREATE_DAYS);
xaccSchedXactionSetAdvanceCreation( sx, daysInAdvance );
daysInAdvance =
gnc_prefs_get_float (GNC_PREFS_GROUP_SXED, GNC_PREF_REMIND_DAYS);
xaccSchedXactionSetAdvanceReminder( sx, daysInAdvance );
}
if ( sxftd_add_template_trans( sxfti ) != 0 )
{
sxftd_errno = SXFTD_ERRNO_UNBALANCED_XACTION;
}
return sxftd_errno;
}