Commodity windows

Files
file	dialog-commodity.h
	"select" and "new" commodity windows

Data Structures
struct	SelectCommodityWindow
struct	CommodityWindow

Enumerations
enum	{ SOURCE_COL_NAME = 0 , SOURCE_COL_FQ_SUPPORTED , NUM_SOURCE_COLS }
enum	dialog_commodity_mode { DIAG_COMM_CURRENCY , DIAG_COMM_NON_CURRENCY , DIAG_COMM_NON_CURRENCY_SELECT , DIAG_COMM_ALL }
	The dialog commodity types are used to determine what commodity namespaces the currency dialog will present to a user. More...

Functions
void	gnc_ui_select_commodity_new_cb (GtkButton *button, gpointer user_data)
	This function is called whenever the user clicks on the "New" button in the commodity picker.
void	gnc_ui_select_commodity_changed_cb (GtkComboBox *cbwe, gpointer user_data)
	This function is called whenever the commodity combo box is changed.
void	gnc_ui_select_commodity_namespace_changed_cb (GtkComboBox *cbwe, gpointer user_data)
	This function is called whenever the commodity namespace combo box is changed.
void	gnc_ui_commodity_changed_cb (GtkWidget *dummy, gpointer user_data)
void	gnc_ui_commodity_quote_info_cb (GtkWidget *w, gpointer data)
gboolean	gnc_ui_commodity_dialog_to_object (CommodityWindow *w)
void	gnc_ui_update_namespace_picker (GtkWidget *cbwe, const char *init_string, dialog_commodity_mode mode)

Commodity Selection
gnc_commodity *	gnc_ui_select_commodity_modal_full (gnc_commodity *orig_sel, GtkWidget *parent, dialog_commodity_mode mode, const char *user_message, const char *cusip, const char *fullname, const char *mnemonic)
	Ask the user to select a commodity from the existing set of commodities.
gnc_commodity *	gnc_ui_select_commodity_modal (gnc_commodity *orig_sel, GtkWidget *parent, dialog_commodity_mode mode)
	Ask the user to select a commodity from the existing set of commodities.

Auxiliary Dialog Functions
void	gnc_ui_update_commodity_picker (GtkWidget *cbwe, const gchar *name_space, const gchar *sel)
	Given a combo box, fill in all the known commodities for the specified namespace, and then select one.
gchar *	gnc_ui_namespace_picker_ns (GtkWidget *cbwe)
	Given a combo box, return the currently selected namespaces.
void	gnc_ui_update_namespace_picker (GtkWidget *cbwe, const gchar *sel, dialog_commodity_mode mode)
	Given a combo box, fill in the known commodity namespaces and then select one.

Commodity Creation or Modification
gnc_commodity *	gnc_ui_new_commodity_modal_full (const char *name_space, GtkWidget *parent, const char *cusip, const char *fullname, const char *mnemonic, const char *user_symbol, int fraction)
	Ask the user to provide the information necessary to create a new commodity.
gnc_commodity *	gnc_ui_new_commodity_modal (const char *default_namespace, GtkWidget *parent)
	Ask the user to provide the information necessary to create a new commodity.
gboolean	gnc_ui_edit_commodity_modal (gnc_commodity *commodity, GtkWidget *parent)
	Given an existing commodity, uses the gnc_ui_build_commodity_dialog() routine to build a basic edit dialog, then fills in the price quote information at the bottom of the dialog.

Detailed Description

Enumeration Type Documentation

anonymous enum

anonymous enum

Definition at line 54 of file dialog-commodity.cpp.

{
    SOURCE_COL_NAME = 0,
    SOURCE_COL_FQ_SUPPORTED,
    NUM_SOURCE_COLS
};

dialog_commodity_mode

enum dialog_commodity_mode

The dialog commodity types are used to determine what commodity namespaces the currency dialog will present to a user.

These values can be safely changed from one release to the next. Note that if values are added, the routines in dialog-commodity.c will need to be updated to match.

