CsvImpTransAssist Class Reference

Public Member Functions
	CsvImpTransAssist (const CsvImpTransAssist &)=delete
CsvImpTransAssist &	operator= (const CsvImpTransAssist &)=delete
	CsvImpTransAssist (CsvImpTransAssist &&)=delete
CsvImpTransAssist &	operator= (CsvImpTransAssist &&)=delete
void	assist_prepare_cb (GtkWidget *page)
void	assist_file_page_prepare ()
void	assist_preview_page_prepare ()
void	assist_account_match_page_prepare ()
void	assist_doc_page_prepare ()
void	assist_match_page_prepare ()
void	assist_summary_page_prepare ()
void	assist_finish ()
void	assist_compmgr_close ()
void	file_activated_cb ()
void	file_selection_changed_cb ()
void	preview_settings_delete ()
void	preview_settings_save ()
void	preview_settings_name (GtkEntry *entry)
void	preview_settings_load ()
void	preview_update_skipped_rows ()
void	preview_multi_split (bool multi)
void	preview_update_separators (GtkWidget *widget)
	Event handler for separator changes.
void	preview_update_file_format ()
	Event handler for clicking one of the format type radio buttons.
void	preview_update_account ()
void	preview_update_encoding (const char *encoding)
	Event handler for a new encoding.
void	preview_update_date_format ()
void	preview_update_currency_format ()
void	preview_update_col_type (GtkComboBox *cbox)
	Event handler for the user selecting a new column type.
void	preview_update_fw_columns (GtkTreeView *treeview, GdkEventButton *event)
	Event handler for clicking on column headers.
void	preview_populate_settings_combo ()
void	preview_handle_save_del_sensitivity (GtkComboBox *combo)
void	preview_split_column (int col, int offset)
void	preview_refresh_table ()
void	preview_refresh ()
void	preview_validate_settings ()
void	acct_match_via_button ()
bool	acct_match_via_view_dblclick (GdkEventButton *event)
void	acct_match_select (GtkTreeModel *model, GtkTreeIter *iter)
void	acct_match_set_accounts ()

Friends
gboolean	fixed_context_menu_handler (GnumericPopupMenuElement const *element, gpointer userdata)

Detailed Description

Definition at line 152 of file assistant-csv-trans-import.cpp.

Constructor & Destructor Documentation

CsvImpTransAssist()

CsvImpTransAssist::CsvImpTransAssist

(

)

Definition at line 469 of file assistant-csv-trans-import.cpp.

