IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge Richard Cohen's 'declare-type-gnome-utils' into stable.

Browse Source
This commit is contained in:
John Ralls 2023-07-16 09:20:13 -07:00
commit 7f56b5cbc4
34 changed files with 433 additions and 1250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gnucash/gnome-utils/gnc-account-sel.c
View File

@ -234,7 +234,7 @@ gnc_account_sel_class_init (GNCAccountSelClass *klass)
g_signal_new ("account_sel_changed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GNCAccountSelClass, account_sel_changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,

15
gnucash/gnome-utils/gnc-account-sel.h
View File

@ -38,21 +38,8 @@ extern "C" {
#endif
#define GNC_TYPE_ACCOUNT_SEL (gnc_account_sel_get_type())
#define GNC_ACCOUNT_SEL(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, GNC_TYPE_ACCOUNT_SEL, GNCAccountSel)
#define GNC_ACCOUNT_SEL_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, GNC_TYPE_ACCOUNT_SEL, GNCAccountSelClass)
#define GNC_IS_ACCOUNT_SEL(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, GNC_TYPE_ACCOUNT_SEL)
G_DECLARE_FINAL_TYPE (GNCAccountSel, gnc_account_sel, GNC, ACCOUNT_SEL, GtkBox)
typedef struct _GNCAccountSel GNCAccountSel;
typedef struct
{
GtkBoxClass parent_class;
/* Signals for notification/filtering of changes */
void (*account_sel_changed) (GNCAccountSel *gas);
} GNCAccountSelClass;
GType gnc_account_sel_get_type (void) G_GNUC_CONST;
GtkWidget* gnc_account_sel_new (void);
/**

31
gnucash/gnome-utils/gnc-amount-edit.c
View File

@ -63,6 +63,31 @@ static gint gnc_amount_edit_key_press (GtkWidget *widget,
#define GNC_AMOUNT_EDIT_PATH "gnc-amount-edit-path"
struct _GNCAmountEdit
{
GtkBox box;
GtkEntry *entry;
GtkWidget *image;
gboolean disposed;
gboolean need_to_parse;
GNCPrintAmountInfo print_info;
gboolean block_changed;
gnc_numeric amount;
int fraction;
gboolean evaluate_on_enter;
gboolean validate_on_change;
gboolean show_warning_symbol;
};
G_DEFINE_TYPE (GNCAmountEdit, gnc_amount_edit, GTK_TYPE_BOX)
static void
@ -110,7 +135,7 @@ gnc_amount_edit_class_init (GNCAmountEditClass *klass)
g_signal_new ("activate",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GNCAmountEditClass, activate),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
@ -121,7 +146,7 @@ gnc_amount_edit_class_init (GNCAmountEditClass *klass)
g_signal_new ("changed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GNCAmountEditClass, changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
@ -132,7 +157,7 @@ gnc_amount_edit_class_init (GNCAmountEditClass *klass)
g_signal_new ("amount_changed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GNCAmountEditClass, amount_changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,

46
gnucash/gnome-utils/gnc-amount-edit.h
View File

@ -37,51 +37,7 @@ extern "C" {
#endif
#define GNC_TYPE_AMOUNT_EDIT (gnc_amount_edit_get_type ())
#define GNC_AMOUNT_EDIT(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, GNC_TYPE_AMOUNT_EDIT, GNCAmountEdit)
#define GNC_AMOUNT_EDIT_CLASS(klass) G_TYPE_CHECK_CLASS_CAST(klass, GNC_TYPE_AMOUNT_EDIT, GNCAmountEditClass)
#define GNC_IS_AMOUNT_EDIT(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, GNC_TYPE_AMOUNT_EDIT)
typedef struct
{
GtkBox box;
GtkEntry *entry;
GtkWidget *image;
gboolean disposed;
gboolean need_to_parse;
GNCPrintAmountInfo print_info;
gboolean block_changed;
gnc_numeric amount;
int fraction;
gboolean evaluate_on_enter;
gboolean validate_on_change;
gboolean show_warning_symbol;
} GNCAmountEdit;
typedef struct
{
GtkBoxClass parent_class;
/* Signals for notification/filtering of changes */
void (*activate) (GNCAmountEdit *gae);
void (*changed) (GNCAmountEdit *gae);
void (*amount_changed) (GNCAmountEdit *gae);
} GNCAmountEditClass;
/**
* gnc_amount_edit_get_type:
*
* Returns the GType for the GNCAmountEdit widget
*/
GType gnc_amount_edit_get_type (void) G_GNUC_CONST;
G_DECLARE_FINAL_TYPE (GNCAmountEdit, gnc_amount_edit, GNC, AMOUNT_EDIT, GtkBox)
/**
* gnc_amount_edit_new:

63
gnucash/gnome-utils/gnc-cell-renderer-text-flag.c
View File

@ -65,22 +65,26 @@ enum
LAST_PROP
};
G_DEFINE_TYPE_WITH_PRIVATE(GncCellRendererTextFlag,
gnc_cell_renderer_text_flag,
GTK_TYPE_CELL_RENDERER_TEXT)
struct _GncCellRendererTextFlag
{
GtkCellRendererText parent;
gint size;
GdkRGBA color;
GdkRGBA color_selected;
gboolean flagged;
};
G_DEFINE_TYPE(GncCellRendererTextFlag,
gnc_cell_renderer_text_flag,
GTK_TYPE_CELL_RENDERER_TEXT)
static void
gnc_cell_renderer_text_flag_init(GncCellRendererTextFlag *celltext)
{
GncCellRendererTextFlagPrivate *priv;
celltext->priv =
gnc_cell_renderer_text_flag_get_instance_private(celltext);
priv = celltext->priv;
priv->size = 8;
gdk_rgba_parse(&priv->color, "red");
priv->flagged = FALSE;
celltext->size = 8;
gdk_rgba_parse(&celltext->color, "red");
celltext->flagged = FALSE;
}
static void
@ -135,24 +139,23 @@ gnc_cell_renderer_text_flag_get_property(GObject *object, guint param_id,
GValue *value, GParamSpec *pspec)
{
GncCellRendererTextFlag *celltext = GNC_CELL_RENDERER_TEXT_FLAG(object);
GncCellRendererTextFlagPrivate *priv = celltext->priv;
switch (param_id)
{
case PROP_FLAGGED:
g_value_set_boolean(value, priv->flagged);
g_value_set_boolean(value, celltext->flagged);
break;
case PROP_FLAG_SIZE:
g_value_set_int(value, priv->size);
g_value_set_int(value, celltext->size);
break;
case PROP_FLAG_COLOR_RGBA:
g_value_set_boxed (value, &priv->color);
g_value_set_boxed (value, &celltext->color);
break;
case PROP_FLAG_COLOR_RGBA_SELECTED:
g_value_set_boxed (value, &priv->color_selected);
g_value_set_boxed (value, &celltext->color_selected);
break;
default:
@ -167,7 +170,6 @@ gnc_cell_renderer_text_flag_set_property(GObject *object, guint param_id,
GParamSpec *pspec)
{
GncCellRendererTextFlag *celltext = GNC_CELL_RENDERER_TEXT_FLAG(object);
GncCellRendererTextFlagPrivate *priv = celltext->priv;
switch (param_id)
{
case PROP_FLAG_COLOR:
@ -180,9 +182,9 @@ gnc_cell_renderer_text_flag_set_property(GObject *object, guint param_id,
else if (gdk_rgba_parse(&rgba, g_value_get_string(value)))
{
if (param_id == PROP_FLAG_COLOR_SELECTED)
priv->color = rgba;
celltext->color = rgba;
else
priv->color_selected = rgba;
celltext->color_selected = rgba;
}
else
g_warning("Don't know color '%s'", g_value_get_string(value));
@ -194,8 +196,8 @@ gnc_cell_renderer_text_flag_set_property(GObject *object, guint param_id,
GdkRGBA *rgba;
rgba = g_value_get_boxed(value);
if (rgba)
priv->color = *rgba;
if (rgba)
celltext->color = *rgba;
}
break;
@ -204,17 +206,17 @@ gnc_cell_renderer_text_flag_set_property(GObject *object, guint param_id,
GdkRGBA *rgba;
rgba = g_value_get_boxed(value);
if (rgba)
priv->color_selected = *rgba;
if (rgba)
celltext->color_selected = *rgba;
}
break;
case PROP_FLAGGED:
priv->flagged = g_value_get_boolean(value);
celltext->flagged = g_value_get_boolean(value);
break;
case PROP_FLAG_SIZE:
priv->size = g_value_get_int(value);
celltext->size = g_value_get_int(value);
break;
default:
@ -247,16 +249,15 @@ gnc_cell_renderer_text_flag_render(GtkCellRenderer *cell, cairo_t *cr,
{
GncCellRendererTextFlag *celltext = GNC_CELL_RENDERER_TEXT_FLAG(cell);
GncCellRendererTextFlagPrivate *priv = celltext->priv;
// call the parent renderer to do the standard drawing
GTK_CELL_RENDERER_CLASS(gnc_cell_renderer_text_flag_parent_class)
->render(cell, cr, widget, background_area, cell_area, flags);
// add the flag (triangle in the top right corner)
if (priv->flagged)
if (celltext->flagged)
{
guint size = MIN(MIN(background_area->height, priv->size),
guint size = MIN(MIN(background_area->height, celltext->size),
background_area->width);
double x = background_area->x + background_area->width - size;
double y = background_area->y;
@ -266,8 +267,8 @@ gnc_cell_renderer_text_flag_render(GtkCellRenderer *cell, cairo_t *cr,
cairo_rel_line_to(cr, 0, size);
cairo_close_path(cr);
gdk_cairo_set_source_rgba(cr, (flags & GTK_CELL_RENDERER_SELECTED)
? &priv->color_selected
: &priv->color);
? &celltext->color_selected
: &celltext->color);
cairo_fill(cr);
}
}

30
gnucash/gnome-utils/gnc-cell-renderer-text-flag.h
View File

@ -30,36 +30,8 @@
#define GNC_TYPE_CELL_RENDERER_TEXT_FLAG (gnc_cell_renderer_text_flag_get_type ())
#define GNC_CELL_RENDERER_TEXT_FLAG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_CELL_RENDERER_TEXT_FLAG, GncCellRendererTextFlag))
#define GNC_CELL_RENDERER_TEXT_FLAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_CELL_RENDERER_TEXT_FLAG, GncCellRendererTextFlagClass))
#define GNC_IS_CELL_RENDERER_TEXT_FLAG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_CELL_RENDERER_TEXT_FLAG))
#define GNC_IS_CELL_RENDERER_TEXT_FLAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_CELL_RENDERER_TEXT_FLAG))
#define GNC_CELL_RENDERER_TEXT_FLAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_CELL_RENDERER_TEXT_FLAG, GncCellRendererTextFlagClass))
G_DECLARE_FINAL_TYPE (GncCellRendererTextFlag, gnc_cell_renderer_text_flag, GNC, CELL_RENDERER_TEXT_FLAG, GtkCellRendererText)
typedef struct _GncCellRendererTextFlag GncCellRendererTextFlag;
typedef struct _GncCellRendererTextFlagClass GncCellRendererTextFlagClass;
typedef struct _GtkCellRendererTextPrivate
{
guint size;
GdkRGBA color;
GdkRGBA color_selected;
gboolean flagged;
} GncCellRendererTextFlagPrivate;
struct _GncCellRendererTextFlag
{
GtkCellRendererText parent;
/*< private >*/
GncCellRendererTextFlagPrivate *priv;
};
struct _GncCellRendererTextFlagClass
{
GtkCellRendererTextClass parent_class;
};
GType gnc_cell_renderer_text_flag_get_type(void) G_GNUC_CONST;
GtkCellRenderer *gnc_cell_renderer_text_flag_new(void);
#endif /* __GNC_CELL_RENDERER_TEXT_FLAG_H__ */

8
gnucash/gnome-utils/gnc-cell-renderer-text-view.c
View File