Enumerator
DIAG_COMM_CURRENCY	Dialog box should only allow selection of a currency.
DIAG_COMM_NON_CURRENCY	Dialog box should allow selection of anything but a currency.
DIAG_COMM_NON_CURRENCY_SELECT	Dialog box should allow selection of anything but a currency and should include the "ALL" namespace to display all such commodities in a single list.
DIAG_COMM_ALL	Dialog box should allow selection of anything.

Definition at line 51 of file dialog-commodity.h.

{
    DIAG_COMM_CURRENCY,   
    DIAG_COMM_NON_CURRENCY, 
    DIAG_COMM_NON_CURRENCY_SELECT, 
    DIAG_COMM_ALL,    
} dialog_commodity_mode;

Function Documentation

gnc_ui_commodity_changed_cb()

void gnc_ui_commodity_changed_cb	(	GtkWidget *	dummy,
		gpointer	user_data
	)

Definition at line 712 of file dialog-commodity.cpp.

{
    auto w = static_cast<CommodityWindow*>(user_data);
    gchar *name_space;
    const char * fullname;
    const char * mnemonic;
    gboolean ok;
 
    ENTER("widget=%p, user_data=%p", dummy, user_data);
    if (!w->is_currency)
    {
        name_space = gnc_ui_namespace_picker_ns (w->namespace_combo);
        fullname  = gtk_entry_get_text(GTK_ENTRY(w->fullname_entry));
        mnemonic  = gtk_entry_get_text(GTK_ENTRY(w->mnemonic_entry));
        DEBUG("namespace=%s, name=%s, mnemonic=%s", name_space, fullname, mnemonic);
        ok = (fullname    && name_space    && mnemonic &&
              fullname[0] && name_space[0] && mnemonic[0]);
        g_free(name_space);
    }
    else
    {
        ok = TRUE;
    }
    gtk_widget_set_sensitive(w->ok_button, ok);
    gtk_dialog_set_default_response(GTK_DIALOG(w->dialog), ok ? 0 : 1);
    LEAVE("sensitive=%d, default = %d", ok, ok ? 0 : 1);
}

gnc_ui_commodity_dialog_to_object()

gboolean gnc_ui_commodity_dialog_to_object

(

CommodityWindow *

w

)

Definition at line 1231 of file dialog-commodity.cpp.