{
    auto builder = gtk_builder_new();
    gnc_builder_add_from_file  (builder , "assistant-csv-trans-import.glade", "start_row_adj");
    gnc_builder_add_from_file  (builder , "assistant-csv-trans-import.glade", "end_row_adj");
    gnc_builder_add_from_file  (builder , "assistant-csv-trans-import.glade", "account_match_store");
    gnc_builder_add_from_file  (builder , "assistant-csv-trans-import.glade", "csv_transaction_assistant");
    csv_imp_asst = GTK_ASSISTANT(gtk_builder_get_object (builder, "csv_transaction_assistant"));
 
    // Set the name for this assistant so it can be easily manipulated with css
    gtk_widget_set_name (GTK_WIDGET(csv_imp_asst), "gnc-id-assistant-csv-transaction-import");
    gnc_widget_style_context_add_class (GTK_WIDGET(csv_imp_asst), "gnc-class-imports");
 
    /* Enable buttons on all page. */
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "start_page")),
                                     true);
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "file_page")),
                                     false);
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "preview_page")),
                                     false);
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "account_match_page")),
                                     false);
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "doc_page")),
                                     true);
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "match_page")),
                                     true);
    gtk_assistant_set_page_complete (csv_imp_asst,
                                     GTK_WIDGET(gtk_builder_get_object (builder, "summary_page")),
                                     true);
 
    /* File chooser Page */
    file_page = GTK_WIDGET(gtk_builder_get_object (builder, "file_page"));
    file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
    g_signal_connect (G_OBJECT(file_chooser), "selection-changed",
                      G_CALLBACK(csv_tximp_file_selection_changed_cb), this);
    g_signal_connect (G_OBJECT(file_chooser), "file-activated",
                      G_CALLBACK(csv_tximp_file_activated_cb), this);
 
    auto box = GTK_WIDGET(gtk_builder_get_object (builder, "file_page"));
    gtk_box_pack_start (GTK_BOX(box), file_chooser, TRUE, TRUE, 6);
    gtk_widget_show (file_chooser);
 
    /* Preview Settings Page */
    {
        preview_page = GTK_WIDGET(gtk_builder_get_object (builder, "preview_page"));
 
        // Add Settings combo
        auto settings_store = gtk_list_store_new (2, G_TYPE_POINTER, G_TYPE_STRING);
        settings_combo = GTK_COMBO_BOX(gtk_combo_box_new_with_model_and_entry (GTK_TREE_MODEL(settings_store)));
        g_object_unref (settings_store);
        gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX(settings_combo), SET_NAME);
        gtk_combo_box_set_active (GTK_COMBO_BOX(settings_combo), 0);
 
        combo_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "combo_hbox"));
        gtk_box_pack_start (GTK_BOX(combo_hbox), GTK_WIDGET(settings_combo), true, true, 6);
        gtk_widget_show (GTK_WIDGET(settings_combo));
 
        g_signal_connect (G_OBJECT(settings_combo), "changed",
                         G_CALLBACK(csv_tximp_preview_settings_sel_changed_cb), this);
 
        // Additionally connect to the changed signal of the embedded GtkEntry
        auto emb_entry = gtk_bin_get_child (GTK_BIN (settings_combo));
        g_signal_connect (G_OBJECT(emb_entry), "changed",
                         G_CALLBACK(csv_tximp_preview_settings_text_changed_cb), this);
        g_signal_connect (G_OBJECT(emb_entry), "insert-text",
                         G_CALLBACK(csv_tximp_preview_settings_text_inserted_cb), this);
 
        // Add Save Settings button
        save_button = GTK_WIDGET(gtk_builder_get_object (builder, "save_settings"));
 
        // Add Delete Settings button
        del_button = GTK_WIDGET(gtk_builder_get_object (builder, "delete_settings"));
 
        /* The table containing the separator configuration widgets */
        start_row_spin = GTK_SPIN_BUTTON(gtk_builder_get_object (builder, "start_row"));
        end_row_spin = GTK_SPIN_BUTTON(gtk_builder_get_object (builder, "end_row"));
        skip_alt_rows_button = GTK_WIDGET(gtk_builder_get_object (builder, "skip_rows"));
        skip_errors_button = GTK_WIDGET(gtk_builder_get_object (builder, "skip_errors_button"));
        multi_split_cbutton = GTK_WIDGET(gtk_builder_get_object (builder, "multi_split_button"));
        separator_table = GTK_WIDGET(gtk_builder_get_object (builder, "separator_table"));
        fw_instructions_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "fw_instructions_hbox"));
 
        /* Load the separator buttons from the glade builder file into the
         * sep_buttons array. */
        const char* sep_button_names[] = {
                "space_cbutton",
                "tab_cbutton",
                "comma_cbutton",
                "colon_cbutton",
                "semicolon_cbutton",
                "hyphen_cbutton"
            };
        for (int i = 0; i < SEP_NUM_OF_TYPES; i++)
            sep_button[i]
                = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, sep_button_names[i]));
 
        /* Load and connect the custom separator checkbutton in the same way
         * as the other separator buttons. */
        custom_cbutton
            = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, "custom_cbutton"));
 
        /* Load the entry for the custom separator entry. Connect it to the
         * sep_button_clicked event handler as well. */
        custom_entry = GTK_ENTRY(gtk_builder_get_object (builder, "custom_entry"));
 
        /* Load and connect the escape checkbutton in the same way
         * as the other separator buttons. */
        escape_cbutton
            = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, "escape_cbutton"));
 
        /* Add account selection widget */
        acct_selector = gnc_account_sel_new();
        auto account_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "account_hbox"));
        gtk_box_pack_start (GTK_BOX(account_hbox), acct_selector, TRUE, TRUE, 6);
        gtk_widget_show (acct_selector);
 
        g_signal_connect(G_OBJECT(acct_selector), "account_sel_changed",
                         G_CALLBACK(csv_tximp_preview_acct_sel_cb), this);
 
 
        /* Create the encoding selector widget and add it to the assistant */
        encselector = GO_CHARMAP_SEL(go_charmap_sel_new(GO_CHARMAP_SEL_TO_UTF8));
        /* Connect the selector to the encoding_selected event handler. */
        g_signal_connect (G_OBJECT(encselector), "charmap_changed",
                         G_CALLBACK(csv_tximp_preview_enc_sel_cb), this);
 
        auto encoding_container = GTK_CONTAINER(gtk_builder_get_object (builder, "encoding_container"));
        gtk_container_add (encoding_container, GTK_WIDGET(encselector));
        gtk_widget_set_hexpand (GTK_WIDGET(encselector), true);
        gtk_widget_show_all (GTK_WIDGET(encoding_container));
 
        /* The instructions label and image */
        instructions_label = GTK_LABEL(gtk_builder_get_object (builder, "instructions_label"));
        instructions_image = GTK_IMAGE(gtk_builder_get_object (builder, "instructions_image"));
 
        /* Add in the date format combo box and hook it up to an event handler. */
        date_format_combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new());
        for (auto& date_fmt : GncDate::c_formats)
            gtk_combo_box_text_append_text (date_format_combo, _(date_fmt.m_fmt.c_str()));
        gtk_combo_box_set_active (GTK_COMBO_BOX(date_format_combo), 0);
        g_signal_connect (G_OBJECT(date_format_combo), "changed",
                         G_CALLBACK(csv_tximp_preview_date_fmt_sel_cb), this);
 
        /* Add it to the assistant. */
        auto date_format_container = GTK_CONTAINER(gtk_builder_get_object (builder, "date_format_container"));
        gtk_container_add (date_format_container, GTK_WIDGET(date_format_combo));
        gtk_widget_set_hexpand (GTK_WIDGET(date_format_combo), true);
        gtk_widget_show_all (GTK_WIDGET(date_format_container));
 
        /* Add in the currency format combo box and hook it up to an event handler. */
        currency_format_combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new());
        for (int i = 0; i < num_currency_formats; i++)
        {
            gtk_combo_box_text_append_text (currency_format_combo, _(currency_format_user[i]));
        }
        /* Default will the locale */
        gtk_combo_box_set_active (GTK_COMBO_BOX(currency_format_combo), 0);
        g_signal_connect (G_OBJECT(currency_format_combo), "changed",
                         G_CALLBACK(csv_tximp_preview_currency_fmt_sel_cb), this);
 
        /* Add it to the assistant. */
        auto currency_format_container = GTK_CONTAINER(gtk_builder_get_object (builder, "currency_format_container"));
        gtk_container_add (currency_format_container, GTK_WIDGET(currency_format_combo));
        gtk_widget_set_hexpand (GTK_WIDGET(currency_format_combo), true);
        gtk_widget_show_all (GTK_WIDGET(currency_format_container));
 
        /* Connect the CSV/Fixed-Width radio button event handler. */
        csv_button = GTK_WIDGET(gtk_builder_get_object (builder, "csv_button"));
        fixed_button = GTK_WIDGET(gtk_builder_get_object (builder, "fixed_button"));
 
        /* Load the data treeview and connect it to its resizing event handler. */
        treeview = GTK_TREE_VIEW(gtk_builder_get_object (builder, "treeview"));
        gtk_tree_view_set_headers_clickable (treeview, true);
 
        /* This is true only after encoding_selected is called, so we must
         * set it initially to false. */
        encoding_selected_called = false;
    }
 
    /* Account Match Page */
    account_match_page  = GTK_WIDGET(gtk_builder_get_object (builder, "account_match_page"));
    account_match_view  = GTK_WIDGET(gtk_builder_get_object (builder, "account_match_view"));
    account_match_label = GTK_WIDGET(gtk_builder_get_object (builder, "account_match_label"));
    account_match_btn = GTK_WIDGET(gtk_builder_get_object (builder, "account_match_change"));
 
    /* Doc Page */
    doc_page = GTK_WIDGET(gtk_builder_get_object (builder, "doc_page"));
 
    /* Matcher page */
    match_page  = GTK_WIDGET(gtk_builder_get_object (builder, "match_page"));
    match_label = GTK_WIDGET(gtk_builder_get_object (builder, "match_label"));
 
    /* Create the generic transaction importer GUI.
       Note, this will call g_new0 internally. The returned object is g_freed again
       either directly by the main matcher or in our assistant_finish code of the matcher
       is never reached. */
    gnc_csv_importer_gui = gnc_gen_trans_assist_new (GTK_WIDGET(csv_imp_asst),
                                                     match_page, nullptr, false, 42);
 
    /* Summary Page */
    summary_page  = GTK_WIDGET(gtk_builder_get_object (builder, "summary_page"));
    summary_label = GTK_WIDGET(gtk_builder_get_object (builder, "summary_label"));
 
    gnc_restore_window_size (GNC_PREFS_GROUP,
                             GTK_WINDOW(csv_imp_asst), gnc_ui_get_main_window(nullptr));
 
    gtk_builder_connect_signals (builder, this);
    g_object_unref (G_OBJECT(builder));
 
    gtk_widget_show_all (GTK_WIDGET(csv_imp_asst));
    gnc_window_adjust_for_screen (GTK_WINDOW(csv_imp_asst));
 
    /* In order to trigger a book options display on the creation of a new book,
     * we need to detect when we are dealing with a new book. */
    new_book = gnc_is_new_book();
}

~CsvImpTransAssist()

CsvImpTransAssist::~CsvImpTransAssist

(

)

Definition at line 696 of file assistant-csv-trans-import.cpp.

{
    /* This function is safe to call on a null pointer */
    gnc_gen_trans_list_delete (gnc_csv_importer_gui);
    /* The call above frees gnc_csv_importer_gui but can't nullify it.
     * Do it here so no one accidentally can access it still */
    gnc_csv_importer_gui = nullptr;
    gtk_widget_destroy (GTK_WIDGET(csv_imp_asst));
}

Member Function Documentation

acct_match_select()

void CsvImpTransAssist::acct_match_select	(	GtkTreeModel *	model,
		GtkTreeIter *	iter
	)

Definition at line 1897 of file assistant-csv-trans-import.cpp.