@ -37,6 +37,14 @@ static GtkCellEditable *gcrtv_start_editing (GtkCellRenderer *cell,
#define GNC_CELL_RENDERER_TEXT_VIEW_PATH "gnc-cell-renderer-text-view-path"
struct _GncCellRendererTextView
{
GtkCellRendererText parent;
/* The editable entry. */
GtkWidget *editable;
};
G_DEFINE_TYPE (GncCellRendererTextView, gnc_cell_renderer_text_view, GTK_TYPE_CELL_RENDERER_TEXT)
static void

25
gnucash/gnome-utils/gnc-cell-renderer-text-view.h
View File

@ -26,30 +26,7 @@
#include <gtk/gtk.h>
#define GNC_TYPE_CELL_RENDERER_TEXT_VIEW (gnc_cell_renderer_text_view_get_type ())
#define GNC_CELL_RENDERER_TEXT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_CELL_RENDERER_TEXT_VIEW, GncCellRendererTextView))
#define GNC_CELL_RENDERER_TEXT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_CELL_RENDERER_TEXT_VIEW, GncCellRendererTextViewClass))
#define GNC_IS_CELL_RENDERER_TEXT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_CELL_RENDERER_TEXT_VIEW))
#define GNC_IS_CELL_RENDERER_TEXT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GNC_TYPE_CELL_RENDERER_TEXT_VIEW))
#define GNC_CELL_RENDERER_TEXT_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_CELL_RENDERER_TEXT_VIEW, GncCellRendererTextViewClass))
typedef struct _GncCellRendererTextView GncCellRendererTextView;
typedef struct _GncCellRendererTextViewClass GncCellRendererTextViewClass;
struct _GncCellRendererTextView
{
GtkCellRendererText parent;
/* The editable entry. */
GtkWidget *editable;
};
struct _GncCellRendererTextViewClass
{
GtkCellRendererTextClass parent_class;
};
GType gnc_cell_renderer_text_view_get_type (void) G_GNUC_CONST;
G_DECLARE_FINAL_TYPE (GncCellRendererTextView, gnc_cell_renderer_text_view, GNC, CELL_RENDERER_TEXT_VIEW, GtkCellRendererText)
GtkCellRenderer *gnc_cell_renderer_text_view_new (void);

36
gnucash/gnome-utils/gnc-currency-edit.c
View File

@ -71,16 +71,14 @@ static void gnc_currency_edit_mnemonic_changed (GObject *gobject,
static void gnc_currency_edit_active_changed (GtkComboBox *gobject,
gpointer user_data);
/** The instance private data for a content plugin. */
typedef struct _GNCCurrencyEditPrivate
struct _GNCCurrencyEdit
{
GtkComboBox combobox;
gchar *mnemonic;
} GNCCurrencyEditPrivate;
};
G_DEFINE_TYPE_WITH_PRIVATE(GNCCurrencyEdit, gnc_currency_edit, GTK_TYPE_COMBO_BOX)
#define GET_PRIVATE(o) \
((GNCCurrencyEditPrivate*)gnc_currency_edit_get_instance_private((GNCCurrencyEdit*)o))
G_DEFINE_TYPE(GNCCurrencyEdit, gnc_currency_edit, GTK_TYPE_COMBO_BOX)
/** @name Basic Object Implementation */
/** @{ */
@ -103,14 +101,13 @@ gnc_currency_edit_set_property (GObject *object,
GParamSpec *pspec)
{
GNCCurrencyEdit *self = GNC_CURRENCY_EDIT (object);
GNCCurrencyEditPrivate *priv = GET_PRIVATE (self);
switch (property_id)
{
case PROP_GCE_MNEMONIC:
g_free (priv->mnemonic);
priv->mnemonic = g_value_dup_string (value);
DEBUG ("mnemonic: %s\n", priv->mnemonic);
g_free (self->mnemonic);
self->mnemonic = g_value_dup_string (value);
DEBUG ("mnemonic: %s\n", self->mnemonic);
break;
default:
@ -127,12 +124,11 @@ gnc_currency_edit_get_property (GObject *object,
GParamSpec *pspec)
{
GNCCurrencyEdit *self = GNC_CURRENCY_EDIT (object);
GNCCurrencyEditPrivate *priv = GET_PRIVATE (self);
switch (property_id)
{
case PROP_GCE_MNEMONIC:
g_value_set_string (value, priv->mnemonic);
g_value_set_string (value, self->mnemonic);
break;
default:
@ -202,19 +198,12 @@ gnc_currency_edit_init (GNCCurrencyEdit *gce)
static void
gnc_currency_edit_finalize (GObject *object)
{
GNCCurrencyEditPrivate *priv;
GNCCurrencyEdit *period;
g_return_if_fail (object != NULL);
g_return_if_fail (GNC_IS_CURRENCY_EDIT (object));
period = GNC_CURRENCY_EDIT(object);
priv = GET_PRIVATE(period);
GNCCurrencyEdit *self = GNC_CURRENCY_EDIT(object);
g_free (priv->mnemonic);
/* Do not free the private data structure itself. It is part of
* a larger memory block allocated by the type system. */
g_free (self->mnemonic);
G_OBJECT_CLASS(gnc_currency_edit_parent_class)->finalize (object);
}
@ -227,11 +216,10 @@ gnc_currency_edit_mnemonic_changed (GObject *gobject,
{
GNCCurrencyEdit *self = GNC_CURRENCY_EDIT (gobject);
GNCCurrencyEditPrivate *priv = GET_PRIVATE (self);
gnc_commodity *currency = gnc_commodity_table_lookup (gnc_get_current_commodities (),
GNC_COMMODITY_NS_CURRENCY,
priv->mnemonic);
self->mnemonic);
/* If there isn't any such commodity, get the default */
if (!currency)

21
gnucash/gnome-utils/gnc-currency-edit.h
View File

@ -65,26 +65,7 @@ extern "C" {
/** @{ */
#define GNC_TYPE_CURRENCY_EDIT (gnc_currency_edit_get_type())
#define GNC_CURRENCY_EDIT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_CURRENCY_EDIT, GNCCurrencyEdit))
#define GNC_CURRENCY_EDIT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GNC_TYPE_CURRENCY_EDIT, GNCCurrencyEditClass))
#define GNC_IS_CURRENCY_EDIT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_CURRENCY_EDIT))
typedef struct
{
GtkComboBox combobox;
} GNCCurrencyEdit;
typedef struct
{
GtkComboBoxClass combobox;
} GNCCurrencyEditClass;
/** Return the GType for the GNCCurrencyEdit currency selection widget.
*
* @return A GType value.
*/
GType gnc_currency_edit_get_type (void);
G_DECLARE_FINAL_TYPE (GNCCurrencyEdit, gnc_currency_edit, GNC, CURRENCY_EDIT, GtkComboBox)
/** Create a new GNCCurrencyEdit widget which can be used to provide
* an easy way to enter ISO currency codes.

152
gnucash/gnome-utils/gnc-date-format.c
View File

@ -53,10 +53,12 @@ enum
LAST_SIGNAL
};
typedef struct _GNCDateFormatPrivate GNCDateFormatPrivate;
struct _GNCDateFormatPrivate
/**
**/
struct _GNCDateFormat
{
GtkBox hbox;
GtkWidget* format_combobox;
GtkWidget* label;
@ -76,9 +78,6 @@ struct _GNCDateFormatPrivate
GtkWidget* sample_label;
};
#define GNC_DATE_FORMAT_GET_PRIVATE(o) \
((GNCDateFormatPrivate*)gnc_date_format_get_instance_private((GNCDateFormat*)o))
static guint date_format_signals [LAST_SIGNAL] = { 0 };
static void gnc_date_format_finalize (GObject *object);
@ -86,7 +85,7 @@ static void gnc_date_format_compute_format(GNCDateFormat *gdf);
void gnc_ui_date_format_changed_cb(GtkWidget *unused, gpointer user_data);
G_DEFINE_TYPE_WITH_PRIVATE(GNCDateFormat, gnc_date_format, GTK_TYPE_BOX)
G_DEFINE_TYPE(GNCDateFormat, gnc_date_format, GTK_TYPE_BOX)
static void
gnc_date_format_class_init (GNCDateFormatClass *klass)
@ -99,7 +98,7 @@ gnc_date_format_class_init (GNCDateFormatClass *klass)
g_signal_new ("format_changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GNCDateFormatClass, format_changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
@ -111,7 +110,6 @@ gnc_date_format_class_init (GNCDateFormatClass *klass)
static void
gnc_date_format_init (GNCDateFormat *gdf)
{
GNCDateFormatPrivate *priv;
GtkBuilder *builder;
GtkWidget *dialog;
@ -131,22 +129,21 @@ gnc_date_format_init (GNCDateFormat *gdf)
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, gdf);
/* pull in all the child widgets */
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
priv->label = GTK_WIDGET(gtk_builder_get_object (builder, "widget_label"));
priv->format_combobox = GTK_WIDGET(gtk_builder_get_object (builder, "format_combobox"));
gdf->label = GTK_WIDGET(gtk_builder_get_object (builder, "widget_label"));
gdf->format_combobox = GTK_WIDGET(gtk_builder_get_object (builder, "format_combobox"));
priv->months_label = GTK_WIDGET(gtk_builder_get_object (builder, "months_label"));
priv->months_number = GTK_WIDGET(gtk_builder_get_object (builder, "month_number_button"));
priv->months_abbrev = GTK_WIDGET(gtk_builder_get_object (builder, "month_abbrev_button"));
priv->months_name = GTK_WIDGET(gtk_builder_get_object (builder, "month_name_button"));
gdf->months_label = GTK_WIDGET(gtk_builder_get_object (builder, "months_label"));
gdf->months_number = GTK_WIDGET(gtk_builder_get_object (builder, "month_number_button"));
gdf->months_abbrev = GTK_WIDGET(gtk_builder_get_object (builder, "month_abbrev_button"));
gdf->months_name = GTK_WIDGET(gtk_builder_get_object (builder, "month_name_button"));
priv->years_label = GTK_WIDGET(gtk_builder_get_object (builder, "years_label"));
priv->years_button = GTK_WIDGET(gtk_builder_get_object (builder, "years_button"));
gdf->years_label = GTK_WIDGET(gtk_builder_get_object (builder, "years_label"));
gdf->years_button = GTK_WIDGET(gtk_builder_get_object (builder, "years_button"));
priv->custom_label = GTK_WIDGET(gtk_builder_get_object (builder, "format_label"));
priv->custom_entry = GTK_WIDGET(gtk_builder_get_object (builder, "format_entry"));
gdf->custom_label = GTK_WIDGET(gtk_builder_get_object (builder, "format_label"));
gdf->custom_entry = GTK_WIDGET(gtk_builder_get_object (builder, "format_entry"));
priv->sample_label = GTK_WIDGET(gtk_builder_get_object (builder, "sample_label"));
gdf->sample_label = GTK_WIDGET(gtk_builder_get_object (builder, "sample_label"));
/* Set initial format to gnucash default */
gnc_date_format_set_format(gdf, QOF_DATE_FORMAT_UNSET);
@ -154,11 +151,11 @@ gnc_date_format_init (GNCDateFormat *gdf)
/* pull in the dialog and table widgets and play the reconnect game */
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "gnc_date_format_window"));
priv->table = GTK_WIDGET(gtk_builder_get_object (builder, "date_format_table"));
g_object_ref (G_OBJECT(priv->table));
gtk_container_remove (GTK_CONTAINER(dialog), priv->table);
gtk_container_add (GTK_CONTAINER(gdf), priv->table);
g_object_unref (G_OBJECT(priv->table));
gdf->table = GTK_WIDGET(gtk_builder_get_object (builder, "date_format_table"));
g_object_ref (G_OBJECT(gdf->table));
gtk_container_remove (GTK_CONTAINER(dialog), gdf->table);
gtk_container_add (GTK_CONTAINER(gdf), gdf->table);
g_object_unref (G_OBJECT(gdf->table));
g_object_unref(G_OBJECT(builder));
@ -197,11 +194,10 @@ gnc_date_format_new_without_label (void)
{
GtkWidget *widget = gnc_date_format_new_with_label(NULL);
GNCDateFormat *gdf = GNC_DATE_FORMAT(widget);
GNCDateFormatPrivate *priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
// remove the first column which has the label
gtk_grid_remove_column (GTK_GRID(priv->table), 0);
priv->label = NULL;
gtk_grid_remove_column (GTK_GRID(gdf->table), 0);
gdf->label = NULL;
return widget;
}
@ -219,13 +215,11 @@ GtkWidget *
gnc_date_format_new_with_label (const char *label)
{
GNCDateFormat *gdf;
GNCDateFormatPrivate *priv;
gdf = g_object_new(GNC_TYPE_DATE_FORMAT, NULL);
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
if (label)
gtk_label_set_text(GTK_LABEL(priv->label), label);
gtk_label_set_text(GTK_LABEL(gdf->label), label);
gnc_date_format_compute_format(gdf);
return GTK_WIDGET(gdf);
@ -235,13 +229,10 @@ gnc_date_format_new_with_label (const char *label)
void
gnc_date_format_set_format (GNCDateFormat *gdf, QofDateFormat format)
{
GNCDateFormatPrivate *priv;
g_return_if_fail(gdf);
g_return_if_fail(GNC_IS_DATE_FORMAT(gdf));
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->format_combobox), format);
gtk_combo_box_set_active(GTK_COMBO_BOX(gdf->format_combobox), format);
gnc_date_format_compute_format(gdf);
}
@ -249,36 +240,31 @@ gnc_date_format_set_format (GNCDateFormat *gdf, QofDateFormat format)
QofDateFormat
gnc_date_format_get_format (GNCDateFormat *gdf)
{
GNCDateFormatPrivate *priv;
g_return_val_if_fail (gdf, QOF_DATE_FORMAT_LOCALE);
g_return_val_if_fail (GNC_IS_DATE_FORMAT(gdf), QOF_DATE_FORMAT_LOCALE);
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
return gtk_combo_box_get_active(GTK_COMBO_BOX(priv->format_combobox));
return gtk_combo_box_get_active(GTK_COMBO_BOX(gdf->format_combobox));
}
void
gnc_date_format_set_months (GNCDateFormat *gdf, GNCDateMonthFormat months)
{
GNCDateFormatPrivate *priv;
GtkWidget *button = NULL;
g_return_if_fail(gdf);
g_return_if_fail(GNC_IS_DATE_FORMAT(gdf));
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
switch (months)
{
case GNCDATE_MONTH_NUMBER:
button = priv->months_number;
button = gdf->months_number;
break;
case GNCDATE_MONTH_ABBREV:
button = priv->months_abbrev;
button = gdf->months_abbrev;
break;
case GNCDATE_MONTH_NAME:
button = priv->months_name;
button = gdf->months_name;
break;
default:
break;
@ -294,17 +280,14 @@ gnc_date_format_set_months (GNCDateFormat *gdf, GNCDateMonthFormat months)
GNCDateMonthFormat
gnc_date_format_get_months (GNCDateFormat *gdf)
{
GNCDateFormatPrivate *priv;
g_return_val_if_fail(gdf, GNCDATE_MONTH_NUMBER);
g_return_val_if_fail(GNC_IS_DATE_FORMAT(gdf), GNCDATE_MONTH_NUMBER);
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_number)))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->months_number)))
return GNCDATE_MONTH_NUMBER;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_abbrev)))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->months_abbrev)))
return GNCDATE_MONTH_ABBREV;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_name)))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->months_name)))
return GNCDATE_MONTH_NAME;
/* We should never reach this point */
@ -316,13 +299,10 @@ gnc_date_format_get_months (GNCDateFormat *gdf)
void
gnc_date_format_set_years (GNCDateFormat *gdf, gboolean include_century)
{
GNCDateFormatPrivate *priv;
g_return_if_fail(gdf);
g_return_if_fail(GNC_IS_DATE_FORMAT(gdf));
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->years_button),
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gdf->years_button),
include_century);
gnc_date_format_compute_format(gdf);
}
@ -331,29 +311,23 @@ gnc_date_format_set_years (GNCDateFormat *gdf, gboolean include_century)
gboolean
gnc_date_format_get_years (GNCDateFormat *gdf)
{
GNCDateFormatPrivate *priv;
g_return_val_if_fail(gdf, FALSE);
g_return_val_if_fail(GNC_IS_DATE_FORMAT(gdf), FALSE);
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->years_button));
return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->years_button));
}
void
gnc_date_format_set_custom (GNCDateFormat *gdf, const char *format)
{
GNCDateFormatPrivate *priv;
g_return_if_fail(gdf);
g_return_if_fail(GNC_IS_DATE_FORMAT(gdf));
if (format == NULL || *format == '\0')
return;
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
gtk_entry_set_text(GTK_ENTRY(priv->custom_entry), format);
gtk_entry_set_text(GTK_ENTRY(gdf->custom_entry), format);
gnc_date_format_compute_format(gdf);
}
@ -361,13 +335,10 @@ gnc_date_format_set_custom (GNCDateFormat *gdf, const char *format)
const char *
gnc_date_format_get_custom (GNCDateFormat *gdf)
{
GNCDateFormatPrivate *priv;
g_return_val_if_fail(gdf, "");
g_return_val_if_fail(GNC_IS_DATE_FORMAT(gdf), "");
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
return gtk_entry_get_text(GTK_ENTRY(priv->custom_entry));
return gtk_entry_get_text(GTK_ENTRY(gdf->custom_entry));
}
@ -383,42 +354,32 @@ gnc_ui_date_format_changed_cb(GtkWidget *unused, gpointer user_data)
static void
gnc_date_format_enable_month (GNCDateFormat *gdf, gboolean sensitive)
{
GNCDateFormatPrivate *priv;
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
gtk_widget_set_sensitive(priv->months_label, sensitive);
gtk_widget_set_sensitive(priv->months_number, sensitive);
gtk_widget_set_sensitive(priv->months_abbrev, sensitive);
gtk_widget_set_sensitive(priv->months_name, sensitive);
gtk_widget_set_sensitive(gdf->months_label, sensitive);
gtk_widget_set_sensitive(gdf->months_number, sensitive);
gtk_widget_set_sensitive(gdf->months_abbrev, sensitive);
gtk_widget_set_sensitive(gdf->months_name, sensitive);
}
static void
gnc_date_format_enable_year (GNCDateFormat *gdf, gboolean sensitive)
{
GNCDateFormatPrivate *priv;
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
gtk_widget_set_sensitive(priv->years_label, sensitive);
gtk_widget_set_sensitive(priv->years_button, sensitive);
gtk_widget_set_sensitive(gdf->years_label, sensitive);
gtk_widget_set_sensitive(gdf->years_button, sensitive);
}
static void
gnc_date_format_enable_format (GNCDateFormat *gdf, gboolean sensitive)
{
GNCDateFormatPrivate *priv;
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
gtk_widget_set_sensitive(priv->custom_label, sensitive);
gtk_widget_set_sensitive(priv->custom_entry, sensitive);
gtk_widget_set_sensitive(gdf->custom_label, sensitive);
gtk_widget_set_sensitive(gdf->custom_entry, sensitive);
}
void
gnc_date_format_refresh (GNCDateFormat *gdf)
{
GNCDateFormatPrivate *priv;
int sel_option;
gboolean enable_year, enable_month, enable_custom, check_modifiers;
static gchar *format, *c;
@ -429,14 +390,13 @@ gnc_date_format_refresh (GNCDateFormat *gdf)
g_return_if_fail(gdf);
g_return_if_fail(GNC_IS_DATE_FORMAT(gdf));
priv = GNC_DATE_FORMAT_GET_PRIVATE(gdf);
sel_option =
gtk_combo_box_get_active(GTK_COMBO_BOX(priv->format_combobox));
gtk_combo_box_get_active(GTK_COMBO_BOX(gdf->format_combobox));
switch (sel_option)
{
case QOF_DATE_FORMAT_CUSTOM:
format = g_strdup(gtk_entry_get_text(GTK_ENTRY(priv->custom_entry)));
format = g_strdup(gtk_entry_get_text(GTK_ENTRY(gdf->custom_entry)));
enable_year = enable_month = check_modifiers = FALSE;
enable_custom = TRUE;
break;
@ -449,7 +409,7 @@ gnc_date_format_refresh (GNCDateFormat *gdf)
break;
case QOF_DATE_FORMAT_ISO:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->months_number), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gdf->months_number), TRUE);
enable_year = check_modifiers = TRUE;
enable_month = enable_custom = FALSE;
break;
@ -468,21 +428,21 @@ gnc_date_format_refresh (GNCDateFormat *gdf)
/* Update the format string based upon the user's preferences */
if (check_modifiers)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_number)))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->months_number)))
{
format = g_strdup(qof_date_format_get_string(sel_option));
}
else
{
format = g_strdup(qof_date_text_format_get_string(sel_option));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->months_name)))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->months_name)))
{
c = strchr(format, 'b');
if (c)
*c = 'B';
}
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->years_button)))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gdf->years_button)))
{
c = strchr(format, 'y');
if (c)
@ -495,17 +455,17 @@ gnc_date_format_refresh (GNCDateFormat *gdf)
* without having to read the strftime man page. Prevent recursive
* signals.
*/
g_signal_handlers_block_matched(priv->custom_entry, G_SIGNAL_MATCH_DATA,
g_signal_handlers_block_matched(gdf->custom_entry, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, gdf);
gtk_entry_set_text(GTK_ENTRY(priv->custom_entry), format);
g_signal_handlers_unblock_matched(priv->custom_entry, G_SIGNAL_MATCH_DATA,
gtk_entry_set_text(GTK_ENTRY(gdf->custom_entry), format);
g_signal_handlers_unblock_matched(gdf->custom_entry, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, gdf);
/* Visual feedback on what the date will look like. */
secs_now = gnc_time (NULL);
gnc_localtime_r (&secs_now, &today);
qof_strftime(date_string, MAX_DATE_LEN, format, &today);
gtk_label_set_text(GTK_LABEL(priv->sample_label), date_string);
gtk_label_set_text(GTK_LABEL(gdf->sample_label), date_string);
g_free(format);
}

19
gnucash/gnome-utils/gnc-date-format.h
View File

@ -36,24 +36,7 @@ extern "C" {
#endif
#define GNC_TYPE_DATE_FORMAT (gnc_date_format_get_type ())
#define GNC_DATE_FORMAT(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gnc_date_format_get_type(), GNCDateFormat)
#define GNC_DATE_FORMAT_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gnc_date_format_get_type(), GNCDateFormatClass)
#define GNC_IS_DATE_FORMAT(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gnc_date_format_get_type ())
/**
**/
typedef struct
{
GtkBox hbox;
} GNCDateFormat;
typedef struct
{
GtkBoxClass hbox_class;
void (*format_changed) (GNCDateFormat *gdf);
} GNCDateFormatClass;
GType gnc_date_format_get_type (void);
G_DECLARE_FINAL_TYPE (GNCDateFormat, gnc_date_format, GNC, DATE_FORMAT, GtkBox)
GtkWidget *gnc_date_format_new (void);
GtkWidget *gnc_date_format_new_without_label (void);

5
gnucash/gnome-utils/gnc-dense-cal-store.c
View File

@ -54,11 +54,6 @@ struct _GncDenseCalStore
GDate **cal_marks;
};
struct _GncDenseCalStoreClass
{
GObjectClass parent_class;
};
static void gnc_dense_cal_store_iface_init(GncDenseCalModelInterface *iface);
static void gnc_dense_cal_store_finalize(GObject *obj);

10
gnucash/gnome-utils/gnc-dense-cal-store.h
View File

@ -32,18 +32,10 @@
G_BEGIN_DECLS
#define GNC_TYPE_DENSE_CAL_STORE (gnc_dense_cal_store_get_type())
#define GNC_DENSE_CAL_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_DENSE_CAL_STORE, GncDenseCalStore))
#define GNC_DENSE_CAL_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_DENSE_CAL_STORE, GncDenseCalStoreClass))
#define GNC_IS_DENSE_CAL_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_DENSE_CAL_STORE))
#define GNC_IS_DENSE_CAL_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_DENSE_CAL_STORE))
#define GNC_DENSE_CAL_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_DENSE_CAL_STORE, GncDenseCalStore))
G_DECLARE_FINAL_TYPE (GncDenseCalStore, gnc_dense_cal_store, GNC, DENSE_CAL_STORE, GObject)
typedef enum { NEVER_END, END_ON_DATE, END_AFTER_N_OCCS, BAD_END } gdcs_end_type;
typedef struct _GncDenseCalStore GncDenseCalStore;
typedef struct _GncDenseCalStoreClass GncDenseCalStoreClass;
GType gnc_dense_cal_store_get_type(void);
GncDenseCalStore* gnc_dense_cal_store_new(int num_marks);
void gnc_dense_cal_store_clear(GncDenseCalStore *model);
void gnc_dense_cal_store_update_name(GncDenseCalStore *model, const gchar* name);

73
gnucash/gnome-utils/gnc-dense-cal.c
View File

@ -145,6 +145,79 @@ static void gdc_add_tag_markings(GncDenseCal *cal, guint tag);
static void gdc_add_markings(GncDenseCal *cal);
static void gdc_remove_markings(GncDenseCal *cal);
typedef struct _gdc_month_coords
{
gint x, y;
} gdc_month_coords;
struct _GncDenseCal
{
GtkBox widget;
GtkComboBox *view_options;
GtkDrawingArea *cal_drawing_area;
cairo_surface_t *surface;
gboolean initialized;
gboolean showPopup;
GtkWindow *transPopup;
gint screen_width;
gint screen_height;
gint doc;
gint min_x_scale;
gint min_y_scale;
gint x_scale;
gint y_scale;
gint numMonths;
gint monthsPerCol;
gint num_weeks; /* computed */
GDateMonth month;
guint year;
gint firstOfMonthOffset;
gint leftPadding;
gint topPadding;
gdc_month_coords monthPositions[12];
guint label_width;
guint label_height;
gint dayLabelHeight;
GncDenseCalModel *model;
guint lastMarkTag;
gint week_starts_monday;
/**
* A GList of gdc_mark_data structs, one for each active/valid markTag.
**/
GList *markData;
int numMarks;
/* array of GList*s of per-cell markings. */
GList **marks;
int disposed; /* private */
};
typedef struct _gdc_mark_data
{
gchar *name;
gchar *info;
guint tag;
/**
* A GList of the dcal->marks indexes containing this mark.
**/
GList *ourMarks;
} gdc_mark_data;
G_DEFINE_TYPE (GncDenseCal, gnc_dense_cal, GTK_TYPE_BOX)
#define MONTH_NAME_BUFSIZE 10

87
gnucash/gnome-utils/gnc-dense-cal.h
View File

@ -32,96 +32,11 @@
G_BEGIN_DECLS
#define GNC_TYPE_DENSE_CAL (gnc_dense_cal_get_type ())
#define GNC_DENSE_CAL(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gnc_dense_cal_get_type (), GncDenseCal)
#define GNC_DENSE_CAL_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gnc_dense_cal_get_type (), GncDenseCalClass)
#define GNC_IS_DENSE_CAL(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gnc_dense_cal_get_type ())
typedef struct _GncDenseCal GncDenseCal;
typedef struct _GncDenseCalClass GncDenseCalClass;
typedef struct _gdc_month_coords
{
gint x, y;
} gdc_month_coords;
struct _GncDenseCal
{
GtkBox widget;
GtkComboBox *view_options;
GtkDrawingArea *cal_drawing_area;
cairo_surface_t *surface;
gboolean initialized;
gboolean showPopup;
GtkWindow *transPopup;
gint screen_width;
gint screen_height;
gint doc;
gint min_x_scale;
gint min_y_scale;
gint x_scale;
gint y_scale;
gint numMonths;
gint monthsPerCol;
gint num_weeks; /* computed */
GDateMonth month;
gint year;
gint firstOfMonthOffset;
gint leftPadding;
gint topPadding;
gdc_month_coords monthPositions[12];
guint label_width;
guint label_height;
gint dayLabelHeight;
GncDenseCalModel *model;
guint lastMarkTag;
gint week_starts_monday;
/**
* A GList of gdc_mark_data structs, one for each active/valid markTag.
**/
GList *markData;
int numMarks;
/* array of GList*s of per-cell markings. */
GList **marks;
int disposed; /* private */
};
struct _GncDenseCalClass
{
GtkBoxClass parent_class;
};
typedef struct _gdc_mark_data
{
gchar *name;
gchar *info;
guint tag;
/**
* A GList of the dcal->marks indexes containing this mark.
**/
GList *ourMarks;
} gdc_mark_data;
G_DECLARE_FINAL_TYPE (GncDenseCal, gnc_dense_cal, GNC, DENSE_CAL, GtkBox)
GtkWidget* gnc_dense_cal_new (GtkWindow *parent);
GtkWidget* gnc_dense_cal_new_with_model (GtkWindow *parent,
GncDenseCalModel *model);
GType gnc_dense_cal_get_type (void);
void gnc_dense_cal_set_model(GncDenseCal *cal, GncDenseCalModel *model);
void gnc_dense_cal_set_month(GncDenseCal *dcal, GDateMonth mon);

129
gnucash/gnome-utils/gnc-embedded-window.c
View File

@ -63,9 +63,12 @@ static void gnc_window_embedded_window_init (GncWindowInterface *iface);
static void gnc_embedded_window_setup_window (GncEmbeddedWindow *window);
/** The instance private data for an embedded window object. */
typedef struct GncEmbeddedWindowPrivate
/** The instance data structure for an embedded window object. */
struct _GncEmbeddedWindow
{
/** The parent object for an embedded window. */
GtkBox vbox;
/** The dock (vbox) at the top of the window containing the menubar
* and toolbar. These items are generated bu the UI manager and
* stored here when the UI manager provides them to the main
@ -97,16 +100,12 @@ typedef struct GncEmbeddedWindowPrivate
/** The parent of this embedded "window". This points to a real
* GtkWindow widget. */
GtkWidget *parent_window;
} GncEmbeddedWindowPrivate;
};
G_DEFINE_TYPE_WITH_CODE(GncEmbeddedWindow, gnc_embedded_window, GTK_TYPE_BOX,
G_ADD_PRIVATE(GncEmbeddedWindow)
G_IMPLEMENT_INTERFACE(GNC_TYPE_WINDOW,
gnc_window_embedded_window_init))
#define GNC_EMBEDDED_WINDOW_GET_PRIVATE(o) \
((GncEmbeddedWindowPrivate*)gnc_embedded_window_get_instance_private((GncEmbeddedWindow*)o))
/** A holding place for all the signals generated by the embedded window
* code. */
static guint embedded_window_signals[LAST_SIGNAL] = { 0 };
@ -116,15 +115,12 @@ void
gnc_embedded_window_open_page (GncEmbeddedWindow *window,
GncPluginPage *page)
{
GncEmbeddedWindowPrivate *priv;
g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (window));
g_return_if_fail (GNC_IS_PLUGIN_PAGE (page));
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
g_return_if_fail (priv->page == NULL);
g_return_if_fail (window->page == NULL);
ENTER("window %p, page %p", window, page);
priv->page = page;
window->page = page;
page->window = GTK_WIDGET(window);
page->notebook_page = gnc_plugin_page_create_widget (page);
@ -139,12 +135,9 @@ void
gnc_embedded_window_close_page (GncEmbeddedWindow *window,
GncPluginPage *page)
{
GncEmbeddedWindowPrivate *priv;
g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (window));
g_return_if_fail (GNC_IS_PLUGIN_PAGE (page));
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
g_return_if_fail (priv->page == page);
g_return_if_fail (window->page == page);
ENTER("window %p, page %p", window, page);
@ -155,7 +148,7 @@ gnc_embedded_window_close_page (GncEmbeddedWindow *window,
}
gtk_container_remove (GTK_CONTAINER(window), GTK_WIDGET(page->notebook_page));
priv->page = NULL;
window->page = NULL;
gnc_plugin_page_removed (page);
gnc_plugin_page_destroy_widget (page);
@ -168,10 +161,7 @@ gnc_embedded_window_close_page (GncEmbeddedWindow *window,
GncPluginPage *
gnc_embedded_window_get_page (GncEmbeddedWindow *window)
{
GncEmbeddedWindowPrivate *priv;
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return priv->page;
return window->page;
}
@ -206,7 +196,7 @@ gnc_embedded_window_class_init (GncEmbeddedWindowClass *klass)
g_signal_new ("page_changed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GncEmbeddedWindowClass, page_changed),
0,
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
@ -275,21 +265,19 @@ static void
gnc_embedded_window_dispose (GObject *object)
{
GncEmbeddedWindow *window;
GncEmbeddedWindowPrivate *priv;
g_return_if_fail (object != NULL);
g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (object));
ENTER("object %p", object);
window = GNC_EMBEDDED_WINDOW (object);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
if (priv->page)
if (window->page)
{
DEBUG("unreffing page %p (count currently %d)", priv->page,
G_OBJECT(priv->page)->ref_count);
g_object_unref(priv->page);
priv->page = NULL;
DEBUG("unreffing page %p (count currently %d)", window->page,
G_OBJECT(window->page)->ref_count);
g_object_unref(window->page);
window->page = NULL;
}
G_OBJECT_CLASS (gnc_embedded_window_parent_class)->dispose (object);
@ -303,24 +291,21 @@ gnc_embedded_window_dispose (GObject *object)
static void
gnc_embedded_window_setup_window (GncEmbeddedWindow *window)
{
GncEmbeddedWindowPrivate *priv;
ENTER("window %p", window);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
/* Create widgets and add them to the window */
gtk_widget_show (GTK_WIDGET(window));
priv->menu_dock = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (priv->menu_dock), FALSE);
gtk_widget_show (priv->menu_dock);
gtk_box_pack_start (GTK_BOX (window), priv->menu_dock, FALSE, TRUE, 0);
window->menu_dock = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (window->menu_dock), FALSE);
gtk_widget_show (window->menu_dock);
gtk_box_pack_start (GTK_BOX (window), window->menu_dock, FALSE, TRUE, 0);
priv->statusbar = gtk_statusbar_new ();
gtk_widget_show (priv->statusbar);
gtk_box_pack_end (GTK_BOX (window), priv->statusbar, FALSE, TRUE, 0);
window->statusbar = gtk_statusbar_new ();
gtk_widget_show (window->statusbar);
gtk_box_pack_end (GTK_BOX (window), window->statusbar, FALSE, TRUE, 0);
priv->simple_action_group = NULL;
window->simple_action_group = NULL;
LEAVE(" ");
}
@ -335,7 +320,6 @@ gnc_embedded_window_new (const gchar *action_group_name,
gboolean add_accelerators,
gpointer user_data)
{
GncEmbeddedWindowPrivate *priv;
GncEmbeddedWindow *window;
gchar *ui_fullname;
GError *error = NULL;
@ -346,7 +330,6 @@ gnc_embedded_window_new (const gchar *action_group_name,
enclosing_win, add_accelerators, user_data);
window = g_object_new (GNC_TYPE_EMBEDDED_WINDOW, NULL);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, PROJECT_NAME);
@ -362,35 +345,35 @@ gnc_embedded_window_new (const gchar *action_group_name,
return NULL;
}
priv->menubar_model = (GMenuModel *)gtk_builder_get_object (builder, "embeddedwin-menu");
window->menubar_model = (GMenuModel *)gtk_builder_get_object (builder, "embeddedwin-menu");
priv->menubar = gtk_menu_bar_new_from_model (priv->menubar_model);
gtk_container_add (GTK_CONTAINER(priv->menu_dock), priv->menubar);
gtk_widget_show (GTK_WIDGET(priv->menubar));
window->menubar = gtk_menu_bar_new_from_model (window->menubar_model);
gtk_container_add (GTK_CONTAINER(window->menu_dock), window->menubar);
gtk_widget_show (GTK_WIDGET(window->menubar));
priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "embeddedwin-toolbar");
g_object_set (priv->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
gtk_container_add (GTK_CONTAINER(priv->menu_dock), GTK_WIDGET(priv->toolbar));
gtk_widget_show (GTK_WIDGET(priv->toolbar));
window->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "embeddedwin-toolbar");
g_object_set (window->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
gtk_container_add (GTK_CONTAINER(window->menu_dock), GTK_WIDGET(window->toolbar));
gtk_widget_show (GTK_WIDGET(window->toolbar));
g_object_unref (builder);
priv->simple_action_group = g_simple_action_group_new ();
window->simple_action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP(priv->simple_action_group),
g_action_map_add_action_entries (G_ACTION_MAP(window->simple_action_group),
action_entries,
n_action_entries,
user_data);
gtk_widget_insert_action_group (GTK_WIDGET(window), "embeddedwin",
G_ACTION_GROUP(priv->simple_action_group));
G_ACTION_GROUP(window->simple_action_group));
priv->parent_window = enclosing_win;
window->parent_window = enclosing_win;
// need to add the accelerator keys
priv->accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW(enclosing_win), priv->accel_group);
gnc_add_accelerator_keys_for_menu (GTK_WIDGET(priv->menubar), priv->menubar_model, priv->accel_group);
window->accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW(enclosing_win), window->accel_group);
gnc_add_accelerator_keys_for_menu (GTK_WIDGET(window->menubar), window->menubar_model, window->accel_group);
g_free (ui_fullname);
LEAVE("window %p", window);
@ -407,13 +390,11 @@ static GtkWindow *
gnc_embedded_window_get_gtk_window (GncWindow *window_in)
{
GncEmbeddedWindow *window;
GncEmbeddedWindowPrivate *priv;
g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW (window_in), NULL);
window = GNC_EMBEDDED_WINDOW(window_in);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return GTK_WINDOW(priv->parent_window);
return GTK_WINDOW(window->parent_window);
}
@ -425,14 +406,12 @@ gnc_embedded_window_get_gtk_window (GncWindow *window_in)
static GtkWidget *
gnc_embedded_window_get_statusbar (GncWindow *window_in)
{
GncEmbeddedWindowPrivate *priv;
GncEmbeddedWindow *window;
g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW (window_in), NULL);
window = GNC_EMBEDDED_WINDOW(window_in);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return priv->statusbar;
return window->statusbar;
}
@ -444,13 +423,9 @@ gnc_embedded_window_get_statusbar (GncWindow *window_in)
static GtkWidget *
gnc_embedded_window_get_menubar (GncWindow *window)
{
GncEmbeddedWindowPrivate *priv;
g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return priv->menubar;
return GNC_EMBEDDED_WINDOW (window)->menubar;
}
/** Retrieve the tool bar associated with an embedded window object.
@ -461,13 +436,9 @@ gnc_embedded_window_get_menubar (GncWindow *window)
static GtkWidget *
gnc_embedded_window_get_toolbar (GncWindow *window)
{
GncEmbeddedWindowPrivate *priv;
g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return priv->toolbar;
return GNC_EMBEDDED_WINDOW (window)->toolbar;
}
/** Retrieve the menubar model associated with an embedded window object.
@ -478,13 +449,9 @@ gnc_embedded_window_get_toolbar (GncWindow *window)
static GMenuModel *
gnc_embedded_window_get_menubar_model (GncWindow *window)
{
GncEmbeddedWindowPrivate *priv;
g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return priv->menubar_model;
return GNC_EMBEDDED_WINDOW (window)->menubar_model;
}
/** Retrieve the accelerator group associated with an embedded window object.
@ -495,13 +462,9 @@ gnc_embedded_window_get_menubar_model (GncWindow *window)
static GtkAccelGroup *
gnc_embedded_window_get_accel_group (GncWindow *window)
{
GncEmbeddedWindowPrivate *priv;
g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
return priv->accel_group;
return GNC_EMBEDDED_WINDOW (window)->accel_group;
}
/** Initialize the generic window interface for an embedded window.

32
gnucash/gnome-utils/gnc-embedded-window.h
View File

@ -44,42 +44,12 @@ G_BEGIN_DECLS
/* type macros */
#define GNC_TYPE_EMBEDDED_WINDOW (gnc_embedded_window_get_type ())
#define GNC_EMBEDDED_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_EMBEDDED_WINDOW, GncEmbeddedWindow))
#define GNC_EMBEDDED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_EMBEDDED_WINDOW, GncEmbeddedWindowClass))
#define GNC_IS_EMBEDDED_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_EMBEDDED_WINDOW))
#define GNC_IS_EMBEDDED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_EMBEDDED_WINDOW))
#define GNC_EMBEDDED_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_EMBEDDED_WINDOW, GncEmbeddedWindowClass))
G_DECLARE_FINAL_TYPE (GncEmbeddedWindow, gnc_embedded_window, GNC, EMBEDDED_WINDOW, GtkBox)
/* typedefs & structures */
/** The instance data structure for an embedded window object. */
typedef struct
{
/** The parent object for an embedded window. */
GtkBox vbox;
} GncEmbeddedWindow;
/** The class data structure for an embedded window object. */
typedef struct
{
/** The parent class for an embedded window. */
GtkBoxClass vbox;
/* callbacks */
void (*page_changed) (GncEmbeddedWindow *window,
GncPluginPage *page);
} GncEmbeddedWindowClass;
/* function prototypes */
/** Get the type of a gnc embedded window.
*
* @return A GType. */
GType gnc_embedded_window_get_type (void);
/** Create a new gnc embedded window plugin.
*
* @return A pointer to the new object.

18
gnucash/gnome-utils/gnc-frequency.c
View File

@ -94,6 +94,22 @@ static const char *CHECKBOX_NAMES[] =
/** Implementations ********************/
/**
* A GncFrequency is a VBox containing a scrollable GtkNotebook [and other
* widgets] which allows the user to specify the frequency [of a scheduled
* transaction or budgeting category, for instance], manipulating a FreqSpec
* object in the process.
**/
typedef struct _GncFrequency
{
GtkBox widget;
GtkBox *vb;
GtkNotebook *nb;
GtkComboBox *freqComboBox;
GNCDateEdit *startDate;
GtkBuilder *builder;
} GncFrequency;
G_DEFINE_TYPE (GncFrequency, gnc_frequency, GTK_TYPE_BOX)
static void
@ -109,7 +125,7 @@ gnc_frequency_class_init( GncFrequencyClass *klass )
g_signal_new ("changed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GncFrequencyClass, changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,

36
gnucash/gnome-utils/gnc-frequency.h
View File

@ -34,41 +34,7 @@ extern "C" {
#endif
#define GNC_TYPE_FREQUENCY (gnc_frequency_get_type())
#define GNC_FREQUENCY(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, GNC_TYPE_FREQUENCY, GncFrequency)
#define GNC_FREQENCY_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, GNC_TYPE_FREQUENCY, GncFrequency)
#define GNC_IS_FREQUENCY(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, GNC_TYPE_FREQUENCY)
/**
* A GncFrequency is a VBox containing a scrollable GtkNotebook [and other
* widgets] which allows the user to specify the frequency [of a scheduled
* transaction or budgeting category, for instance], manipulating a FreqSpec
* object in the process.
**/
typedef struct _GncFrequency
{
GtkBox widget;
GtkBox *vb;
GtkNotebook *nb;
GtkComboBox *freqComboBox;
GNCDateEdit *startDate;
GtkBuilder *builder;
} GncFrequency;
typedef struct _GncFrequencyClass
{
GtkBoxClass parent_class;
void (*changed) (GncFrequency *gf);
} GncFrequencyClass;
struct pageDataTuple
{
int idx;
UIFreqType uiFTVal;
char *name;
};
GType gnc_frequency_get_type(void);
G_DECLARE_FINAL_TYPE (GncFrequency, gnc_frequency, GNC, FREQUENCY, GtkBox)
/**
* Either or both param may be NULL for reasonable defaults.

154
gnucash/gnome-utils/gnc-period-select.c
View File

@ -94,9 +94,10 @@ const gchar *end_strings[GNC_ACCOUNTING_PERIOD_LAST] =
/** Private Data Structure ***********************************************/
typedef struct _GncPeriodSelectPrivate GncPeriodSelectPrivate;
struct _GncPeriodSelectPrivate
struct _GncPeriodSelect
{
GtkBox hbox;
GtkWidget *selector;
gboolean start;
@ -106,10 +107,7 @@ struct _GncPeriodSelectPrivate
GtkWidget *date_label;
};
G_DEFINE_TYPE_WITH_PRIVATE(GncPeriodSelect, gnc_period_select, GTK_TYPE_BOX)
#define GNC_PERIOD_SELECT_GET_PRIVATE(o) \
((GncPeriodSelectPrivate*)gnc_period_select_get_instance_private((GncPeriodSelect*)o))
G_DEFINE_TYPE(GncPeriodSelect, gnc_period_select, GTK_TYPE_BOX)
/************************************************************/
@ -135,27 +133,25 @@ gnc_period_select_changed (GncPeriodSelect *period)
static void
gnc_period_sample_update_date_label (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
gchar time_string[MAX_DATE_LENGTH + 1];
GDate *date;
GncAccountingPeriod which;
g_return_if_fail(GNC_IS_PERIOD_SELECT(period));
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
if (!priv->date_label)
if (!period->date_label)
return;
which = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->selector));
which = gtk_combo_box_get_active (GTK_COMBO_BOX (period->selector));
if (which == -1)
date = g_date_new_dmy (31, 7, 2013);
else if (priv->start)
date = gnc_accounting_period_start_gdate (which, priv->fy_end,
priv->date_base);
else if (period->start)
date = gnc_accounting_period_start_gdate (which, period->fy_end,
period->date_base);
else
date = gnc_accounting_period_end_gdate (which, priv->fy_end,
priv->date_base);
date = gnc_accounting_period_end_gdate (which, period->fy_end,
period->date_base);
qof_print_gdate (time_string, MAX_DATE_LENGTH, date);
gtk_label_set_label (GTK_LABEL(priv->date_label), time_string);
gtk_label_set_label (GTK_LABEL(period->date_label), time_string);
g_date_free (date);
}
@ -216,18 +212,14 @@ static void
gnc_period_select_set_active_internal (GncPeriodSelect *period,
GncAccountingPeriod which)
{
GncPeriodSelectPrivate *priv;
g_return_if_fail(period != NULL);
g_return_if_fail(GNC_IS_PERIOD_SELECT(period));
g_return_if_fail(which >= 0);
g_return_if_fail(which < GNC_ACCOUNTING_PERIOD_LAST);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
g_signal_handlers_block_by_func(G_OBJECT(period),
G_CALLBACK(gnc_period_sample_combobox_changed), period);
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->selector), which);
gtk_combo_box_set_active(GTK_COMBO_BOX(period->selector), which);
g_signal_handlers_unblock_by_func(G_OBJECT(period),
G_CALLBACK(gnc_period_sample_combobox_changed), period);
@ -249,16 +241,13 @@ gnc_period_select_set_active_internal (GncPeriodSelect *period,
GDate *
gnc_period_select_get_fy_end (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
g_return_val_if_fail(period != NULL, NULL);
g_return_val_if_fail(GNC_IS_PERIOD_SELECT(period), NULL);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
if (!priv->fy_end)
if (!period->fy_end)
return NULL;
return g_date_new_dmy(g_date_get_day(priv->fy_end),
g_date_get_month(priv->fy_end),
return g_date_new_dmy(g_date_get_day(period->fy_end),
g_date_get_month(period->fy_end),
G_DATE_BAD_YEAR);
}
@ -270,41 +259,39 @@ gnc_period_select_get_fy_end (GncPeriodSelect *period)
void
gnc_period_select_set_fy_end (GncPeriodSelect *period, const GDate *fy_end)
{
GncPeriodSelectPrivate *priv;
const gchar *label;
gint i;
g_return_if_fail(period != NULL);
g_return_if_fail(GNC_IS_PERIOD_SELECT(period));
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
if (priv->fy_end)
g_date_free(priv->fy_end);
if (period->fy_end)
g_date_free(period->fy_end);
if (fy_end)
{
priv->fy_end = g_date_new_dmy(g_date_get_day(fy_end),
period->fy_end = g_date_new_dmy(g_date_get_day(fy_end),
g_date_get_month(fy_end),
G_DATE_BAD_YEAR);
}
else
{
priv->fy_end = NULL;
period->fy_end = NULL;
}
if (fy_end)
{
for (i = GNC_ACCOUNTING_PERIOD_CYEAR_LAST; i < GNC_ACCOUNTING_PERIOD_FYEAR_LAST; i++)
{
label = priv->start ? _(start_strings[i]) : _(end_strings[i]);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->selector), label);
label = period->start ? _(start_strings[i]) : _(end_strings[i]);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(period->selector), label);
}
}
else
{
for (i = GNC_ACCOUNTING_PERIOD_FYEAR_LAST - 1; i >= GNC_ACCOUNTING_PERIOD_FYEAR_LAST; i--)
{
gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(priv->selector), i);
gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(period->selector), i);
}
}
}
@ -313,33 +300,30 @@ gnc_period_select_set_fy_end (GncPeriodSelect *period, const GDate *fy_end)
static void
gnc_period_select_set_date_common (GncPeriodSelect *period, const GDate *date)
{
GncPeriodSelectPrivate *priv;
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
if (date)
{
if (priv->date_base)
g_date_free(priv->date_base);
priv->date_base = g_date_new_dmy(g_date_get_day(date),
if (period->date_base)
g_date_free(period->date_base);
period->date_base = g_date_new_dmy(g_date_get_day(date),
g_date_get_month(date),
g_date_get_year(date));
if (priv->date_label == NULL)
if (period->date_label == NULL)
{
priv->date_label = gtk_label_new("");
gtk_widget_set_margin_start (GTK_WIDGET(priv->date_label), 6);
gtk_box_pack_start(GTK_BOX(period), priv->date_label, TRUE, TRUE, 0);
gtk_widget_show_all(priv->date_label);
period->date_label = gtk_label_new("");
gtk_widget_set_margin_start (GTK_WIDGET(period->date_label), 6);
gtk_box_pack_start(GTK_BOX(period), period->date_label, TRUE, TRUE, 0);
gtk_widget_show_all(period->date_label);
}
gnc_period_sample_update_date_label(period);
return;
}
if (priv->date_base)
if (period->date_base)
{
g_date_free(priv->date_base);
priv->date_base = NULL;
gtk_widget_destroy(priv->date_label);
priv->date_label = NULL;
g_date_free(period->date_base);
period->date_base = NULL;
gtk_widget_destroy(period->date_label);
period->date_label = NULL;
}
}
@ -350,13 +334,10 @@ gnc_period_select_set_date_common (GncPeriodSelect *period, const GDate *date)
gboolean
gnc_period_select_get_show_date (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
g_return_val_if_fail(period != NULL, FALSE);
g_return_val_if_fail(GNC_IS_PERIOD_SELECT(period), FALSE);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
return (priv->date_base != NULL);
return (period->date_base != NULL);
}
/* Set the "show date" setting on a GncPeriodSelect widget. If set
@ -387,17 +368,14 @@ gnc_period_select_set_show_date (GncPeriodSelect *period, const gboolean show_da
GDate *
gnc_period_select_get_date_base (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
g_return_val_if_fail(period != NULL, NULL);
g_return_val_if_fail(GNC_IS_PERIOD_SELECT(period), NULL);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
if (!priv->date_base)
if (!period->date_base)
return NULL;
return g_date_new_dmy(g_date_get_day(priv->date_base),
g_date_get_month(priv->date_base),
g_date_get_year(priv->date_base));
return g_date_new_dmy(g_date_get_day(period->date_base),
g_date_get_month(period->date_base),
g_date_get_year(period->date_base));
}
@ -518,7 +496,7 @@ gnc_period_select_class_init (GncPeriodSelectClass *klass)
signals[CHANGED] = g_signal_new("changed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GncPeriodSelectClass, changed),
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
@ -566,15 +544,12 @@ gnc_period_select_class_init (GncPeriodSelectClass *klass)
static void
gnc_period_select_init (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
gtk_orientable_set_orientation (GTK_ORIENTABLE(period), GTK_ORIENTATION_HORIZONTAL);
// Set the name for this widget so it can be easily manipulated with css
gtk_widget_set_name (GTK_WIDGET(period), "gnc-id-period-select");
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
priv->start = TRUE;
period->start = TRUE;
}
@ -591,14 +566,12 @@ gnc_period_select_init (GncPeriodSelect *period)
static void
gnc_period_select_finalize (GObject *object)
{
GncPeriodSelectPrivate *priv;
GncPeriodSelect *period;
g_return_if_fail (object != NULL);
g_return_if_fail (GNC_IS_PERIOD_SELECT (object));
period = GNC_PERIOD_SELECT(object);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
/* Stop tracking changes to date formatting */
gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL, GNC_PREF_DATE_FORMAT,
@ -606,10 +579,10 @@ gnc_period_select_finalize (GObject *object)
/* The selector and date_label were added to the hbox. They will be
* freed automatically. */
if (priv->fy_end)
g_date_free(priv->fy_end);
if (priv->date_base)
g_date_free(priv->date_base);
if (period->fy_end)
g_date_free(period->fy_end);
if (period->date_base)
g_date_free(period->date_base);
/* Do not free the private data structure. It is part of a larger
* memory block allocated by the type system. */
@ -630,7 +603,6 @@ gnc_period_select_finalize (GObject *object)
GtkWidget *
gnc_period_select_new (gboolean starting_labels)
{
GncPeriodSelectPrivate *priv;
GncPeriodSelect *period;
const gchar *label;
gint i;
@ -638,23 +610,22 @@ gnc_period_select_new (gboolean starting_labels)
period = g_object_new(GNC_TYPE_PERIOD_SELECT, NULL);
/* Set up private data structures */
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
priv->selector = gtk_combo_box_text_new();
priv->start = starting_labels;
period->selector = gtk_combo_box_text_new();
period->start = starting_labels;
/* Add the internal widgets to the hbox */
gtk_box_pack_start(GTK_BOX(period), priv->selector, TRUE, TRUE, 0);
gtk_widget_show(priv->selector);
gtk_box_pack_start(GTK_BOX(period), period->selector, TRUE, TRUE, 0);
gtk_widget_show(period->selector);
/* Find out when the combo box changes */
g_signal_connect(G_OBJECT(priv->selector), "changed",
g_signal_connect(G_OBJECT(period->selector), "changed",
G_CALLBACK(gnc_period_sample_combobox_changed), period);
/* Build all the labels except the fiscal year labels */
for (i = 0; i < GNC_ACCOUNTING_PERIOD_CYEAR_LAST; i++)
{
label = starting_labels ? _(start_strings[i]) : _(end_strings[i]);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->selector), label);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(period->selector), label);
}
/* Track changes to date formatting */
@ -714,13 +685,10 @@ gnc_period_select_set_active (GncPeriodSelect *period,
GncAccountingPeriod
gnc_period_select_get_active (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
g_return_val_if_fail(period != NULL, -1);
g_return_val_if_fail(GNC_IS_PERIOD_SELECT(period), -1);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
return gtk_combo_box_get_active(GTK_COMBO_BOX(priv->selector));
return gtk_combo_box_get_active(GTK_COMBO_BOX(period->selector));
}
@ -731,22 +699,20 @@ gnc_period_select_get_active (GncPeriodSelect *period)
GDate *
gnc_period_select_get_date (GncPeriodSelect *period)
{
GncPeriodSelectPrivate *priv;
GncAccountingPeriod which;
g_return_val_if_fail(period != NULL, 0);
g_return_val_if_fail(GNC_IS_PERIOD_SELECT(period), 0);
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
which = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->selector));
which = gtk_combo_box_get_active(GTK_COMBO_BOX(period->selector));
if (which == -1)
return NULL;
if (priv->start)
return gnc_accounting_period_start_gdate(which, priv->fy_end,
priv->date_base);
return gnc_accounting_period_end_gdate(which, priv->fy_end,
priv->date_base);
if (period->start)
return gnc_accounting_period_start_gdate(which, period->fy_end,
period->date_base);
return gnc_accounting_period_end_gdate(which, period->fy_end,
period->date_base);
}
/** @} */