{
    gnc_quote_source *source;
    QuoteSourceType type;
    const char * fullname  = gtk_entry_get_text(GTK_ENTRY(w->fullname_entry));
    gchar *name_space = gnc_ui_namespace_picker_ns (w->namespace_combo);
    const char * mnemonic  = gtk_entry_get_text(GTK_ENTRY(w->mnemonic_entry));
    const char * user_symbol = gtk_entry_get_text(GTK_ENTRY(w->user_symbol_entry));
    const char * code      = gtk_entry_get_text(GTK_ENTRY(w->code_entry));
    QofBook * book = gnc_get_current_book ();
    int fraction = gtk_spin_button_get_value_as_int
                   (GTK_SPIN_BUTTON(w->fraction_spinbutton));
    const char *string;
    gnc_commodity * c;
    gint selection;
 
    ENTER(" ");
    /* Special case currencies */
    if (gnc_commodity_namespace_is_iso (name_space))
    {
        if (w->edit_commodity)
        {
            gboolean quote_set;
            quote_set = gtk_toggle_button_get_active
                        (GTK_TOGGLE_BUTTON (w->get_quote_check));
            c = w->edit_commodity;
            gnc_commodity_begin_edit(c);
            gnc_commodity_user_set_quote_flag (c, quote_set);
            if (quote_set)
            {
                selection = gtk_combo_box_get_active(GTK_COMBO_BOX(w->quote_tz_menu));
                string = gnc_timezone_menu_position_to_string(selection);
                gnc_commodity_set_quote_tz(c, string);
            }
            else
                gnc_commodity_set_quote_tz(c, nullptr);
 
            gnc_commodity_set_user_symbol(c, user_symbol);
 
            gnc_commodity_commit_edit(c);
            g_free (name_space);
            return TRUE;
        }
        gnc_warning_dialog (GTK_WINDOW (w->dialog), "%s",
                            _("You may not create a new national currency."));
        g_free (name_space);
        return FALSE;
    }
 
    /* Don't allow user to create commodities in namespace
     * "template". That's reserved for scheduled transaction use.
     */
    if (g_utf8_collate(name_space, GNC_COMMODITY_NS_TEMPLATE) == 0)
    {
        gnc_warning_dialog (GTK_WINDOW (w->dialog),
                            _("%s is a reserved commodity type."
                            " Please use something else."), GNC_COMMODITY_NS_TEMPLATE);
        g_free (name_space);
        return FALSE;
    }
 
    if (fullname && fullname[0] &&
            name_space && name_space[0] &&
            mnemonic && mnemonic[0])
    {
        c = gnc_commodity_table_lookup (gnc_get_current_commodities(),
                                        name_space, mnemonic);
 
        if ((!w->edit_commodity && c) ||
                (w->edit_commodity && c && (c != w->edit_commodity)))
        {
            gnc_warning_dialog (GTK_WINDOW (w->dialog), "%s",  _("That commodity already exists."));
            g_free(name_space);
            return FALSE;
        }
 
        if (!w->edit_commodity)
        {
            c = gnc_commodity_new(book, fullname, name_space, mnemonic, code, fraction);
            w->edit_commodity = c;
            gnc_commodity_begin_edit(c);
 
            gnc_commodity_set_user_symbol(c, user_symbol);
        }
        else
        {
            c = w->edit_commodity;
            gnc_commodity_begin_edit(c);
 
            gnc_commodity_table_remove (gnc_get_current_commodities(), c);
 
            gnc_commodity_set_fullname (c, fullname);
            gnc_commodity_set_mnemonic (c, mnemonic);
            gnc_commodity_set_namespace (c, name_space);
            gnc_commodity_set_cusip (c, code);
            gnc_commodity_set_fraction (c, fraction);
            gnc_commodity_set_user_symbol(c, user_symbol);
        }
 
        gnc_commodity_user_set_quote_flag (c, gtk_toggle_button_get_active
                                           (GTK_TOGGLE_BUTTON (w->get_quote_check)));
 
        for (type = SOURCE_SINGLE; type < SOURCE_MAX; type = static_cast<QuoteSourceType>(type+1))
        {
            if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w->source_button[type])))
                break;
        }
        selection = gtk_combo_box_get_active(GTK_COMBO_BOX(w->source_menu[type]));
        source = gnc_quote_source_lookup_by_ti (type, selection);
        gnc_commodity_set_quote_source(c, source);
 
        selection = gtk_combo_box_get_active(GTK_COMBO_BOX(w->quote_tz_menu));
        string = gnc_timezone_menu_position_to_string(selection);
        gnc_commodity_set_quote_tz(c, string);
        gnc_commodity_commit_edit(c);
 
        /* remember the commodity */
        gnc_commodity_table_insert(gnc_get_current_commodities(), c);
    }
    else
    {
        gnc_warning_dialog (GTK_WINDOW (w->dialog), "%s",
                            _("You must enter a non-empty \"Full name\", "
                              "\"Symbol/abbreviation\", "
                              "and \"Type\" for the commodity."));
        g_free(name_space);
        return FALSE;
    }
    g_free(name_space);
    LEAVE(" ");
    return TRUE;
}

gnc_ui_commodity_quote_info_cb()

void gnc_ui_commodity_quote_info_cb	(	GtkWidget *	w,
		gpointer	data
	)

Definition at line 680 of file dialog-commodity.cpp.