{
    // Get the stored string and account (if any)
    gchar *text = nullptr;
    Account *account = nullptr;
    gtk_tree_model_get (model, iter, MAPPING_STRING, &text,
                                     MAPPING_ACCOUNT, &account, -1);
 
    auto acct_name = csv_tximp_acct_match_text_parse (text);
    auto gnc_acc = gnc_import_select_account (GTK_WIDGET(csv_imp_asst), nullptr, true,
            acct_name.c_str(), nullptr, ACCT_TYPE_NONE, account, nullptr);
 
    if (gnc_acc) // We may have canceled
    {
        auto fullpath = gnc_account_get_full_name (gnc_acc);
        gtk_list_store_set (GTK_LIST_STORE(model), iter,
                MAPPING_ACCOUNT, gnc_acc,
                MAPPING_FULLPATH, fullpath, -1);
 
        // Update the account kvp mappings
        if (text && *text)
        {
            gnc_account_imap_delete_account (account, IMAP_CAT_CSV, text);
            gnc_account_imap_add_account (gnc_acc, IMAP_CAT_CSV, text, gnc_acc);
        }
 
        // Force reparsing of account columns - may impact multi-currency mode
        auto col_types = tx_imp->column_types();
        auto col_type_it = std::find (col_types.cbegin(),
                                      col_types.cend(), GncTransPropType::ACCOUNT);
        if (col_type_it != col_types.cend())
            tx_imp->set_column_type(col_type_it - col_types.cbegin(),
                                    GncTransPropType::ACCOUNT, true);
        col_type_it = std::find (col_types.cbegin(),
                                 col_types.cend(), GncTransPropType::TACCOUNT);
        if (col_type_it != col_types.cend())
            tx_imp->set_column_type(col_type_it - col_types.cbegin(),
                                    GncTransPropType::TACCOUNT, true);
 
        g_free (fullpath);
    }
    g_free (text);
 
 
    /* Enable the "Next" Assistant Button */
    auto all_checked = csv_tximp_acct_match_check_all (model);
    gtk_assistant_set_page_complete (csv_imp_asst, account_match_page,
                                     all_checked);
 
    /* Update information message and whether to display account errors */
    m_req_mapped_accts = all_checked;
    auto errs = tx_imp->verify(m_req_mapped_accts);
    gtk_label_set_text (GTK_LABEL(account_match_label), errs.c_str());
}

acct_match_set_accounts()

void CsvImpTransAssist::acct_match_set_accounts

(

)

Definition at line 1788 of file assistant-csv-trans-import.cpp.

{
    auto store = gtk_tree_view_get_model (GTK_TREE_VIEW(account_match_view));
    gtk_list_store_clear (GTK_LIST_STORE(store));
 
    auto accts = tx_imp->accounts();
    for (auto acct : accts)
    {
        GtkTreeIter acct_iter;
        gtk_list_store_append (GTK_LIST_STORE(store), &acct_iter);
        gtk_list_store_set (GTK_LIST_STORE(store), &acct_iter, MAPPING_STRING, acct.c_str(),
                            MAPPING_FULLPATH, _("No Linked Account"), MAPPING_ACCOUNT, nullptr, -1);
    }
}

acct_match_via_button()

void CsvImpTransAssist::acct_match_via_button

(

)

Definition at line 1953 of file assistant-csv-trans-import.cpp.

{
    auto model = gtk_tree_view_get_model (GTK_TREE_VIEW(account_match_view));
    auto selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(account_match_view));
 
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected (selection, &model, &iter))
        acct_match_select (model, &iter);
}

acct_match_via_view_dblclick()

bool CsvImpTransAssist::acct_match_via_view_dblclick

(

GdkEventButton *

event

)

Definition at line 1966 of file assistant-csv-trans-import.cpp.

{
    /* This is for a double click */
    if (event->button == 1 && event->type == GDK_2BUTTON_PRESS)
    {
        auto window = gtk_tree_view_get_bin_window (GTK_TREE_VIEW (account_match_view));
        if (event->window != window)
            return false;
 
        /* Get tree path for row that was clicked, true if row exists */
        GtkTreePath *path;
        if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (account_match_view), (gint) event->x, (gint) event->y,
                                             &path, nullptr, nullptr, nullptr))
        {
            DEBUG("event->x is %d and event->y is %d", (gint)event->x, (gint)event->y);
 
            auto model = gtk_tree_view_get_model (GTK_TREE_VIEW(account_match_view));
            GtkTreeIter iter;
            if (gtk_tree_model_get_iter (model, &iter, path))
                acct_match_select (model, &iter);
            gtk_tree_path_free (path);
        }
        return true;
    }
    return false;
}

assist_account_match_page_prepare()

void CsvImpTransAssist::assist_account_match_page_prepare

(

)

Definition at line 2071 of file assistant-csv-trans-import.cpp.

{
 
    // Load the account strings into the store
    acct_match_set_accounts ();
 
    // Match the account strings to account maps from previous imports
    auto store = gtk_tree_view_get_model (GTK_TREE_VIEW(account_match_view));
    csv_tximp_acct_match_load_mappings (store);
 
    // Enable the view, possibly after an error
    gtk_widget_set_sensitive (account_match_view, true);
    gtk_widget_set_sensitive (account_match_btn, true);
 
    /* Enable the "Next" Assistant Button */
    auto all_checked = csv_tximp_acct_match_check_all (store);
    gtk_assistant_set_page_complete (csv_imp_asst, account_match_page,
                                     all_checked);
 
    /* Update information message and whether to display account errors */
    m_req_mapped_accts = all_checked;
    auto text = tx_imp->verify (m_req_mapped_accts);
    gtk_label_set_text (GTK_LABEL(account_match_label), text.c_str());
}

assist_compmgr_close()

void CsvImpTransAssist::assist_compmgr_close

(

)

Definition at line 2287 of file assistant-csv-trans-import.cpp.

{
    gnc_save_window_size (GNC_PREFS_GROUP, GTK_WINDOW(csv_imp_asst));
}

assist_doc_page_prepare()

void CsvImpTransAssist::assist_doc_page_prepare

(

)

Definition at line 2098 of file assistant-csv-trans-import.cpp.

{
    if (!tx_imp->verify (true).empty())
    {
        /* New accounts can change the multi-currency situation and hence
         * may require more column tweaks. If so
         * inform the user and go back to the preview page.
         */
        gtk_assistant_set_current_page (csv_imp_asst, 2);
    }
 
    /* Block going back */
    gtk_assistant_commit (csv_imp_asst);
 
    /* Before creating transactions, if this is a new book, let user specify
     * book options, since they affect how transactions are created */
    if (new_book)
        new_book = gnc_new_book_option_display (GTK_WIDGET(csv_imp_asst));
 
    /* Add the Cancel button for the matcher */
    cancel_button = gtk_button_new_with_mnemonic (_("_Cancel"));
    gtk_assistant_add_action_widget (csv_imp_asst, cancel_button);
    auto button_area = gtk_widget_get_parent (cancel_button);
 
    if (GTK_IS_HEADER_BAR(button_area))
        gtk_container_child_set (GTK_CONTAINER(button_area),
                                 cancel_button,
                                 "pack-type", GTK_PACK_START,
                                 nullptr);
 
    g_signal_connect (cancel_button, "clicked",
                     G_CALLBACK(csv_tximp_assist_close_cb), this);
    gtk_widget_show (GTK_WIDGET(cancel_button));
}

assist_file_page_prepare()

void CsvImpTransAssist::assist_file_page_prepare

(

)

Definition at line 1999 of file assistant-csv-trans-import.cpp.

{
    /* Set the default directory */
    if (!m_final_file_name.empty())
        gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(file_chooser),
                                       m_final_file_name.c_str());
    else
    {
        auto starting_dir = gnc_get_default_directory (GNC_PREFS_GROUP);
        if (starting_dir)
        {
            gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(file_chooser), starting_dir);
            g_free (starting_dir);
        }
    }
 
    /* Disable the "Next" Assistant Button */
    gtk_assistant_set_page_complete (csv_imp_asst, account_match_page, false);
}

assist_finish()

void CsvImpTransAssist::assist_finish

(

)

