Public Member Functions
	CsvImpPriceAssist (const CsvImpPriceAssist &)=delete

CsvImpPriceAssist &	operator= (const CsvImpPriceAssist &)=delete

	CsvImpPriceAssist (CsvImpPriceAssist &&)=delete

CsvImpPriceAssist &	operator= (CsvImpPriceAssist &&)=delete

void	assist_prepare_cb (GtkWidget *page)

void	assist_file_page_prepare ()

void	assist_preview_page_prepare ()

void	assist_confirm_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_over_write (bool over)

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_encoding (const char *encoding)
	Event handler for a new encoding.

void	preview_update_date_format ()

void	preview_update_currency_format ()

void	preview_update_currency ()

void	preview_update_commodity ()

void	preview_reparse_col_type (GncPricePropType type)

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 ()

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

Detailed Description

Definition at line 80 of file assistant-csv-price-import.cpp.

Constructor & Destructor Documentation

◆ CsvImpPriceAssist()

CsvImpPriceAssist::CsvImpPriceAssist ( )

Definition at line 520 of file assistant-csv-price-import.cpp.

{
    auto builder = gtk_builder_new();
    gnc_builder_add_from_file  (builder , "assistant-csv-price-import.glade", "start_row_adj");
    gnc_builder_add_from_file  (builder , "assistant-csv-price-import.glade", "end_row_adj");
    gnc_builder_add_from_file  (builder , "assistant-csv-price-import.glade", "liststore1");
    gnc_builder_add_from_file  (builder , "assistant-csv-price-import.glade", "liststore2");
    gnc_builder_add_from_file  (builder , "assistant-csv-price-import.glade", "CSV Price Assistant");
    csv_imp_asst = GTK_ASSISTANT(gtk_builder_get_object (builder, "CSV Price 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-price-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, "confirm_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_price_imp_file_selection_changed_cb), this);
    g_signal_connect (G_OBJECT(file_chooser), "file-activated",
                      G_CALLBACK(csv_price_imp_file_activated_changed_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_price_imp_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_price_imp_preview_settings_text_changed_cb), this);
        g_signal_connect (G_OBJECT(emb_entry), "insert-text",
                         G_CALLBACK(csv_price_imp_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"));
        over_write_cbutton = GTK_WIDGET(gtk_builder_get_object (builder, "over_write_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"));
 
        /* 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_price_imp_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));
 
        /* Add commodity selection widget */
        commodity_selector = GTK_WIDGET(gtk_builder_get_object (builder, "commodity_cbox"));
        gtk_combo_box_set_model (GTK_COMBO_BOX(commodity_selector), get_model (true));
        gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX(commodity_selector),
                                              separator_row_func, nullptr, nullptr);
        g_signal_connect (G_OBJECT(commodity_selector), "changed",
                          G_CALLBACK(csv_price_imp_preview_commodity_sel_cb), this);
 
        /* Add currency selection widget */
        currency_selector = GTK_WIDGET(gtk_builder_get_object (builder, "currency_cbox"));
        gtk_combo_box_set_model (GTK_COMBO_BOX(currency_selector), get_model (false));
        g_signal_connect(G_OBJECT(currency_selector), "changed",
                         G_CALLBACK(csv_price_imp_preview_currency_sel_cb), this);
 
        /* 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_price_imp_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_price; i++)
        {
            gtk_combo_box_text_append_text (currency_format_combo, _(currency_format_user_price[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_price_imp_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;
    }
 
    /* Confirm Page */
    confirm_page = GTK_WIDGET(gtk_builder_get_object (builder, "confirm_page"));
 
    /* 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));
}

◆ ~CsvImpPriceAssist()

CsvImpPriceAssist::~CsvImpPriceAssist ( )

Definition at line 726 of file assistant-csv-price-import.cpp.

{
    gtk_widget_destroy (GTK_WIDGET(csv_imp_asst));
}

Member Function Documentation

◆ assist_compmgr_close()

void CsvImpPriceAssist::assist_compmgr_close ( )

Definition at line 2005 of file assistant-csv-price-import.cpp.

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

◆ assist_confirm_page_prepare()

void CsvImpPriceAssist::assist_confirm_page_prepare ( )

Definition at line 1928 of file assistant-csv-price-import.cpp.

{
    /* Confirm Page */
}

◆ assist_file_page_prepare()

void CsvImpPriceAssist::assist_file_page_prepare ( )

Definition at line 1852 of file assistant-csv-price-import.cpp.

{
    /* Disable the "Next" Assistant Button */
    gtk_assistant_set_page_complete (csv_imp_asst, file_page, false);
    gtk_assistant_set_page_complete (csv_imp_asst, preview_page, false);
 
    /* 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);
        }
    }
}

◆ assist_finish()

void CsvImpPriceAssist::assist_finish ( )

Definition at line 1983 of file assistant-csv-price-import.cpp.

{
    /* Start the import */
    /* Create prices from the parsed data */
    try
    {
        price_imp->create_prices ();
        gnc_gui_refresh_all ();
    }
    catch (const std::invalid_argument& err)
    {
        /* Oops! This shouldn't happen when using the import assistant !
         * Inform the user and go back to the preview page.
         */
        gnc_error_dialog (GTK_WINDOW(csv_imp_asst),
            _("An unexpected error has occurred while creating prices. Please report this as a bug.\n\n"
              "Error message:\n%s"), err.what());
        gtk_assistant_set_current_page (csv_imp_asst, 2);
    }
}

◆ assist_prepare_cb()

void CsvImpPriceAssist::assist_prepare_cb ( GtkWidget * page )

Definition at line 1970 of file assistant-csv-price-import.cpp.

{
    if (page == file_page)
        assist_file_page_prepare ();
    else if (page == preview_page)
        assist_preview_page_prepare ();
    else if (page == confirm_page)
        assist_confirm_page_prepare ();
    else if (page == summary_page)
        assist_summary_page_prepare ();
}

◆ assist_preview_page_prepare()

void CsvImpPriceAssist::assist_preview_page_prepare ( )

Definition at line 1874 of file assistant-csv-price-import.cpp.

{
    auto go_back = false;
 
 
    if (m_final_file_name != m_fc_file_name)
    {
        /* Load the file into parse_data. */
        price_imp = std::unique_ptr<GncPriceImport>(new GncPriceImport);
        /* Assume data is CSV. User can later override to Fixed Width if needed */
        try
        {
            price_imp->file_format (GncImpFileFormat::CSV);
            price_imp->load_file (m_fc_file_name);
            price_imp->tokenize (true);
 
            /* Get settings store and populate */
            preview_populate_settings_combo();
            gtk_combo_box_set_active (settings_combo, 0);
 
            // set over_write to false as default
            price_imp->over_write (false);
 
            /* 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 CsvImpPriceAssist::assist_summary_page_prepare ( )

Definition at line 1934 of file assistant-csv-price-import.cpp.

{
    auto text = std::string("<span size=\"medium\"><b>");
    /* Translators: This is a ngettext(3) message, %d is the number of prices added */
    auto added_str = g_strdup_printf (ngettext ("%d added price",
                                                "%d added prices",
                                                price_imp->m_prices_added),
                                                price_imp->m_prices_added);
    /* Translators: This is a ngettext(3) message, %d is the number of duplicate prices */
    auto dupl_str = g_strdup_printf (ngettext ("%d duplicate price",
                                               "%d duplicate prices",
                                               price_imp->m_prices_duplicated),
                                               price_imp->m_prices_duplicated);
    /* Translators: This is a ngettext(3) message, %d is the number of replaced prices */
    auto repl_str = g_strdup_printf (ngettext ("%d replaced price",
                                               "%d replaced prices",
                                               price_imp->m_prices_replaced),
                                               price_imp->m_prices_replaced);
    auto msg = g_strdup_printf (
        _("The prices were imported from file '%s'.\n\n"
          "Import summary:\n"
          "- %s\n"
          "- %s\n"
          "- %s"),
          m_final_file_name.c_str(), added_str, dupl_str,repl_str);
    text += msg;
    text += "</b></span>";
 
    g_free (added_str);
    g_free (dupl_str);
    g_free (repl_str);
 
    gtk_label_set_markup (GTK_LABEL(summary_label), text.c_str());
}

◆ file_activated_cb()

void CsvImpPriceAssist::file_activated_cb ( )

Definition at line 768 of file assistant-csv-price-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 CsvImpPriceAssist::file_selection_changed_cb ( )

Definition at line 785 of file assistant-csv-price-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 CsvImpPriceAssist::preview_handle_save_del_sensitivity ( GtkComboBox * combo )

Definition at line 824 of file assistant-csv-price-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))
    {
        CsvPriceImpSettings *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_over_write()

void CsvImpPriceAssist::preview_over_write ( bool over )

Definition at line 1010 of file assistant-csv-price-import.cpp.

{
    price_imp->over_write (over);
}

◆ preview_populate_settings_combo()

void CsvImpPriceAssist::preview_populate_settings_combo ( )

Definition at line 799 of file assistant-csv-price-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_price ();
    for (const 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 CsvImpPriceAssist::preview_refresh ( )

Definition at line 1732 of file assistant-csv-price-import.cpp.

{
    // Cache skip settings. Updating the widgets one by one
    // triggers a callback that 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 preveneting us from using it
    // here sensibly.
 
    auto skip_start_lines = price_imp->skip_start_lines();
    auto skip_end_lines = price_imp->skip_end_lines();
    auto skip_alt_lines = price_imp->skip_alt_lines();
 
    // Set start row
    auto adj = gtk_spin_button_get_adjustment (start_row_spin);
    gtk_adjustment_set_upper (adj, price_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, price_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 over-write indicator
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(over_write_cbutton),
                                  price_imp->over_write());
 
    // Set Import Format
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(csv_button),
            (price_imp->file_format() == GncImpFileFormat::CSV));
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(fixed_button),
            (price_imp->file_format() != GncImpFileFormat::CSV));
 
    // This section deals with the combo's and character encoding
    gtk_combo_box_set_active (GTK_COMBO_BOX(date_format_combo),
            price_imp->date_format());
    gtk_combo_box_set_active (GTK_COMBO_BOX(currency_format_combo),
            price_imp->currency_format());
    go_charmap_sel_set_encoding (encselector, price_imp->encoding().c_str());
 
    // Set the commodity and currency combos
    set_commodity_for_combo(GTK_COMBO_BOX(commodity_selector),
            price_imp->from_commodity());
 
    set_commodity_for_combo(GTK_COMBO_BOX(currency_selector),
            price_imp->to_currency());
 
    // 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 that would
    // cause our list of saved column types to be truncated
    if (price_imp->file_format() == GncImpFileFormat::CSV)
    {
        auto separators = price_imp->separators();
        auto escape = price_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_price_imp_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_price_imp_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 (escape_cbutton, (gpointer) csv_price_imp_preview_sep_button_cb, this);
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(escape_cbutton),
                                      escape);
        g_signal_handlers_unblock_by_func (escape_cbutton, (gpointer) csv_price_imp_preview_sep_button_cb, this);
 
        g_signal_handlers_block_by_func (custom_cbutton, (gpointer) csv_price_imp_preview_sep_button_cb, this);
        g_signal_handlers_block_by_func (custom_entry, (gpointer) csv_price_imp_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_unblock_by_func (custom_cbutton, (gpointer) csv_price_imp_preview_sep_button_cb, this);
        g_signal_handlers_unblock_by_func (custom_entry, (gpointer) csv_price_imp_preview_sep_button_cb, this);
        try
        {
            price_imp->tokenize (false);
        }
        catch (std::range_error& err)
        {
            PERR ("CSV Tokenization Failed: %s", err.what ());
        }
    }
    // Repopulate the parsed data table
    g_idle_add ((GSourceFunc)csv_imp_preview_queue_rebuild_table, this);
}

◆ preview_refresh_table()

void CsvImpPriceAssist::preview_refresh_table ( )

Definition at line 1613 of file assistant-csv-price-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 + price_imp->column_types_price().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 : price_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 uses an icon */
        auto renderer = (ntcols == 0) ? gtk_cell_renderer_pixbuf_new () : gtk_cell_renderer_text_new ();
        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_price ();
    for (uint32_t i = 0; i < ntcols; i++)
        preview_style_column (i, combostore);
 
    auto column_types = price_imp->column_types_price();
    auto any_of_type = [](std::vector<GncPricePropType>& column_types,
                          GncPricePropType req_column_type) -> bool
    {
        return std::any_of (column_types.begin(), column_types.end(),
                            [&req_column_type](GncPricePropType column_type) -> bool
                            { return column_type == req_column_type; });
    };
 
    // look for a namespace column, clear the commodity combo
    if (any_of_type (column_types, GncPricePropType::FROM_NAMESPACE))
    {
        g_signal_handlers_block_by_func (commodity_selector, (gpointer) csv_price_imp_preview_commodity_sel_cb, this);
        set_commodity_for_combo (GTK_COMBO_BOX(commodity_selector), nullptr);
        g_signal_handlers_unblock_by_func (commodity_selector, (gpointer) csv_price_imp_preview_commodity_sel_cb, this);
    }
 
    // look for a symbol column, clear the commodity combo
    if (any_of_type (column_types, GncPricePropType::FROM_SYMBOL))
    {
        g_signal_handlers_block_by_func (commodity_selector, (gpointer) csv_price_imp_preview_commodity_sel_cb, this);
        set_commodity_for_combo (GTK_COMBO_BOX(commodity_selector), nullptr);
        g_signal_handlers_unblock_by_func (commodity_selector, (gpointer) csv_price_imp_preview_commodity_sel_cb, this);
    }
 
    // look for a currency column, clear the currency combo
    if (any_of_type (column_types, GncPricePropType::TO_CURRENCY))
    {
        g_signal_handlers_block_by_func (currency_selector, (gpointer) csv_price_imp_preview_currency_sel_cb, this);
        set_commodity_for_combo (GTK_COMBO_BOX(currency_selector), nullptr);
        g_signal_handlers_unblock_by_func (currency_selector, (gpointer) csv_price_imp_preview_currency_sel_cb, this);
    }
 
    /* Release our reference for the stores to allow proper memory management. */
    g_object_unref (store);
    g_object_unref (combostore);
 
    /* Make the things actually appear. */
    gtk_widget_show_all (GTK_WIDGET(treeview));
}