{
    auto cw = static_cast<CommodityWindow*>(data);
    gboolean get_quote, allow_src, active;
    const gchar *text;
    gint i;
 
    ENTER(" ");
    get_quote = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w));
 
    text = gtk_entry_get_text( GTK_ENTRY( gtk_bin_get_child( GTK_BIN( GTK_COMBO_BOX(cw->namespace_combo)))));
 
    allow_src = !gnc_commodity_namespace_is_iso(text);
 
    gtk_widget_set_sensitive(cw->source_label, get_quote && allow_src);
 
    for (i = SOURCE_SINGLE; i < SOURCE_MAX; i++)
    {
        if (!cw->source_button[i])
            continue;
        active =
            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw->source_button[i]));
        gtk_widget_set_sensitive(cw->source_button[i], get_quote && allow_src);
        gtk_widget_set_sensitive(cw->source_menu[i], get_quote && allow_src && active);
    }
    gtk_widget_set_sensitive(cw->quote_tz_label, get_quote);
    gtk_widget_set_sensitive(cw->quote_tz_menu, get_quote);
    LEAVE(" ");
}

gnc_ui_edit_commodity_modal()

gboolean gnc_ui_edit_commodity_modal	(	gnc_commodity *	commodity,
		GtkWidget *	parent
	)

Given an existing commodity, uses the gnc_ui_build_commodity_dialog() routine to build a basic edit dialog, then fills in the price quote information at the bottom of the dialog.

Allow the user to edit the information about a commodity.

For currencies, only the price quote information may be changed. For any other commodity, all aspects of the commodity information may be changed except that the namespace may not be changed to indicate a currency. The new information overwrites any old information, so this routine may not be used to create new commodities.

Parameters

commodity	The commodity to edit.
parent	The parent window of the new dialog.

Returns

The newly created commodity, or NULL if the user cancelled.

Definition at line 1214 of file dialog-commodity.cpp.

{
    gnc_commodity *result;
 
    ENTER(" ");
    result = gnc_ui_common_commodity_modal(commodity, parent, nullptr, nullptr,
                                           nullptr, nullptr, nullptr, 0);
    LEAVE(" ");
    return result != nullptr;
}

gnc_ui_namespace_picker_ns()

gchar * gnc_ui_namespace_picker_ns

(

GtkWidget *

cbwe

)

Given a combo box, return the currently selected namespaces.

Parameters

cbwe	The combo box of namespaces.

Returns

The currently selected namespace.

Note

This string must be freed by with g_free.

Definition at line 658 of file dialog-commodity.cpp.

{
    const gchar *name_space;
 
    g_return_val_if_fail(GTK_IS_COMBO_BOX (cbwe), nullptr);
 
    name_space = gtk_entry_get_text( GTK_ENTRY( gtk_bin_get_child( GTK_BIN( GTK_COMBO_BOX(cbwe)))));
 
    /* Map several currency related names to one common namespace */
    if ((g_strcmp0 (name_space, GNC_COMMODITY_NS_ISO) == 0) ||
        (g_strcmp0 (name_space, GNC_COMMODITY_NS_ISO_GUI) == 0) ||
        (g_strcmp0 (name_space, _(GNC_COMMODITY_NS_ISO_GUI)) == 0))
        return g_strdup(GNC_COMMODITY_NS_CURRENCY);
    else
        return g_strdup(name_space);
}

gnc_ui_new_commodity_modal()

gnc_commodity * gnc_ui_new_commodity_modal	(	const char *	default_namespace,
		GtkWidget *	parent
	)

Ask the user to provide the information necessary to create a new commodity.

Parameters

default_namespace	If present, this will be the default namespace for the new commodity. This value will be ignored if it is the namespace for ISO 4217 currencies.
parent	The parent window of the new dialog.

Returns

The newly created commodity, or NULL if the user cancelled.

Definition at line 1192 of file dialog-commodity.cpp.

{
    gnc_commodity *result;
 
    ENTER(" ");
    result = gnc_ui_common_commodity_modal(nullptr, parent, default_namespace, nullptr,
                                           nullptr, nullptr, nullptr, 0);
    LEAVE(" ");
    return result;
}

gnc_ui_new_commodity_modal_full()

gnc_commodity * gnc_ui_new_commodity_modal_full	(	const char *	name_space,
		GtkWidget *	parent,
		const char *	cusip,
		const char *	fullname,
		const char *	mnemonic,
		const char *	user_symbol,
		int	fraction
	)

Ask the user to provide the information necessary to create a new commodity.

Parameters