Definition at line 2268 of file assistant-csv-trans-import.cpp.

{
    /* Start the import */
    if (!tx_imp->m_transactions.empty())
    {
        /* The call to gnc_gen_trans_assist_start below will free the
         * object passed into it. To avoid our c++ destructor from
         * attempting a second free on that object, we'll release
         * our own reference to it here  before passing it to
         * gnc_gen_trans_assist_start.
         */
        auto local_csv_imp_gui = gnc_csv_importer_gui;
        gnc_csv_importer_gui = nullptr;
        gnc_gen_trans_assist_start (local_csv_imp_gui);
    }
}

assist_match_page_prepare()

void CsvImpTransAssist::assist_match_page_prepare

(

)

Definition at line 2135 of file assistant-csv-trans-import.cpp.

{
    /* Create transactions from the parsed data */
    try
    {
        tx_imp->create_transactions ();
    }
    catch (const GncCsvImpParseError& err)
    {
        /* Oops! This shouldn't happen when using the import assistant !
         * Inform the user and go back to the preview page.
         */
        auto err_msg = std::string(err.what());
        auto err_msgs = err.errors();
        auto add_bullet_item = [](std::string& a, ErrMap::value_type& b)->std::string { return std::move(a) + "\n• " + b.second; };
        err_msg = std::accumulate (err_msgs.begin(), err_msgs.end(), std::move (err_msg), add_bullet_item);
 
        gnc_error_dialog (GTK_WINDOW (csv_imp_asst),
            _("An unexpected error has occurred while creating transactions. Please report this as a bug.\n\n"
              "Error message:\n%s"), err_msg.c_str());
        gtk_assistant_set_current_page (csv_imp_asst, 2);
    }
 
    /* Block going back */
    gtk_assistant_commit (csv_imp_asst);
 
    auto text = std::string( "<span size=\"medium\" color=\"red\"><b>");
    text += _("Double click on rows to change, then click on Apply to Import");
    text += "</b></span>";
    gtk_label_set_markup (GTK_LABEL(match_label), text.c_str());
 
    /* Add the help button for the matcher */
    help_button = gtk_button_new_with_mnemonic (_("_Help"));
    gtk_assistant_add_action_widget (csv_imp_asst, help_button);
    auto button_area = gtk_widget_get_parent (help_button);
 
    if (GTK_IS_HEADER_BAR(button_area))
    {
        gtk_container_child_set (GTK_CONTAINER(button_area),
                                 help_button,
                                 "pack-type", GTK_PACK_START,
                                 nullptr);
    }
    else
    {
        // align the help button on the left side
        gtk_widget_set_halign (GTK_WIDGET(button_area), GTK_ALIGN_FILL);
        gtk_widget_set_hexpand (GTK_WIDGET(button_area), TRUE);
        gtk_box_set_child_packing (GTK_BOX(button_area), help_button,
                                   FALSE, FALSE, 0, GTK_PACK_START);
    }
    g_signal_connect (help_button, "clicked",
                     G_CALLBACK(on_matcher_help_clicked), gnc_csv_importer_gui);
 
    gtk_widget_show (GTK_WIDGET(help_button));
 
    /* Copy all of the transactions to the importer GUI. */
    for (auto trans_it : tx_imp->m_transactions)
    {
        auto draft_trans = trans_it.second;
        if (draft_trans->trans)
        {
            auto lsplit = GNCImportLastSplitInfo {
                draft_trans->m_price ? static_cast<gnc_numeric>(*draft_trans->m_price) : gnc_numeric{0, 0},
                draft_trans->m_taction ? draft_trans->m_taction->c_str() : nullptr,
                draft_trans->m_tmemo ? draft_trans->m_tmemo->c_str() : nullptr,
                draft_trans->m_tamount ? static_cast<gnc_numeric>(*draft_trans->m_tamount) : gnc_numeric{0, 0},
                draft_trans->m_taccount ? *draft_trans->m_taccount : nullptr,
                draft_trans->m_trec_state ? *draft_trans->m_trec_state : '\0',
                draft_trans->m_trec_date ? static_cast<time64>(GncDateTime(*draft_trans->m_trec_date, DayPart::neutral)) : 0,
            };
 
//A tramsaction with no splits is invalid and will crash later.
            if (xaccTransGetSplit(draft_trans->trans, 0))
                gnc_gen_trans_list_add_trans_with_split_data (gnc_csv_importer_gui, std::move (draft_trans->trans),
                                                              &lsplit);
            else
                xaccTransDestroy(draft_trans->trans);
            draft_trans->trans = nullptr;
        }
    }
    /* Show the matcher dialog */
    gnc_gen_trans_list_show_all (gnc_csv_importer_gui);
}

assist_prepare_cb()

void CsvImpTransAssist::assist_prepare_cb

(

GtkWidget *

page

)

Definition at line 2250 of file assistant-csv-trans-import.cpp.

{
    if (page == file_page)
        assist_file_page_prepare ();
    else if (page == preview_page)
        assist_preview_page_prepare ();
    else if (page == account_match_page)
        assist_account_match_page_prepare ();
    else if (page == doc_page)
        assist_doc_page_prepare ();
    else if (page == match_page)
        assist_match_page_prepare ();
    else if (page == summary_page)
        assist_summary_page_prepare ();
}

assist_preview_page_prepare()

void CsvImpTransAssist::assist_preview_page_prepare

(

)

Definition at line 2021 of file assistant-csv-trans-import.cpp.

{
    auto go_back = false;
 
    if (m_final_file_name != m_fc_file_name)
    {
        tx_imp = std::unique_ptr<GncTxImport>(new GncTxImport);
 
        /* Assume data is CSV. User can later override to Fixed Width if needed */
        try
        {
            tx_imp->file_format (GncImpFileFormat::CSV);
            tx_imp->load_file (m_fc_file_name);
            tx_imp->tokenize (true);
            m_req_mapped_accts = false;
 
            /* Get settings store and populate */
            preview_populate_settings_combo();
            gtk_combo_box_set_active (settings_combo, 0);
 
            /* Disable the "Next" Assistant Button */
            gtk_assistant_set_page_complete (csv_imp_asst, preview_page, false);
        }
        catch (std::ifstream::failure& e)
        {
            /* File loading failed ... */
            gnc_error_dialog (GTK_WINDOW (csv_imp_asst), "%s", e.what());
            go_back = true;
        }
        catch (std::range_error &e)
        {
            /* Parsing failed ... */
            gnc_error_dialog (GTK_WINDOW (csv_imp_asst), "%s", _(e.what()));
            /* Stay in this step so user can override */
            go_back = false;
        }
    }
 
    if (go_back)
        gtk_assistant_previous_page (csv_imp_asst);
    else
    {
        m_final_file_name = m_fc_file_name;
        preview_refresh ();
 
        /* Load the data into the treeview. */
        g_idle_add ((GSourceFunc)csv_imp_preview_queue_rebuild_table, this);
    }
}

assist_summary_page_prepare()

void CsvImpTransAssist::assist_summary_page_prepare

(

)

Definition at line 2222 of file assistant-csv-trans-import.cpp.

{
    /* Remove the added buttons */
    gtk_assistant_remove_action_widget (csv_imp_asst, help_button);
    gtk_assistant_remove_action_widget (csv_imp_asst, cancel_button);
 
    auto text = std::string("<span size=\"medium\"><b>");
    try
    {
    /* Translators: {1} will be replaced with a filename */
        text += (bl::format (std::string{_("The transactions were imported from file '{1}'.")}) % m_final_file_name).str();
        text += "</b></span>";
    }
    catch (const bl::conv::conversion_error& err)
    {
        PERR("Transcoding error: %s", err.what());
        text += "The transactions were imported from the file.</b></span>";
    }
    catch (const bl::conv::invalid_charset_error& err)
    {
        PERR("Invalid charset error: %s", err.what());
        text += "The transactions were imported from the file.</b></span>";
    }
    gtk_label_set_markup (GTK_LABEL(summary_label), text.c_str());
}