◆ preview_reparse_col_type()

void CsvImpPriceAssist::preview_reparse_col_type ( GncPricePropType type )

Definition at line 1216 of file assistant-csv-price-import.cpp.

{
    auto column_types = price_imp->column_types_price();
 
    // look for column type and force a reparse
    auto col_type = std::find (column_types.begin(),
                column_types.end(), type);
    if (col_type != column_types.end())
    {
        price_imp->set_column_type_price (col_type -column_types.begin(),
                        type, true);
    }
}

◆ preview_settings_delete()

void CsvImpPriceAssist::preview_settings_delete ( )

Definition at line 897 of file assistant-csv-price-import.cpp.

{
    // Get the Active Selection
    GtkTreeIter iter;
    if (!gtk_combo_box_get_active_iter (settings_combo, &iter))
        return;
 
    CsvPriceImpSettings *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 CsvImpPriceAssist::preview_settings_load ( )

Definition at line 870 of file assistant-csv-price-import.cpp.

{
    // Get the Active Selection
    GtkTreeIter iter;
    if (!gtk_combo_box_get_active_iter (settings_combo, &iter))
        return;
 
    CsvPriceImpSettings *preset = nullptr;
    auto model = gtk_combo_box_get_model (settings_combo);
    gtk_tree_model_get (model, &iter, SET_GROUP, &preset, -1);
 
    if (!preset)
        return;
 
    price_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 CsvImpPriceAssist::preview_settings_name ( GtkEntry * entry )

Definition at line 854 of file assistant-csv-price-import.cpp.

{
    auto text = gtk_entry_get_text (entry);
    if (text)
        price_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 CsvImpPriceAssist::preview_settings_save ( )

Definition at line 923 of file assistant-csv-price-import.cpp.

{
    auto new_name = price_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
            CsvPriceImpSettings *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 (!price_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 CsvImpPriceAssist::preview_split_column	(	int	col,
		int	offset
	)

Definition at line 1429 of file assistant-csv-price-import.cpp.

{
    auto fwtok = dynamic_cast<GncFwTokenizer*>(price_imp->m_tokenizer.get());
    fwtok->col_split (col, offset);
    try
    {
        price_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_col_type()

void CsvImpPriceAssist::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

renderer	The renderer of the column the user changed
path	There is only 1 row in info->ctreeview, so this is always 0.
new_text	The text the user selected
info	The display of the data being imported

Definition at line 1239 of file assistant-csv-price-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 = GncPricePropType::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"));
 
    auto column_types = price_imp->column_types_price();
    auto old_col_type = column_types.at(col_num);
 
    price_imp->set_column_type_price (col_num, new_col_type);
 
    // if old_col_type is TO_CURRENCY, force a reparse of commodity
    if (old_col_type == GncPricePropType::TO_CURRENCY)
    {
        // look for a from_commodity column to reparse
        preview_reparse_col_type (GncPricePropType::FROM_SYMBOL);
        preview_reparse_col_type (GncPricePropType::FROM_NAMESPACE);
    }
 
    // if old_col_type is FROM_SYMBOL, or FROM_NAMESPACE force a reparse of currency
    if ((old_col_type == GncPricePropType::FROM_SYMBOL) ||
        (old_col_type == GncPricePropType::FROM_NAMESPACE))
    {
        // look for a to_currency column to reparse
        preview_reparse_col_type (GncPricePropType::TO_CURRENCY);
    }
 
    /* 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_commodity()

void CsvImpPriceAssist::preview_update_commodity ( )

Definition at line 1185 of file assistant-csv-price-import.cpp.

{
    gnc_commodity *comm = get_commodity_from_combo (GTK_COMBO_BOX(commodity_selector));
    price_imp->from_commodity (comm);
    preview_refresh_table ();
}

◆ preview_update_currency()

void CsvImpPriceAssist::preview_update_currency ( )

Definition at line 1177 of file assistant-csv-price-import.cpp.

{
    gnc_commodity *comm = get_commodity_from_combo (GTK_COMBO_BOX(currency_selector));
    price_imp->to_currency (comm);
    preview_refresh_table ();
}

◆ preview_update_currency_format()

void CsvImpPriceAssist::preview_update_currency_format ( )

Definition at line 1170 of file assistant-csv-price-import.cpp.

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

◆ preview_update_date_format()

void CsvImpPriceAssist::preview_update_date_format ( )

Definition at line 1163 of file assistant-csv-price-import.cpp.

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

◆ preview_update_encoding()

void CsvImpPriceAssist::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

selector	The widget the user uses to select a new encoding
encoding	The encoding that the user selected

Definition at line 1136 of file assistant-csv-price-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 = price_imp->m_tokenizer->encoding();
        /* Try converting the new encoding and reparsing. */
        try
        {
            price_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 CsvImpPriceAssist::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.

Parameters

csv_button	The "Separated" radio button
info	The display of the data being imported

Definition at line 1090 of file assistant-csv-price-import.cpp.

{
    /* Set the parsing type correctly. */
    try
    {
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(csv_button)))
        {
            price_imp->file_format (GncImpFileFormat::CSV);
            g_signal_handlers_disconnect_by_func(G_OBJECT(treeview),
                    (gpointer)csv_price_imp_preview_treeview_clicked_cb, (gpointer)this);
            gtk_widget_set_visible (separator_table, true);
            gtk_widget_set_visible (fw_instructions_hbox, false);
        }
        else
        {
            price_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_price_imp_preview_treeview_clicked_cb), (gpointer)this);
            gtk_widget_set_visible (separator_table, false);
            gtk_widget_set_visible (fw_instructions_hbox, true);
 
        }
        price_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 CsvImpPriceAssist::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

button	The button at the top of a column of the treeview
event	The event that happened (where the user clicked)
info	The data being configured

Returns: true if further processing of this even should stop, false if other event handlers can have a go at this as well

Definition at line 1455 of file assistant-csv-price-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 CsvImpPriceAssist::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
info	The data that is being configured

Definition at line 1022 of file assistant-csv-price-import.cpp.

{
    /* Only manipulate separator characters if the currently open file is
     * csv separated. */
    if (price_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. */
    price_imp->separators (checked_separators);
    price_imp->enable_escape (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(escape_cbutton)));
                                                                    
    /* if there are no separators, there will only be one column
     * so make sure column header is NONE */
    if (checked_separators.empty())
        price_imp->set_column_type_price (0, GncPricePropType::NONE);
 
    /* 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
    {
        price_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 CsvImpPriceAssist::preview_update_skipped_rows ( )

Definition at line 988 of file assistant-csv-price-import.cpp.

{
    /* Update skip rows in the parser */
    price_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, price_imp->m_parsed_lines.size()
            - price_imp->skip_start_lines() -1);
 
    adj = gtk_spin_button_get_adjustment (start_row_spin);
    gtk_adjustment_set_upper (adj, price_imp->m_parsed_lines.size()
            - price_imp->skip_end_lines() - 1);
 
    preview_refresh_table ();
}

◆ preview_validate_settings()

void CsvImpPriceAssist::preview_validate_settings ( )

Definition at line 1838 of file assistant-csv-price-import.cpp.

{
    /* Allow the user to proceed only if there are no inconsistencies in the settings */
    auto error_msg = price_imp->verify();
    gtk_assistant_set_page_complete (csv_imp_asst, preview_page, error_msg.empty());
    gtk_label_set_markup(GTK_LABEL(instructions_label), error_msg.c_str());
    gtk_widget_set_visible (GTK_WIDGET(instructions_image), !error_msg.empty());
}

Friends And Related Symbol Documentation

◆ fixed_context_menu_handler_price

gboolean fixed_context_menu_handler_price	(	GnumericPopupMenuElement const *	element,
		gpointer	userdata
	)

friend

Definition at line 1361 of file assistant-csv-price-import.cpp.

{
    auto info = (CsvImpPriceAssist*)userdata;
    auto fwtok = dynamic_cast<GncFwTokenizer*>(info->price_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->price_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-price-import.cpp

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ CsvImpPriceAssist()

◆ ~CsvImpPriceAssist()

Member Function Documentation

◆ assist_compmgr_close()

◆ assist_confirm_page_prepare()

◆ assist_file_page_prepare()

◆ assist_finish()

◆ assist_prepare_cb()

◆ assist_preview_page_prepare()

◆ assist_summary_page_prepare()

◆ file_activated_cb()

◆ file_selection_changed_cb()

◆ preview_handle_save_del_sensitivity()

◆ preview_over_write()

◆ preview_populate_settings_combo()

◆ preview_refresh()

◆ preview_refresh_table()

◆ preview_reparse_col_type()

◆ preview_settings_delete()

◆ preview_settings_load()

◆ preview_settings_name()

◆ preview_settings_save()

◆ preview_split_column()

◆ preview_update_col_type()

◆ preview_update_commodity()

◆ preview_update_currency()

◆ preview_update_currency_format()

◆ preview_update_date_format()

◆ preview_update_encoding()

◆ preview_update_file_format()

◆ preview_update_fw_columns()

◆ preview_update_separators()

◆ preview_update_skipped_rows()

◆ preview_validate_settings()

Friends And Related Symbol Documentation

◆ fixed_context_menu_handler_price