namespace	If present, this will be the default namespace for the new commodity. This value will be ignored if it is the namespace for ISO 4217 currencies.
parent	The parent window of the new dialog.
cusip	If present, this will be the default exchange specific data for the new commodity.
fullname	If present, this will be the default fullname for the new commodity.
mnemonic	If present, this will be the default mnemonic for the new commodity.
user_symbol	If present, this will be the default user symbol for the new commodity.
fraction	If present, this will be the default fraction for the new commodity. If absent, a default of 1000 will be used.

Returns

The newly created commodity, or NULL if the user cancelled.

Definition at line 1169 of file dialog-commodity.cpp.

{
    gnc_commodity *result;
 
    ENTER(" ");
    result = gnc_ui_common_commodity_modal(nullptr, parent, name_space, cusip,
                                           fullname, mnemonic, user_symbol,
                                           10000);
    LEAVE(" ");
    return result;
}

gnc_ui_select_commodity_changed_cb()

void gnc_ui_select_commodity_changed_cb	(	GtkComboBox *	cbwe,
		gpointer	user_data
	)

This function is called whenever the commodity combo box is changed.

Its function is to determine if a valid commodity has been selected, record the selection, and update the OK button.

Note

This function is an internal helper function for the Commodity Selection dialog. It should not be used outside of the dialog-commodity.c file.

Parameters

cbwe	A pointer to the commodity name entry widget in the dialog.
user_data	A pointer to the data structure describing the current state of the commodity picker.

Definition at line 370 of file dialog-commodity.cpp.

{
    auto w = static_cast<SelectCommodityWindow*>(user_data);
    gchar *name_space;
    const gchar *fullname;
    gboolean ok;
 
    ENTER("cbwe=%p, user_data=%p", cbwe, user_data);
    name_space = gnc_ui_namespace_picker_ns (w->namespace_combo);
    fullname = gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (GTK_COMBO_BOX(w->commodity_combo)))));
 
    DEBUG("namespace=%s, name=%s", name_space, fullname);
    w->selection = gnc_commodity_table_find_full(gnc_get_current_commodities(),
                   name_space, fullname);
    g_free(name_space);
 
    ok = (w->selection != nullptr);
    gtk_widget_set_sensitive(w->ok_button, ok);
    gtk_dialog_set_default_response(GTK_DIALOG(w->dialog), ok ? 0 : 2);
    LEAVE("sensitive=%d, default = %d", ok, ok ? 0 : 2);
}

gnc_ui_select_commodity_modal()

gnc_commodity * gnc_ui_select_commodity_modal	(	gnc_commodity *	orig_sel,
		GtkWidget *	parent,
		dialog_commodity_mode	mode
	)

Ask the user to select a commodity from the existing set of commodities.

The user will also have the option of creating a new commodity from this dialog box.. If the user decides to create a new one, those provided values are used as default values for the new commodity.

Parameters

orig_sel	A pointer to a commodity that should initially be selected in the dialog box.
parent	The parent window for this new selection window.
mode	Determines which namespaces the user may select a commodity from.

Returns

The commodity selected. May or may not be a newly created commodity.

Definition at line 217 of file dialog-commodity.cpp.

{
    return gnc_ui_select_commodity_modal_full(orig_sel,
            parent,
            mode,
            nullptr,
            nullptr,
            nullptr,
            nullptr);
}

gnc_ui_select_commodity_modal_full()

gnc_commodity * gnc_ui_select_commodity_modal_full	(	gnc_commodity *	orig_sel,
		GtkWidget *	parent,
		dialog_commodity_mode	mode,
		const char *	user_message,
		const char *	cusip,
		const char *	fullname,
		const char *	mnemonic
	)

Ask the user to select a commodity from the existing set of commodities.

Arguments to this function determine the message placed at the top of the dialog but force no restriction on the commodities that may be chosen. The user will also have the option of creating a new commodity from this dialog box.. If the user decides to create a new one, those provided values are used as default values for the new commodity.

Parameters