file_activated_cb()

void CsvImpTransAssist::file_activated_cb

(

)

Definition at line 744 of file assistant-csv-trans-import.cpp.

{
    gtk_assistant_set_page_complete (csv_imp_asst, file_page, false);
 
    /* Test for a valid filename and not a directory */
    if (check_for_valid_filename ())
    {
        gtk_assistant_set_page_complete (csv_imp_asst, file_page, true);
        gtk_assistant_next_page (csv_imp_asst);
    }
}

file_selection_changed_cb()

void CsvImpTransAssist::file_selection_changed_cb

(

)

Definition at line 761 of file assistant-csv-trans-import.cpp.

{
    /* Enable the "Next" button based on a valid filename */
    gtk_assistant_set_page_complete (csv_imp_asst, file_page,
        check_for_valid_filename ());
}

preview_handle_save_del_sensitivity()

void CsvImpTransAssist::preview_handle_save_del_sensitivity

(

GtkComboBox *

combo

)

Definition at line 800 of file assistant-csv-trans-import.cpp.

{
    GtkTreeIter iter;
    auto can_delete = false;
    auto can_save = false;
    auto entry = gtk_bin_get_child (GTK_BIN(combo));
    auto entry_text = gtk_entry_get_text (GTK_ENTRY(entry));
    /* Handle sensitivity of the delete and save button */
    if (gtk_combo_box_get_active_iter (combo, &iter))
    {
        CsvTransImpSettings *preset;
        GtkTreeModel *model = gtk_combo_box_get_model (combo);
        gtk_tree_model_get (model, &iter, SET_GROUP, &preset, -1);
 
        if (preset && !preset_is_reserved_name (preset->m_name))
        {
            /* Current preset is not read_only, so buttons can be enabled */
            can_delete = true;
            can_save = true;
        }
    }
    else if (entry_text && (strlen (entry_text) > 0) &&
            !preset_is_reserved_name (std::string(entry_text)))
        can_save = true;
 
    gtk_widget_set_sensitive (save_button, can_save);
    gtk_widget_set_sensitive (del_button, can_delete);
 
}

preview_multi_split()

void CsvImpTransAssist::preview_multi_split

(

bool

multi

)

Definition at line 986 of file assistant-csv-trans-import.cpp.

{
    tx_imp->multi_split(multi);
    preview_refresh ();
}

preview_populate_settings_combo()

void CsvImpTransAssist::preview_populate_settings_combo

(

)

Definition at line 775 of file assistant-csv-trans-import.cpp.

{
    // Clear the list store
    auto model = gtk_combo_box_get_model (settings_combo);
    gtk_list_store_clear (GTK_LIST_STORE(model));
 
    // Append the default entry
    auto presets = get_import_presets_trans ();
    for (auto preset : presets)
    {
        GtkTreeIter iter;
        gtk_list_store_append (GTK_LIST_STORE(model), &iter);
        /* FIXME we store the raw pointer to the preset, while it's
         * managed by a shared pointer. This is dangerous because
         * when the shared pointer goes out of scope, our pointer will dangle.
         * For now this is safe, because the shared pointers in this case are
         * long-lived, but this may need refactoring.
         */
        gtk_list_store_set (GTK_LIST_STORE(model), &iter, SET_GROUP, preset.get(), SET_NAME, _(preset->m_name.c_str()), -1);
    }
}

preview_refresh()

void CsvImpTransAssist::preview_refresh

(

)

Definition at line 1662 of file assistant-csv-trans-import.cpp.

{
    // Cache skip settings. Updating the widgets one by one
    // triggers a callback the transfers all skip widgets'
    // values to settings. So by the time the next widget value
    // is to be set, that widget's 'new' setting has already been replaced by
    // its old setting preventing us from using it here sensibly.
    // Another solution might have been to delay callbacks from running
    // until after all values are set.
    auto skip_start_lines = tx_imp->skip_start_lines();
    auto skip_end_lines = tx_imp->skip_end_lines();
    auto skip_alt_lines = tx_imp->skip_alt_lines();
 
    // Set start row
    auto adj = gtk_spin_button_get_adjustment (start_row_spin);
    gtk_adjustment_set_upper (adj, tx_imp->m_parsed_lines.size());
    gtk_spin_button_set_value (start_row_spin, skip_start_lines);
 
    // Set end row
    adj = gtk_spin_button_get_adjustment (end_row_spin);
    gtk_adjustment_set_upper (adj, tx_imp->m_parsed_lines.size());
    gtk_spin_button_set_value (end_row_spin, skip_end_lines);
 
    // Set Alternate rows
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(skip_alt_rows_button),
            skip_alt_lines);
 
    // Set multi-split indicator
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(multi_split_cbutton),
            tx_imp->multi_split());
    gtk_widget_set_sensitive (acct_selector, !tx_imp->multi_split());
 
    // Set Import Format
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(csv_button),
            (tx_imp->file_format() == GncImpFileFormat::CSV));
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(fixed_button),
            (tx_imp->file_format() != GncImpFileFormat::CSV));
 
    // Set Date & Currency Format and Character encoding
    gtk_combo_box_set_active (GTK_COMBO_BOX(date_format_combo),
            tx_imp->date_format());
    gtk_combo_box_set_active (GTK_COMBO_BOX(currency_format_combo),
            tx_imp->currency_format());
    go_charmap_sel_set_encoding (encselector, tx_imp->encoding().c_str());
 
    // Handle separator checkboxes and custom field, only relevant if the file format is csv
    // Note we defer the change signal until all buttons have been updated
    // An early update may result in an incomplete tokenize run and that would
    // cause our list of saved column types to be truncated
    if (tx_imp->file_format() == GncImpFileFormat::CSV)
    {
        auto separators = tx_imp->separators();
        auto enable_escape = tx_imp->enable_escape();
        const auto stock_sep_chars = std::string (" \t,:;-");
        for (int i = 0; i < SEP_NUM_OF_TYPES; i++)
        {
            g_signal_handlers_block_by_func (sep_button[i], (gpointer) csv_tximp_preview_sep_button_cb, this);
            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(sep_button[i]),
                separators.find (stock_sep_chars[i]) != std::string::npos);
            g_signal_handlers_unblock_by_func (sep_button[i], (gpointer) csv_tximp_preview_sep_button_cb, this);
        }
 
        // If there are any other separators in the separators string,
        // add them as custom separators
        auto pos = separators.find_first_of (stock_sep_chars);
        while (!separators.empty() && pos != std::string::npos)
        {
            separators.erase(pos);
            pos = separators.find_first_of (stock_sep_chars);
        }
        g_signal_handlers_block_by_func (custom_cbutton, (gpointer) csv_tximp_preview_sep_button_cb, this);
        g_signal_handlers_block_by_func (custom_entry, (gpointer) csv_tximp_preview_sep_button_cb, this);
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(custom_cbutton),
                                      !separators.empty());
        gtk_entry_set_text (GTK_ENTRY(custom_entry), separators.c_str());
 
        g_signal_handlers_block_by_func (escape_cbutton, (gpointer) csv_tximp_preview_sep_button_cb, this);
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(escape_cbutton),
                                      enable_escape);
        g_signal_handlers_unblock_by_func (escape_cbutton, (gpointer) csv_tximp_preview_sep_button_cb, this);
 
        g_signal_handlers_unblock_by_func (custom_cbutton, (gpointer) csv_tximp_preview_sep_button_cb, this);
        g_signal_handlers_unblock_by_func (custom_entry, (gpointer) csv_tximp_preview_sep_button_cb, this);
        g_signal_handlers_unblock_by_func (custom_cbutton, (gpointer) csv_tximp_preview_sep_button_cb, this);
        try
        {
            tx_imp->tokenize (false);
        }
        catch(std::range_error& err)
        {
            PERR("CSV Tokenization Failed: %s", err.what());
        }
    }
 
    // Repopulate the parsed data table
    preview_refresh_table ();
}