25
gnucash/gnome-utils/gnc-period-select.h
View File

@ -37,34 +37,11 @@
G_BEGIN_DECLS
#define GNC_TYPE_PERIOD_SELECT (gnc_period_select_get_type())
#define GNC_PERIOD_SELECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_PERIOD_SELECT, GncPeriodSelect))
#define GNC_PERIOD_SELECT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GNC_TYPE_PERIOD_SELECT, GncPeriodSelectClass))
#define GNC_IS_PERIOD_SELECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_PERIOD_SELECT))
/* typedefs & structures */
typedef struct
{
GtkBox hbox;
} GncPeriodSelect;
typedef struct
{
GtkBoxClass hbox;
/* Signals */
void (*changed) (GncPeriodSelect *period);
} GncPeriodSelectClass;
G_DECLARE_FINAL_TYPE (GncPeriodSelect, gnc_period_select, GNC, PERIOD_SELECT, GtkBox)
/** @name GncPeriodSelect Widget Implementation
@{ */
/** Returns the GType of a GncPeriodSelect widget.
*/
GType gnc_period_select_get_type (void);
/** Create a new GncPeriodSelect widget which is used to select a
* accounting period like "previous month" or "this year".
*

59
gnucash/gnome-utils/gnc-plugin-manager.c
View File

@ -36,16 +36,16 @@ static void gnc_plugin_manager_dispose (GObject *object);
static void gnc_plugin_manager_finalize (GObject *object);
static void gnc_plugin_manager_shutdown (gpointer dummy, gpointer dummy2);
typedef struct GncPluginManagerPrivate
/* typedefs & structures */
struct _GncPluginManager
{
GObject gobject;
GList *plugins;
GHashTable *plugins_table;
} GncPluginManagerPrivate;
G_DEFINE_TYPE_WITH_PRIVATE(GncPluginManager, gnc_plugin_manager, G_TYPE_OBJECT)
#define GNC_PLUGIN_MANAGER_GET_PRIVATE(o) \
((GncPluginManagerPrivate*)gnc_plugin_manager_get_instance_private((GncPluginManager*)o))
G_DEFINE_TYPE(GncPluginManager, gnc_plugin_manager, G_TYPE_OBJECT)
enum
{
@ -75,21 +75,19 @@ void
gnc_plugin_manager_add_plugin (GncPluginManager *manager,
GncPlugin *plugin)
{
GncPluginManagerPrivate *priv;
gint index;
ENTER (" ");
g_return_if_fail (GNC_IS_PLUGIN_MANAGER (manager));
g_return_if_fail (GNC_IS_PLUGIN (plugin));
priv = GNC_PLUGIN_MANAGER_GET_PRIVATE(manager);
index = g_list_index (priv->plugins, plugin);
index = g_list_index (manager->plugins, plugin);
if (index >= 0)
return;
priv->plugins = g_list_append (priv->plugins, plugin);
g_hash_table_insert (priv->plugins_table,
manager->plugins = g_list_append (manager->plugins, plugin);
g_hash_table_insert (manager->plugins_table,
g_strdup( GNC_PLUGIN_GET_CLASS(plugin)->plugin_name ),
plugin);
@ -101,21 +99,19 @@ void
gnc_plugin_manager_remove_plugin (GncPluginManager *manager,
GncPlugin *plugin)
{
GncPluginManagerPrivate *priv;
gint index;
ENTER (" ");
g_return_if_fail (GNC_IS_PLUGIN_MANAGER (manager));
g_return_if_fail (GNC_IS_PLUGIN (plugin));
priv = GNC_PLUGIN_MANAGER_GET_PRIVATE(manager);
index = g_list_index (priv->plugins, plugin);
index = g_list_index (manager->plugins, plugin);
if (index < 0)
return;
priv->plugins = g_list_remove (priv->plugins, plugin);
g_hash_table_remove (priv->plugins_table,
manager->plugins = g_list_remove (manager->plugins, plugin);
g_hash_table_remove (manager->plugins_table,
GNC_PLUGIN_GET_CLASS(plugin)->plugin_name);
g_signal_emit (G_OBJECT (manager), signals[PLUGIN_REMOVED], 0, plugin);
@ -128,25 +124,19 @@ gnc_plugin_manager_remove_plugin (GncPluginManager *manager,
GList *
gnc_plugin_manager_get_plugins (GncPluginManager *manager)
{
GncPluginManagerPrivate *priv;
g_return_val_if_fail (GNC_IS_PLUGIN_MANAGER (manager), NULL);
priv = GNC_PLUGIN_MANAGER_GET_PRIVATE(manager);
return g_list_copy (priv->plugins);
return g_list_copy (manager->plugins);
}
GncPlugin *
gnc_plugin_manager_get_plugin (GncPluginManager *manager,
const gchar *name)
{
GncPluginManagerPrivate *priv;
g_return_val_if_fail (GNC_IS_PLUGIN_MANAGER (manager), NULL);
g_return_val_if_fail (name != NULL, NULL);
priv = GNC_PLUGIN_MANAGER_GET_PRIVATE(manager);
return GNC_PLUGIN (g_hash_table_lookup (priv->plugins_table, name));
return GNC_PLUGIN (g_hash_table_lookup (manager->plugins_table, name));
}
static void
@ -160,7 +150,7 @@ gnc_plugin_manager_class_init (GncPluginManagerClass *klass)
signals[PLUGIN_ADDED] = g_signal_new ("plugin-added",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GncPluginManagerClass, plugin_added),
0,
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
@ -169,7 +159,7 @@ gnc_plugin_manager_class_init (GncPluginManagerClass *klass)
signals[PLUGIN_REMOVED] = g_signal_new ("plugin-removed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GncPluginManagerClass, plugin_removed),
0,
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
@ -180,29 +170,24 @@ gnc_plugin_manager_class_init (GncPluginManagerClass *klass)
static void
gnc_plugin_manager_init (GncPluginManager *manager)
{
GncPluginManagerPrivate *priv;
priv = GNC_PLUGIN_MANAGER_GET_PRIVATE(manager);
priv->plugins_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
manager->plugins_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
}
static void
gnc_plugin_manager_dispose (GObject *object)
{
GncPluginManager *manager = GNC_PLUGIN_MANAGER (object);
GncPluginManagerPrivate *priv;
g_return_if_fail (GNC_IS_PLUGIN_MANAGER (manager));
priv = GNC_PLUGIN_MANAGER_GET_PRIVATE(manager);
if (priv->plugins_table)
if (manager->plugins_table)
{
g_hash_table_destroy (priv->plugins_table);
priv->plugins_table = NULL;
g_hash_table_destroy (manager->plugins_table);
manager->plugins_table = NULL;
g_list_foreach (priv->plugins, (GFunc)g_object_unref, NULL);
g_list_free (priv->plugins);
priv->plugins = NULL;
g_list_foreach (manager->plugins, (GFunc)g_object_unref, NULL);
g_list_free (manager->plugins);
manager->plugins = NULL;
}
G_OBJECT_CLASS (gnc_plugin_manager_parent_class)->dispose (object);

29
gnucash/gnome-utils/gnc-plugin-manager.h
View File

@ -59,34 +59,7 @@ G_BEGIN_DECLS
/* type macros */
#define GNC_TYPE_PLUGIN_MANAGER (gnc_plugin_manager_get_type ())
#define GNC_PLUGIN_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_PLUGIN_MANAGER, GncPluginManager))
#define GNC_PLUGIN_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_PLUGIN_MANAGER, GncPluginManagerClass))
#define GNC_IS_PLUGIN_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_PLUGIN_MANAGER))
#define GNC_IS_PLUGIN_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_PLUGIN_MANAGER))
#define GNC_PLUGIN_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_PLUGIN_MANAGER, GncPluginManagerClass))
/* typedefs & structures */
typedef struct
{
GObject gobject;
} GncPluginManager;
typedef struct
{
GObjectClass gobject;
/* Signals */
void (* plugin_added)
(GncPluginManager *plugin_manager, GncPlugin *plugin);
void (* plugin_removed)
(GncPluginManager *plugin_manager, GncPlugin *plugin);
} GncPluginManagerClass;
/** Retrieve the GType value for the gnucash plugin manager.
*
* @return The GType that corresponds to an object of this type.
*/
GType gnc_plugin_manager_get_type (void);
G_DECLARE_FINAL_TYPE (GncPluginManager, gnc_plugin_manager, GNC, PLUGIN_MANAGER, GObject)
/** @} */

206
gnucash/gnome-utils/gnc-recurrence.c
View File

@ -50,12 +50,6 @@ struct _GncRecurrence
Recurrence recurrence;
};
typedef struct
{
GtkBoxClass parent_class;
void (*changed) (GncRecurrence *gr);
} GncRecurrenceClass;
typedef enum
{
GNCRECURRENCE_CHANGED,
@ -353,7 +347,7 @@ gnc_recurrence_class_init( GncRecurrenceClass *klass )
g_signal_new ("changed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GncRecurrenceClass, changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
@ -374,202 +368,4 @@ gnc_recurrence_new()
return GTK_WIDGET(gr);
}
/* TODO: Maybe this stuff should go into another file.
*
*/
struct _GncRecurrenceComp
{
GtkScrolledWindow widget;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *hbb;
gint num_rec;
GtkButton *buttRemove;
GtkButton *buttAdd;
GList *rlist;
};
typedef struct
{
GtkScrolledWindowClass parent_class;
void (*changed) (GncRecurrenceComp *gr);
} GncRecurrenceCompClass;
typedef enum
{
GNCRECURRENCECOMP_CHANGED,
GNCRC_LAST_SIGNAL
} GNCRC_Signals;
static void grc_changed(GtkWidget *w, gpointer data)
{
g_signal_emit_by_name(data, "changed");
}
static void addRecurrence(GncRecurrenceComp *grc, GncRecurrence *gr)
{
gtk_box_pack_start(GTK_BOX(grc->vbox), GTK_WIDGET(gr),
FALSE, FALSE, 3);
g_signal_connect( G_OBJECT(gr), "changed",
G_CALLBACK(grc_changed), grc );
grc->num_rec++;
gtk_widget_set_sensitive(GTK_WIDGET(grc->buttRemove), (grc->num_rec > 1));
g_signal_emit_by_name(G_OBJECT(grc), "changed");
}
static void removeRecurrence(GncRecurrenceComp *grc)
{
GList *children, *last;
grc->num_rec--;
children = gtk_container_get_children(GTK_CONTAINER(grc->vbox));
last = g_list_last(children);
gtk_widget_destroy(GTK_WIDGET(last->data));
g_list_free(children);
g_signal_emit_by_name(G_OBJECT(grc), "changed");
gtk_widget_set_sensitive(GTK_WIDGET(grc->buttRemove), (grc->num_rec > 1));
}
static void addClicked(GtkButton *b, gpointer data)
{
GncRecurrenceComp *grc = data;
GncRecurrence *gr;
gr = GNC_RECURRENCE(gnc_recurrence_new());
addRecurrence(grc, gr);
}
static void removeClicked(GtkButton *b, gpointer data)
{
GncRecurrenceComp *grc = data;
if (grc->num_rec > 1)
removeRecurrence(grc);
}
G_DEFINE_TYPE (GncRecurrenceComp, gnc_recurrence_comp, GTK_TYPE_SCROLLED_WINDOW)
void
gnc_recurrence_comp_set_list(GncRecurrenceComp *grc, const GList *rlist)
{
const GList *iter;
g_return_if_fail(grc);
while (grc->num_rec > 0)
removeRecurrence(grc);
for (iter = rlist; iter; iter = iter->next)
{
GncRecurrence *gr = GNC_RECURRENCE(gnc_recurrence_new());
gnc_recurrence_set(gr, (Recurrence *)iter->data);
addRecurrence(grc, gr);
}
}
GList *
gnc_recurrence_comp_get_list(GncRecurrenceComp *grc)
{
GList *rlist = NULL, *children;
children = gtk_container_get_children(GTK_CONTAINER(grc->vbox));
for (GList *n = children; n; n = n->next)
{
const Recurrence *r = gnc_recurrence_get (GNC_RECURRENCE (n->data));
rlist = g_list_prepend (rlist, (gpointer)r);
}
g_list_free(children);
return g_list_reverse (rlist);
}
static void
gnc_recurrence_comp_init(GncRecurrenceComp *grc)
{
GtkWidget *vb;
gtk_orientable_set_orientation (GTK_ORIENTABLE(grc), GTK_ORIENTATION_VERTICAL);
grc->hbb = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
grc->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_box_set_homogeneous (GTK_BOX (grc->vbox), FALSE);
grc->rlist = NULL;
grc->buttAdd = GTK_BUTTON(gtk_button_new_with_mnemonic(_("_Add")));
g_signal_connect(G_OBJECT(grc->buttAdd), "clicked",
G_CALLBACK(addClicked), grc);
grc->buttRemove = GTK_BUTTON(gtk_button_new_with_mnemonic(_("_Remove")));
g_signal_connect(G_OBJECT(grc->buttRemove), "clicked",
G_CALLBACK(removeClicked), grc);
gtk_box_pack_start(GTK_BOX(grc->hbb), GTK_WIDGET(grc->buttAdd),
FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(grc->hbb), GTK_WIDGET(grc->buttRemove),
FALSE, FALSE, 3);
vb = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_box_set_homogeneous (GTK_BOX (vb), FALSE);
gtk_box_pack_start(GTK_BOX(vb), GTK_WIDGET(grc->hbb),
FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(vb), GTK_WIDGET(grc->vbox),
FALSE, FALSE, 3);
gtk_container_add (GTK_CONTAINER(grc), GTK_WIDGET(vb));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grc),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
grc->num_rec = 0;
gtk_widget_show_all(GTK_WIDGET(grc));
addClicked(NULL, grc);
}
static void
gnc_recurrence_comp_class_init( GncRecurrenceCompClass *klass )
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
g_signal_new ("changed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GncRecurrenceCompClass, changed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
//object_class->finalize = gnc_recurrence_finalize;
}
GtkWidget *
gnc_recurrence_comp_new()
{
GncRecurrenceComp *grc;
grc = g_object_new(gnc_recurrence_comp_get_type(), NULL);
return GTK_WIDGET(grc);
}
/* ========================= END OF FILE =========================== */

22
gnucash/gnome-utils/gnc-recurrence.h
View File

@ -33,17 +33,8 @@
#include "Recurrence.h"
#define GNC_TYPE_RECURRENCE (gnc_recurrence_get_type())
#define GNC_RECURRENCE(obj) G_TYPE_CHECK_INSTANCE_CAST \
(obj, GNC_TYPE_RECURRENCE, GncRecurrence)
#define GNC_RECURRENCE_CLASS(klass) G_TYPE_CHECK_CLASS_CAST \
(klass, GNC_TYPE_RECURRENCE, GncRecurrence)
#define GNC_IS_RECURRENCE(obj) G_TYPE_CHECK_INSTANCE_TYPE \
(obj, GNC_TYPE_RECURRENCE)
G_DECLARE_FINAL_TYPE (GncRecurrence, gnc_recurrence, GNC, RECURRENCE, GtkBox)
typedef struct _GncRecurrence GncRecurrence;
typedef struct _GncRecurrenceComp GncRecurrenceComp;
GType gnc_recurrence_get_type(void);
GtkWidget * gnc_recurrence_new(void);
void gnc_recurrence_set(GncRecurrence *gr, const Recurrence *r);
@ -52,15 +43,4 @@ void gnc_recurrence_set(GncRecurrence *gr, const Recurrence *r);
long as the GncRecurrence is around. */
const Recurrence * gnc_recurrence_get(GncRecurrence *gr);
/* "composite" recurrences */
void gnc_recurrence_comp_set_list(GncRecurrenceComp *grc, const GList *r);
/* The GList is newly-allocated, but the Recurrences are internally
owned. */
GList * gnc_recurrence_comp_get_list(GncRecurrenceComp *grc);
/* This works, but is not used. Kind of experimental... */
GtkWidget * gnc_recurrence_comp_new(void);
GType gnc_recurrence_comp_get_type(void);
#endif

146
gnucash/gnome-utils/gnc-report-combo.c
View File

@ -46,9 +46,10 @@ enum
RC_MISSING
};
/** The instance private data for a content plugin. */
typedef struct _GncReportComboPrivate
struct _GncReportCombo
{
GtkBox box;
GtkWidget *combo;
GtkWidget *warning_image;
@ -60,12 +61,9 @@ typedef struct _GncReportComboPrivate
gchar *active_report_guid;
gchar *active_report_name;
} GncReportComboPrivate;
};
G_DEFINE_TYPE_WITH_PRIVATE(GncReportCombo, gnc_report_combo, GTK_TYPE_BOX)
#define GET_PRIVATE(o) \
((GncReportComboPrivate*)g_type_instance_get_private ((GTypeInstance*)o, GNC_TYPE_REPORT_COMBO))
G_DEFINE_TYPE(GncReportCombo, gnc_report_combo, GTK_TYPE_BOX)
enum
{
@ -92,12 +90,11 @@ gnc_report_combo_get_property (GObject *object,
GParamSpec *pspec)
{
GncReportCombo *grc = GNC_REPORT_COMBO(object);
GncReportComboPrivate *priv = GET_PRIVATE(grc);
switch (property_id)
{
case PROP_POPUP_SHOWN:
g_value_set_boolean (value, priv->popup_shown);
g_value_set_boolean (value, grc->popup_shown);
break;
default:
@ -126,7 +123,7 @@ gnc_report_combo_class_init (GncReportComboClass *klass)
g_signal_new ("changed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GncReportComboClass, changed),
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
@ -154,20 +151,16 @@ gnc_report_combo_class_init (GncReportComboClass *klass)
static void
gnc_report_combo_init (GncReportCombo *grc)
{
GncReportComboPrivate *priv;
g_return_if_fail (grc != NULL);
g_return_if_fail (GNC_IS_REPORT_COMBO(grc));
priv = GET_PRIVATE(grc);
// Set the name for this widget so it can be easily manipulated with css
gtk_widget_set_name (GTK_WIDGET(grc), "gnc-id-report-combo");
priv->block_signal = FALSE;
priv->active_report_guid = NULL;
priv->active_report_name = NULL;
priv->popup_shown = FALSE;
grc->block_signal = FALSE;
grc->active_report_guid = NULL;
grc->active_report_name = NULL;
grc->popup_shown = FALSE;
}
/** Dispopse the GncReportCombo object. This function is called from
@ -202,17 +195,15 @@ gnc_report_combo_dispose (GObject *object)
static void
gnc_report_combo_finalize (GObject *object)
{
GncReportComboPrivate *priv;
GncReportCombo *grc;
g_return_if_fail (object != NULL);
g_return_if_fail (GNC_IS_REPORT_COMBO(object));
grc = GNC_REPORT_COMBO(object);
priv = GET_PRIVATE(grc);
g_free (priv->active_report_guid);
g_free (priv->active_report_name);
g_free (grc->active_report_guid);
g_free (grc->active_report_name);
G_OBJECT_CLASS (gnc_report_combo_parent_class)->finalize (object);
}
@ -230,8 +221,7 @@ gnc_report_combo_finalize (GObject *object)
static gboolean
select_active_and_check_exists (GncReportCombo *grc)
{
GncReportComboPrivate *priv = GET_PRIVATE(grc);
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(priv->combo));
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(grc->combo));
GtkTreeIter iter;
gboolean valid_iter = gtk_tree_model_get_iter_first (model, &iter);
gchar *tmp;
@ -241,9 +231,9 @@ select_active_and_check_exists (GncReportCombo *grc)
gchar *guid;
gtk_tree_model_get (model, &iter, RC_GUID, &guid, -1);
if (g_strcmp0 (priv->active_report_guid, guid) == 0)
if (g_strcmp0 (grc->active_report_guid, guid) == 0)
{
gtk_combo_box_set_active_iter (GTK_COMBO_BOX(priv->combo), &iter);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX(grc->combo), &iter);
g_free (guid);
return TRUE;
}
@ -251,28 +241,27 @@ select_active_and_check_exists (GncReportCombo *grc)
valid_iter = gtk_tree_model_iter_next (model, &iter);
}
if (priv->active_report_name)
tmp = g_strdup (priv->active_report_name);
if (grc->active_report_name)
tmp = g_strdup (grc->active_report_name);
else
tmp = g_strdup (_("Selected Report is Missing"));
gtk_list_store_prepend (GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
RC_NAME, tmp,
RC_GUID, priv->active_report_guid,
RC_GUID, grc->active_report_guid,
RC_MISSING, TRUE,
-1);
g_free (tmp);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX(priv->combo), &iter);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX(grc->combo), &iter);
return FALSE;
}
static void
update_report_list (GncReportCombo *grc, GSList *report_list)
{
GncReportComboPrivate *priv = GET_PRIVATE(grc);
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(priv->combo));
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(grc->combo));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(model),
RC_NAME, GTK_SORT_ASCENDING);
@ -304,20 +293,19 @@ update_report_list (GncReportCombo *grc, GSList *report_list)
static void
update_warning_tooltip (GncReportCombo *grc)
{
GncReportComboPrivate *priv = GET_PRIVATE(grc);
gchar *tool_tip;
if (priv->active_report_name)
if (grc->active_report_name)
/* Translators: %s is the report name. */
tool_tip = g_strdup_printf (_("'%s' is missing"),
priv->active_report_name);
grc->active_report_name);
else
/* Translators: %s is the internal report guid. */
tool_tip = g_strdup_printf (_("Report with GUID '%s' is missing"),
priv->active_report_guid);
grc->active_report_guid);
gtk_widget_show (priv->warning_image);
gtk_widget_set_tooltip_text (priv->warning_image, tool_tip);
gtk_widget_show (grc->warning_image);
gtk_widget_set_tooltip_text (grc->warning_image, tool_tip);
g_free (tool_tip);
}
@ -326,44 +314,37 @@ gnc_report_combo_set_active (GncReportCombo *grc,
const char* active_report_guid,
const char* active_report_name)
{
GncReportComboPrivate *priv;
g_return_if_fail (grc != NULL);
g_return_if_fail (GNC_IS_REPORT_COMBO(grc));
priv = GET_PRIVATE(grc);
g_free (grc->active_report_guid);
g_free (priv->active_report_guid);
grc->active_report_guid = g_strdup (active_report_guid);
priv->active_report_guid = g_strdup (active_report_guid);
g_free (grc->active_report_name);
g_free (priv->active_report_name);
grc->active_report_name = g_strdup (active_report_name);
priv->active_report_name = g_strdup (active_report_name);
priv->block_signal = TRUE;
grc->block_signal = TRUE;
if (!select_active_and_check_exists (grc))
update_warning_tooltip (grc);
priv->block_signal = FALSE;
grc->block_signal = FALSE;
}
gchar *
gnc_report_combo_get_active_guid (GncReportCombo *grc)
{
GncReportComboPrivate *priv;
gchar *guid = NULL;
GtkTreeIter iter;
g_return_val_if_fail (grc != NULL, NULL);
g_return_val_if_fail (GNC_IS_REPORT_COMBO(grc), NULL);
priv = GET_PRIVATE(grc);
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(priv->combo), &iter))
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(grc->combo), &iter))
{
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(priv->combo));
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(grc->combo));
gtk_tree_model_get (model, &iter, RC_GUID, &guid, -1);
}
return guid;
@ -372,18 +353,15 @@ gnc_report_combo_get_active_guid (GncReportCombo *grc)
gchar *
gnc_report_combo_get_active_name (GncReportCombo *grc)
{
GncReportComboPrivate *priv;
gchar *name = NULL;
GtkTreeIter iter;
g_return_val_if_fail (grc != NULL, NULL);
g_return_val_if_fail (GNC_IS_REPORT_COMBO(grc), NULL);
priv = GET_PRIVATE(grc);
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(priv->combo), &iter))
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(grc->combo), &iter))
{
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(priv->combo));
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(grc->combo));
gtk_tree_model_get (model, &iter, RC_NAME, &name, -1);
}
return name;
@ -392,18 +370,15 @@ gnc_report_combo_get_active_name (GncReportCombo *grc)
gchar*
gnc_report_combo_get_active_guid_name (GncReportCombo *grc)
{
GncReportComboPrivate *priv;
gchar *report = NULL;
GtkTreeIter iter;
g_return_val_if_fail (grc != NULL, NULL);
g_return_val_if_fail (GNC_IS_REPORT_COMBO(grc), NULL);
priv = GET_PRIVATE(grc);
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(priv->combo), &iter))
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(grc->combo), &iter))
{
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(priv->combo));
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX(grc->combo));
gchar *report_guid;
gchar *report_name;
gtk_tree_model_get (model, &iter, RC_NAME, &report_name,
@ -441,21 +416,16 @@ gnc_report_combo_set_active_guid_name (GncReportCombo *grc,
gboolean
gnc_report_combo_is_warning_visible_for_active (GncReportCombo *grc)
{
GncReportComboPrivate *priv;
g_return_val_if_fail (grc != NULL, FALSE);
g_return_val_if_fail (GNC_IS_REPORT_COMBO(grc), FALSE);
priv = GET_PRIVATE(grc);
return gtk_widget_is_visible (GTK_WIDGET(priv->warning_image));
return gtk_widget_is_visible (GTK_WIDGET(grc->warning_image));
}
static void
combo_changed_cb (GtkComboBox *widget, gpointer user_data)
{
GncReportCombo *grc = GNC_REPORT_COMBO(user_data);
GncReportComboPrivate *priv = GET_PRIVATE(grc);
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (widget, &iter))
@ -464,9 +434,9 @@ combo_changed_cb (GtkComboBox *widget, gpointer user_data)
gboolean missing;
gtk_tree_model_get (model, &iter, RC_MISSING, &missing, -1);
// set visibility of the warning image
gtk_widget_set_visible (priv->warning_image, missing);
gtk_widget_set_visible (grc->warning_image, missing);
if (!priv->block_signal)
if (!grc->block_signal)
g_signal_emit (grc, report_combo_signals [CHANGED], 0);
gtk_widget_queue_resize (GTK_WIDGET(widget));
@ -479,34 +449,29 @@ combo_popped_cb (GObject *gobject,
gpointer user_data)
{
GncReportCombo *grc = GNC_REPORT_COMBO(user_data);
GncReportComboPrivate *priv = GET_PRIVATE(grc);
gboolean popup_shown;
g_object_get (G_OBJECT(gobject), "popup-shown", &popup_shown, NULL);
priv->popup_shown = popup_shown;
grc->popup_shown = popup_shown;
g_object_notify (G_OBJECT(grc), "popup-shown");
}
void
gnc_report_combo_refresh (GncReportCombo *grc, GSList *report_list)
{
GncReportComboPrivate *priv;
g_return_if_fail (grc != NULL);
g_return_if_fail (GNC_IS_REPORT_COMBO(grc));
g_return_if_fail (report_list != NULL);
priv = GET_PRIVATE(grc);
priv->block_signal = TRUE;
grc->block_signal = TRUE;
update_report_list (grc, report_list);
if (!select_active_and_check_exists (grc))
update_warning_tooltip (grc);
priv->block_signal = FALSE;
grc->block_signal = FALSE;
}
/* Create a new GncReportCombo widget which can be used to select
@ -518,36 +483,33 @@ GtkWidget *
gnc_report_combo_new (GSList *report_list)
{
GncReportCombo *grc;
GncReportComboPrivate *priv;
GtkListStore *store;
GtkCellRenderer *renderer;
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
grc = g_object_new (GNC_TYPE_REPORT_COMBO, NULL);
priv = GET_PRIVATE(grc);
priv->combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(store));
grc->combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(store));
g_object_unref (store);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(priv->combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT(priv->combo), renderer,
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(grc->combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT(grc->combo), renderer,
"text", RC_NAME, NULL);
gtk_box_pack_start (GTK_BOX(grc), GTK_WIDGET(priv->combo), TRUE, TRUE, 0);
priv->warning_image = gtk_image_new_from_icon_name ("dialog-warning",
gtk_box_pack_start (GTK_BOX(grc), GTK_WIDGET(grc->combo), TRUE, TRUE, 0);
grc->warning_image = gtk_image_new_from_icon_name ("dialog-warning",
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_box_pack_start (GTK_BOX(grc), GTK_WIDGET(priv->warning_image), FALSE, FALSE, 6);
gtk_widget_set_no_show_all (GTK_WIDGET(priv->warning_image), TRUE);
gtk_widget_hide (GTK_WIDGET(priv->warning_image));
gtk_box_pack_start (GTK_BOX(grc), GTK_WIDGET(grc->warning_image), FALSE, FALSE, 6);
gtk_widget_set_no_show_all (GTK_WIDGET(grc->warning_image), TRUE);
gtk_widget_hide (GTK_WIDGET(grc->warning_image));
update_report_list (grc, report_list);
g_signal_connect (G_OBJECT(priv->combo), "changed",
g_signal_connect (G_OBJECT(grc->combo), "changed",
G_CALLBACK(combo_changed_cb), grc);
g_signal_connect (G_OBJECT(priv->combo), "notify::popup-shown",
g_signal_connect (G_OBJECT(grc->combo), "notify::popup-shown",
G_CALLBACK(combo_popped_cb), grc);
gtk_widget_show_all (GTK_WIDGET(grc));

35
gnucash/gnome-utils/gnc-report-combo.h
View File

@ -25,25 +25,13 @@
#ifndef GNC_REPORT_COMBO_H
#define GNC_REPORT_COMBO_H
#ifdef __cplusplus
extern "C"
{
#endif
#define GNC_TYPE_REPORT_COMBO (gnc_report_combo_get_type())
#define GNC_REPORT_COMBO(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_REPORT_COMBO, GncReportCombo))
#define GNC_REPORT_COMBO_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GNC_TYPE_REPORT_COMBO, GncReportComboClass))
#define GNC_IS_REPORT_COMBO(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_REPORT_COMBO))
#define GNC_IS_REPORT_COMBO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GNC_TYPE_REPORT_COMBO))
#define GNC_REPORT_COMBO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_REPORT_COMBO, GncReportComboClass))
typedef struct
{
GtkBox box;
} GncReportCombo;
typedef struct
{
GtkBoxClass parent_class;
void (*changed) (GncReportCombo *grc);
} GncReportComboClass;
G_DECLARE_FINAL_TYPE (GncReportCombo, gnc_report_combo, GNC, REPORT_COMBO, GtkBox)
typedef struct
{
@ -51,17 +39,6 @@ typedef struct
char *report_name;
} ReportListEntry;
#ifdef __cplusplus
extern "C"
{
#endif
/** Return the GType for the GncReportCombo widget.
*
* @return A GType value.
*/
GType gnc_report_combo_get_type (void) G_GNUC_CONST;
/** Create a new GncReportCombo widget which can be used to provide
* a list of reports and select one.
*

5
gnucash/gnome-utils/gnc-sx-instance-dense-cal-adapter.c
View File

@ -50,11 +50,6 @@ static gchar* gsidca_get_info(GncDenseCalModel *model, guint tag);
static gint gsidca_get_instance_count(GncDenseCalModel *model, guint tag);
static void gsidca_get_instance(GncDenseCalModel *model, guint tag, gint instance_index, GDate *date);
struct _GncSxInstanceDenseCalAdapterClass
{
GObjectClass parent;
};
struct _GncSxInstanceDenseCalAdapter
{
GObject parent;

10
gnucash/gnome-utils/gnc-sx-instance-dense-cal-adapter.h
View File

@ -27,17 +27,9 @@
#include <glib.h>
#include "gnc-sx-instance-model.h"
typedef struct _GncSxInstanceDenseCalAdapterClass GncSxInstanceDenseCalAdapterClass;
typedef struct _GncSxInstanceDenseCalAdapter GncSxInstanceDenseCalAdapter;
#define GNC_TYPE_SX_INSTANCE_DENSE_CAL_ADAPTER (gnc_sx_instance_dense_cal_adapter_get_type ())
#define GNC_SX_INSTANCE_DENSE_CAL_ADAPTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_SX_INSTANCE_DENSE_CAL_ADAPTER, GncSxInstanceDenseCalAdapter))
#define GNC_SX_INSTANCE_DENSE_CAL_ADAPTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_SX_INSTANCE_DENSE_CAL_ADAPTER, GncSxInstanceDenseCalAdapterClass))
#define GNC_IS_SX_INSTANCE_DENSE_CAL_ADAPTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_SX_INSTANCE_DENSE_CAL_ADAPTER))
#define GNC_IS_SX_INSTANCE_DENSE_CAL_ADAPTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_SX_INSTANCE_DENSE_CAL_ADAPTER))
#define GNC_SX_INSTANCE_DENSE_CAL_ADAPTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_SX_INSTANCE_DENSE_CAL_ADAPTER, GncSxInstanceDenseCalAdapterClass))
G_DECLARE_FINAL_TYPE (GncSxInstanceDenseCalAdapter, gnc_sx_instance_dense_cal_adapter, GNC, SX_INSTANCE_DENSE_CAL_ADAPTER, GObject)
GncSxInstanceDenseCalAdapter* gnc_sx_instance_dense_cal_adapter_new(GncSxInstanceModel *instances);
GType gnc_sx_instance_dense_cal_adapter_get_type(void);
#endif // _GNC_SX_INSTANCE_DENSE_CAL_ADAPTER_H

12
gnucash/gnome-utils/gnc-sx-list-tree-model-adapter.c
View File

@ -51,14 +51,6 @@ struct _GncSxListTreeModelAdapter
GtkTreeModelSort *real;
};
struct _GncSxListTreeModelAdapterClass
{
GObjectClass parent;
/* This signal is emitted when the model is populated */
void (*model_populated) (GncSxListTreeModelAdapter *model, gpointer user_data);
};
/* Signal codes */
enum
{
@ -92,12 +84,10 @@ gnc_sx_list_tree_model_adapter_class_init (GncSxListTreeModelAdapterClass *klass
g_signal_new("model_populated",
G_TYPE_FROM_CLASS(obj_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GncSxListTreeModelAdapterClass, model_populated),
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
klass->model_populated = NULL;
}
static GtkTreeModelFlags

10
gnucash/gnome-utils/gnc-sx-list-tree-model-adapter.h
View File

@ -44,14 +44,7 @@
G_BEGIN_DECLS
#define GNC_TYPE_SX_LIST_TREE_MODEL_ADAPTER (gnc_sx_list_tree_model_adapter_get_type ())
#define GNC_SX_LIST_TREE_MODEL_ADAPTER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GNC_TYPE_SX_LIST_TREE_MODEL_ADAPTER, GncSxListTreeModelAdapter))
#define GNC_SX_LIST_TREE_MODEL_ADAPTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GNC_TYPE_SX_LIST_TREE_MODEL_ADAPTER, GncSxListTreeModelAdapterClass))
#define GNC_IS_SX_LIST_TREE_MODEL_ADAPTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GNC_TYPE_SX_LIST_TREE_MODEL_ADAPTER))
#define GNC_IS_SX_LIST_TREE_MODEL_ADAPTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GNC_TYPE_SX_LIST_TREE_MODEL_ADAPTER))
#define GNC_SX_LIST_TREE_MODEL_ADAPTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GNC_TYPE_SX_LIST_TREE_MODEL_ADAPTER, GncSxListTreeModelAdapterClass))
typedef struct _GncSxListTreeModelAdapter GncSxListTreeModelAdapter;
typedef struct _GncSxListTreeModelAdapterClass GncSxListTreeModelAdapterClass;
G_DECLARE_FINAL_TYPE (GncSxListTreeModelAdapter, gnc_sx_list_tree_model_adapter, GNC, SX_LIST_TREE_MODEL_ADAPTER, GObject)
// model columns
enum
@ -63,7 +56,6 @@ enum
SXLTMA_COL_NEXT_OCCUR
};
GType gnc_sx_list_tree_model_adapter_get_type (void);
GncSxListTreeModelAdapter* gnc_sx_list_tree_model_adapter_new (GncSxInstanceModel *instances);
GncSxInstances* gnc_sx_list_tree_model_adapter_get_sx_instances (GncSxListTreeModelAdapter *model, GtkTreeIter *iter);

6
gnucash/gnome-utils/test/CMakeLists.txt
View File

@ -9,11 +9,7 @@ set(GNOME_UTILS_GUI_TEST_LIBS
test-core
gnc-gnome-utils
)
#This is a GUI test
#gnc_add_test(test-gnc-recurrence test-gnc-recurrence.c
# GNOME_UTILS_GUI_TEST_INCLUDE_DIRS
# GNOME_UTILS_GUI_TEST_LIBS
#
set(GUILE_DEPENDS
scm-gnome-utils
test-core

126
gnucash/gnome-utils/test/test-gnc-recurrence.c
View File

@ -1,126 +0,0 @@
/********************************************************************\
* Copyright (C) 2005, Chris Shoemaker <c.shoemaker@cox.net> *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of *
* the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License*
* along with this program; if not, contact: *
* *
* Free Software Foundation Voice: +1-617-542-5942 *
* 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
* Boston, MA 02110-1301, USA gnu@gnu.org *
* *
\********************************************************************/
/* test-gnc-recurrence.c:
*
* When you close the window, a text description of the
* recurrence is printed.
*
*/
#include <config.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <stdio.h>
#include "gnc-recurrence.h"
#include "Recurrence.h"
static GtkWidget * mainwin;
static GncRecurrence *rw;
static GncRecurrenceComp *grc;
static void get_list(GtkWidget *w)
{
gchar *s;
GList *rlist;
rlist = gnc_recurrence_comp_get_list(grc);
s = recurrenceListToString(rlist);
printf("%s\n", s);
g_free(s);
g_list_free(rlist);
}
static void changed(GtkWidget *widget)
{
gchar *s;
const Recurrence *r;
r = gnc_recurrence_get(rw);
s = recurrenceToString(r);
printf("%s\n", s);
g_free(s);
}
static void die(GtkWidget *widget)
{
gtk_main_quit();
}
static void show_gnc_recurrence()
{
GDate d;
Recurrence *r;
GList *rl = NULL;
rw = GNC_RECURRENCE(gnc_recurrence_new());
r = g_new(Recurrence, 1);
rl = g_list_append(rl, r);
g_date_set_dmy(&d, 17, 4, 2005);
recurrenceSet(r, 1, PERIOD_WEEK, &d, WEEKEND_ADJ_NONE);
gnc_recurrence_set(rw, r);
g_free(r);
gtk_container_add(GTK_CONTAINER(mainwin), GTK_WIDGET(rw));
g_signal_connect(rw, "changed", G_CALLBACK(changed), NULL);
}
static void show_gnc_recurrence_comp()
{
GList *rlist = NULL;
Recurrence r[2];
grc = (GncRecurrenceComp *)gnc_recurrence_comp_new();
gtk_container_add(GTK_CONTAINER(mainwin), GTK_WIDGET(grc));
recurrenceSet(&r[0], 1, PERIOD_MONTH, NULL, WEEKEND_ADJ_NONE);
rlist = g_list_append(rlist, &r[0]);
recurrenceSet(&r[1], 1, PERIOD_YEAR, NULL, WEEKEND_ADJ_NONE);
rlist = g_list_append(rlist, &r[1]);
gnc_recurrence_comp_set_list(grc, rlist);
g_list_free(rlist);
g_signal_connect(grc, "changed", G_CALLBACK(get_list), NULL);
//rlist = gnc_recurrence_comp_get_list(grc);
}
int main (int argc, char ** argv)
{
gtk_init(&argc, &argv);
mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(mainwin, "delete-event", G_CALLBACK(die), NULL);
if (argc > 1)
show_gnc_recurrence();
else
show_gnc_recurrence_comp();
gtk_widget_show_all(mainwin);
gtk_main();
return 0;
}