orig_sel	A pointer to a commodity that should initially be selected in the dialog box.
parent	The parent window of the new dialog.
user_message	A string that will be installed in the top of the dialog box as an instruction to the user. If NULL, a generic instruction will be used.
cusip	If present, a note will be added to the user instruction providing this exchange specific code, and this will be the default exchange specific data for any newly created commodities.
fullname	If present, a note will be added to the user instruction providing this commodity's full name, and this will be the default fullname for any newly created commodities.
mnemonic	If present, a note will be added to the user instruction providing this commodity's mnemonic, and this will be the default mnemonic for any newly created commodities.
mode	Determines which namespaces the user may select a commodity from.

Returns

The commodity selected. May or may not be a newly created commodity.

Definition at line 135 of file dialog-commodity.cpp.

{
    gnc_commodity * retval = nullptr;
    const gchar *initial;
    gchar *user_prompt_text;
    SelectCommodityWindow * win;
    gboolean done;
    gint value;
 
    win = gnc_ui_select_commodity_create(orig_sel, mode);
    win->default_cusip = cusip;
    win->default_fullname = fullname;
    win->default_mnemonic = mnemonic;
    win->default_user_symbol = "";
 
    if (parent)
        gtk_window_set_transient_for (GTK_WINDOW (win->dialog), GTK_WINDOW (parent));
 
    if (user_message != nullptr)
        initial = user_message;
    else if ((cusip != nullptr) || (fullname != nullptr) || (mnemonic != nullptr))
        initial = _("\nPlease select a commodity to match");
    else
        initial = "";
 
    user_prompt_text =
        g_strdup_printf("%s%s%s%s%s%s%s",
                        initial,
                        fullname ? _("\nCommodity: ") : "",
                        fullname ? fullname : "",
                        /* Translators: Replace here and later CUSIP by the name of your local
                           National Securities Identifying Number
                           like gb:SEDOL, de:WKN, ch:Valorennummer, fr:SICOVAM ...
                           See https://en.wikipedia.org/wiki/ISIN and
                           https://en.wikipedia.org/wiki/National_numbering_agency for hints. */
                        cusip    ? _("\nExchange code (ISIN, CUSIP or similar): ") : "",
                        cusip    ? cusip : "",
                        mnemonic ? _("\nMnemonic (Ticker symbol or similar): ") : "",
                        mnemonic ? mnemonic : "");
    gtk_label_set_text ((GtkLabel *)(win->select_user_prompt),
                        user_prompt_text);
    g_free(user_prompt_text);
 
    /* Run the dialog, handling the terminal conditions. */
    done = FALSE;
    while (!done)
    {
        switch (value = gtk_dialog_run(GTK_DIALOG(win->dialog)))
        {
        case GTK_RESPONSE_OK:
            DEBUG("case OK");
            retval = win->selection;
            done = TRUE;
            break;
        case GNC_RESPONSE_NEW:
            DEBUG("case NEW");
            gnc_ui_select_commodity_new_cb (nullptr, win);
            break;
        default:    /* Cancel, Escape, Close, etc. */
            DEBUG("default: %d", value);
            retval = nullptr;
            done = TRUE;
            break;
        }
    }
    gtk_widget_destroy (GTK_WIDGET (win->dialog)); /* Close and destroy */
    g_free(win);
 
    return retval;
}

gnc_ui_select_commodity_namespace_changed_cb()

void gnc_ui_select_commodity_namespace_changed_cb	(	GtkComboBox *	cbwe,
		gpointer	user_data
	)

This function is called whenever the commodity namespace combo box is changed.

Its function is to update the commodity name combo box with the strings that are appropriate to the selected namespace.

Note

This function is an internal helper function for the Commodity Selection dialog. It should not be used outside of the dialog-commodity.c file.

Parameters

cbwe	A pointer to the commodity namespace entry widget in the dialog.
user_data	A pointer to the data structure describing the current state of the commodity picker.

Definition at line 411 of file dialog-commodity.cpp.

{
    auto w = static_cast<SelectCommodityWindow*>(user_data);
    gchar *name_space;
 
    ENTER("cbwe=%p, user_data=%p", cbwe, user_data);
    name_space = gnc_ui_namespace_picker_ns (w->namespace_combo);
    DEBUG("name_space=%s", name_space);
    gnc_ui_update_commodity_picker(w->commodity_combo, name_space, nullptr);
    g_free(name_space);
    LEAVE(" ");
}