preview_refresh_table()

void CsvImpTransAssist::preview_refresh_table

(

)

Definition at line 1565 of file assistant-csv-trans-import.cpp.

{
    preview_validate_settings ();
 
    /* Create a new liststore to hold status and data from the file being imported.
       The first columns hold status information (row-color, row-errors, row-error-icon,...
       All following columns represent the tokenized data as strings. */
    auto ncols = PREV_N_FIXED_COLS + tx_imp->column_types().size();
    auto model_col_types = g_new (GType, ncols);
    model_col_types[PREV_COL_FCOLOR] = G_TYPE_STRING;
    model_col_types[PREV_COL_BCOLOR] = G_TYPE_STRING;
    model_col_types[PREV_COL_ERROR] = G_TYPE_STRING;
    model_col_types[PREV_COL_ERR_ICON] = G_TYPE_STRING;
    model_col_types[PREV_COL_STRIKE] = G_TYPE_BOOLEAN;
    for (guint i = PREV_N_FIXED_COLS; i <  ncols; i++)
        model_col_types[i] = G_TYPE_STRING;
    auto store = gtk_list_store_newv (ncols, model_col_types);
    g_free (model_col_types);
 
    /* Fill the data liststore with data from importer object. */
    for (auto parse_line : tx_imp->m_parsed_lines)
    {
        /* Fill the state cells */
        GtkTreeIter iter;
        gtk_list_store_append (store, &iter);
        preview_row_fill_state_cells (store, &iter,
                std::get<PL_ERROR>(parse_line), std::get<PL_SKIP>(parse_line));
 
        /* Fill the data cells. */
        for (auto cell_str_it = std::get<PL_INPUT>(parse_line).cbegin(); cell_str_it != std::get<PL_INPUT>(parse_line).cend(); cell_str_it++)
        {
            uint32_t pos = PREV_N_FIXED_COLS + cell_str_it - std::get<PL_INPUT>(parse_line).cbegin();
            gtk_list_store_set (store, &iter, pos, cell_str_it->c_str(), -1);
        }
    }
    gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(store));
    gtk_tree_view_set_tooltip_column (treeview, PREV_COL_ERROR);
 
    /* Adjust treeview to go with the just created model. This consists of adding
     * or removing columns and resetting any parameters related to how
     * the columns and data should be rendered.
     */
 
    /* Start with counting the current number of columns (ntcols)
     * we have in the treeview */
    auto ntcols = gtk_tree_view_get_n_columns (treeview);
 
    /* Drop redundant columns if the model has less data columns than the new model
     * ntcols = n° of columns in treeview (1 error column + x data columns)
     * ncols = n° of columns in model (fixed state columns + x data columns)
     */
    while (ntcols > ncols - PREV_N_FIXED_COLS + 1)
    {
        auto col = gtk_tree_view_get_column (treeview, ntcols - 1);
        gtk_tree_view_column_clear (col);
        ntcols = gtk_tree_view_remove_column(treeview, col);
    }
 
    /* Insert columns if the model has more data columns than the treeview. */
    while (ntcols < ncols - PREV_N_FIXED_COLS + 1)
    {
        /* Default cell renderer is text, except for the first (error) column */
        auto renderer = gtk_cell_renderer_text_new();
        if (ntcols == 0)
            renderer = gtk_cell_renderer_pixbuf_new(); // Error column uses an icon
        auto col = gtk_tree_view_column_new ();
        gtk_tree_view_column_pack_start (col, renderer, false);
        ntcols = gtk_tree_view_append_column (treeview, col);
    }
 
    /* Reset column attributes as they are undefined after recreating the model */
    auto combostore = make_column_header_model (tx_imp->multi_split());
    for (uint32_t i = 0; i < ntcols; i++)
        preview_style_column (i, combostore);
 
    /* Release our reference for the stores to allow proper memory management. */
    g_object_unref (store);
    g_object_unref (combostore);
 
    /* Also reset the base account combo box as it's value may have changed due to column changes here */
    auto base_acct = gnc_account_sel_get_account(GNC_ACCOUNT_SEL(acct_selector));
    if (tx_imp->base_account() != base_acct)
    {
        g_signal_handlers_block_by_func (acct_selector, (gpointer) csv_tximp_preview_acct_sel_cb, this);
        gnc_account_sel_set_account(GNC_ACCOUNT_SEL(acct_selector),
                tx_imp->base_account() , false);
        g_signal_handlers_unblock_by_func (acct_selector, (gpointer) csv_tximp_preview_acct_sel_cb, this);
    }
 
    /* Make the things actually appear. */
    gtk_widget_show_all (GTK_WIDGET(treeview));
}

preview_settings_delete()

void CsvImpTransAssist::preview_settings_delete

(

)

Definition at line 875 of file assistant-csv-trans-import.cpp.

{
    // Get the Active Selection
    GtkTreeIter iter;
    if (!gtk_combo_box_get_active_iter (settings_combo, &iter))
        return;
 
    CsvTransImpSettings *preset = nullptr;
    auto model = gtk_combo_box_get_model (settings_combo);
    gtk_tree_model_get (model, &iter, SET_GROUP, &preset, -1);
 
    auto response = gnc_ok_cancel_dialog (GTK_WINDOW (csv_imp_asst),
                                GTK_RESPONSE_CANCEL,
                                "%s", _("Delete the Import Settings."));
    if (response == GTK_RESPONSE_OK)
    {
        preset->remove();
        preview_populate_settings_combo();
        gtk_combo_box_set_active (settings_combo, 0); // Default
        preview_refresh (); // Reset the widgets
    }
}

preview_settings_load()

void CsvImpTransAssist::preview_settings_load

(

)

Definition at line 848 of file assistant-csv-trans-import.cpp.

{
    // Get the Active Selection
    GtkTreeIter iter;
    if (!gtk_combo_box_get_active_iter (settings_combo, &iter))
        return;
 
    CsvTransImpSettings *preset = nullptr;
    auto model = gtk_combo_box_get_model (settings_combo);
    gtk_tree_model_get (model, &iter, SET_GROUP, &preset, -1);
 
    if (!preset)
        return;
 
    tx_imp->settings (*preset);
    if (preset->m_load_error)
        gnc_error_dialog (GTK_WINDOW (csv_imp_asst),
            "%s", _("There were problems reading some saved settings, continuing to load.\n"
                    "Please review and save again."));
 
    preview_refresh ();
    preview_handle_save_del_sensitivity (settings_combo);
}

preview_settings_name()

void CsvImpTransAssist::preview_settings_name

(

GtkEntry *

entry

)

Definition at line 831 of file assistant-csv-trans-import.cpp.

{
    auto text = gtk_entry_get_text (entry);
    if (text)
        tx_imp->settings_name(text);
 
    auto box = gtk_widget_get_parent (GTK_WIDGET(entry));
    auto combo = gtk_widget_get_parent (GTK_WIDGET(box));
 
    preview_handle_save_del_sensitivity (GTK_COMBO_BOX(combo));
}

preview_settings_save()

void CsvImpTransAssist::preview_settings_save

(

)

Definition at line 901 of file assistant-csv-trans-import.cpp.

{
    auto new_name = tx_imp->settings_name();
 
    /* Check if the entry text matches an already existing preset */
    GtkTreeIter iter;
    if (!gtk_combo_box_get_active_iter (settings_combo, &iter))
    {
 
        auto model = gtk_combo_box_get_model (settings_combo);
        bool valid = gtk_tree_model_get_iter_first (model, &iter);
        while (valid)
        {
            // Walk through the list, reading each row
            CsvTransImpSettings *preset;
            gtk_tree_model_get (model, &iter, SET_GROUP, &preset, -1);
 
            if (preset && (preset->m_name == std::string(new_name)))
            {
                auto response = gnc_ok_cancel_dialog (GTK_WINDOW (csv_imp_asst),
                        GTK_RESPONSE_OK,
                        "%s", _("Setting name already exists, overwrite?"));
                if (response != GTK_RESPONSE_OK)
                    return;
 
                break;
            }
            valid = gtk_tree_model_iter_next (model, &iter);
        }
    }
 
    /* All checks passed, let's save this preset */
    if (!tx_imp->save_settings())
    {
        gnc_info_dialog (GTK_WINDOW (csv_imp_asst),
            "%s", _("The settings have been saved."));
 
        // Update the settings store
        preview_populate_settings_combo();
        auto model = gtk_combo_box_get_model (settings_combo);
 
        // Get the first entry in model
        GtkTreeIter   iter;
        bool valid = gtk_tree_model_get_iter_first (model, &iter);
        while (valid)
        {
            // Walk through the list, reading each row
            gchar *name = nullptr;
            gtk_tree_model_get (model, &iter, SET_NAME, &name, -1);
 
            if (g_strcmp0 (name, new_name.c_str()) == 0) // Set Active, the one Saved.
                gtk_combo_box_set_active_iter (settings_combo, &iter);
 
            g_free (name);
 
            valid = gtk_tree_model_iter_next (model, &iter);
        }
    }
    else
        gnc_error_dialog (GTK_WINDOW (csv_imp_asst),
            "%s", _("There was a problem saving the settings, please try again."));
}

preview_split_column()

void CsvImpTransAssist::preview_split_column	(	int	col,
		int	offset
	)

Definition at line 1359 of file assistant-csv-trans-import.cpp.

{
    auto fwtok = dynamic_cast<GncFwTokenizer*>(tx_imp->m_tokenizer.get());
    fwtok->col_split (col, offset);
    try
    {
        tx_imp->tokenize (false);
    }
    catch (std::range_error& e)
    {
        gnc_error_dialog (GTK_WINDOW (csv_imp_asst), "%s", e.what());
        return;
    }
    preview_refresh_table();
}

preview_update_account()

void CsvImpTransAssist::preview_update_account

(

)

Definition at line 1103 of file assistant-csv-trans-import.cpp.

{;
    auto acct = gnc_account_sel_get_account( GNC_ACCOUNT_SEL(acct_selector) );
    tx_imp->base_account(acct);
    preview_refresh_table ();
}

preview_update_col_type()

void CsvImpTransAssist::preview_update_col_type

(

GtkComboBox *

cbox

)

Event handler for the user selecting a new column type.

When the user selects a new column type, that column's text must be changed to the selection, and any other columns containing that selection must be changed to "None" because we don't allow duplicates.

Parameters

cbox	The combo box the user just clicked to make a change

Definition at line 1188 of file assistant-csv-trans-import.cpp.

{
    /* Get the new text */
    GtkTreeIter iter;
    auto model = gtk_combo_box_get_model (cbox);
    gtk_combo_box_get_active_iter (cbox, &iter);
    auto new_col_type = GncTransPropType::NONE;
    gtk_tree_model_get (model, &iter, COL_TYPE_ID, &new_col_type, -1);
 
    auto col_num = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT(cbox), "col-num"));
    tx_imp->set_column_type (col_num, new_col_type);
 
    /* Delay rebuilding our data table to avoid critical warnings due to
     * pending events still acting on them after this event is processed.
     */
    g_idle_add ((GSourceFunc)csv_imp_preview_queue_rebuild_table, this);
 
}

preview_update_currency_format()

void CsvImpTransAssist::preview_update_currency_format

(

)

Definition at line 1154 of file assistant-csv-trans-import.cpp.

{
    tx_imp->currency_format (gtk_combo_box_get_active (GTK_COMBO_BOX(currency_format_combo)));
    preview_refresh_table ();
}

preview_update_date_format()

void CsvImpTransAssist::preview_update_date_format

(

)

Definition at line 1146 of file assistant-csv-trans-import.cpp.

{
    tx_imp->date_format (gtk_combo_box_get_active (GTK_COMBO_BOX(date_format_combo)));
    preview_refresh_table ();
}

preview_update_encoding()

void CsvImpTransAssist::preview_update_encoding

(

const char *

encoding

)

Event handler for a new encoding.

This is called when the user selects a new encoding; the data is reparsed and shown to the user.

Parameters

encoding

The encoding that the user selected

Definition at line 1117 of file assistant-csv-trans-import.cpp.

{
    /* This gets called twice every time a new encoding is selected. The
     * second call actually passes the correct data; thus, we only do
     * something the second time this is called. */
 
    /* If this is the second time the function is called ... */
    if (encoding_selected_called)
    {
        std::string previous_encoding = tx_imp->m_tokenizer->encoding();
        /* Try converting the new encoding and reparsing. */
        try
        {
            tx_imp->encoding (encoding);
            preview_refresh_table ();
        }
        catch (...)
        {
            /* If it fails, change back to the old encoding. */
            gnc_error_dialog (GTK_WINDOW (csv_imp_asst), "%s", _("Invalid encoding selected"));
            go_charmap_sel_set_encoding (encselector, previous_encoding.c_str());
        }
    }
 
    encoding_selected_called = !encoding_selected_called;
}

preview_update_file_format()

void CsvImpTransAssist::preview_update_file_format

(

)

Event handler for clicking one of the format type radio buttons.

This occurs if the format (Fixed-Width or CSV) is changed.

Definition at line 1062 of file assistant-csv-trans-import.cpp.

{
    /* Set the parsing type correctly. */
    try
    {
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(csv_button)))
        {
            tx_imp->file_format (GncImpFileFormat::CSV);
            g_signal_handlers_disconnect_by_func(G_OBJECT(treeview),
                    (gpointer)csv_tximp_preview_treeview_clicked_cb, (gpointer)this);
            gtk_widget_set_visible (separator_table, true);
            gtk_widget_set_visible (fw_instructions_hbox, false);
        }
        else
        {
            tx_imp->file_format (GncImpFileFormat::FIXED_WIDTH);
            /* Enable context menu for adding/removing columns. */
            g_signal_connect (G_OBJECT(treeview), "button-press-event",
                    G_CALLBACK(csv_tximp_preview_treeview_clicked_cb), (gpointer)this);
            gtk_widget_set_visible (separator_table, false);
            gtk_widget_set_visible (fw_instructions_hbox, true);
 
        }
 
        tx_imp->tokenize (false);
        preview_refresh_table ();
    }
    catch (std::range_error &e)
    {
        /* Parsing failed ... */
        gnc_error_dialog (GTK_WINDOW (csv_imp_asst), "%s", e.what());
        return;
    }
    catch (...)
    {
        // FIXME Handle file loading errors (possibly thrown by file_format above)
        PWARN("Got an error during file loading");
    }
}