gnc_ui_select_commodity_new_cb()

void gnc_ui_select_commodity_new_cb	(	GtkButton *	button,
		gpointer	user_data
	)

This function is called whenever the user clicks on the "New" button in the commodity picker.

Its function is pop up a new dialog alling the user to create a new commodity.

Note

This function is an internal helper function for the Commodity Selection dialog. It should not be used outside of the dialog-commodity.c file.

Parameters

button	A pointer to the "new" button widget in the dialog.
user_data	A pointer to the data structure describing the current state of the commodity picker.

Definition at line 326 of file dialog-commodity.cpp.

{
    auto w = static_cast<SelectCommodityWindow*>(user_data);
 
    gchar * name_space = gnc_ui_namespace_picker_ns (w->namespace_combo);
 
    const gnc_commodity * new_commodity =
        gnc_ui_new_commodity_modal_full(name_space,
                                        w->dialog,
                                        w->default_cusip,
                                        w->default_fullname,
                                        w->default_mnemonic,
                                        w->default_user_symbol,
                                        w->default_fraction);
    if (new_commodity)
    {
        gnc_ui_update_namespace_picker(w->namespace_combo,
                                       gnc_commodity_get_namespace(new_commodity),
                                       DIAG_COMM_ALL);
        gnc_ui_update_commodity_picker(w->commodity_combo,
                                       gnc_commodity_get_namespace(new_commodity),
                                       gnc_commodity_get_printname(new_commodity));
    }
    g_free(name_space);
}

gnc_ui_update_commodity_picker()

void gnc_ui_update_commodity_picker	(	GtkWidget *	cbwe,
		const gchar *	name_space,
		const gchar *	sel
	)

Given a combo box, fill in all the known commodities for the specified namespace, and then select one.

Parameters

cbwe	The widget to populate with information.
namespace	All commodities with this namespace will be added to the combo box.
sel	The commodity that should be initially selected when the combo box appears.

Definition at line 441 of file dialog-commodity.cpp.

{
    GList      * commodities;
    GList      * iterator = nullptr;
    GList      * commodity_items = nullptr;
    GtkComboBox *combo_box;
    GtkEntry *entry;
    GtkTreeModel *model;
    GtkTreeIter iter;
    gnc_commodity_table *table;
    gint current = 0, match = 0;
    gchar *name;
 
    g_return_if_fail(GTK_IS_COMBO_BOX(cbwe));
    g_return_if_fail(name_space);
 
    /* Erase the old entries */
    combo_box = GTK_COMBO_BOX(cbwe);
    model = gtk_combo_box_get_model(combo_box);
    gtk_list_store_clear(GTK_LIST_STORE(model));
 
    /* Erase the entry text */
    entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo_box)));
    gtk_editable_delete_text(GTK_EDITABLE(entry), 0, -1);
 
    gtk_combo_box_set_active(combo_box, -1);
 
    table = gnc_commodity_table_get_table (gnc_get_current_book ());
    commodities = gnc_commodity_table_get_commodities(table, name_space);
    for (iterator = commodities; iterator; iterator = iterator->next)
    {
        commodity_items =
            g_list_prepend (commodity_items,
                            (gpointer) gnc_commodity_get_printname(GNC_COMMODITY(iterator->data)));
    }
    g_list_free(commodities);
 
    commodity_items = g_list_sort(commodity_items, collate);
    for (iterator = commodity_items; iterator; iterator = iterator->next)
    {
        name = (char *)iterator->data;
        gtk_list_store_append(GTK_LIST_STORE(model), &iter);
        gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, name, -1);
 
        if (init_string && g_utf8_collate(name, init_string) == 0)
            match = current;
        current++;
    }
 
    gtk_combo_box_set_active(combo_box, match);
    g_list_free(commodity_items);
}

gnc_ui_update_namespace_picker() [1/2]