preview_update_fw_columns()

void CsvImpTransAssist::preview_update_fw_columns	(	GtkTreeView *	treeview,
		GdkEventButton *	event
	)

Event handler for clicking on column headers.

This function is called whenever the user clicks on column headers in preview->treeview to modify columns when in fixed-width mode.

Parameters

event

The event that happened (where the user clicked)

Definition at line 1382 of file assistant-csv-trans-import.cpp.

{
    /* Nothing to do if this was not triggered on our treeview body */
    if (event->window != gtk_tree_view_get_bin_window (treeview))
        return;
 
    /* Find the column that was clicked. */
    GtkTreeViewColumn *tcol = nullptr;
    int cell_x = 0;
    auto success = gtk_tree_view_get_path_at_pos (treeview,
            (int)event->x, (int)event->y,
            nullptr, &tcol, &cell_x, nullptr);
    if (!success)
        return;
 
    /* Stop if no column found in this treeview (-1) or
     * if column is the error messages column (0) */
    auto tcol_list = gtk_tree_view_get_columns(treeview);
    auto tcol_num = g_list_index (tcol_list, tcol);
    g_list_free (tcol_list);
    if (tcol_num <= 0)
        return;
 
    /* Data columns in the treeview are offset by one
     * because the first column is the error column
     */
    auto dcol = tcol_num - 1;
    auto offset = get_new_col_rel_pos (tcol, cell_x);
    if (event->type == GDK_2BUTTON_PRESS && event->button == 1)
        /* Double clicks can split columns. */
        preview_split_column (dcol, offset);
    else if (event->type == GDK_BUTTON_PRESS && event->button == 3)
        /* Right clicking brings up a context menu. */
        fixed_context_menu (event, dcol, offset);
}

preview_update_separators()

void CsvImpTransAssist::preview_update_separators

(

GtkWidget *

widget

)

Event handler for separator changes.

This function is called whenever one of the widgets for configuring the separators (the separator checkbuttons, the escape checkbutton or the custom separator entry) is changed.

Parameters

widget

The widget that was changed

Definition at line 999 of file assistant-csv-trans-import.cpp.

{
 
    /* Only manipulate separator characters if the currently open file is
     * csv separated. */
    if (tx_imp->file_format() != GncImpFileFormat::CSV)
        return;
 
    /* Add the corresponding characters to checked_separators for each
     * button that is checked. */
    auto checked_separators = std::string();
    const auto stock_sep_chars = std::string (" \t,:;-");
    for (int i = 0; i < SEP_NUM_OF_TYPES; i++)
    {
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(sep_button[i])))
            checked_separators += stock_sep_chars[i];
    }
 
    /* Add the custom separator if the user checked its button. */
    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(custom_cbutton)))
    {
        auto custom_sep = gtk_entry_get_text (custom_entry);
        if (custom_sep[0] != '\0') /* Don't add a blank separator (bad things will happen!). */
            checked_separators += custom_sep;
    }
 
    /* Set the parse options using the checked_separators list. */
    tx_imp->separators (checked_separators);
    tx_imp->enable_escape (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(escape_cbutton)));
 
    /* Parse the data using the new options. We don't want to reguess
     * the column types because we want to leave the user's
     * configurations intact. */
    try
    {
        tx_imp->tokenize (false);
        preview_refresh_table ();
    }
    catch (std::range_error &e)
    {
        /* Warn the user there was a problem and try to undo what caused
         * the error. (This will cause a reparsing and ideally a usable
         * configuration.) */
        gnc_error_dialog (GTK_WINDOW (csv_imp_asst), "Error in parsing");
        /* If we're here because the user changed the file format, we should just wait for the user
         * to update the configuration */
        if (!widget)
            return;
        /* If the user changed the custom separator, erase that custom separator. */
        if (widget == GTK_WIDGET(custom_entry))
            gtk_entry_set_text (GTK_ENTRY(widget), "");
        /* If the user checked a checkbutton, toggle that checkbutton back. */
        else
            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget),
                                         !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)));
        return;
    }
}

preview_update_skipped_rows()

void CsvImpTransAssist::preview_update_skipped_rows

(

)

Definition at line 966 of file assistant-csv-trans-import.cpp.

{
    /* Update skip rows in the parser */
    tx_imp->update_skipped_lines (gtk_spin_button_get_value_as_int (start_row_spin),
        gtk_spin_button_get_value_as_int (end_row_spin),
        gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(skip_alt_rows_button)),
        gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(skip_errors_button)));
 
    /* And adjust maximum number of lines that can be skipped at each end accordingly */
    auto adj = gtk_spin_button_get_adjustment (end_row_spin);
    gtk_adjustment_set_upper (adj, tx_imp->m_parsed_lines.size()
            - tx_imp->skip_start_lines() -1);
 
    adj = gtk_spin_button_get_adjustment (start_row_spin);
    gtk_adjustment_set_upper (adj, tx_imp->m_parsed_lines.size()
            - tx_imp->skip_end_lines() - 1);
 
    preview_refresh_table ();
}

preview_validate_settings()

void CsvImpTransAssist::preview_validate_settings

(

)

Definition at line 1762 of file assistant-csv-trans-import.cpp.

{
    /* Allow the user to proceed only if there are no inconsistencies in the settings */
    auto has_non_acct_errors = !tx_imp->verify (false).empty();
    auto error_msg = tx_imp->verify (m_req_mapped_accts);
    gtk_assistant_set_page_complete (csv_imp_asst, preview_page, !has_non_acct_errors);
    gtk_label_set_markup(GTK_LABEL(instructions_label), error_msg.c_str());
    gtk_widget_set_visible (GTK_WIDGET(instructions_image), !error_msg.empty());
 
    /* Show or hide the account match page based on whether there are
     * accounts in the user data according to the importer configuration
     * only if there are no errors
     */
    if (!has_non_acct_errors)
        gtk_widget_set_visible (GTK_WIDGET(account_match_page),
                !tx_imp->accounts().empty());
}

Friends And Related Symbol Documentation

fixed_context_menu_handler

gboolean fixed_context_menu_handler ( GnumericPopupMenuElement const *  element, gpointer  userdata  )

friend

Definition at line 1291 of file assistant-csv-trans-import.cpp.

{
    auto info = (CsvImpTransAssist*)userdata;
    auto fwtok = dynamic_cast<GncFwTokenizer*>(info->tx_imp->m_tokenizer.get());
 
    switch (element->index)
    {
    case CONTEXT_STF_IMPORT_MERGE_LEFT:
        fwtok->col_delete (info->fixed_context_col - 1);
        break;
    case CONTEXT_STF_IMPORT_MERGE_RIGHT:
        fwtok->col_delete (info->fixed_context_col);
        break;
    case CONTEXT_STF_IMPORT_SPLIT:
        fwtok->col_split (info->fixed_context_col, info->fixed_context_offset);
        break;
    case CONTEXT_STF_IMPORT_WIDEN:
        fwtok->col_widen (info->fixed_context_col);
        break;
    case CONTEXT_STF_IMPORT_NARROW:
        fwtok->col_narrow (info->fixed_context_col);
        break;
    default:
        ; /* Nothing */
    }
 
    try
    {
        info->tx_imp->tokenize (false);
    }
    catch(std::range_error& e)
    {
        gnc_error_dialog (GTK_WINDOW (info->csv_imp_asst), "%s", e.what());
        return false;
    }
    info->preview_refresh_table ();
    return true;
}

---

The documentation for this class was generated from the following file:

• assistant-csv-trans-import.cpp