void gnc_ui_update_namespace_picker	(	GtkWidget *	cbwe,
		const char *	init_string,
		dialog_commodity_mode	mode
	)

Definition at line 556 of file dialog-commodity.cpp.

{
    GtkComboBox *combo_box;
    GtkTreeModel *model;
    GtkTreeIter iter, match;
    GList *namespaces, *node;
    gboolean matched = FALSE;
 
    g_return_if_fail(GTK_IS_COMBO_BOX (cbwe));
 
    /* Erase the old entries */
    combo_box = GTK_COMBO_BOX(cbwe);
    model = gtk_combo_box_get_model(combo_box);
    gtk_list_store_clear(GTK_LIST_STORE(model));
 
    /* fetch a list of the namespaces */
    switch (mode)
    {
    case DIAG_COMM_ALL:
        namespaces =
            gnc_commodity_table_get_namespaces (gnc_get_current_commodities());
        break;
 
    case DIAG_COMM_NON_CURRENCY:
    case DIAG_COMM_NON_CURRENCY_SELECT:
        namespaces =
            gnc_commodity_table_get_namespaces (gnc_get_current_commodities());
        node = g_list_find_custom (namespaces, GNC_COMMODITY_NS_CURRENCY, collate);
        if (node)
        {
            namespaces = g_list_remove_link (namespaces, node);
            g_list_free_1 (node);
        }
 
        if (gnc_commodity_namespace_is_iso (init_string))
            init_string = nullptr;
        break;
 
    case DIAG_COMM_CURRENCY:
    default:
        namespaces = g_list_prepend (nullptr, (gpointer)GNC_COMMODITY_NS_CURRENCY);
        break;
    }
 
    /* First insert "Currencies" entry if requested */
    if (mode == DIAG_COMM_CURRENCY || mode == DIAG_COMM_ALL)
    {
        gtk_list_store_append(GTK_LIST_STORE(model), &iter);
        gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0,
                            _(GNC_COMMODITY_NS_ISO_GUI), -1);
 
        if (init_string &&
            (g_utf8_collate(GNC_COMMODITY_NS_ISO_GUI, init_string) == 0))
        {
            matched = TRUE;
            match = iter;
        }
    }
 
    /* Next insert "All non-currency" entry if requested */
    if (mode == DIAG_COMM_NON_CURRENCY_SELECT || mode == DIAG_COMM_ALL)
    {
        gtk_list_store_append(GTK_LIST_STORE(model), &iter);
        gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0,
                            GNC_COMMODITY_NS_NONISO_GUI, -1);
    }
 
    /* add all others to the combobox */
    namespaces = g_list_sort(namespaces, collate);
    for (node = namespaces; node; node = node->next)
    {
        auto ns = static_cast<const char*>(node->data);
        /* Skip template, legacy and currency namespaces.
           The latter was added as first entry earlier */
        if ((g_utf8_collate(ns, GNC_COMMODITY_NS_LEGACY) == 0) ||
            (g_utf8_collate(ns, GNC_COMMODITY_NS_TEMPLATE ) == 0) ||
            (g_utf8_collate(ns, GNC_COMMODITY_NS_CURRENCY ) == 0))
            continue;
 
        gtk_list_store_append(GTK_LIST_STORE(model), &iter);
        gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, ns, -1);
 
        if (init_string &&
            (g_utf8_collate(ns, init_string) == 0))
        {
            matched = TRUE;
            match = iter;
        }
    }
 
    if (!matched)
        matched = gtk_tree_model_get_iter_first (model, &match);
 
    if (matched)
        gtk_combo_box_set_active_iter (combo_box, &match);
    g_list_free(namespaces);
}

gnc_ui_update_namespace_picker() [2/2]

void gnc_ui_update_namespace_picker	(	GtkWidget *	cbwe,
		const gchar *	sel,
		dialog_commodity_mode	mode
	)

Given a combo box, fill in the known commodity namespaces and then select one.

Parameters

cbwe	The widget to populate with information.
sel	The namespace that should be initially selected when the combo box appears.
mode	Determines in which namespaces the user may select a commodity