From d9f7a348ac82d04928761b7460e62a653dd39812 Mon Sep 17 00:00:00 2001 From: Andrea Zagli Date: Fri, 8 Oct 2010 11:49:00 +0200 Subject: [PATCH] Aggiunto namespace territorio per trasformazione in libreria. --- .cproject | 208 +++++++++++++++++++++++++++-- src/aggregazioneterritoriale.c | 116 ++++++++-------- src/aggregazioneterritoriale.h | 32 ++--- src/aggregazioniterritoriali.c | 168 +++++++++++------------ src/aggregazioniterritoriali.h | 32 ++--- src/comune.c | 140 +++++++++---------- src/comune.h | 32 ++--- src/comuni.c | 168 +++++++++++------------ src/comuni.h | 32 ++--- src/main.c | 28 ++-- src/province.c | 168 +++++++++++------------ src/province.h | 32 ++--- src/provincia.c | 140 +++++++++---------- src/provincia.h | 32 ++--- src/regione.c | 116 ++++++++-------- src/regione.h | 32 ++--- src/regioni.c | 168 +++++++++++------------ src/regioni.h | 32 ++--- src/stati.c | 168 +++++++++++------------ src/stati.h | 32 ++--- src/stato.c | 116 ++++++++-------- src/stato.h | 32 ++--- src/tipiaggregazioneterritoriale.c | 168 +++++++++++------------ src/tipiaggregazioneterritoriale.h | 32 ++--- src/tipoaggregazioneterritoriale.c | 116 ++++++++-------- src/tipoaggregazioneterritoriale.h | 32 ++--- src/via.c | 140 +++++++++---------- src/via.h | 32 ++--- src/vie.c | 168 +++++++++++------------ src/vie.h | 32 ++--- 30 files changed, 1468 insertions(+), 1276 deletions(-) diff --git a/.cproject b/.cproject index 5113583..6812572 100644 --- a/.cproject +++ b/.cproject @@ -11,24 +11,51 @@ + - + - + - - + + + + - - + + + + + + + + - + + + + + + + @@ -111,8 +138,173 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - diff --git a/src/aggregazioneterritoriale.c b/src/aggregazioneterritoriale.c index 088eacc..c9aebfd 100644 --- a/src/aggregazioneterritoriale.c +++ b/src/aggregazioneterritoriale.c @@ -21,41 +21,41 @@ #include "aggregazioneterritoriale.h" -static void aggregazione_territoriale_class_init (AggregazioneTerritorialeClass *klass); -static void aggregazione_territoriale_init (AggregazioneTerritoriale *aggregazione_territoriale); +static void territorio_aggregazione_territoriale_class_init (TerritorioAggregazioneTerritorialeClass *klass); +static void territorio_aggregazione_territoriale_init (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale); -static void aggregazione_territoriale_carica (AggregazioneTerritoriale *aggregazione_territoriale); -static void aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territoriale); +static void territorio_aggregazione_territoriale_carica (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale); +static void territorio_aggregazione_territoriale_salva (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale); -static gboolean aggregazione_territoriale_conferma_chiusura (AggregazioneTerritoriale *aggregazione_territoriale); +static gboolean territorio_aggregazione_territoriale_conferma_chiusura (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale); -static void aggregazione_territoriale_set_property (GObject *object, +static void territorio_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void aggregazione_territoriale_get_property (GObject *object, +static void territorio_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static gboolean aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event (GtkWidget *widget, +static gboolean territorio_aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, +static void territorio_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, +static void territorio_aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define AGGREGAZIONE_TERRITORIALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_AGGREGAZIONE_TERRITORIALE, AggregazioneTerritorialePrivate)) +#define TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE, TerritorioAggregazioneTerritorialePrivate)) enum { LBL_ID }; -typedef struct _AggregazioneTerritorialePrivate AggregazioneTerritorialePrivate; -struct _AggregazioneTerritorialePrivate +typedef struct _TerritorioAggregazioneTerritorialePrivate TerritorioAggregazioneTerritorialePrivate; +struct _TerritorioAggregazioneTerritorialePrivate { Commons *commons; @@ -68,21 +68,21 @@ struct _AggregazioneTerritorialePrivate gint id; }; -G_DEFINE_TYPE (AggregazioneTerritoriale, aggregazione_territoriale, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioAggregazioneTerritoriale, territorio_aggregazione_territoriale, G_TYPE_OBJECT) static void -aggregazione_territoriale_class_init (AggregazioneTerritorialeClass *klass) +territorio_aggregazione_territoriale_class_init (TerritorioAggregazioneTerritorialeClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (AggregazioneTerritorialePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioAggregazioneTerritorialePrivate)); - object_class->set_property = aggregazione_territoriale_set_property; - object_class->get_property = aggregazione_territoriale_get_property; + object_class->set_property = territorio_aggregazione_territoriale_set_property; + object_class->get_property = territorio_aggregazione_territoriale_get_property; /** - * AggregazioneTerritoriale::aggiornato: - * @aggregazione_territoriale: + * TerritorioAggregazioneTerritoriale::aggiornato: + * @territorio_aggregazione_territoriale: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -97,26 +97,26 @@ aggregazione_territoriale_class_init (AggregazioneTerritorialeClass *klass) } static void -aggregazione_territoriale_init (AggregazioneTerritoriale *aggregazione_territoriale) +territorio_aggregazione_territoriale_init (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale) { - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); } /** - * aggregazione_territoriale_new: + * territorio_aggregazione_territoriale_new: * @commons: * @id: * - * Returns: the newly created #AggregazioneTerritoriale object. + * Returns: the newly created #TerritorioAggregazioneTerritoriale object. */ -AggregazioneTerritoriale -*aggregazione_territoriale_new (Commons *commons, gint id) +TerritorioAggregazioneTerritoriale +*territorio_aggregazione_territoriale_new (Commons *commons, gint id) { GError *error; - AggregazioneTerritoriale *a = AGGREGAZIONE_TERRITORIALE (g_object_new (aggregazione_territoriale_get_type (), NULL)); + TerritorioAggregazioneTerritoriale *a = TERRITORIO_AGGREGAZIONE_TERRITORIALE (g_object_new (territorio_aggregazione_territoriale_get_type (), NULL)); - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); priv->commons = commons; @@ -142,12 +142,12 @@ AggregazioneTerritoriale NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button41"), - "clicked", G_CALLBACK (aggregazione_territoriale_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_aggregazione_territoriale_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button42"), - "clicked", G_CALLBACK (aggregazione_territoriale_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_aggregazione_territoriale_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -160,30 +160,30 @@ AggregazioneTerritoriale else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - aggregazione_territoriale_carica (a); + territorio_aggregazione_territoriale_carica (a); } return a; } /** - * aggregazione_territoriale_get_widget: - * @aggregazione_territoriale: + * territorio_aggregazione_territoriale_get_widget: + * @territorio_aggregazione_territoriale: * */ GtkWidget -*aggregazione_territoriale_get_widget (AggregazioneTerritoriale *aggregazione_territoriale) +*territorio_aggregazione_territoriale_get_widget (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale) { - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); return priv->w; } /* PRIVATE */ static void -aggregazione_territoriale_carica (AggregazioneTerritoriale *aggregazione_territoriale) +territorio_aggregazione_territoriale_carica (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale) { - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); if (gtk_form_fill_from_table (priv->form)) { @@ -191,7 +191,7 @@ aggregazione_territoriale_carica (AggregazioneTerritoriale *aggregazione_territo } static void -aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territoriale) +territorio_aggregazione_territoriale_salva (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale) { GError *error = NULL; gchar *sql; @@ -200,9 +200,9 @@ aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territor GDate *da; GDate *a; - AggregazioneTerritorialeClass *klass = AGGREGAZIONE_TERRITORIALE_GET_CLASS (aggregazione_territoriale); + TerritorioAggregazioneTerritorialeClass *klass = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_CLASS (territorio_aggregazione_territoriale); - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -220,7 +220,7 @@ aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territor if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (aggregazione_territoriale, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_aggregazione_territoriale, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -255,11 +255,11 @@ aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territor } static void -aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - AggregazioneTerritoriale *aggregazione_territoriale = AGGREGAZIONE_TERRITORIALE (object); + TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale = TERRITORIO_AGGREGAZIONE_TERRITORIALE (object); - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); switch (property_id) { @@ -270,11 +270,11 @@ aggregazione_territoriale_set_property (GObject *object, guint property_id, cons } static void -aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - AggregazioneTerritoriale *aggregazione_territoriale = AGGREGAZIONE_TERRITORIALE (object); + TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale = TERRITORIO_AGGREGAZIONE_TERRITORIALE (object); - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); switch (property_id) { @@ -285,13 +285,13 @@ aggregazione_territoriale_get_property (GObject *object, guint property_id, GVal } static gboolean -aggregazione_territoriale_conferma_chiusura (AggregazioneTerritoriale *aggregazione_territoriale) +territorio_aggregazione_territoriale_conferma_chiusura (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale) { GtkWidget *dialog; gboolean ret; - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -313,27 +313,27 @@ aggregazione_territoriale_conferma_chiusura (AggregazioneTerritoriale *aggregazi /* CALLBACK */ static gboolean -aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event (GtkWidget *widget, +territorio_aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !aggregazione_territoriale_conferma_chiusura ((AggregazioneTerritoriale *)user_data); + return !territorio_aggregazione_territoriale_conferma_chiusura ((TerritorioAggregazioneTerritoriale *)user_data); } static void -aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, +territorio_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - AggregazioneTerritoriale *aggregazione_territoriale = (AggregazioneTerritoriale *)user_data; + TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale = (TerritorioAggregazioneTerritoriale *)user_data; - AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + TerritorioAggregazioneTerritorialePrivate *priv = TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_aggregazione_territoriale); - if (aggregazione_territoriale_conferma_chiusura (aggregazione_territoriale)) gtk_widget_destroy (priv->w); + if (territorio_aggregazione_territoriale_conferma_chiusura (territorio_aggregazione_territoriale)) gtk_widget_destroy (priv->w); } static void -aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, +territorio_aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - aggregazione_territoriale_salva ((AggregazioneTerritoriale *)user_data); + territorio_aggregazione_territoriale_salva ((TerritorioAggregazioneTerritoriale *)user_data); } diff --git a/src/aggregazioneterritoriale.h b/src/aggregazioneterritoriale.h index c9fe59d..907f25c 100644 --- a/src/aggregazioneterritoriale.h +++ b/src/aggregazioneterritoriale.h @@ -17,8 +17,8 @@ * */ -#ifndef __AGGREGAZIONE_TERRITORIALE_H__ -#define __AGGREGAZIONE_TERRITORIALE_H__ +#ifndef __TERRITORIO_AGGREGAZIONE_TERRITORIALE_H__ +#define __TERRITORIO_AGGREGAZIONE_TERRITORIALE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_AGGREGAZIONE_TERRITORIALE (aggregazione_territoriale_get_type ()) -#define AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_AGGREGAZIONE_TERRITORIALE, AggregazioneTerritoriale)) -#define AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_AGGREGAZIONE_TERRITORIALE, AggregazioneTerritorialeClass)) -#define IS_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_AGGREGAZIONE_TERRITORIALE)) -#define IS_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_AGGREGAZIONE_TERRITORIALE)) -#define AGGREGAZIONE_TERRITORIALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_AGGREGAZIONE_TERRITORIALE, AggregazioneTerritorialeClass)) +#define TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE (territorio_aggregazione_territoriale_get_type ()) +#define TERRITORIO_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE, TerritorioAggregazioneTerritoriale)) +#define TERRITORIO_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE, TerritorioAggregazioneTerritorialeClass)) +#define IS_TERRITORIO_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE)) +#define IS_TERRITORIO_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE)) +#define TERRITORIO_AGGREGAZIONE_TERRITORIALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_AGGREGAZIONE_TERRITORIALE, TerritorioAggregazioneTerritorialeClass)) -typedef struct _AggregazioneTerritoriale AggregazioneTerritoriale; -typedef struct _AggregazioneTerritorialeClass AggregazioneTerritorialeClass; +typedef struct _TerritorioAggregazioneTerritoriale TerritorioAggregazioneTerritoriale; +typedef struct _TerritorioAggregazioneTerritorialeClass TerritorioAggregazioneTerritorialeClass; -struct _AggregazioneTerritoriale +struct _TerritorioAggregazioneTerritoriale { GObject parent; }; -struct _AggregazioneTerritorialeClass +struct _TerritorioAggregazioneTerritorialeClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType aggregazione_territoriale_get_type (void) G_GNUC_CONST; +GType territorio_aggregazione_territoriale_get_type (void) G_GNUC_CONST; -AggregazioneTerritoriale *aggregazione_territoriale_new (Commons *commons, gint id); +TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale_new (Commons *commons, gint id); -GtkWidget *aggregazione_territoriale_get_widget (AggregazioneTerritoriale *aggregazione_territoriale); +GtkWidget *territorio_aggregazione_territoriale_get_widget (TerritorioAggregazioneTerritoriale *territorio_aggregazione_territoriale); G_END_DECLS -#endif /* __AGGREGAZIONE_TERRITORIALE_H__ */ +#endif /* __TERRITORIO_AGGREGAZIONE_TERRITORIALE_H__ */ diff --git a/src/aggregazioniterritoriali.c b/src/aggregazioniterritoriali.c index 9fe32d9..ec8ee5e 100644 --- a/src/aggregazioniterritoriali.c +++ b/src/aggregazioniterritoriali.c @@ -20,41 +20,41 @@ #include "aggregazioniterritoriali.h" #include "aggregazioneterritoriale.h" -static void aggregazioni_territoriali_class_init (AggregazioniTerritorialiClass *klass); -static void aggregazioni_territoriali_init (AggregazioniTerritoriali *aggregazioni_territoriali); +static void territorio_aggregazioni_territoriali_class_init (TerritorioAggregazioniTerritorialiClass *klass); +static void territorio_aggregazioni_territoriali_init (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali); -static void aggregazioni_territoriali_carica (AggregazioniTerritoriali *aggregazioni_territoriali); -static void aggregazioni_territoriali_modifica (AggregazioniTerritoriali *aggregazioni_territoriali); +static void territorio_aggregazioni_territoriali_carica (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali); +static void territorio_aggregazioni_territoriali_modifica (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali); -static void aggregazioni_territoriali_selezionato (AggregazioniTerritoriali *aggregazioni_territoriali); -static void aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data); +static void territorio_aggregazioni_territoriali_selezionato (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali); +static void territorio_aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data); -static void aggregazioni_territoriali_set_property (GObject *object, +static void territorio_aggregazioni_territoriali_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void aggregazioni_territoriali_get_property (GObject *object, +static void territorio_aggregazioni_territoriali_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void aggregazioni_territoriali_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_aggregazioni_territoriali_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void aggregazioni_territoriali_on_btn_modifica_clicked (GtkButton *button, +static void territorio_aggregazioni_territoriali_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, +static void territorio_aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void aggregazioni_territoriali_on_trv_aggregazioni_territoriali_row_activated (GtkTreeView *tree_view, +static void territorio_aggregazioni_territoriali_on_trv_territorio_aggregazioni_territoriali_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void aggregazioni_territoriali_on_btn_annulla_clicked (GtkButton *button, +static void territorio_aggregazioni_territoriali_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void aggregazioni_territoriali_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_aggregazioni_territoriali_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define AGGREGAZIONI_TERRITORIALI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_AGGREGAZIONI_TERRITORIALI, AggregazioniTerritorialiPrivate)) +#define TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI, TerritorioAggregazioniTerritorialiPrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _AggregazioniTerritorialiPrivate AggregazioniTerritorialiPrivate; -struct _AggregazioniTerritorialiPrivate +typedef struct _TerritorioAggregazioniTerritorialiPrivate TerritorioAggregazioniTerritorialiPrivate; +struct _TerritorioAggregazioniTerritorialiPrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _AggregazioniTerritorialiPrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (AggregazioniTerritoriali, aggregazioni_territoriali, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioAggregazioniTerritoriali, territorio_aggregazioni_territoriali, G_TYPE_OBJECT) static void -aggregazioni_territoriali_class_init (AggregazioniTerritorialiClass *klass) +territorio_aggregazioni_territoriali_class_init (TerritorioAggregazioniTerritorialiClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (AggregazioniTerritorialiPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioAggregazioniTerritorialiPrivate)); - object_class->set_property = aggregazioni_territoriali_set_property; - object_class->get_property = aggregazioni_territoriali_get_property; + object_class->set_property = territorio_aggregazioni_territoriali_set_property; + object_class->get_property = territorio_aggregazioni_territoriali_get_property; /** - * AggregazioniTerritoriali::selezionato: - * @aggregazioni_territoriali: + * TerritorioAggregazioniTerritoriali::selezionato: + * @territorio_aggregazioni_territoriali: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ aggregazioni_territoriali_class_init (AggregazioniTerritorialiClass *klass) } static void -aggregazioni_territoriali_init (AggregazioniTerritoriali *aggregazioni_territoriali) +territorio_aggregazioni_territoriali_init (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali) { - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); } /** - * aggregazioni_territoriali_new: + * territorio_aggregazioni_territoriali_new: * @commons: * @selezione: * - * Returns: the newly created #AggregazioniTerritoriali object. + * Returns: the newly created #TerritorioAggregazioniTerritoriali object. */ -AggregazioniTerritoriali -*aggregazioni_territoriali_new (Commons *commons, gboolean selezione) +TerritorioAggregazioniTerritoriali +*territorio_aggregazioni_territoriali_new (Commons *commons, gboolean selezione) { GError *error; - AggregazioniTerritoriali *a = AGGREGAZIONI_TERRITORIALI (g_object_new (aggregazioni_territoriali_get_type (), NULL)); + TerritorioAggregazioniTerritoriali *a = TERRITORIO_AGGREGAZIONI_TERRITORIALI (g_object_new (territorio_aggregazioni_territoriali_get_type (), NULL)); - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (a); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ AggregazioniTerritoriali } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button36"), - "clicked", G_CALLBACK (aggregazioni_territoriali_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_aggregazioni_territoriali_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button37"), - "clicked", G_CALLBACK (aggregazioni_territoriali_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_aggregazioni_territoriali_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button38"), - "clicked", G_CALLBACK (aggregazioni_territoriali_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_aggregazioni_territoriali_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview6"), - "row-activated", G_CALLBACK (aggregazioni_territoriali_on_trv_aggregazioni_territoriali_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_aggregazioni_territoriali_on_trv_territorio_aggregazioni_territoriali_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label30"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button39"), - "clicked", G_CALLBACK (aggregazioni_territoriali_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_aggregazioni_territoriali_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button40"), - "clicked", G_CALLBACK (aggregazioni_territoriali_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_aggregazioni_territoriali_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ AggregazioniTerritoriali gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button40"))); } - aggregazioni_territoriali_carica (a); + territorio_aggregazioni_territoriali_carica (a); return a; } /** - * aggregazioni_territoriali_get_widget: - * @aggregazioni_territoriali: + * territorio_aggregazioni_territoriali_get_widget: + * @territorio_aggregazioni_territoriali: * */ GtkWidget -*aggregazioni_territoriali_get_widget (AggregazioniTerritoriali *aggregazioni_territoriali) +*territorio_aggregazioni_territoriali_get_widget (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali) { - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); return priv->widget; } /* PRIVATE */ static void -aggregazioni_territoriali_carica (AggregazioniTerritoriali *aggregazioni_territoriali) +territorio_aggregazioni_territoriali_carica (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ aggregazioni_territoriali_carica (AggregazioniTerritoriali *aggregazioni_territo gint rows; gint row; - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); gtk_list_store_clear (priv->lstore_aggregazioni_territoriali); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM aggregazioni_territoriali AS c" + " FROM territorio_aggregazioni_territoriali AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ aggregazioni_territoriali_carica (AggregazioniTerritoriali *aggregazioni_territo } static void -aggregazioni_territoriali_modifica (AggregazioniTerritoriali *aggregazioni_territoriali) +territorio_aggregazioni_territoriali_modifica (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali) { GtkTreeIter iter; gchar *id; - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ aggregazioni_territoriali_modifica (AggregazioniTerritoriali *aggregazioni_terri COL_ID, &id, -1); - AggregazioneTerritoriale *c = aggregazione_territoriale_new (priv->commons, strtol (id, NULL, 10)); + TerritorioAggregazioneTerritoriale *c = territorio_aggregazione_territoriale_new (priv->commons, strtol (id, NULL, 10)); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato), (gpointer)aggregazioni_territoriali); + G_CALLBACK (territorio_aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato), (gpointer)territorio_aggregazioni_territoriali); - w = aggregazione_territoriale_get_widget (c); + w = territorio_aggregazione_territoriale_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ aggregazioni_territoriali_modifica (AggregazioniTerritoriali *aggregazioni_terri } static void -aggregazioni_territoriali_selezionato (AggregazioniTerritoriali *aggregazioni_territoriali) +territorio_aggregazioni_territoriali_selezionato (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali) { GtkTreeIter iter; gchar *id; - AggregazioniTerritorialiClass *klass = AGGREGAZIONI_TERRITORIALI_GET_CLASS (aggregazioni_territoriali); - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiClass *klass = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_CLASS (territorio_aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ aggregazioni_territoriali_selezionato (AggregazioniTerritoriali *aggregazioni_te COL_ID, &id, -1); - g_signal_emit (G_OBJECT (aggregazioni_territoriali), klass->selezionato_signal_id, 0, strtol (id, NULL, 10)); + g_signal_emit (G_OBJECT (territorio_aggregazioni_territoriali), klass->selezionato_signal_id, 0, strtol (id, NULL, 10)); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (aggregazioni_territoriali)); + g_object_unref (G_OBJECT (territorio_aggregazioni_territoriali)); } else { @@ -300,17 +300,17 @@ aggregazioni_territoriali_selezionato (AggregazioniTerritoriali *aggregazioni_te } static void -aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data) +territorio_aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data) { - aggregazioni_territoriali_carica ((AggregazioniTerritoriali *)user_data); + territorio_aggregazioni_territoriali_carica ((TerritorioAggregazioniTerritoriali *)user_data); } static void -aggregazioni_territoriali_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_aggregazioni_territoriali_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - AggregazioniTerritoriali *aggregazioni_territoriali = AGGREGAZIONI_TERRITORIALI (object); + TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali = TERRITORIO_AGGREGAZIONI_TERRITORIALI (object); - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); switch (property_id) { @@ -321,11 +321,11 @@ aggregazioni_territoriali_set_property (GObject *object, guint property_id, cons } static void -aggregazioni_territoriali_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_aggregazioni_territoriali_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - AggregazioniTerritoriali *aggregazioni_territoriali = AGGREGAZIONI_TERRITORIALI (object); + TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali = TERRITORIO_AGGREGAZIONI_TERRITORIALI (object); - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); switch (property_id) { @@ -337,33 +337,33 @@ aggregazioni_territoriali_get_property (GObject *object, guint property_id, GVal /* CALLBACK */ static void -aggregazioni_territoriali_on_btn_nuovo_clicked (GtkButton *button, +territorio_aggregazioni_territoriali_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - AggregazioniTerritoriali *aggregazioni_territoriali = (AggregazioniTerritoriali *)user_data; - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali = (TerritorioAggregazioniTerritoriali *)user_data; + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); - AggregazioneTerritoriale *c = aggregazione_territoriale_new (priv->commons, 0); + TerritorioAggregazioneTerritoriale *c = territorio_aggregazione_territoriale_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato), (gpointer)aggregazioni_territoriali); + G_CALLBACK (territorio_aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato), (gpointer)territorio_aggregazioni_territoriali); - w = aggregazione_territoriale_get_widget (c); + w = territorio_aggregazione_territoriale_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -aggregazioni_territoriali_on_btn_modifica_clicked (GtkButton *button, +territorio_aggregazioni_territoriali_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - aggregazioni_territoriali_modifica ((AggregazioniTerritoriali *)user_data); + territorio_aggregazioni_territoriali_modifica ((TerritorioAggregazioniTerritoriali *)user_data); } static void -aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, +territorio_aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; gchar *id; - AggregazioniTerritoriali *aggregazioni_territoriali = (AggregazioniTerritoriali *)user_data; - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali = (TerritorioAggregazioniTerritoriali *)user_data; + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (territorio_aggregazioni_territoriali); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE aggregazioni_territoriali SET status = 'E' WHERE id = %s", id)); - aggregazioni_territoriali_carica (aggregazioni_territoriali); + territorio_aggregazioni_territoriali_carica (territorio_aggregazioni_territoriali); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, } static void -aggregazioni_territoriali_on_trv_aggregazioni_territoriali_row_activated (GtkTreeView *tree_view, +territorio_aggregazioni_territoriali_on_trv_territorio_aggregazioni_territoriali_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE ((AggregazioniTerritoriali *)user_data); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE ((TerritorioAggregazioniTerritoriali *)user_data); if (priv->selezione) { - aggregazioni_territoriali_selezionato ((AggregazioniTerritoriali *)user_data); + territorio_aggregazioni_territoriali_selezionato ((TerritorioAggregazioniTerritoriali *)user_data); } else { - aggregazioni_territoriali_modifica ((AggregazioniTerritoriali *)user_data); + territorio_aggregazioni_territoriali_modifica ((TerritorioAggregazioniTerritoriali *)user_data); } } static void -aggregazioni_territoriali_on_btn_annulla_clicked (GtkButton *button, +territorio_aggregazioni_territoriali_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE ((AggregazioniTerritoriali *)user_data); + TerritorioAggregazioniTerritorialiPrivate *priv = TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_PRIVATE ((TerritorioAggregazioniTerritoriali *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -aggregazioni_territoriali_on_btn_seleziona_clicked (GtkButton *button, +territorio_aggregazioni_territoriali_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - aggregazioni_territoriali_selezionato ((AggregazioniTerritoriali *)user_data); + territorio_aggregazioni_territoriali_selezionato ((TerritorioAggregazioniTerritoriali *)user_data); } diff --git a/src/aggregazioniterritoriali.h b/src/aggregazioniterritoriali.h index b3773ca..2492f85 100644 --- a/src/aggregazioniterritoriali.h +++ b/src/aggregazioniterritoriali.h @@ -17,8 +17,8 @@ * */ -#ifndef __AGGREGAZIONI_TERRITORIALI_H__ -#define __AGGREGAZIONI_TERRITORIALI_H__ +#ifndef __TERRITORIO_AGGREGAZIONI_TERRITORIALI_H__ +#define __TERRITORIO_AGGREGAZIONI_TERRITORIALI_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_AGGREGAZIONI_TERRITORIALI (aggregazioni_territoriali_get_type ()) -#define AGGREGAZIONI_TERRITORIALI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_AGGREGAZIONI_TERRITORIALI, AggregazioniTerritoriali)) -#define AGGREGAZIONI_TERRITORIALI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_AGGREGAZIONI_TERRITORIALI, AggregazioniTerritorialiClass)) -#define IS_AGGREGAZIONI_TERRITORIALI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_AGGREGAZIONI_TERRITORIALI)) -#define IS_AGGREGAZIONI_TERRITORIALI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_AGGREGAZIONI_TERRITORIALI)) -#define AGGREGAZIONI_TERRITORIALI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_AGGREGAZIONI_TERRITORIALI, AggregazioniTerritorialiClass)) +#define TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI (territorio_aggregazioni_territoriali_get_type ()) +#define TERRITORIO_AGGREGAZIONI_TERRITORIALI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI, TerritorioAggregazioniTerritoriali)) +#define TERRITORIO_AGGREGAZIONI_TERRITORIALI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI, TerritorioAggregazioniTerritorialiClass)) +#define IS_TERRITORIO_AGGREGAZIONI_TERRITORIALI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI)) +#define IS_TERRITORIO_AGGREGAZIONI_TERRITORIALI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI)) +#define TERRITORIO_AGGREGAZIONI_TERRITORIALI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_AGGREGAZIONI_TERRITORIALI, TerritorioAggregazioniTerritorialiClass)) -typedef struct _AggregazioniTerritoriali AggregazioniTerritoriali; -typedef struct _AggregazioniTerritorialiClass AggregazioniTerritorialiClass; +typedef struct _TerritorioAggregazioniTerritoriali TerritorioAggregazioniTerritoriali; +typedef struct _TerritorioAggregazioniTerritorialiClass TerritorioAggregazioniTerritorialiClass; -struct _AggregazioniTerritoriali +struct _TerritorioAggregazioniTerritoriali { GObject parent; }; -struct _AggregazioniTerritorialiClass +struct _TerritorioAggregazioniTerritorialiClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType aggregazioni_territoriali_get_type (void) G_GNUC_CONST; +GType territorio_aggregazioni_territoriali_get_type (void) G_GNUC_CONST; -AggregazioniTerritoriali *aggregazioni_territoriali_new (Commons *commons, gboolean selezione); +TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali_new (Commons *commons, gboolean selezione); -GtkWidget *aggregazioni_territoriali_get_widget (AggregazioniTerritoriali *aggregazioni_territoriali); +GtkWidget *territorio_aggregazioni_territoriali_get_widget (TerritorioAggregazioniTerritoriali *territorio_aggregazioni_territoriali); G_END_DECLS -#endif /* __AGGREGAZIONI_TERRITORIALI_H__ */ +#endif /* __TERRITORIO_AGGREGAZIONI_TERRITORIALI_H__ */ diff --git a/src/comune.c b/src/comune.c index b82f903..25af6e4 100644 --- a/src/comune.c +++ b/src/comune.c @@ -22,46 +22,46 @@ #include "comune.h" #include "province.h" -static void comune_class_init (ComuneClass *klass); -static void comune_init (Comune *comune); +static void territorio_comune_class_init (TerritorioComuneClass *klass); +static void territorio_comune_init (TerritorioComune *territorio_comune); -static void comune_carica (Comune *comune); -static void comune_salva (Comune *comune); +static void territorio_comune_carica (TerritorioComune *territorio_comune); +static void territorio_comune_salva (TerritorioComune *territorio_comune); -static gboolean comune_conferma_chiusura (Comune *comune); +static gboolean territorio_comune_conferma_chiusura (TerritorioComune *territorio_comune); -static void comune_set_property (GObject *object, +static void territorio_comune_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void comune_get_property (GObject *object, +static void territorio_comune_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void comune_on_provincia_selezionato (gpointer instance, guint id, gpointer user_data); +static void territorio_comune_on_provincia_selezionato (gpointer instance, guint id, gpointer user_data); -static gboolean comune_on_w_comune_delete_event (GtkWidget *widget, +static gboolean territorio_comune_on_w_comune_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void comune_on_btn_provincia_clicked (GtkButton *button, +static void territorio_comune_on_btn_provincia_clicked (GtkButton *button, gpointer user_data); -static void comune_on_btn_annulla_clicked (GtkButton *button, +static void territorio_comune_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void comune_on_btn_salva_clicked (GtkButton *button, +static void territorio_comune_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define COMUNE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_COMUNE, ComunePrivate)) +#define TERRITORIO_COMUNE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_COMUNE, TerritorioComunePrivate)) enum { LBL_ID }; -typedef struct _ComunePrivate ComunePrivate; -struct _ComunePrivate +typedef struct _TerritorioComunePrivate TerritorioComunePrivate; +struct _TerritorioComunePrivate { Commons *commons; @@ -74,21 +74,21 @@ struct _ComunePrivate gint id; }; -G_DEFINE_TYPE (Comune, comune, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioComune, territorio_comune, G_TYPE_OBJECT) static void -comune_class_init (ComuneClass *klass) +territorio_comune_class_init (TerritorioComuneClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (ComunePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioComunePrivate)); - object_class->set_property = comune_set_property; - object_class->get_property = comune_get_property; + object_class->set_property = territorio_comune_set_property; + object_class->get_property = territorio_comune_get_property; /** - * Comune::aggiornato: - * @comune: + * TerritorioComune::aggiornato: + * @territorio_comune: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -103,26 +103,26 @@ comune_class_init (ComuneClass *klass) } static void -comune_init (Comune *comune) +territorio_comune_init (TerritorioComune *territorio_comune) { - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); } /** - * comune_new: + * territorio_comune_new: * @commons: * @id: * - * Returns: the newly created #Comune object. + * Returns: the newly created #TerritorioComune object. */ -Comune -*comune_new (Commons *commons, gint id) +TerritorioComune +*territorio_comune_new (Commons *commons, gint id) { GError *error; - Comune *a = COMUNE (g_object_new (comune_get_type (), NULL)); + TerritorioComune *a = TERRITORIO_COMUNE (g_object_new (territorio_comune_get_type (), NULL)); - ComunePrivate *priv = COMUNE_GET_PRIVATE (a); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (a); priv->commons = commons; @@ -147,15 +147,15 @@ Comune NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (comune_on_w_comune_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_comune_on_w_comune_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button44"), - "clicked", G_CALLBACK (comune_on_btn_provincia_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_comune_on_btn_provincia_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button27"), - "clicked", G_CALLBACK (comune_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_comune_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button28"), - "clicked", G_CALLBACK (comune_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_comune_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -168,30 +168,30 @@ Comune else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - comune_carica (a); + territorio_comune_carica (a); } return a; } /** - * comune_get_widget: - * @comune: + * territorio_comune_get_widget: + * @territorio_comune: * */ GtkWidget -*comune_get_widget (Comune *comune) +*territorio_comune_get_widget (TerritorioComune *territorio_comune) { - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); return priv->w; } /* PRIVATE */ static void -comune_carica (Comune *comune) +territorio_comune_carica (TerritorioComune *territorio_comune) { - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); if (gtk_form_fill_from_table (priv->form)) { @@ -199,7 +199,7 @@ comune_carica (Comune *comune) } static void -comune_salva (Comune *comune) +territorio_comune_salva (TerritorioComune *territorio_comune) { GError *error = NULL; gchar *sql; @@ -208,9 +208,9 @@ comune_salva (Comune *comune) GDate *da; GDate *a; - ComuneClass *klass = COMUNE_GET_CLASS (comune); + TerritorioComuneClass *klass = TERRITORIO_COMUNE_GET_CLASS (territorio_comune); - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -228,7 +228,7 @@ comune_salva (Comune *comune) if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (comune, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_comune, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -263,11 +263,11 @@ comune_salva (Comune *comune) } static void -comune_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_comune_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Comune *comune = COMUNE (object); + TerritorioComune *territorio_comune = TERRITORIO_COMUNE (object); - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); switch (property_id) { @@ -278,11 +278,11 @@ comune_set_property (GObject *object, guint property_id, const GValue *value, GP } static void -comune_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_comune_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Comune *comune = COMUNE (object); + TerritorioComune *territorio_comune = TERRITORIO_COMUNE (object); - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); switch (property_id) { @@ -293,13 +293,13 @@ comune_get_property (GObject *object, guint property_id, GValue *value, GParamSp } static gboolean -comune_conferma_chiusura (Comune *comune) +territorio_comune_conferma_chiusura (TerritorioComune *territorio_comune) { GtkWidget *dialog; gboolean ret; - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -321,56 +321,56 @@ comune_conferma_chiusura (Comune *comune) /* CALLBACK */ static void -comune_on_provincia_selezionato (gpointer instance, guint id, gpointer user_data) +territorio_comune_on_provincia_selezionato (gpointer instance, guint id, gpointer user_data) { - Comune *f = (Comune *)user_data; - ComunePrivate *priv = COMUNE_GET_PRIVATE (f); + TerritorioComune *f = (TerritorioComune *)user_data; + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (f); gtk_form_widget_set_value_stringify (gtk_form_get_form_widget_from_name (priv->form, "label38"), g_strdup_printf ("%d", id)); } static gboolean -comune_on_w_comune_delete_event (GtkWidget *widget, +territorio_comune_on_w_comune_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !comune_conferma_chiusura ((Comune *)user_data); + return !territorio_comune_conferma_chiusura ((TerritorioComune *)user_data); } static void -comune_on_btn_provincia_clicked (GtkButton *button, +territorio_comune_on_btn_provincia_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Comune *rf = (Comune *)user_data; + TerritorioComune *rf = (TerritorioComune *)user_data; - ComunePrivate *priv = COMUNE_GET_PRIVATE (rf); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (rf); - Province *c = province_new (priv->commons, TRUE); + TerritorioProvince *c = territorio_province_new (priv->commons, TRUE); g_signal_connect (G_OBJECT (c), "selezionato", - G_CALLBACK (comune_on_provincia_selezionato), user_data); + G_CALLBACK (territorio_comune_on_provincia_selezionato), user_data); - w = province_get_widget (c); + w = territorio_province_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), GTK_WINDOW (priv->w)); gtk_widget_show (w); } static void -comune_on_btn_annulla_clicked (GtkButton *button, +territorio_comune_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - Comune *comune = (Comune *)user_data; + TerritorioComune *territorio_comune = (TerritorioComune *)user_data; - ComunePrivate *priv = COMUNE_GET_PRIVATE (comune); + TerritorioComunePrivate *priv = TERRITORIO_COMUNE_GET_PRIVATE (territorio_comune); - if (comune_conferma_chiusura (comune)) gtk_widget_destroy (priv->w); + if (territorio_comune_conferma_chiusura (territorio_comune)) gtk_widget_destroy (priv->w); } static void -comune_on_btn_salva_clicked (GtkButton *button, +territorio_comune_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - comune_salva ((Comune *)user_data); + territorio_comune_salva ((TerritorioComune *)user_data); } diff --git a/src/comune.h b/src/comune.h index c7fe4ac..655cb0f 100644 --- a/src/comune.h +++ b/src/comune.h @@ -17,8 +17,8 @@ * */ -#ifndef __COMUNE_H__ -#define __COMUNE_H__ +#ifndef __TERRITORIO_COMUNE_H__ +#define __TERRITORIO_COMUNE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_COMUNE (comune_get_type ()) -#define COMUNE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_COMUNE, Comune)) -#define COMUNE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_COMUNE, ComuneClass)) -#define IS_COMUNE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_COMUNE)) -#define IS_COMUNE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_COMUNE)) -#define COMUNE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_COMUNE, ComuneClass)) +#define TYPE_TERRITORIO_COMUNE (territorio_comune_get_type ()) +#define TERRITORIO_COMUNE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_COMUNE, TerritorioComune)) +#define TERRITORIO_COMUNE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_COMUNE, TerritorioComuneClass)) +#define IS_TERRITORIO_COMUNE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_COMUNE)) +#define IS_TERRITORIO_COMUNE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_COMUNE)) +#define TERRITORIO_COMUNE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_COMUNE, TerritorioComuneClass)) -typedef struct _Comune Comune; -typedef struct _ComuneClass ComuneClass; +typedef struct _TerritorioComune TerritorioComune; +typedef struct _TerritorioComuneClass TerritorioComuneClass; -struct _Comune +struct _TerritorioComune { GObject parent; }; -struct _ComuneClass +struct _TerritorioComuneClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType comune_get_type (void) G_GNUC_CONST; +GType territorio_comune_get_type (void) G_GNUC_CONST; -Comune *comune_new (Commons *commons, gint id); +TerritorioComune *territorio_comune_new (Commons *commons, gint id); -GtkWidget *comune_get_widget (Comune *comune); +GtkWidget *territorio_comune_get_widget (TerritorioComune *territorio_comune); G_END_DECLS -#endif /* __COMUNE_H__ */ +#endif /* __TERRITORIO_COMUNE_H__ */ diff --git a/src/comuni.c b/src/comuni.c index 512b557..0929214 100644 --- a/src/comuni.c +++ b/src/comuni.c @@ -20,41 +20,41 @@ #include "comuni.h" #include "comune.h" -static void comuni_class_init (ComuniClass *klass); -static void comuni_init (Comuni *comuni); +static void territorio_comuni_class_init (TerritorioComuniClass *klass); +static void territorio_comuni_init (TerritorioComuni *territorio_comuni); -static void comuni_carica (Comuni *comuni); -static void comuni_modifica (Comuni *comuni); +static void territorio_comuni_carica (TerritorioComuni *territorio_comuni); +static void territorio_comuni_modifica (TerritorioComuni *territorio_comuni); -static void comuni_selezionato (Comuni *comuni); -static void comuni_on_comune_aggiornato (gpointer instance, gpointer user_data); +static void territorio_comuni_selezionato (TerritorioComuni *territorio_comuni); +static void territorio_comuni_on_comune_aggiornato (gpointer instance, gpointer user_data); -static void comuni_set_property (GObject *object, +static void territorio_comuni_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void comuni_get_property (GObject *object, +static void territorio_comuni_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void comuni_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_comuni_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void comuni_on_btn_modifica_clicked (GtkButton *button, +static void territorio_comuni_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void comuni_on_btn_elimina_clicked (GtkButton *button, +static void territorio_comuni_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void comuni_on_trv_comuni_row_activated (GtkTreeView *tree_view, +static void territorio_comuni_on_trv_territorio_comuni_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void comuni_on_btn_annulla_clicked (GtkButton *button, +static void territorio_comuni_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void comuni_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_comuni_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define COMUNI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_COMUNI, ComuniPrivate)) +#define TERRITORIO_COMUNI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_COMUNI, TerritorioComuniPrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _ComuniPrivate ComuniPrivate; -struct _ComuniPrivate +typedef struct _TerritorioComuniPrivate TerritorioComuniPrivate; +struct _TerritorioComuniPrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _ComuniPrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (Comuni, comuni, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioComuni, territorio_comuni, G_TYPE_OBJECT) static void -comuni_class_init (ComuniClass *klass) +territorio_comuni_class_init (TerritorioComuniClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (ComuniPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioComuniPrivate)); - object_class->set_property = comuni_set_property; - object_class->get_property = comuni_get_property; + object_class->set_property = territorio_comuni_set_property; + object_class->get_property = territorio_comuni_get_property; /** - * Comuni::selezionato: - * @comuni: + * TerritorioComuni::selezionato: + * @territorio_comuni: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ comuni_class_init (ComuniClass *klass) } static void -comuni_init (Comuni *comuni) +territorio_comuni_init (TerritorioComuni *territorio_comuni) { - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); } /** - * comuni_new: + * territorio_comuni_new: * @commons: * @selezione: * - * Returns: the newly created #Comuni object. + * Returns: the newly created #TerritorioComuni object. */ -Comuni -*comuni_new (Commons *commons, gboolean selezione) +TerritorioComuni +*territorio_comuni_new (Commons *commons, gboolean selezione) { GError *error; - Comuni *a = COMUNI (g_object_new (comuni_get_type (), NULL)); + TerritorioComuni *a = TERRITORIO_COMUNI (g_object_new (territorio_comuni_get_type (), NULL)); - ComuniPrivate *priv = COMUNI_GET_PRIVATE (a); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ Comuni } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button22"), - "clicked", G_CALLBACK (comuni_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_comuni_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button23"), - "clicked", G_CALLBACK (comuni_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_comuni_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button24"), - "clicked", G_CALLBACK (comuni_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_comuni_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview4"), - "row-activated", G_CALLBACK (comuni_on_trv_comuni_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_comuni_on_trv_territorio_comuni_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label20"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button25"), - "clicked", G_CALLBACK (comuni_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_comuni_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button26"), - "clicked", G_CALLBACK (comuni_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_comuni_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ Comuni gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button26"))); } - comuni_carica (a); + territorio_comuni_carica (a); return a; } /** - * comuni_get_widget: - * @comuni: + * territorio_comuni_get_widget: + * @territorio_comuni: * */ GtkWidget -*comuni_get_widget (Comuni *comuni) +*territorio_comuni_get_widget (TerritorioComuni *territorio_comuni) { - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); return priv->widget; } /* PRIVATE */ static void -comuni_carica (Comuni *comuni) +territorio_comuni_carica (TerritorioComuni *territorio_comuni) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ comuni_carica (Comuni *comuni) gint rows; gint row; - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); gtk_list_store_clear (priv->lstore_comuni); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM comuni AS c" + " FROM territorio_comuni AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ comuni_carica (Comuni *comuni) } static void -comuni_modifica (Comuni *comuni) +territorio_comuni_modifica (TerritorioComuni *territorio_comuni) { GtkTreeIter iter; guint id; - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ comuni_modifica (Comuni *comuni) COL_ID, &id, -1); - Comune *c = comune_new (priv->commons, id); + TerritorioComune *c = territorio_comune_new (priv->commons, id); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (comuni_on_comune_aggiornato), (gpointer)comuni); + G_CALLBACK (territorio_comuni_on_comune_aggiornato), (gpointer)territorio_comuni); - w = comune_get_widget (c); + w = territorio_comune_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ comuni_modifica (Comuni *comuni) } static void -comuni_selezionato (Comuni *comuni) +territorio_comuni_selezionato (TerritorioComuni *territorio_comuni) { GtkTreeIter iter; guint *id; - ComuniClass *klass = COMUNI_GET_CLASS (comuni); - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniClass *klass = TERRITORIO_COMUNI_GET_CLASS (territorio_comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ comuni_selezionato (Comuni *comuni) COL_ID, &id, -1); - g_signal_emit (G_OBJECT (comuni), klass->selezionato_signal_id, 0, id); + g_signal_emit (G_OBJECT (territorio_comuni), klass->selezionato_signal_id, 0, id); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (comuni)); + g_object_unref (G_OBJECT (territorio_comuni)); } else { @@ -300,17 +300,17 @@ comuni_selezionato (Comuni *comuni) } static void -comuni_on_comune_aggiornato (gpointer instance, gpointer user_data) +territorio_comuni_on_comune_aggiornato (gpointer instance, gpointer user_data) { - comuni_carica ((Comuni *)user_data); + territorio_comuni_carica ((TerritorioComuni *)user_data); } static void -comuni_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_comuni_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Comuni *comuni = COMUNI (object); + TerritorioComuni *territorio_comuni = TERRITORIO_COMUNI (object); - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); switch (property_id) { @@ -321,11 +321,11 @@ comuni_set_property (GObject *object, guint property_id, const GValue *value, GP } static void -comuni_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_comuni_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Comuni *comuni = COMUNI (object); + TerritorioComuni *territorio_comuni = TERRITORIO_COMUNI (object); - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); switch (property_id) { @@ -337,33 +337,33 @@ comuni_get_property (GObject *object, guint property_id, GValue *value, GParamSp /* CALLBACK */ static void -comuni_on_btn_nuovo_clicked (GtkButton *button, +territorio_comuni_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Comuni *comuni = (Comuni *)user_data; - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuni *territorio_comuni = (TerritorioComuni *)user_data; + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); - Comune *c = comune_new (priv->commons, 0); + TerritorioComune *c = territorio_comune_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (comuni_on_comune_aggiornato), (gpointer)comuni); + G_CALLBACK (territorio_comuni_on_comune_aggiornato), (gpointer)territorio_comuni); - w = comune_get_widget (c); + w = territorio_comune_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -comuni_on_btn_modifica_clicked (GtkButton *button, +territorio_comuni_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - comuni_modifica ((Comuni *)user_data); + territorio_comuni_modifica ((TerritorioComuni *)user_data); } static void -comuni_on_btn_elimina_clicked (GtkButton *button, +territorio_comuni_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ comuni_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; guint id; - Comuni *comuni = (Comuni *)user_data; - ComuniPrivate *priv = COMUNI_GET_PRIVATE (comuni); + TerritorioComuni *territorio_comuni = (TerritorioComuni *)user_data; + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE (territorio_comuni); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ comuni_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE comuni SET status = 'E' WHERE id = %d", id)); - comuni_carica (comuni); + territorio_comuni_carica (territorio_comuni); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ comuni_on_btn_elimina_clicked (GtkButton *button, } static void -comuni_on_trv_comuni_row_activated (GtkTreeView *tree_view, +territorio_comuni_on_trv_territorio_comuni_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - ComuniPrivate *priv = COMUNI_GET_PRIVATE ((Comuni *)user_data); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE ((TerritorioComuni *)user_data); if (priv->selezione) { - comuni_selezionato ((Comuni *)user_data); + territorio_comuni_selezionato ((TerritorioComuni *)user_data); } else { - comuni_modifica ((Comuni *)user_data); + territorio_comuni_modifica ((TerritorioComuni *)user_data); } } static void -comuni_on_btn_annulla_clicked (GtkButton *button, +territorio_comuni_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - ComuniPrivate *priv = COMUNI_GET_PRIVATE ((Comuni *)user_data); + TerritorioComuniPrivate *priv = TERRITORIO_COMUNI_GET_PRIVATE ((TerritorioComuni *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -comuni_on_btn_seleziona_clicked (GtkButton *button, +territorio_comuni_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - comuni_selezionato ((Comuni *)user_data); + territorio_comuni_selezionato ((TerritorioComuni *)user_data); } diff --git a/src/comuni.h b/src/comuni.h index c533b95..e6f298e 100644 --- a/src/comuni.h +++ b/src/comuni.h @@ -17,8 +17,8 @@ * */ -#ifndef __COMUNI_H__ -#define __COMUNI_H__ +#ifndef __TERRITORIO_COMUNI_H__ +#define __TERRITORIO_COMUNI_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_COMUNI (comuni_get_type ()) -#define COMUNI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_COMUNI, Comuni)) -#define COMUNI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_COMUNI, ComuniClass)) -#define IS_COMUNI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_COMUNI)) -#define IS_COMUNI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_COMUNI)) -#define COMUNI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_COMUNI, ComuniClass)) +#define TYPE_TERRITORIO_COMUNI (territorio_comuni_get_type ()) +#define TERRITORIO_COMUNI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_COMUNI, TerritorioComuni)) +#define TERRITORIO_COMUNI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_COMUNI, TerritorioComuniClass)) +#define IS_TERRITORIO_COMUNI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_COMUNI)) +#define IS_TERRITORIO_COMUNI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_COMUNI)) +#define TERRITORIO_COMUNI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_COMUNI, TerritorioComuniClass)) -typedef struct _Comuni Comuni; -typedef struct _ComuniClass ComuniClass; +typedef struct _TerritorioComuni TerritorioComuni; +typedef struct _TerritorioComuniClass TerritorioComuniClass; -struct _Comuni +struct _TerritorioComuni { GObject parent; }; -struct _ComuniClass +struct _TerritorioComuniClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType comuni_get_type (void) G_GNUC_CONST; +GType territorio_comuni_get_type (void) G_GNUC_CONST; -Comuni *comuni_new (Commons *commons, gboolean selezione); +TerritorioComuni *territorio_comuni_new (Commons *commons, gboolean selezione); -GtkWidget *comuni_get_widget (Comuni *comuni); +GtkWidget *territorio_comuni_get_widget (TerritorioComuni *territorio_comuni); G_END_DECLS -#endif /* __COMUNI_H__ */ +#endif /* __TERRITORIO_COMUNI_H__ */ diff --git a/src/main.c b/src/main.c index 94ccf7d..d1f01b2 100644 --- a/src/main.c +++ b/src/main.c @@ -63,9 +63,9 @@ on_mnu_view_stati_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - Stati *m = stati_new (commons, FALSE); + TerritorioStati *m = territorio_stati_new (commons, FALSE); - vbx = stati_get_widget (m); + vbx = territorio_stati_get_widget (m); main_set_vbx_body_child (vbx); } @@ -76,9 +76,9 @@ on_mnu_view_regioni_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - Regioni *m = regioni_new (commons, FALSE); + TerritorioRegioni *m = territorio_regioni_new (commons, FALSE); - vbx = regioni_get_widget (m); + vbx = territorio_regioni_get_widget (m); main_set_vbx_body_child (vbx); } @@ -89,9 +89,9 @@ on_mnu_view_province_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - Province *m = province_new (commons, FALSE); + TerritorioProvince *m = territorio_province_new (commons, FALSE); - vbx = province_get_widget (m); + vbx = territorio_province_get_widget (m); main_set_vbx_body_child (vbx); } @@ -102,9 +102,9 @@ on_mnu_view_comuni_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - Comuni *m = comuni_new (commons, FALSE); + TerritorioComuni *m = territorio_comuni_new (commons, FALSE); - vbx = comuni_get_widget (m); + vbx = territorio_comuni_get_widget (m); main_set_vbx_body_child (vbx); } @@ -115,9 +115,9 @@ on_mnu_view_vie_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - Vie *m = vie_new (commons, FALSE); + TerritorioVie *m = territorio_vie_new (commons, FALSE); - vbx = vie_get_widget (m); + vbx = territorio_vie_get_widget (m); main_set_vbx_body_child (vbx); } @@ -128,9 +128,9 @@ on_mnu_tables_tipi_aggregazione_territoriale_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - TipiAggregazioneTerritoriale *m = tipi_aggregazione_territoriale_new (commons, FALSE); + TerritorioTipiAggregazioneTerritoriale *m = territorio_tipi_aggregazione_territoriale_new (commons, FALSE); - vbx = tipi_aggregazione_territoriale_get_widget (m); + vbx = territorio_tipi_aggregazione_territoriale_get_widget (m); main_set_vbx_body_child (vbx); } @@ -141,9 +141,9 @@ on_mnu_tables_aggregazioni_territoriali_activate (GtkMenuItem *menuitem, { GtkWidget *vbx; - AggregazioniTerritoriali *m = aggregazioni_territoriali_new (commons, FALSE); + TerritorioAggregazioniTerritoriali *m = territorio_aggregazioni_territoriali_new (commons, FALSE); - vbx = aggregazioni_territoriali_get_widget (m); + vbx = territorio_aggregazioni_territoriali_get_widget (m); main_set_vbx_body_child (vbx); } diff --git a/src/province.c b/src/province.c index 99bfb2d..bbdb62f 100644 --- a/src/province.c +++ b/src/province.c @@ -20,41 +20,41 @@ #include "province.h" #include "provincia.h" -static void province_class_init (ProvinceClass *klass); -static void province_init (Province *province); +static void territorio_province_class_init (TerritorioProvinceClass *klass); +static void territorio_province_init (TerritorioProvince *territorio_province); -static void province_carica (Province *province); -static void province_modifica (Province *province); +static void territorio_province_carica (TerritorioProvince *territorio_province); +static void territorio_province_modifica (TerritorioProvince *territorio_province); -static void province_selezionato (Province *province); -static void province_on_provincia_aggiornato (gpointer instance, gpointer user_data); +static void territorio_province_selezionato (TerritorioProvince *territorio_province); +static void territorio_province_on_provincia_aggiornato (gpointer instance, gpointer user_data); -static void province_set_property (GObject *object, +static void territorio_province_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void province_get_property (GObject *object, +static void territorio_province_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void province_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_province_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void province_on_btn_modifica_clicked (GtkButton *button, +static void territorio_province_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void province_on_btn_elimina_clicked (GtkButton *button, +static void territorio_province_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void province_on_trv_province_row_activated (GtkTreeView *tree_view, +static void territorio_province_on_trv_territorio_province_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void province_on_btn_annulla_clicked (GtkButton *button, +static void territorio_province_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void province_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_province_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define PROVINCE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_PROVINCE, ProvincePrivate)) +#define TERRITORIO_PROVINCE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_PROVINCE, TerritorioProvincePrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _ProvincePrivate ProvincePrivate; -struct _ProvincePrivate +typedef struct _TerritorioProvincePrivate TerritorioProvincePrivate; +struct _TerritorioProvincePrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _ProvincePrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (Province, province, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioProvince, territorio_province, G_TYPE_OBJECT) static void -province_class_init (ProvinceClass *klass) +territorio_province_class_init (TerritorioProvinceClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (ProvincePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioProvincePrivate)); - object_class->set_property = province_set_property; - object_class->get_property = province_get_property; + object_class->set_property = territorio_province_set_property; + object_class->get_property = territorio_province_get_property; /** - * Province::selezionato: - * @province: + * TerritorioProvince::selezionato: + * @territorio_province: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ province_class_init (ProvinceClass *klass) } static void -province_init (Province *province) +territorio_province_init (TerritorioProvince *territorio_province) { - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); } /** - * province_new: + * territorio_province_new: * @commons: * @selezione: * - * Returns: the newly created #Province object. + * Returns: the newly created #TerritorioProvince object. */ -Province -*province_new (Commons *commons, gboolean selezione) +TerritorioProvince +*territorio_province_new (Commons *commons, gboolean selezione) { GError *error; - Province *a = PROVINCE (g_object_new (province_get_type (), NULL)); + TerritorioProvince *a = TERRITORIO_PROVINCE (g_object_new (territorio_province_get_type (), NULL)); - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (a); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ Province } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button15"), - "clicked", G_CALLBACK (province_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_province_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button16"), - "clicked", G_CALLBACK (province_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_province_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button17"), - "clicked", G_CALLBACK (province_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_province_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview3"), - "row-activated", G_CALLBACK (province_on_trv_province_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_province_on_trv_territorio_province_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label13"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button18"), - "clicked", G_CALLBACK (province_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_province_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button19"), - "clicked", G_CALLBACK (province_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_province_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ Province gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button19"))); } - province_carica (a); + territorio_province_carica (a); return a; } /** - * province_get_widget: - * @province: + * territorio_province_get_widget: + * @territorio_province: * */ GtkWidget -*province_get_widget (Province *province) +*territorio_province_get_widget (TerritorioProvince *territorio_province) { - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); return priv->widget; } /* PRIVATE */ static void -province_carica (Province *province) +territorio_province_carica (TerritorioProvince *territorio_province) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ province_carica (Province *province) gint rows; gint row; - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); gtk_list_store_clear (priv->lstore_province); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM province AS c" + " FROM territorio_province AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ province_carica (Province *province) } static void -province_modifica (Province *province) +territorio_province_modifica (TerritorioProvince *territorio_province) { GtkTreeIter iter; guint id; - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ province_modifica (Province *province) COL_ID, &id, -1); - Provincia *c = provincia_new (priv->commons, id); + TerritorioProvincia *c = territorio_provincia_new (priv->commons, id); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (province_on_provincia_aggiornato), (gpointer)province); + G_CALLBACK (territorio_province_on_provincia_aggiornato), (gpointer)territorio_province); - w = provincia_get_widget (c); + w = territorio_provincia_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ province_modifica (Province *province) } static void -province_selezionato (Province *province) +territorio_province_selezionato (TerritorioProvince *territorio_province) { GtkTreeIter iter; guint *id; - ProvinceClass *klass = PROVINCE_GET_CLASS (province); - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvinceClass *klass = TERRITORIO_PROVINCE_GET_CLASS (territorio_province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ province_selezionato (Province *province) COL_ID, &id, -1); - g_signal_emit (G_OBJECT (province), klass->selezionato_signal_id, 0, id); + g_signal_emit (G_OBJECT (territorio_province), klass->selezionato_signal_id, 0, id); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (province)); + g_object_unref (G_OBJECT (territorio_province)); } else { @@ -300,17 +300,17 @@ province_selezionato (Province *province) } static void -province_on_provincia_aggiornato (gpointer instance, gpointer user_data) +territorio_province_on_provincia_aggiornato (gpointer instance, gpointer user_data) { - province_carica ((Province *)user_data); + territorio_province_carica ((TerritorioProvince *)user_data); } static void -province_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_province_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Province *province = PROVINCE (object); + TerritorioProvince *territorio_province = TERRITORIO_PROVINCE (object); - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); switch (property_id) { @@ -321,11 +321,11 @@ province_set_property (GObject *object, guint property_id, const GValue *value, } static void -province_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_province_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Province *province = PROVINCE (object); + TerritorioProvince *territorio_province = TERRITORIO_PROVINCE (object); - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); switch (property_id) { @@ -337,33 +337,33 @@ province_get_property (GObject *object, guint property_id, GValue *value, GParam /* CALLBACK */ static void -province_on_btn_nuovo_clicked (GtkButton *button, +territorio_province_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Province *province = (Province *)user_data; - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvince *territorio_province = (TerritorioProvince *)user_data; + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); - Provincia *c = provincia_new (priv->commons, 0); + TerritorioProvincia *c = territorio_provincia_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (province_on_provincia_aggiornato), (gpointer)province); + G_CALLBACK (territorio_province_on_provincia_aggiornato), (gpointer)territorio_province); - w = provincia_get_widget (c); + w = territorio_provincia_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -province_on_btn_modifica_clicked (GtkButton *button, +territorio_province_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - province_modifica ((Province *)user_data); + territorio_province_modifica ((TerritorioProvince *)user_data); } static void -province_on_btn_elimina_clicked (GtkButton *button, +territorio_province_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ province_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; guint id; - Province *province = (Province *)user_data; - ProvincePrivate *priv = PROVINCE_GET_PRIVATE (province); + TerritorioProvince *territorio_province = (TerritorioProvince *)user_data; + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE (territorio_province); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ province_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE province SET status = 'E' WHERE id = %d", id)); - province_carica (province); + territorio_province_carica (territorio_province); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ province_on_btn_elimina_clicked (GtkButton *button, } static void -province_on_trv_province_row_activated (GtkTreeView *tree_view, +territorio_province_on_trv_territorio_province_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - ProvincePrivate *priv = PROVINCE_GET_PRIVATE ((Province *)user_data); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE ((TerritorioProvince *)user_data); if (priv->selezione) { - province_selezionato ((Province *)user_data); + territorio_province_selezionato ((TerritorioProvince *)user_data); } else { - province_modifica ((Province *)user_data); + territorio_province_modifica ((TerritorioProvince *)user_data); } } static void -province_on_btn_annulla_clicked (GtkButton *button, +territorio_province_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - ProvincePrivate *priv = PROVINCE_GET_PRIVATE ((Province *)user_data); + TerritorioProvincePrivate *priv = TERRITORIO_PROVINCE_GET_PRIVATE ((TerritorioProvince *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -province_on_btn_seleziona_clicked (GtkButton *button, +territorio_province_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - province_selezionato ((Province *)user_data); + territorio_province_selezionato ((TerritorioProvince *)user_data); } diff --git a/src/province.h b/src/province.h index 5c3da36..95ad06b 100644 --- a/src/province.h +++ b/src/province.h @@ -17,8 +17,8 @@ * */ -#ifndef __PROVINCE_H__ -#define __PROVINCE_H__ +#ifndef __TERRITORIO_PROVINCE_H__ +#define __TERRITORIO_PROVINCE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_PROVINCE (province_get_type ()) -#define PROVINCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PROVINCE, Province)) -#define PROVINCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PROVINCE, ProvinceClass)) -#define IS_PROVINCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PROVINCE)) -#define IS_PROVINCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PROVINCE)) -#define PROVINCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PROVINCE, ProvinceClass)) +#define TYPE_TERRITORIO_PROVINCE (territorio_province_get_type ()) +#define TERRITORIO_PROVINCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_PROVINCE, TerritorioProvince)) +#define TERRITORIO_PROVINCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_PROVINCE, TerritorioProvinceClass)) +#define IS_TERRITORIO_PROVINCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_PROVINCE)) +#define IS_TERRITORIO_PROVINCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_PROVINCE)) +#define TERRITORIO_PROVINCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_PROVINCE, TerritorioProvinceClass)) -typedef struct _Province Province; -typedef struct _ProvinceClass ProvinceClass; +typedef struct _TerritorioProvince TerritorioProvince; +typedef struct _TerritorioProvinceClass TerritorioProvinceClass; -struct _Province +struct _TerritorioProvince { GObject parent; }; -struct _ProvinceClass +struct _TerritorioProvinceClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType province_get_type (void) G_GNUC_CONST; +GType territorio_province_get_type (void) G_GNUC_CONST; -Province *province_new (Commons *commons, gboolean selezione); +TerritorioProvince *territorio_province_new (Commons *commons, gboolean selezione); -GtkWidget *province_get_widget (Province *province); +GtkWidget *territorio_province_get_widget (TerritorioProvince *territorio_province); G_END_DECLS -#endif /* __PROVINCE_H__ */ +#endif /* __TERRITORIO_PROVINCE_H__ */ diff --git a/src/provincia.c b/src/provincia.c index 9ac5edb..d0a2da4 100644 --- a/src/provincia.c +++ b/src/provincia.c @@ -22,46 +22,46 @@ #include "provincia.h" #include "regioni.h" -static void provincia_class_init (ProvinciaClass *klass); -static void provincia_init (Provincia *provincia); +static void territorio_provincia_class_init (TerritorioProvinciaClass *klass); +static void territorio_provincia_init (TerritorioProvincia *territorio_provincia); -static void provincia_carica (Provincia *provincia); -static void provincia_salva (Provincia *provincia); +static void territorio_provincia_carica (TerritorioProvincia *territorio_provincia); +static void territorio_provincia_salva (TerritorioProvincia *territorio_provincia); -static gboolean provincia_conferma_chiusura (Provincia *provincia); +static gboolean territorio_provincia_conferma_chiusura (TerritorioProvincia *territorio_provincia); -static void provincia_set_property (GObject *object, +static void territorio_provincia_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void provincia_get_property (GObject *object, +static void territorio_provincia_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void provincia_on_regione_selezionato (gpointer instance, guint id, gpointer user_data); +static void territorio_provincia_on_regione_selezionato (gpointer instance, guint id, gpointer user_data); -static gboolean provincia_on_w_provincia_delete_event (GtkWidget *widget, +static gboolean territorio_provincia_on_w_provincia_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void provincia_on_btn_regione_clicked (GtkButton *button, +static void territorio_provincia_on_btn_regione_clicked (GtkButton *button, gpointer user_data); -static void provincia_on_btn_annulla_clicked (GtkButton *button, +static void territorio_provincia_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void provincia_on_btn_salva_clicked (GtkButton *button, +static void territorio_provincia_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define PROVINCIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_PROVINCIA, ProvinciaPrivate)) +#define TERRITORIO_PROVINCIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_PROVINCIA, TerritorioProvinciaPrivate)) enum { LBL_ID }; -typedef struct _ProvinciaPrivate ProvinciaPrivate; -struct _ProvinciaPrivate +typedef struct _TerritorioProvinciaPrivate TerritorioProvinciaPrivate; +struct _TerritorioProvinciaPrivate { Commons *commons; @@ -74,21 +74,21 @@ struct _ProvinciaPrivate gint id; }; -G_DEFINE_TYPE (Provincia, provincia, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioProvincia, territorio_provincia, G_TYPE_OBJECT) static void -provincia_class_init (ProvinciaClass *klass) +territorio_provincia_class_init (TerritorioProvinciaClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (ProvinciaPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioProvinciaPrivate)); - object_class->set_property = provincia_set_property; - object_class->get_property = provincia_get_property; + object_class->set_property = territorio_provincia_set_property; + object_class->get_property = territorio_provincia_get_property; /** - * Provincia::aggiornato: - * @provincia: + * TerritorioProvincia::aggiornato: + * @territorio_provincia: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -103,26 +103,26 @@ provincia_class_init (ProvinciaClass *klass) } static void -provincia_init (Provincia *provincia) +territorio_provincia_init (TerritorioProvincia *territorio_provincia) { - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); } /** - * provincia_new: + * territorio_provincia_new: * @commons: * @id: * - * Returns: the newly created #Provincia object. + * Returns: the newly created #TerritorioProvincia object. */ -Provincia -*provincia_new (Commons *commons, gint id) +TerritorioProvincia +*territorio_provincia_new (Commons *commons, gint id) { GError *error; - Provincia *a = PROVINCIA (g_object_new (provincia_get_type (), NULL)); + TerritorioProvincia *a = TERRITORIO_PROVINCIA (g_object_new (territorio_provincia_get_type (), NULL)); - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (a); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (a); priv->commons = commons; @@ -147,15 +147,15 @@ Provincia NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (provincia_on_w_provincia_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_provincia_on_w_provincia_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button43"), - "clicked", G_CALLBACK (provincia_on_btn_regione_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_provincia_on_btn_regione_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button20"), - "clicked", G_CALLBACK (provincia_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_provincia_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button21"), - "clicked", G_CALLBACK (provincia_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_provincia_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -168,30 +168,30 @@ Provincia else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - provincia_carica (a); + territorio_provincia_carica (a); } return a; } /** - * provincia_get_widget: - * @provincia: + * territorio_provincia_get_widget: + * @territorio_provincia: * */ GtkWidget -*provincia_get_widget (Provincia *provincia) +*territorio_provincia_get_widget (TerritorioProvincia *territorio_provincia) { - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); return priv->w; } /* PRIVATE */ static void -provincia_carica (Provincia *provincia) +territorio_provincia_carica (TerritorioProvincia *territorio_provincia) { - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); if (gtk_form_fill_from_table (priv->form)) { @@ -199,7 +199,7 @@ provincia_carica (Provincia *provincia) } static void -provincia_salva (Provincia *provincia) +territorio_provincia_salva (TerritorioProvincia *territorio_provincia) { GError *error = NULL; gchar *sql; @@ -208,9 +208,9 @@ provincia_salva (Provincia *provincia) GDate *da; GDate *a; - ProvinciaClass *klass = PROVINCIA_GET_CLASS (provincia); + TerritorioProvinciaClass *klass = TERRITORIO_PROVINCIA_GET_CLASS (territorio_provincia); - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -228,7 +228,7 @@ provincia_salva (Provincia *provincia) if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (provincia, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_provincia, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -263,11 +263,11 @@ provincia_salva (Provincia *provincia) } static void -provincia_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_provincia_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Provincia *provincia = PROVINCIA (object); + TerritorioProvincia *territorio_provincia = TERRITORIO_PROVINCIA (object); - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); switch (property_id) { @@ -278,11 +278,11 @@ provincia_set_property (GObject *object, guint property_id, const GValue *value, } static void -provincia_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_provincia_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Provincia *provincia = PROVINCIA (object); + TerritorioProvincia *territorio_provincia = TERRITORIO_PROVINCIA (object); - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); switch (property_id) { @@ -293,13 +293,13 @@ provincia_get_property (GObject *object, guint property_id, GValue *value, GPara } static gboolean -provincia_conferma_chiusura (Provincia *provincia) +territorio_provincia_conferma_chiusura (TerritorioProvincia *territorio_provincia) { GtkWidget *dialog; gboolean ret; - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -321,56 +321,56 @@ provincia_conferma_chiusura (Provincia *provincia) /* CALLBACK */ static void -provincia_on_regione_selezionato (gpointer instance, guint id, gpointer user_data) +territorio_provincia_on_regione_selezionato (gpointer instance, guint id, gpointer user_data) { - Provincia *f = (Provincia *)user_data; - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (f); + TerritorioProvincia *f = (TerritorioProvincia *)user_data; + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (f); gtk_form_widget_set_value_stringify (gtk_form_get_form_widget_from_name (priv->form, "label36"), g_strdup_printf ("%d", id)); } static gboolean -provincia_on_w_provincia_delete_event (GtkWidget *widget, +territorio_provincia_on_w_provincia_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !provincia_conferma_chiusura ((Provincia *)user_data); + return !territorio_provincia_conferma_chiusura ((TerritorioProvincia *)user_data); } static void -provincia_on_btn_regione_clicked (GtkButton *button, +territorio_provincia_on_btn_regione_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Provincia *rf = (Provincia *)user_data; + TerritorioProvincia *rf = (TerritorioProvincia *)user_data; - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (rf); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (rf); - Regioni *c = regioni_new (priv->commons, TRUE); + TerritorioRegioni *c = territorio_regioni_new (priv->commons, TRUE); g_signal_connect (G_OBJECT (c), "selezionato", - G_CALLBACK (provincia_on_regione_selezionato), user_data); + G_CALLBACK (territorio_provincia_on_regione_selezionato), user_data); - w = regioni_get_widget (c); + w = territorio_regioni_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), GTK_WINDOW (priv->w)); gtk_widget_show (w); } static void -provincia_on_btn_annulla_clicked (GtkButton *button, +territorio_provincia_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - Provincia *provincia = (Provincia *)user_data; + TerritorioProvincia *territorio_provincia = (TerritorioProvincia *)user_data; - ProvinciaPrivate *priv = PROVINCIA_GET_PRIVATE (provincia); + TerritorioProvinciaPrivate *priv = TERRITORIO_PROVINCIA_GET_PRIVATE (territorio_provincia); - if (provincia_conferma_chiusura (provincia)) gtk_widget_destroy (priv->w); + if (territorio_provincia_conferma_chiusura (territorio_provincia)) gtk_widget_destroy (priv->w); } static void -provincia_on_btn_salva_clicked (GtkButton *button, +territorio_provincia_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - provincia_salva ((Provincia *)user_data); + territorio_provincia_salva ((TerritorioProvincia *)user_data); } diff --git a/src/provincia.h b/src/provincia.h index bd8db4d..a228232 100644 --- a/src/provincia.h +++ b/src/provincia.h @@ -17,8 +17,8 @@ * */ -#ifndef __PROVINCIA_H__ -#define __PROVINCIA_H__ +#ifndef __TERRITORIO_PROVINCIA_H__ +#define __TERRITORIO_PROVINCIA_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_PROVINCIA (provincia_get_type ()) -#define PROVINCIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PROVINCIA, Provincia)) -#define PROVINCIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PROVINCIA, ProvinciaClass)) -#define IS_PROVINCIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PROVINCIA)) -#define IS_PROVINCIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PROVINCIA)) -#define PROVINCIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PROVINCIA, ProvinciaClass)) +#define TYPE_TERRITORIO_PROVINCIA (territorio_provincia_get_type ()) +#define TERRITORIO_PROVINCIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_PROVINCIA, TerritorioProvincia)) +#define TERRITORIO_PROVINCIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_PROVINCIA, TerritorioProvinciaClass)) +#define IS_TERRITORIO_PROVINCIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_PROVINCIA)) +#define IS_TERRITORIO_PROVINCIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_PROVINCIA)) +#define TERRITORIO_PROVINCIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_PROVINCIA, TerritorioProvinciaClass)) -typedef struct _Provincia Provincia; -typedef struct _ProvinciaClass ProvinciaClass; +typedef struct _TerritorioProvincia TerritorioProvincia; +typedef struct _TerritorioProvinciaClass TerritorioProvinciaClass; -struct _Provincia +struct _TerritorioProvincia { GObject parent; }; -struct _ProvinciaClass +struct _TerritorioProvinciaClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType provincia_get_type (void) G_GNUC_CONST; +GType territorio_provincia_get_type (void) G_GNUC_CONST; -Provincia *provincia_new (Commons *commons, gint id); +TerritorioProvincia *territorio_provincia_new (Commons *commons, gint id); -GtkWidget *provincia_get_widget (Provincia *provincia); +GtkWidget *territorio_provincia_get_widget (TerritorioProvincia *territorio_provincia); G_END_DECLS -#endif /* __PROVINCIA_H__ */ +#endif /* __TERRITORIO_PROVINCIA_H__ */ diff --git a/src/regione.c b/src/regione.c index 315a4ad..08c0749 100644 --- a/src/regione.c +++ b/src/regione.c @@ -21,41 +21,41 @@ #include "regione.h" -static void regione_class_init (RegioneClass *klass); -static void regione_init (Regione *regione); +static void territorio_regione_class_init (TerritorioRegioneClass *klass); +static void territorio_regione_init (TerritorioRegione *territorio_regione); -static void regione_carica (Regione *regione); -static void regione_salva (Regione *regione); +static void territorio_regione_carica (TerritorioRegione *territorio_regione); +static void territorio_regione_salva (TerritorioRegione *territorio_regione); -static gboolean regione_conferma_chiusura (Regione *regione); +static gboolean territorio_regione_conferma_chiusura (TerritorioRegione *territorio_regione); -static void regione_set_property (GObject *object, +static void territorio_regione_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void regione_get_property (GObject *object, +static void territorio_regione_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static gboolean regione_on_w_regione_delete_event (GtkWidget *widget, +static gboolean territorio_regione_on_w_regione_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void regione_on_btn_annulla_clicked (GtkButton *button, +static void territorio_regione_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void regione_on_btn_salva_clicked (GtkButton *button, +static void territorio_regione_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define REGIONE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_REGIONE, RegionePrivate)) +#define TERRITORIO_REGIONE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_REGIONE, TerritorioRegionePrivate)) enum { LBL_ID }; -typedef struct _RegionePrivate RegionePrivate; -struct _RegionePrivate +typedef struct _TerritorioRegionePrivate TerritorioRegionePrivate; +struct _TerritorioRegionePrivate { Commons *commons; @@ -68,21 +68,21 @@ struct _RegionePrivate gint id; }; -G_DEFINE_TYPE (Regione, regione, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioRegione, territorio_regione, G_TYPE_OBJECT) static void -regione_class_init (RegioneClass *klass) +territorio_regione_class_init (TerritorioRegioneClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (RegionePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioRegionePrivate)); - object_class->set_property = regione_set_property; - object_class->get_property = regione_get_property; + object_class->set_property = territorio_regione_set_property; + object_class->get_property = territorio_regione_get_property; /** - * Regione::aggiornato: - * @regione: + * TerritorioRegione::aggiornato: + * @territorio_regione: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -97,26 +97,26 @@ regione_class_init (RegioneClass *klass) } static void -regione_init (Regione *regione) +territorio_regione_init (TerritorioRegione *territorio_regione) { - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); } /** - * regione_new: + * territorio_regione_new: * @commons: * @id: * - * Returns: the newly created #Regione object. + * Returns: the newly created #TerritorioRegione object. */ -Regione -*regione_new (Commons *commons, gint id) +TerritorioRegione +*territorio_regione_new (Commons *commons, gint id) { GError *error; - Regione *a = REGIONE (g_object_new (regione_get_type (), NULL)); + TerritorioRegione *a = TERRITORIO_REGIONE (g_object_new (territorio_regione_get_type (), NULL)); - RegionePrivate *priv = REGIONE_GET_PRIVATE (a); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (a); priv->commons = commons; @@ -141,12 +141,12 @@ Regione NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (regione_on_w_regione_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_regione_on_w_regione_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button13"), - "clicked", G_CALLBACK (regione_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_regione_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button14"), - "clicked", G_CALLBACK (regione_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_regione_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -159,30 +159,30 @@ Regione else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - regione_carica (a); + territorio_regione_carica (a); } return a; } /** - * regione_get_widget: - * @regione: + * territorio_regione_get_widget: + * @territorio_regione: * */ GtkWidget -*regione_get_widget (Regione *regione) +*territorio_regione_get_widget (TerritorioRegione *territorio_regione) { - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); return priv->w; } /* PRIVATE */ static void -regione_carica (Regione *regione) +territorio_regione_carica (TerritorioRegione *territorio_regione) { - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); if (gtk_form_fill_from_table (priv->form)) { @@ -190,7 +190,7 @@ regione_carica (Regione *regione) } static void -regione_salva (Regione *regione) +territorio_regione_salva (TerritorioRegione *territorio_regione) { GError *error = NULL; gchar *sql; @@ -199,9 +199,9 @@ regione_salva (Regione *regione) GDate *da; GDate *a; - RegioneClass *klass = REGIONE_GET_CLASS (regione); + TerritorioRegioneClass *klass = TERRITORIO_REGIONE_GET_CLASS (territorio_regione); - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -219,7 +219,7 @@ regione_salva (Regione *regione) if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (regione, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_regione, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -254,11 +254,11 @@ regione_salva (Regione *regione) } static void -regione_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_regione_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Regione *regione = REGIONE (object); + TerritorioRegione *territorio_regione = TERRITORIO_REGIONE (object); - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); switch (property_id) { @@ -269,11 +269,11 @@ regione_set_property (GObject *object, guint property_id, const GValue *value, G } static void -regione_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_regione_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Regione *regione = REGIONE (object); + TerritorioRegione *territorio_regione = TERRITORIO_REGIONE (object); - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); switch (property_id) { @@ -284,13 +284,13 @@ regione_get_property (GObject *object, guint property_id, GValue *value, GParamS } static gboolean -regione_conferma_chiusura (Regione *regione) +territorio_regione_conferma_chiusura (TerritorioRegione *territorio_regione) { GtkWidget *dialog; gboolean ret; - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -312,27 +312,27 @@ regione_conferma_chiusura (Regione *regione) /* CALLBACK */ static gboolean -regione_on_w_regione_delete_event (GtkWidget *widget, +territorio_regione_on_w_regione_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !regione_conferma_chiusura ((Regione *)user_data); + return !territorio_regione_conferma_chiusura ((TerritorioRegione *)user_data); } static void -regione_on_btn_annulla_clicked (GtkButton *button, +territorio_regione_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - Regione *regione = (Regione *)user_data; + TerritorioRegione *territorio_regione = (TerritorioRegione *)user_data; - RegionePrivate *priv = REGIONE_GET_PRIVATE (regione); + TerritorioRegionePrivate *priv = TERRITORIO_REGIONE_GET_PRIVATE (territorio_regione); - if (regione_conferma_chiusura (regione)) gtk_widget_destroy (priv->w); + if (territorio_regione_conferma_chiusura (territorio_regione)) gtk_widget_destroy (priv->w); } static void -regione_on_btn_salva_clicked (GtkButton *button, +territorio_regione_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - regione_salva ((Regione *)user_data); + territorio_regione_salva ((TerritorioRegione *)user_data); } diff --git a/src/regione.h b/src/regione.h index 4c2e8a7..425295c 100644 --- a/src/regione.h +++ b/src/regione.h @@ -17,8 +17,8 @@ * */ -#ifndef __REGIONE_H__ -#define __REGIONE_H__ +#ifndef __TERRITORIO_REGIONE_H__ +#define __TERRITORIO_REGIONE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_REGIONE (regione_get_type ()) -#define REGIONE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REGIONE, Regione)) -#define REGIONE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REGIONE, RegioneClass)) -#define IS_REGIONE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REGIONE)) -#define IS_REGIONE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REGIONE)) -#define REGIONE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REGIONE, RegioneClass)) +#define TYPE_TERRITORIO_REGIONE (territorio_regione_get_type ()) +#define TERRITORIO_REGIONE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_REGIONE, TerritorioRegione)) +#define TERRITORIO_REGIONE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_REGIONE, TerritorioRegioneClass)) +#define IS_TERRITORIO_REGIONE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_REGIONE)) +#define IS_TERRITORIO_REGIONE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_REGIONE)) +#define TERRITORIO_REGIONE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_REGIONE, TerritorioRegioneClass)) -typedef struct _Regione Regione; -typedef struct _RegioneClass RegioneClass; +typedef struct _TerritorioRegione TerritorioRegione; +typedef struct _TerritorioRegioneClass TerritorioRegioneClass; -struct _Regione +struct _TerritorioRegione { GObject parent; }; -struct _RegioneClass +struct _TerritorioRegioneClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType regione_get_type (void) G_GNUC_CONST; +GType territorio_regione_get_type (void) G_GNUC_CONST; -Regione *regione_new (Commons *commons, gint id); +TerritorioRegione *territorio_regione_new (Commons *commons, gint id); -GtkWidget *regione_get_widget (Regione *regione); +GtkWidget *territorio_regione_get_widget (TerritorioRegione *territorio_regione); G_END_DECLS -#endif /* __REGIONE_H__ */ +#endif /* __TERRITORIO_REGIONE_H__ */ diff --git a/src/regioni.c b/src/regioni.c index 7a5746b..5637785 100644 --- a/src/regioni.c +++ b/src/regioni.c @@ -20,41 +20,41 @@ #include "regioni.h" #include "regione.h" -static void regioni_class_init (RegioniClass *klass); -static void regioni_init (Regioni *regioni); +static void territorio_regioni_class_init (TerritorioRegioniClass *klass); +static void territorio_regioni_init (TerritorioRegioni *territorio_regioni); -static void regioni_carica (Regioni *regioni); -static void regioni_modifica (Regioni *regioni); +static void territorio_regioni_carica (TerritorioRegioni *territorio_regioni); +static void territorio_regioni_modifica (TerritorioRegioni *territorio_regioni); -static void regioni_selezionato (Regioni *regioni); -static void regioni_on_regione_aggiornato (gpointer instance, gpointer user_data); +static void territorio_regioni_selezionato (TerritorioRegioni *territorio_regioni); +static void territorio_regioni_on_regione_aggiornato (gpointer instance, gpointer user_data); -static void regioni_set_property (GObject *object, +static void territorio_regioni_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void regioni_get_property (GObject *object, +static void territorio_regioni_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void regioni_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_regioni_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void regioni_on_btn_modifica_clicked (GtkButton *button, +static void territorio_regioni_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void regioni_on_btn_elimina_clicked (GtkButton *button, +static void territorio_regioni_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void regioni_on_trv_regioni_row_activated (GtkTreeView *tree_view, +static void territorio_regioni_on_trv_territorio_regioni_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void regioni_on_btn_annulla_clicked (GtkButton *button, +static void territorio_regioni_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void regioni_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_regioni_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define REGIONI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_REGIONI, RegioniPrivate)) +#define TERRITORIO_REGIONI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_REGIONI, TerritorioRegioniPrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _RegioniPrivate RegioniPrivate; -struct _RegioniPrivate +typedef struct _TerritorioRegioniPrivate TerritorioRegioniPrivate; +struct _TerritorioRegioniPrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _RegioniPrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (Regioni, regioni, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioRegioni, territorio_regioni, G_TYPE_OBJECT) static void -regioni_class_init (RegioniClass *klass) +territorio_regioni_class_init (TerritorioRegioniClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (RegioniPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioRegioniPrivate)); - object_class->set_property = regioni_set_property; - object_class->get_property = regioni_get_property; + object_class->set_property = territorio_regioni_set_property; + object_class->get_property = territorio_regioni_get_property; /** - * Regioni::selezionato: - * @regioni: + * TerritorioRegioni::selezionato: + * @territorio_regioni: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ regioni_class_init (RegioniClass *klass) } static void -regioni_init (Regioni *regioni) +territorio_regioni_init (TerritorioRegioni *territorio_regioni) { - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); } /** - * regioni_new: + * territorio_regioni_new: * @commons: * @selezione: * - * Returns: the newly created #Regioni object. + * Returns: the newly created #TerritorioRegioni object. */ -Regioni -*regioni_new (Commons *commons, gboolean selezione) +TerritorioRegioni +*territorio_regioni_new (Commons *commons, gboolean selezione) { GError *error; - Regioni *a = REGIONI (g_object_new (regioni_get_type (), NULL)); + TerritorioRegioni *a = TERRITORIO_REGIONI (g_object_new (territorio_regioni_get_type (), NULL)); - RegioniPrivate *priv = REGIONI_GET_PRIVATE (a); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ Regioni } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button8"), - "clicked", G_CALLBACK (regioni_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_regioni_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button9"), - "clicked", G_CALLBACK (regioni_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_regioni_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button10"), - "clicked", G_CALLBACK (regioni_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_regioni_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview2"), - "row-activated", G_CALLBACK (regioni_on_trv_regioni_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_regioni_on_trv_territorio_regioni_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label9"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button11"), - "clicked", G_CALLBACK (regioni_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_regioni_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button12"), - "clicked", G_CALLBACK (regioni_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_regioni_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ Regioni gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button12"))); } - regioni_carica (a); + territorio_regioni_carica (a); return a; } /** - * regioni_get_widget: - * @regioni: + * territorio_regioni_get_widget: + * @territorio_regioni: * */ GtkWidget -*regioni_get_widget (Regioni *regioni) +*territorio_regioni_get_widget (TerritorioRegioni *territorio_regioni) { - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); return priv->widget; } /* PRIVATE */ static void -regioni_carica (Regioni *regioni) +territorio_regioni_carica (TerritorioRegioni *territorio_regioni) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ regioni_carica (Regioni *regioni) gint rows; gint row; - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); gtk_list_store_clear (priv->lstore_regioni); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM regioni AS c" + " FROM territorio_regioni AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ regioni_carica (Regioni *regioni) } static void -regioni_modifica (Regioni *regioni) +territorio_regioni_modifica (TerritorioRegioni *territorio_regioni) { GtkTreeIter iter; guint id; - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ regioni_modifica (Regioni *regioni) COL_ID, &id, -1); - Regione *c = regione_new (priv->commons, id); + TerritorioRegione *c = territorio_regione_new (priv->commons, id); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (regioni_on_regione_aggiornato), (gpointer)regioni); + G_CALLBACK (territorio_regioni_on_regione_aggiornato), (gpointer)territorio_regioni); - w = regione_get_widget (c); + w = territorio_regione_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ regioni_modifica (Regioni *regioni) } static void -regioni_selezionato (Regioni *regioni) +territorio_regioni_selezionato (TerritorioRegioni *territorio_regioni) { GtkTreeIter iter; guint *id; - RegioniClass *klass = REGIONI_GET_CLASS (regioni); - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniClass *klass = TERRITORIO_REGIONI_GET_CLASS (territorio_regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ regioni_selezionato (Regioni *regioni) COL_ID, &id, -1); - g_signal_emit (G_OBJECT (regioni), klass->selezionato_signal_id, 0, id); + g_signal_emit (G_OBJECT (territorio_regioni), klass->selezionato_signal_id, 0, id); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (regioni)); + g_object_unref (G_OBJECT (territorio_regioni)); } else { @@ -300,17 +300,17 @@ regioni_selezionato (Regioni *regioni) } static void -regioni_on_regione_aggiornato (gpointer instance, gpointer user_data) +territorio_regioni_on_regione_aggiornato (gpointer instance, gpointer user_data) { - regioni_carica ((Regioni *)user_data); + territorio_regioni_carica ((TerritorioRegioni *)user_data); } static void -regioni_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_regioni_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Regioni *regioni = REGIONI (object); + TerritorioRegioni *territorio_regioni = TERRITORIO_REGIONI (object); - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); switch (property_id) { @@ -321,11 +321,11 @@ regioni_set_property (GObject *object, guint property_id, const GValue *value, G } static void -regioni_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_regioni_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Regioni *regioni = REGIONI (object); + TerritorioRegioni *territorio_regioni = TERRITORIO_REGIONI (object); - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); switch (property_id) { @@ -337,33 +337,33 @@ regioni_get_property (GObject *object, guint property_id, GValue *value, GParamS /* CALLBACK */ static void -regioni_on_btn_nuovo_clicked (GtkButton *button, +territorio_regioni_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Regioni *regioni = (Regioni *)user_data; - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioni *territorio_regioni = (TerritorioRegioni *)user_data; + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); - Regione *c = regione_new (priv->commons, 0); + TerritorioRegione *c = territorio_regione_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (regioni_on_regione_aggiornato), (gpointer)regioni); + G_CALLBACK (territorio_regioni_on_regione_aggiornato), (gpointer)territorio_regioni); - w = regione_get_widget (c); + w = territorio_regione_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -regioni_on_btn_modifica_clicked (GtkButton *button, +territorio_regioni_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - regioni_modifica ((Regioni *)user_data); + territorio_regioni_modifica ((TerritorioRegioni *)user_data); } static void -regioni_on_btn_elimina_clicked (GtkButton *button, +territorio_regioni_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ regioni_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; guint id; - Regioni *regioni = (Regioni *)user_data; - RegioniPrivate *priv = REGIONI_GET_PRIVATE (regioni); + TerritorioRegioni *territorio_regioni = (TerritorioRegioni *)user_data; + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE (territorio_regioni); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ regioni_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE regioni SET status = 'E' WHERE id = %d", id)); - regioni_carica (regioni); + territorio_regioni_carica (territorio_regioni); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ regioni_on_btn_elimina_clicked (GtkButton *button, } static void -regioni_on_trv_regioni_row_activated (GtkTreeView *tree_view, +territorio_regioni_on_trv_territorio_regioni_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - RegioniPrivate *priv = REGIONI_GET_PRIVATE ((Regioni *)user_data); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE ((TerritorioRegioni *)user_data); if (priv->selezione) { - regioni_selezionato ((Regioni *)user_data); + territorio_regioni_selezionato ((TerritorioRegioni *)user_data); } else { - regioni_modifica ((Regioni *)user_data); + territorio_regioni_modifica ((TerritorioRegioni *)user_data); } } static void -regioni_on_btn_annulla_clicked (GtkButton *button, +territorio_regioni_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - RegioniPrivate *priv = REGIONI_GET_PRIVATE ((Regioni *)user_data); + TerritorioRegioniPrivate *priv = TERRITORIO_REGIONI_GET_PRIVATE ((TerritorioRegioni *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -regioni_on_btn_seleziona_clicked (GtkButton *button, +territorio_regioni_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - regioni_selezionato ((Regioni *)user_data); + territorio_regioni_selezionato ((TerritorioRegioni *)user_data); } diff --git a/src/regioni.h b/src/regioni.h index 5f4f3cc..1c4308b 100644 --- a/src/regioni.h +++ b/src/regioni.h @@ -17,8 +17,8 @@ * */ -#ifndef __REGIONI_H__ -#define __REGIONI_H__ +#ifndef __TERRITORIO_REGIONI_H__ +#define __TERRITORIO_REGIONI_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_REGIONI (regioni_get_type ()) -#define REGIONI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REGIONI, Regioni)) -#define REGIONI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REGIONI, RegioniClass)) -#define IS_REGIONI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REGIONI)) -#define IS_REGIONI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REGIONI)) -#define REGIONI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REGIONI, RegioniClass)) +#define TYPE_TERRITORIO_REGIONI (territorio_regioni_get_type ()) +#define TERRITORIO_REGIONI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_REGIONI, TerritorioRegioni)) +#define TERRITORIO_REGIONI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_REGIONI, TerritorioRegioniClass)) +#define IS_TERRITORIO_REGIONI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_REGIONI)) +#define IS_TERRITORIO_REGIONI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_REGIONI)) +#define TERRITORIO_REGIONI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_REGIONI, TerritorioRegioniClass)) -typedef struct _Regioni Regioni; -typedef struct _RegioniClass RegioniClass; +typedef struct _TerritorioRegioni TerritorioRegioni; +typedef struct _TerritorioRegioniClass TerritorioRegioniClass; -struct _Regioni +struct _TerritorioRegioni { GObject parent; }; -struct _RegioniClass +struct _TerritorioRegioniClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType regioni_get_type (void) G_GNUC_CONST; +GType territorio_regioni_get_type (void) G_GNUC_CONST; -Regioni *regioni_new (Commons *commons, gboolean selezione); +TerritorioRegioni *territorio_regioni_new (Commons *commons, gboolean selezione); -GtkWidget *regioni_get_widget (Regioni *regioni); +GtkWidget *territorio_regioni_get_widget (TerritorioRegioni *territorio_regioni); G_END_DECLS -#endif /* __REGIONI_H__ */ +#endif /* __TERRITORIO_REGIONI_H__ */ diff --git a/src/stati.c b/src/stati.c index 1c27fb7..5cd2979 100644 --- a/src/stati.c +++ b/src/stati.c @@ -20,41 +20,41 @@ #include "stati.h" #include "stato.h" -static void stati_class_init (StatiClass *klass); -static void stati_init (Stati *stati); +static void territorio_stati_class_init (TerritorioStatiClass *klass); +static void territorio_stati_init (TerritorioStati *territorio_stati); -static void stati_carica (Stati *stati); -static void stati_modifica (Stati *stati); +static void territorio_stati_carica (TerritorioStati *territorio_stati); +static void territorio_stati_modifica (TerritorioStati *territorio_stati); -static void stati_selezionato (Stati *stati); -static void stati_on_stato_aggiornato (gpointer instance, gpointer user_data); +static void territorio_stati_selezionato (TerritorioStati *territorio_stati); +static void territorio_stati_on_stato_aggiornato (gpointer instance, gpointer user_data); -static void stati_set_property (GObject *object, +static void territorio_stati_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void stati_get_property (GObject *object, +static void territorio_stati_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void stati_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_stati_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void stati_on_btn_modifica_clicked (GtkButton *button, +static void territorio_stati_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void stati_on_btn_elimina_clicked (GtkButton *button, +static void territorio_stati_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void stati_on_trv_stati_row_activated (GtkTreeView *tree_view, +static void territorio_stati_on_trv_stati_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void stati_on_btn_annulla_clicked (GtkButton *button, +static void territorio_stati_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void stati_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_stati_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define STATI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_STATI, StatiPrivate)) +#define TERRITORIO_STATI_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_STATI, TerritorioStatiPrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _StatiPrivate StatiPrivate; -struct _StatiPrivate +typedef struct _TerritorioStatiPrivate TerritorioStatiPrivate; +struct _TerritorioStatiPrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _StatiPrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (Stati, stati, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioStati, territorio_stati, G_TYPE_OBJECT) static void -stati_class_init (StatiClass *klass) +territorio_stati_class_init (TerritorioStatiClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (StatiPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioStatiPrivate)); - object_class->set_property = stati_set_property; - object_class->get_property = stati_get_property; + object_class->set_property = territorio_stati_set_property; + object_class->get_property = territorio_stati_get_property; /** - * Stati::selezionato: - * @stati: + * TerritorioStati::selezionato: + * @territorio_stati: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ stati_class_init (StatiClass *klass) } static void -stati_init (Stati *stati) +territorio_stati_init (TerritorioStati *territorio_stati) { - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); } /** - * stati_new: + * territorio_stati_new: * @commons: * @selezione: * - * Returns: the newly created #Stati object. + * Returns: the newly created #TerritorioStati object. */ -Stati -*stati_new (Commons *commons, gboolean selezione) +TerritorioStati +*territorio_stati_new (Commons *commons, gboolean selezione) { GError *error; - Stati *a = STATI (g_object_new (stati_get_type (), NULL)); + TerritorioStati *a = TERRITORIO_STATI (g_object_new (territorio_stati_get_type (), NULL)); - StatiPrivate *priv = STATI_GET_PRIVATE (a); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ Stati } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button1"), - "clicked", G_CALLBACK (stati_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_stati_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button2"), - "clicked", G_CALLBACK (stati_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_stati_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button3"), - "clicked", G_CALLBACK (stati_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_stati_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview1"), - "row-activated", G_CALLBACK (stati_on_trv_stati_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_stati_on_trv_stati_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label1"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button4"), - "clicked", G_CALLBACK (stati_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_stati_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button5"), - "clicked", G_CALLBACK (stati_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_stati_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ Stati gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button5"))); } - stati_carica (a); + territorio_stati_carica (a); return a; } /** - * stati_get_widget: - * @stati: + * territorio_stati_get_widget: + * @territorio_stati: * */ GtkWidget -*stati_get_widget (Stati *stati) +*territorio_stati_get_widget (TerritorioStati *territorio_stati) { - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); return priv->widget; } /* PRIVATE */ static void -stati_carica (Stati *stati) +territorio_stati_carica (TerritorioStati *territorio_stati) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ stati_carica (Stati *stati) gint rows; gint row; - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); gtk_list_store_clear (priv->lstore_stati); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM stati AS c" + " FROM territorio_stati AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ stati_carica (Stati *stati) } static void -stati_modifica (Stati *stati) +territorio_stati_modifica (TerritorioStati *territorio_stati) { GtkTreeIter iter; guint id; - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ stati_modifica (Stati *stati) COL_ID, &id, -1); - Stato *c = stato_new (priv->commons, id); + TerritorioStato *c = territorio_stato_new (priv->commons, id); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (stati_on_stato_aggiornato), (gpointer)stati); + G_CALLBACK (territorio_stati_on_stato_aggiornato), (gpointer)territorio_stati); - w = stato_get_widget (c); + w = territorio_stato_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ stati_modifica (Stati *stati) } static void -stati_selezionato (Stati *stati) +territorio_stati_selezionato (TerritorioStati *territorio_stati) { GtkTreeIter iter; guint *id; - StatiClass *klass = STATI_GET_CLASS (stati); - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiClass *klass = TERRITORIO_STATI_GET_CLASS (territorio_stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ stati_selezionato (Stati *stati) COL_ID, &id, -1); - g_signal_emit (G_OBJECT (stati), klass->selezionato_signal_id, 0, id); + g_signal_emit (G_OBJECT (territorio_stati), klass->selezionato_signal_id, 0, id); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (stati)); + g_object_unref (G_OBJECT (territorio_stati)); } else { @@ -300,17 +300,17 @@ stati_selezionato (Stati *stati) } static void -stati_on_stato_aggiornato (gpointer instance, gpointer user_data) +territorio_stati_on_stato_aggiornato (gpointer instance, gpointer user_data) { - stati_carica ((Stati *)user_data); + territorio_stati_carica ((TerritorioStati *)user_data); } static void -stati_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_stati_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Stati *stati = STATI (object); + TerritorioStati *territorio_stati = TERRITORIO_STATI (object); - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); switch (property_id) { @@ -321,11 +321,11 @@ stati_set_property (GObject *object, guint property_id, const GValue *value, GPa } static void -stati_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_stati_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Stati *stati = STATI (object); + TerritorioStati *territorio_stati = TERRITORIO_STATI (object); - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); switch (property_id) { @@ -337,33 +337,33 @@ stati_get_property (GObject *object, guint property_id, GValue *value, GParamSpe /* CALLBACK */ static void -stati_on_btn_nuovo_clicked (GtkButton *button, +territorio_stati_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Stati *stati = (Stati *)user_data; - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStati *territorio_stati = (TerritorioStati *)user_data; + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); - Stato *c = stato_new (priv->commons, 0); + TerritorioStato *c = territorio_stato_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (stati_on_stato_aggiornato), (gpointer)stati); + G_CALLBACK (territorio_stati_on_stato_aggiornato), (gpointer)territorio_stati); - w = stato_get_widget (c); + w = territorio_stato_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -stati_on_btn_modifica_clicked (GtkButton *button, +territorio_stati_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - stati_modifica ((Stati *)user_data); + territorio_stati_modifica ((TerritorioStati *)user_data); } static void -stati_on_btn_elimina_clicked (GtkButton *button, +territorio_stati_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ stati_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; guint id; - Stati *stati = (Stati *)user_data; - StatiPrivate *priv = STATI_GET_PRIVATE (stati); + TerritorioStati *territorio_stati = (TerritorioStati *)user_data; + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE (territorio_stati); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ stati_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE stati SET status = 'E' WHERE id = %d", id)); - stati_carica (stati); + territorio_stati_carica (territorio_stati); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ stati_on_btn_elimina_clicked (GtkButton *button, } static void -stati_on_trv_stati_row_activated (GtkTreeView *tree_view, +territorio_stati_on_trv_stati_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - StatiPrivate *priv = STATI_GET_PRIVATE ((Stati *)user_data); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE ((TerritorioStati *)user_data); if (priv->selezione) { - stati_selezionato ((Stati *)user_data); + territorio_stati_selezionato ((TerritorioStati *)user_data); } else { - stati_modifica ((Stati *)user_data); + territorio_stati_modifica ((TerritorioStati *)user_data); } } static void -stati_on_btn_annulla_clicked (GtkButton *button, +territorio_stati_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - StatiPrivate *priv = STATI_GET_PRIVATE ((Stati *)user_data); + TerritorioStatiPrivate *priv = TERRITORIO_STATI_GET_PRIVATE ((TerritorioStati *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -stati_on_btn_seleziona_clicked (GtkButton *button, +territorio_stati_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - stati_selezionato ((Stati *)user_data); + territorio_stati_selezionato ((TerritorioStati *)user_data); } diff --git a/src/stati.h b/src/stati.h index 83e57bf..7a922ad 100644 --- a/src/stati.h +++ b/src/stati.h @@ -17,8 +17,8 @@ * */ -#ifndef __STATI_H__ -#define __STATI_H__ +#ifndef __TERRITORIO_STATI_H__ +#define __TERRITORIO_STATI_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_STATI (stati_get_type ()) -#define STATI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_STATI, Stati)) -#define STATI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_STATI, StatiClass)) -#define IS_STATI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_STATI)) -#define IS_STATI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_STATI)) -#define STATI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_STATI, StatiClass)) +#define TYPE_TERRITORIO_STATI (territorio_stati_get_type ()) +#define TERRITORIO_STATI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_STATI, TerritorioStati)) +#define TERRITORIO_STATI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_STATI, TerritorioStatiClass)) +#define IS_TERRITORIO_STATI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_STATI)) +#define IS_TERRITORIO_STATI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_STATI)) +#define TERRITORIO_STATI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_STATI, TerritorioStatiClass)) -typedef struct _Stati Stati; -typedef struct _StatiClass StatiClass; +typedef struct _TerritorioStati TerritorioStati; +typedef struct _TerritorioStatiClass TerritorioStatiClass; -struct _Stati +struct _TerritorioStati { GObject parent; }; -struct _StatiClass +struct _TerritorioStatiClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType stati_get_type (void) G_GNUC_CONST; +GType territorio_stati_get_type (void) G_GNUC_CONST; -Stati *stati_new (Commons *commons, gboolean selezione); +TerritorioStati *territorio_stati_new (Commons *commons, gboolean selezione); -GtkWidget *stati_get_widget (Stati *stati); +GtkWidget *territorio_stati_get_widget (TerritorioStati *territorio_stati); G_END_DECLS -#endif /* __STATI_H__ */ +#endif /* __TERRITORIO_STATI_H__ */ diff --git a/src/stato.c b/src/stato.c index 2aa9707..6fa3e23 100644 --- a/src/stato.c +++ b/src/stato.c @@ -21,41 +21,41 @@ #include "stato.h" -static void stato_class_init (StatoClass *klass); -static void stato_init (Stato *stato); +static void territorio_stato_class_init (TerritorioStatoClass *klass); +static void territorio_stato_init (TerritorioStato *territorio_stato); -static void stato_carica (Stato *stato); -static void stato_salva (Stato *stato); +static void territorio_stato_carica (TerritorioStato *territorio_stato); +static void territorio_stato_salva (TerritorioStato *territorio_stato); -static gboolean stato_conferma_chiusura (Stato *stato); +static gboolean territorio_stato_conferma_chiusura (TerritorioStato *territorio_stato); -static void stato_set_property (GObject *object, +static void territorio_stato_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void stato_get_property (GObject *object, +static void territorio_stato_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static gboolean stato_on_w_stato_delete_event (GtkWidget *widget, +static gboolean territorio_stato_on_w_stato_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void stato_on_btn_annulla_clicked (GtkButton *button, +static void territorio_stato_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void stato_on_btn_salva_clicked (GtkButton *button, +static void territorio_stato_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define STATO_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_STATO, StatoPrivate)) +#define TERRITORIO_STATO_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_STATO, TerritorioStatoPrivate)) enum { LBL_ID }; -typedef struct _StatoPrivate StatoPrivate; -struct _StatoPrivate +typedef struct _TerritorioStatoPrivate TerritorioStatoPrivate; +struct _TerritorioStatoPrivate { Commons *commons; @@ -68,21 +68,21 @@ struct _StatoPrivate gint id; }; -G_DEFINE_TYPE (Stato, stato, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioStato, territorio_stato, G_TYPE_OBJECT) static void -stato_class_init (StatoClass *klass) +territorio_stato_class_init (TerritorioStatoClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (StatoPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioStatoPrivate)); - object_class->set_property = stato_set_property; - object_class->get_property = stato_get_property; + object_class->set_property = territorio_stato_set_property; + object_class->get_property = territorio_stato_get_property; /** - * Stato::aggiornato: - * @stato: + * TerritorioStato::aggiornato: + * @territorio_stato: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -97,26 +97,26 @@ stato_class_init (StatoClass *klass) } static void -stato_init (Stato *stato) +territorio_stato_init (TerritorioStato *territorio_stato) { - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); } /** - * stato_new: + * territorio_stato_new: * @commons: * @id: * - * Returns: the newly created #Stato object. + * Returns: the newly created #TerritorioStato object. */ -Stato -*stato_new (Commons *commons, gint id) +TerritorioStato +*territorio_stato_new (Commons *commons, gint id) { GError *error; - Stato *a = STATO (g_object_new (stato_get_type (), NULL)); + TerritorioStato *a = TERRITORIO_STATO (g_object_new (territorio_stato_get_type (), NULL)); - StatoPrivate *priv = STATO_GET_PRIVATE (a); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (a); priv->commons = commons; @@ -141,12 +141,12 @@ Stato NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (stato_on_w_stato_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_stato_on_w_stato_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button6"), - "clicked", G_CALLBACK (stato_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_stato_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button7"), - "clicked", G_CALLBACK (stato_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_stato_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -159,30 +159,30 @@ Stato else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - stato_carica (a); + territorio_stato_carica (a); } return a; } /** - * stato_get_widget: - * @stato: + * territorio_stato_get_widget: + * @territorio_stato: * */ GtkWidget -*stato_get_widget (Stato *stato) +*territorio_stato_get_widget (TerritorioStato *territorio_stato) { - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); return priv->w; } /* PRIVATE */ static void -stato_carica (Stato *stato) +territorio_stato_carica (TerritorioStato *territorio_stato) { - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); if (gtk_form_fill_from_table (priv->form)) { @@ -190,7 +190,7 @@ stato_carica (Stato *stato) } static void -stato_salva (Stato *stato) +territorio_stato_salva (TerritorioStato *territorio_stato) { GError *error = NULL; gchar *sql; @@ -199,9 +199,9 @@ stato_salva (Stato *stato) GDate *da; GDate *a; - StatoClass *klass = STATO_GET_CLASS (stato); + TerritorioStatoClass *klass = TERRITORIO_STATO_GET_CLASS (territorio_stato); - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -219,7 +219,7 @@ stato_salva (Stato *stato) if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (stato, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_stato, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -254,11 +254,11 @@ stato_salva (Stato *stato) } static void -stato_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_stato_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Stato *stato = STATO (object); + TerritorioStato *territorio_stato = TERRITORIO_STATO (object); - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); switch (property_id) { @@ -269,11 +269,11 @@ stato_set_property (GObject *object, guint property_id, const GValue *value, GPa } static void -stato_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_stato_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Stato *stato = STATO (object); + TerritorioStato *territorio_stato = TERRITORIO_STATO (object); - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); switch (property_id) { @@ -284,13 +284,13 @@ stato_get_property (GObject *object, guint property_id, GValue *value, GParamSpe } static gboolean -stato_conferma_chiusura (Stato *stato) +territorio_stato_conferma_chiusura (TerritorioStato *territorio_stato) { GtkWidget *dialog; gboolean ret; - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -312,27 +312,27 @@ stato_conferma_chiusura (Stato *stato) /* CALLBACK */ static gboolean -stato_on_w_stato_delete_event (GtkWidget *widget, +territorio_stato_on_w_stato_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !stato_conferma_chiusura ((Stato *)user_data); + return !territorio_stato_conferma_chiusura ((TerritorioStato *)user_data); } static void -stato_on_btn_annulla_clicked (GtkButton *button, +territorio_stato_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - Stato *stato = (Stato *)user_data; + TerritorioStato *territorio_stato = (TerritorioStato *)user_data; - StatoPrivate *priv = STATO_GET_PRIVATE (stato); + TerritorioStatoPrivate *priv = TERRITORIO_STATO_GET_PRIVATE (territorio_stato); - if (stato_conferma_chiusura (stato)) gtk_widget_destroy (priv->w); + if (territorio_stato_conferma_chiusura (territorio_stato)) gtk_widget_destroy (priv->w); } static void -stato_on_btn_salva_clicked (GtkButton *button, +territorio_stato_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - stato_salva ((Stato *)user_data); + territorio_stato_salva ((TerritorioStato *)user_data); } diff --git a/src/stato.h b/src/stato.h index 13949f5..e040527 100644 --- a/src/stato.h +++ b/src/stato.h @@ -17,8 +17,8 @@ * */ -#ifndef __STATO_H__ -#define __STATO_H__ +#ifndef __TERRITORIO_STATO_H__ +#define __TERRITORIO_STATO_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_STATO (stato_get_type ()) -#define STATO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_STATO, Stato)) -#define STATO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_STATO, StatoClass)) -#define IS_STATO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_STATO)) -#define IS_STATO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_STATO)) -#define STATO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_STATO, StatoClass)) +#define TYPE_TERRITORIO_STATO (territorio_stato_get_type ()) +#define TERRITORIO_STATO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_STATO, TerritorioStato)) +#define TERRITORIO_STATO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_STATO, TerritorioStatoClass)) +#define IS_TERRITORIO_STATO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_STATO)) +#define IS_TERRITORIO_STATO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_STATO)) +#define TERRITORIO_STATO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_STATO, TerritorioStatoClass)) -typedef struct _Stato Stato; -typedef struct _StatoClass StatoClass; +typedef struct _TerritorioStato TerritorioStato; +typedef struct _TerritorioStatoClass TerritorioStatoClass; -struct _Stato +struct _TerritorioStato { GObject parent; }; -struct _StatoClass +struct _TerritorioStatoClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType stato_get_type (void) G_GNUC_CONST; +GType territorio_stato_get_type (void) G_GNUC_CONST; -Stato *stato_new (Commons *commons, gint id); +TerritorioStato *territorio_stato_new (Commons *commons, gint id); -GtkWidget *stato_get_widget (Stato *stato); +GtkWidget *territorio_stato_get_widget (TerritorioStato *territorio_stato); G_END_DECLS -#endif /* __STATO_H__ */ +#endif /* __TERRITORIO_STATO_H__ */ diff --git a/src/tipiaggregazioneterritoriale.c b/src/tipiaggregazioneterritoriale.c index 68ff5d5..4869bea 100644 --- a/src/tipiaggregazioneterritoriale.c +++ b/src/tipiaggregazioneterritoriale.c @@ -20,41 +20,41 @@ #include "tipiaggregazioneterritoriale.h" #include "tipoaggregazioneterritoriale.h" -static void tipi_aggregazione_territoriale_class_init (TipiAggregazioneTerritorialeClass *klass); -static void tipi_aggregazione_territoriale_init (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale); +static void territorio_tipi_aggregazione_territoriale_class_init (TerritorioTipiAggregazioneTerritorialeClass *klass); +static void territorio_tipi_aggregazione_territoriale_init (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale); -static void tipi_aggregazione_territoriale_carica (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale); -static void tipi_aggregazione_territoriale_modifica (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale); +static void territorio_tipi_aggregazione_territoriale_carica (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale); +static void territorio_tipi_aggregazione_territoriale_modifica (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale); -static void tipi_aggregazione_territoriale_selezionato (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale); -static void tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data); +static void territorio_tipi_aggregazione_territoriale_selezionato (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale); +static void territorio_tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data); -static void tipi_aggregazione_territoriale_set_property (GObject *object, +static void territorio_tipi_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void tipi_aggregazione_territoriale_get_property (GObject *object, +static void territorio_tipi_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void tipi_aggregazione_territoriale_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_tipi_aggregazione_territoriale_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void tipi_aggregazione_territoriale_on_btn_modifica_clicked (GtkButton *button, +static void territorio_tipi_aggregazione_territoriale_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, +static void territorio_tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void tipi_aggregazione_territoriale_on_trv_tipi_aggregazione_territoriale_row_activated (GtkTreeView *tree_view, +static void territorio_tipi_aggregazione_territoriale_on_trv_tipi_aggregazione_territoriale_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void tipi_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, +static void territorio_tipi_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void tipi_aggregazione_territoriale_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_tipi_aggregazione_territoriale_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TIPI_AGGREGAZIONE_TERRITORIALE, TipiAggregazioneTerritorialePrivate)) +#define TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE, TerritorioTipiAggregazioneTerritorialePrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _TipiAggregazioneTerritorialePrivate TipiAggregazioneTerritorialePrivate; -struct _TipiAggregazioneTerritorialePrivate +typedef struct _TerritorioTipiAggregazioneTerritorialePrivate TerritorioTipiAggregazioneTerritorialePrivate; +struct _TerritorioTipiAggregazioneTerritorialePrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _TipiAggregazioneTerritorialePrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (TipiAggregazioneTerritoriale, tipi_aggregazione_territoriale, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioTipiAggregazioneTerritoriale, territorio_tipi_aggregazione_territoriale, G_TYPE_OBJECT) static void -tipi_aggregazione_territoriale_class_init (TipiAggregazioneTerritorialeClass *klass) +territorio_tipi_aggregazione_territoriale_class_init (TerritorioTipiAggregazioneTerritorialeClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (TipiAggregazioneTerritorialePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioTipiAggregazioneTerritorialePrivate)); - object_class->set_property = tipi_aggregazione_territoriale_set_property; - object_class->get_property = tipi_aggregazione_territoriale_get_property; + object_class->set_property = territorio_tipi_aggregazione_territoriale_set_property; + object_class->get_property = territorio_tipi_aggregazione_territoriale_get_property; /** - * TipiAggregazioneTerritoriale::selezionato: - * @tipi_aggregazione_territoriale: + * TerritorioTipiAggregazioneTerritoriale::selezionato: + * @territorio_tipi_aggregazione_territoriale: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ tipi_aggregazione_territoriale_class_init (TipiAggregazioneTerritorialeClass *kl } static void -tipi_aggregazione_territoriale_init (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale) +territorio_tipi_aggregazione_territoriale_init (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale) { - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); } /** - * tipi_aggregazione_territoriale_new: + * territorio_tipi_aggregazione_territoriale_new: * @commons: * @selezione: * - * Returns: the newly created #TipiAggregazioneTerritoriale object. + * Returns: the newly created #TerritorioTipiAggregazioneTerritoriale object. */ -TipiAggregazioneTerritoriale -*tipi_aggregazione_territoriale_new (Commons *commons, gboolean selezione) +TerritorioTipiAggregazioneTerritoriale +*territorio_tipi_aggregazione_territoriale_new (Commons *commons, gboolean selezione) { GError *error; - TipiAggregazioneTerritoriale *a = TIPI_AGGREGAZIONE_TERRITORIALE (g_object_new (tipi_aggregazione_territoriale_get_type (), NULL)); + TerritorioTipiAggregazioneTerritoriale *a = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE (g_object_new (territorio_tipi_aggregazione_territoriale_get_type (), NULL)); - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ TipiAggregazioneTerritoriale } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button29"), - "clicked", G_CALLBACK (tipi_aggregazione_territoriale_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button30"), - "clicked", G_CALLBACK (tipi_aggregazione_territoriale_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button31"), - "clicked", G_CALLBACK (tipi_aggregazione_territoriale_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview5"), - "row-activated", G_CALLBACK (tipi_aggregazione_territoriale_on_trv_tipi_aggregazione_territoriale_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_trv_tipi_aggregazione_territoriale_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label26"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button32"), - "clicked", G_CALLBACK (tipi_aggregazione_territoriale_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button33"), - "clicked", G_CALLBACK (tipi_aggregazione_territoriale_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ TipiAggregazioneTerritoriale gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button33"))); } - tipi_aggregazione_territoriale_carica (a); + territorio_tipi_aggregazione_territoriale_carica (a); return a; } /** - * tipi_aggregazione_territoriale_get_widget: - * @tipi_aggregazione_territoriale: + * territorio_tipi_aggregazione_territoriale_get_widget: + * @territorio_tipi_aggregazione_territoriale: * */ GtkWidget -*tipi_aggregazione_territoriale_get_widget (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale) +*territorio_tipi_aggregazione_territoriale_get_widget (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale) { - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); return priv->widget; } /* PRIVATE */ static void -tipi_aggregazione_territoriale_carica (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale) +territorio_tipi_aggregazione_territoriale_carica (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ tipi_aggregazione_territoriale_carica (TipiAggregazioneTerritoriale *tipi_aggreg gint rows; gint row; - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); gtk_list_store_clear (priv->lstore_tipi_aggregazione_territoriale); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM tipi_aggregazione_territoriale AS c" + " FROM territorio_tipi_aggregazione_territoriale AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ tipi_aggregazione_territoriale_carica (TipiAggregazioneTerritoriale *tipi_aggreg } static void -tipi_aggregazione_territoriale_modifica (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale) +territorio_tipi_aggregazione_territoriale_modifica (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale) { GtkTreeIter iter; gchar *id; - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ tipi_aggregazione_territoriale_modifica (TipiAggregazioneTerritoriale *tipi_aggr COL_ID, &id, -1); - TipoAggregazioneTerritoriale *c = tipo_aggregazione_territoriale_new (priv->commons, strtol (id, NULL, 10)); + TerritorioTipoAggregazioneTerritoriale *c = territorio_tipo_aggregazione_territoriale_new (priv->commons, strtol (id, NULL, 10)); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato), (gpointer)tipi_aggregazione_territoriale); + G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato), (gpointer)territorio_tipi_aggregazione_territoriale); - w = tipo_aggregazione_territoriale_get_widget (c); + w = territorio_tipo_aggregazione_territoriale_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ tipi_aggregazione_territoriale_modifica (TipiAggregazioneTerritoriale *tipi_aggr } static void -tipi_aggregazione_territoriale_selezionato (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale) +territorio_tipi_aggregazione_territoriale_selezionato (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale) { GtkTreeIter iter; gchar *id; - TipiAggregazioneTerritorialeClass *klass = TIPI_AGGREGAZIONE_TERRITORIALE_GET_CLASS (tipi_aggregazione_territoriale); - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialeClass *klass = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_CLASS (territorio_tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ tipi_aggregazione_territoriale_selezionato (TipiAggregazioneTerritoriale *tipi_a COL_ID, &id, -1); - g_signal_emit (G_OBJECT (tipi_aggregazione_territoriale), klass->selezionato_signal_id, 0, strtol (id, NULL, 10)); + g_signal_emit (G_OBJECT (territorio_tipi_aggregazione_territoriale), klass->selezionato_signal_id, 0, strtol (id, NULL, 10)); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (tipi_aggregazione_territoriale)); + g_object_unref (G_OBJECT (territorio_tipi_aggregazione_territoriale)); } else { @@ -300,17 +300,17 @@ tipi_aggregazione_territoriale_selezionato (TipiAggregazioneTerritoriale *tipi_a } static void -tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data) +territorio_tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data) { - tipi_aggregazione_territoriale_carica ((TipiAggregazioneTerritoriale *)user_data); + territorio_tipi_aggregazione_territoriale_carica ((TerritorioTipiAggregazioneTerritoriale *)user_data); } static void -tipi_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_tipi_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale = TIPI_AGGREGAZIONE_TERRITORIALE (object); + TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE (object); - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); switch (property_id) { @@ -321,11 +321,11 @@ tipi_aggregazione_territoriale_set_property (GObject *object, guint property_id, } static void -tipi_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_tipi_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale = TIPI_AGGREGAZIONE_TERRITORIALE (object); + TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE (object); - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); switch (property_id) { @@ -337,33 +337,33 @@ tipi_aggregazione_territoriale_get_property (GObject *object, guint property_id, /* CALLBACK */ static void -tipi_aggregazione_territoriale_on_btn_nuovo_clicked (GtkButton *button, +territorio_tipi_aggregazione_territoriale_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale = (TipiAggregazioneTerritoriale *)user_data; - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale = (TerritorioTipiAggregazioneTerritoriale *)user_data; + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); - TipoAggregazioneTerritoriale *c = tipo_aggregazione_territoriale_new (priv->commons, 0); + TerritorioTipoAggregazioneTerritoriale *c = territorio_tipo_aggregazione_territoriale_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato), (gpointer)tipi_aggregazione_territoriale); + G_CALLBACK (territorio_tipi_aggregazione_territoriale_on_tipo_aggregazione_territoriale_aggiornato), (gpointer)territorio_tipi_aggregazione_territoriale); - w = tipo_aggregazione_territoriale_get_widget (c); + w = territorio_tipo_aggregazione_territoriale_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -tipi_aggregazione_territoriale_on_btn_modifica_clicked (GtkButton *button, +territorio_tipi_aggregazione_territoriale_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - tipi_aggregazione_territoriale_modifica ((TipiAggregazioneTerritoriale *)user_data); + territorio_tipi_aggregazione_territoriale_modifica ((TerritorioTipiAggregazioneTerritoriale *)user_data); } static void -tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, +territorio_tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; gchar *id; - TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale = (TipiAggregazioneTerritoriale *)user_data; - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipi_aggregazione_territoriale); + TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale = (TerritorioTipiAggregazioneTerritoriale *)user_data; + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipi_aggregazione_territoriale); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE tipi_aggregazione_territoriale SET status = 'E' WHERE id = %s", id)); - tipi_aggregazione_territoriale_carica (tipi_aggregazione_territoriale); + territorio_tipi_aggregazione_territoriale_carica (territorio_tipi_aggregazione_territoriale); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ tipi_aggregazione_territoriale_on_btn_elimina_clicked (GtkButton *button, } static void -tipi_aggregazione_territoriale_on_trv_tipi_aggregazione_territoriale_row_activated (GtkTreeView *tree_view, +territorio_tipi_aggregazione_territoriale_on_trv_tipi_aggregazione_territoriale_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE ((TipiAggregazioneTerritoriale *)user_data); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE ((TerritorioTipiAggregazioneTerritoriale *)user_data); if (priv->selezione) { - tipi_aggregazione_territoriale_selezionato ((TipiAggregazioneTerritoriale *)user_data); + territorio_tipi_aggregazione_territoriale_selezionato ((TerritorioTipiAggregazioneTerritoriale *)user_data); } else { - tipi_aggregazione_territoriale_modifica ((TipiAggregazioneTerritoriale *)user_data); + territorio_tipi_aggregazione_territoriale_modifica ((TerritorioTipiAggregazioneTerritoriale *)user_data); } } static void -tipi_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, +territorio_tipi_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - TipiAggregazioneTerritorialePrivate *priv = TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE ((TipiAggregazioneTerritoriale *)user_data); + TerritorioTipiAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE ((TerritorioTipiAggregazioneTerritoriale *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -tipi_aggregazione_territoriale_on_btn_seleziona_clicked (GtkButton *button, +territorio_tipi_aggregazione_territoriale_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - tipi_aggregazione_territoriale_selezionato ((TipiAggregazioneTerritoriale *)user_data); + territorio_tipi_aggregazione_territoriale_selezionato ((TerritorioTipiAggregazioneTerritoriale *)user_data); } diff --git a/src/tipiaggregazioneterritoriale.h b/src/tipiaggregazioneterritoriale.h index d28e414..b506184 100644 --- a/src/tipiaggregazioneterritoriale.h +++ b/src/tipiaggregazioneterritoriale.h @@ -17,8 +17,8 @@ * */ -#ifndef __TIPI_AGGREGAZIONE_TERRITORIALE_H__ -#define __TIPI_AGGREGAZIONE_TERRITORIALE_H__ +#ifndef __TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_H__ +#define __TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_TIPI_AGGREGAZIONE_TERRITORIALE (tipi_aggregazione_territoriale_get_type ()) -#define TIPI_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIPI_AGGREGAZIONE_TERRITORIALE, TipiAggregazioneTerritoriale)) -#define TIPI_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIPI_AGGREGAZIONE_TERRITORIALE, TipiAggregazioneTerritorialeClass)) -#define IS_TIPI_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIPI_AGGREGAZIONE_TERRITORIALE)) -#define IS_TIPI_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIPI_AGGREGAZIONE_TERRITORIALE)) -#define TIPI_AGGREGAZIONE_TERRITORIALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIPI_AGGREGAZIONE_TERRITORIALE, TipiAggregazioneTerritorialeClass)) +#define TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE (territorio_tipi_aggregazione_territoriale_get_type ()) +#define TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE, TerritorioTipiAggregazioneTerritoriale)) +#define TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE, TerritorioTipiAggregazioneTerritorialeClass)) +#define IS_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE)) +#define IS_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE)) +#define TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE, TerritorioTipiAggregazioneTerritorialeClass)) -typedef struct _TipiAggregazioneTerritoriale TipiAggregazioneTerritoriale; -typedef struct _TipiAggregazioneTerritorialeClass TipiAggregazioneTerritorialeClass; +typedef struct _TerritorioTipiAggregazioneTerritoriale TerritorioTipiAggregazioneTerritoriale; +typedef struct _TerritorioTipiAggregazioneTerritorialeClass TerritorioTipiAggregazioneTerritorialeClass; -struct _TipiAggregazioneTerritoriale +struct _TerritorioTipiAggregazioneTerritoriale { GObject parent; }; -struct _TipiAggregazioneTerritorialeClass +struct _TerritorioTipiAggregazioneTerritorialeClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType tipi_aggregazione_territoriale_get_type (void) G_GNUC_CONST; +GType territorio_tipi_aggregazione_territoriale_get_type (void) G_GNUC_CONST; -TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale_new (Commons *commons, gboolean selezione); +TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale_new (Commons *commons, gboolean selezione); -GtkWidget *tipi_aggregazione_territoriale_get_widget (TipiAggregazioneTerritoriale *tipi_aggregazione_territoriale); +GtkWidget *territorio_tipi_aggregazione_territoriale_get_widget (TerritorioTipiAggregazioneTerritoriale *territorio_tipi_aggregazione_territoriale); G_END_DECLS -#endif /* __TIPI_AGGREGAZIONE_TERRITORIALE_H__ */ +#endif /* __TERRITORIO_TIPI_AGGREGAZIONE_TERRITORIALE_H__ */ diff --git a/src/tipoaggregazioneterritoriale.c b/src/tipoaggregazioneterritoriale.c index fc63131..5e41902 100644 --- a/src/tipoaggregazioneterritoriale.c +++ b/src/tipoaggregazioneterritoriale.c @@ -21,41 +21,41 @@ #include "tipoaggregazioneterritoriale.h" -static void tipo_aggregazione_territoriale_class_init (TipoAggregazioneTerritorialeClass *klass); -static void tipo_aggregazione_territoriale_init (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale); +static void territorio_tipo_aggregazione_territoriale_class_init (TerritorioTipoAggregazioneTerritorialeClass *klass); +static void territorio_tipo_aggregazione_territoriale_init (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale); -static void tipo_aggregazione_territoriale_carica (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale); -static void tipo_aggregazione_territoriale_salva (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale); +static void territorio_tipo_aggregazione_territoriale_carica (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale); +static void territorio_tipo_aggregazione_territoriale_salva (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale); -static gboolean tipo_aggregazione_territoriale_conferma_chiusura (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale); +static gboolean territorio_tipo_aggregazione_territoriale_conferma_chiusura (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale); -static void tipo_aggregazione_territoriale_set_property (GObject *object, +static void territorio_tipo_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void tipo_aggregazione_territoriale_get_property (GObject *object, +static void territorio_tipo_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static gboolean tipo_aggregazione_territoriale_on_w_tipo_aggregazione_territoriale_delete_event (GtkWidget *widget, +static gboolean territorio_tipo_aggregazione_territoriale_on_w_tipo_aggregazione_territoriale_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void tipo_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, +static void territorio_tipo_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void tipo_aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, +static void territorio_tipo_aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TIPO_AGGREGAZIONE_TERRITORIALE, TipoAggregazioneTerritorialePrivate)) +#define TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE, TerritorioTipoAggregazioneTerritorialePrivate)) enum { LBL_ID }; -typedef struct _TipoAggregazioneTerritorialePrivate TipoAggregazioneTerritorialePrivate; -struct _TipoAggregazioneTerritorialePrivate +typedef struct _TerritorioTipoAggregazioneTerritorialePrivate TerritorioTipoAggregazioneTerritorialePrivate; +struct _TerritorioTipoAggregazioneTerritorialePrivate { Commons *commons; @@ -68,21 +68,21 @@ struct _TipoAggregazioneTerritorialePrivate gint id; }; -G_DEFINE_TYPE (TipoAggregazioneTerritoriale, tipo_aggregazione_territoriale, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioTipoAggregazioneTerritoriale, territorio_tipo_aggregazione_territoriale, G_TYPE_OBJECT) static void -tipo_aggregazione_territoriale_class_init (TipoAggregazioneTerritorialeClass *klass) +territorio_tipo_aggregazione_territoriale_class_init (TerritorioTipoAggregazioneTerritorialeClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (TipoAggregazioneTerritorialePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioTipoAggregazioneTerritorialePrivate)); - object_class->set_property = tipo_aggregazione_territoriale_set_property; - object_class->get_property = tipo_aggregazione_territoriale_get_property; + object_class->set_property = territorio_tipo_aggregazione_territoriale_set_property; + object_class->get_property = territorio_tipo_aggregazione_territoriale_get_property; /** - * TipoAggregazioneTerritoriale::aggiornato: - * @tipo_aggregazione_territoriale: + * TerritorioTipoAggregazioneTerritoriale::aggiornato: + * @territorio_tipo_aggregazione_territoriale: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -97,26 +97,26 @@ tipo_aggregazione_territoriale_class_init (TipoAggregazioneTerritorialeClass *kl } static void -tipo_aggregazione_territoriale_init (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale) +territorio_tipo_aggregazione_territoriale_init (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale) { - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); } /** - * tipo_aggregazione_territoriale_new: + * territorio_tipo_aggregazione_territoriale_new: * @commons: * @id: * - * Returns: the newly created #TipoAggregazioneTerritoriale object. + * Returns: the newly created #TerritorioTipoAggregazioneTerritoriale object. */ -TipoAggregazioneTerritoriale -*tipo_aggregazione_territoriale_new (Commons *commons, gint id) +TerritorioTipoAggregazioneTerritoriale +*territorio_tipo_aggregazione_territoriale_new (Commons *commons, gint id) { GError *error; - TipoAggregazioneTerritoriale *a = TIPO_AGGREGAZIONE_TERRITORIALE (g_object_new (tipo_aggregazione_territoriale_get_type (), NULL)); + TerritorioTipoAggregazioneTerritoriale *a = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE (g_object_new (territorio_tipo_aggregazione_territoriale_get_type (), NULL)); - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); priv->commons = commons; @@ -141,12 +141,12 @@ TipoAggregazioneTerritoriale NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (tipo_aggregazione_territoriale_on_w_tipo_aggregazione_territoriale_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_tipo_aggregazione_territoriale_on_w_tipo_aggregazione_territoriale_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button34"), - "clicked", G_CALLBACK (tipo_aggregazione_territoriale_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_tipo_aggregazione_territoriale_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button35"), - "clicked", G_CALLBACK (tipo_aggregazione_territoriale_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_tipo_aggregazione_territoriale_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -159,30 +159,30 @@ TipoAggregazioneTerritoriale else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - tipo_aggregazione_territoriale_carica (a); + territorio_tipo_aggregazione_territoriale_carica (a); } return a; } /** - * tipo_aggregazione_territoriale_get_widget: - * @tipo_aggregazione_territoriale: + * territorio_tipo_aggregazione_territoriale_get_widget: + * @territorio_tipo_aggregazione_territoriale: * */ GtkWidget -*tipo_aggregazione_territoriale_get_widget (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale) +*territorio_tipo_aggregazione_territoriale_get_widget (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale) { - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); return priv->w; } /* PRIVATE */ static void -tipo_aggregazione_territoriale_carica (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale) +territorio_tipo_aggregazione_territoriale_carica (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale) { - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); if (gtk_form_fill_from_table (priv->form)) { @@ -190,7 +190,7 @@ tipo_aggregazione_territoriale_carica (TipoAggregazioneTerritoriale *tipo_aggreg } static void -tipo_aggregazione_territoriale_salva (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale) +territorio_tipo_aggregazione_territoriale_salva (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale) { GError *error = NULL; gchar *sql; @@ -199,9 +199,9 @@ tipo_aggregazione_territoriale_salva (TipoAggregazioneTerritoriale *tipo_aggrega GDate *da; GDate *a; - TipoAggregazioneTerritorialeClass *klass = TIPO_AGGREGAZIONE_TERRITORIALE_GET_CLASS (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialeClass *klass = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_CLASS (territorio_tipo_aggregazione_territoriale); - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -219,7 +219,7 @@ tipo_aggregazione_territoriale_salva (TipoAggregazioneTerritoriale *tipo_aggrega if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (tipo_aggregazione_territoriale, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_tipo_aggregazione_territoriale, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -254,11 +254,11 @@ tipo_aggregazione_territoriale_salva (TipoAggregazioneTerritoriale *tipo_aggrega } static void -tipo_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_tipo_aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale = TIPO_AGGREGAZIONE_TERRITORIALE (object); + TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE (object); - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); switch (property_id) { @@ -269,11 +269,11 @@ tipo_aggregazione_territoriale_set_property (GObject *object, guint property_id, } static void -tipo_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_tipo_aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale = TIPO_AGGREGAZIONE_TERRITORIALE (object); + TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE (object); - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); switch (property_id) { @@ -284,13 +284,13 @@ tipo_aggregazione_territoriale_get_property (GObject *object, guint property_id, } static gboolean -tipo_aggregazione_territoriale_conferma_chiusura (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale) +territorio_tipo_aggregazione_territoriale_conferma_chiusura (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale) { GtkWidget *dialog; gboolean ret; - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -312,27 +312,27 @@ tipo_aggregazione_territoriale_conferma_chiusura (TipoAggregazioneTerritoriale * /* CALLBACK */ static gboolean -tipo_aggregazione_territoriale_on_w_tipo_aggregazione_territoriale_delete_event (GtkWidget *widget, +territorio_tipo_aggregazione_territoriale_on_w_tipo_aggregazione_territoriale_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !tipo_aggregazione_territoriale_conferma_chiusura ((TipoAggregazioneTerritoriale *)user_data); + return !territorio_tipo_aggregazione_territoriale_conferma_chiusura ((TerritorioTipoAggregazioneTerritoriale *)user_data); } static void -tipo_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, +territorio_tipo_aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale = (TipoAggregazioneTerritoriale *)user_data; + TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale = (TerritorioTipoAggregazioneTerritoriale *)user_data; - TipoAggregazioneTerritorialePrivate *priv = TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (tipo_aggregazione_territoriale); + TerritorioTipoAggregazioneTerritorialePrivate *priv = TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (territorio_tipo_aggregazione_territoriale); - if (tipo_aggregazione_territoriale_conferma_chiusura (tipo_aggregazione_territoriale)) gtk_widget_destroy (priv->w); + if (territorio_tipo_aggregazione_territoriale_conferma_chiusura (territorio_tipo_aggregazione_territoriale)) gtk_widget_destroy (priv->w); } static void -tipo_aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, +territorio_tipo_aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - tipo_aggregazione_territoriale_salva ((TipoAggregazioneTerritoriale *)user_data); + territorio_tipo_aggregazione_territoriale_salva ((TerritorioTipoAggregazioneTerritoriale *)user_data); } diff --git a/src/tipoaggregazioneterritoriale.h b/src/tipoaggregazioneterritoriale.h index 2d1144e..75dbf17 100644 --- a/src/tipoaggregazioneterritoriale.h +++ b/src/tipoaggregazioneterritoriale.h @@ -17,8 +17,8 @@ * */ -#ifndef __TIPO_AGGREGAZIONE_TERRITORIALE_H__ -#define __TIPO_AGGREGAZIONE_TERRITORIALE_H__ +#ifndef __TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_H__ +#define __TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_TIPO_AGGREGAZIONE_TERRITORIALE (tipo_aggregazione_territoriale_get_type ()) -#define TIPO_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIPO_AGGREGAZIONE_TERRITORIALE, TipoAggregazioneTerritoriale)) -#define TIPO_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIPO_AGGREGAZIONE_TERRITORIALE, TipoAggregazioneTerritorialeClass)) -#define IS_TIPO_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIPO_AGGREGAZIONE_TERRITORIALE)) -#define IS_TIPO_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIPO_AGGREGAZIONE_TERRITORIALE)) -#define TIPO_AGGREGAZIONE_TERRITORIALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIPO_AGGREGAZIONE_TERRITORIALE, TipoAggregazioneTerritorialeClass)) +#define TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE (territorio_tipo_aggregazione_territoriale_get_type ()) +#define TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE, TerritorioTipoAggregazioneTerritoriale)) +#define TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE, TerritorioTipoAggregazioneTerritorialeClass)) +#define IS_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE)) +#define IS_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE)) +#define TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE, TerritorioTipoAggregazioneTerritorialeClass)) -typedef struct _TipoAggregazioneTerritoriale TipoAggregazioneTerritoriale; -typedef struct _TipoAggregazioneTerritorialeClass TipoAggregazioneTerritorialeClass; +typedef struct _TerritorioTipoAggregazioneTerritoriale TerritorioTipoAggregazioneTerritoriale; +typedef struct _TerritorioTipoAggregazioneTerritorialeClass TerritorioTipoAggregazioneTerritorialeClass; -struct _TipoAggregazioneTerritoriale +struct _TerritorioTipoAggregazioneTerritoriale { GObject parent; }; -struct _TipoAggregazioneTerritorialeClass +struct _TerritorioTipoAggregazioneTerritorialeClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType tipo_aggregazione_territoriale_get_type (void) G_GNUC_CONST; +GType territorio_tipo_aggregazione_territoriale_get_type (void) G_GNUC_CONST; -TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale_new (Commons *commons, gint id); +TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale_new (Commons *commons, gint id); -GtkWidget *tipo_aggregazione_territoriale_get_widget (TipoAggregazioneTerritoriale *tipo_aggregazione_territoriale); +GtkWidget *territorio_tipo_aggregazione_territoriale_get_widget (TerritorioTipoAggregazioneTerritoriale *territorio_tipo_aggregazione_territoriale); G_END_DECLS -#endif /* __TIPO_AGGREGAZIONE_TERRITORIALE_H__ */ +#endif /* __TERRITORIO_TIPO_AGGREGAZIONE_TERRITORIALE_H__ */ diff --git a/src/via.c b/src/via.c index 6bef73e..a8debd8 100644 --- a/src/via.c +++ b/src/via.c @@ -22,46 +22,46 @@ #include "via.h" #include "comuni.h" -static void via_class_init (ViaClass *klass); -static void via_init (Via *via); +static void territorio_via_class_init (TerritorioViaClass *klass); +static void territorio_via_init (TerritorioVia *territorio_via); -static void via_carica (Via *via); -static void via_salva (Via *via); +static void territorio_via_carica (TerritorioVia *territorio_via); +static void territorio_via_salva (TerritorioVia *territorio_via); -static gboolean via_conferma_chiusura (Via *via); +static gboolean territorio_via_conferma_chiusura (TerritorioVia *territorio_via); -static void via_set_property (GObject *object, +static void territorio_via_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void via_get_property (GObject *object, +static void territorio_via_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void via_on_comune_selezionato (gpointer instance, guint id, gpointer user_data); +static void territorio_via_on_comune_selezionato (gpointer instance, guint id, gpointer user_data); -static gboolean via_on_w_via_delete_event (GtkWidget *widget, +static gboolean territorio_via_on_w_via_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data); -static void via_on_btn_comune_clicked (GtkButton *button, +static void territorio_via_on_btn_comune_clicked (GtkButton *button, gpointer user_data); -static void via_on_btn_annulla_clicked (GtkButton *button, +static void territorio_via_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void via_on_btn_salva_clicked (GtkButton *button, +static void territorio_via_on_btn_salva_clicked (GtkButton *button, gpointer user_data); -#define VIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_VIA, ViaPrivate)) +#define TERRITORIO_VIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_VIA, TerritorioViaPrivate)) enum { LBL_ID }; -typedef struct _ViaPrivate ViaPrivate; -struct _ViaPrivate +typedef struct _TerritorioViaPrivate TerritorioViaPrivate; +struct _TerritorioViaPrivate { Commons *commons; @@ -74,21 +74,21 @@ struct _ViaPrivate gint id; }; -G_DEFINE_TYPE (Via, via, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioVia, territorio_via, G_TYPE_OBJECT) static void -via_class_init (ViaClass *klass) +territorio_via_class_init (TerritorioViaClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (ViaPrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioViaPrivate)); - object_class->set_property = via_set_property; - object_class->get_property = via_get_property; + object_class->set_property = territorio_via_set_property; + object_class->get_property = territorio_via_get_property; /** - * Via::aggiornato: - * @via: + * TerritorioVia::aggiornato: + * @territorio_via: * */ klass->aggiornato_signal_id = g_signal_new ("aggiornato", @@ -103,26 +103,26 @@ via_class_init (ViaClass *klass) } static void -via_init (Via *via) +territorio_via_init (TerritorioVia *territorio_via) { - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); } /** - * via_new: + * territorio_via_new: * @commons: * @id: * - * Returns: the newly created #Via object. + * Returns: the newly created #TerritorioVia object. */ -Via -*via_new (Commons *commons, gint id) +TerritorioVia +*territorio_via_new (Commons *commons, gint id) { GError *error; - Via *a = VIA (g_object_new (via_get_type (), NULL)); + TerritorioVia *a = TERRITORIO_VIA (g_object_new (territorio_via_get_type (), NULL)); - ViaPrivate *priv = VIA_GET_PRIVATE (a); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (a); priv->commons = commons; @@ -147,15 +147,15 @@ Via NULL); g_signal_connect (priv->w, - "delete-event", G_CALLBACK (via_on_w_via_delete_event), (gpointer *)a); + "delete-event", G_CALLBACK (territorio_via_on_w_via_delete_event), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button50"), - "clicked", G_CALLBACK (via_on_btn_comune_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_via_on_btn_comune_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button51"), - "clicked", G_CALLBACK (via_on_btn_annulla_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_via_on_btn_annulla_clicked), (gpointer *)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button52"), - "clicked", G_CALLBACK (via_on_btn_salva_clicked), (gpointer *)a); + "clicked", G_CALLBACK (territorio_via_on_btn_salva_clicked), (gpointer *)a); priv->id = id; @@ -168,30 +168,30 @@ Via else { gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); - via_carica (a); + territorio_via_carica (a); } return a; } /** - * via_get_widget: - * @via: + * territorio_via_get_widget: + * @territorio_via: * */ GtkWidget -*via_get_widget (Via *via) +*territorio_via_get_widget (TerritorioVia *territorio_via) { - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); return priv->w; } /* PRIVATE */ static void -via_carica (Via *via) +territorio_via_carica (TerritorioVia *territorio_via) { - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); if (gtk_form_fill_from_table (priv->form)) { @@ -199,7 +199,7 @@ via_carica (Via *via) } static void -via_salva (Via *via) +territorio_via_salva (TerritorioVia *territorio_via) { GError *error = NULL; gchar *sql; @@ -208,9 +208,9 @@ via_salva (Via *via) GDate *da; GDate *a; - ViaClass *klass = VIA_GET_CLASS (via); + TerritorioViaClass *klass = TERRITORIO_VIA_GET_CLASS (territorio_via); - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) { @@ -228,7 +228,7 @@ via_salva (Via *via) if (gdaex_execute (priv->commons->gdaex, sql) == 1) { - g_signal_emit (via, klass->aggiornato_signal_id, 0); + g_signal_emit (territorio_via, klass->aggiornato_signal_id, 0); gtk_form_set_as_origin (priv->form); @@ -263,11 +263,11 @@ via_salva (Via *via) } static void -via_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_via_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Via *via = VIA (object); + TerritorioVia *territorio_via = TERRITORIO_VIA (object); - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); switch (property_id) { @@ -278,11 +278,11 @@ via_set_property (GObject *object, guint property_id, const GValue *value, GPara } static void -via_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_via_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Via *via = VIA (object); + TerritorioVia *territorio_via = TERRITORIO_VIA (object); - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); switch (property_id) { @@ -293,13 +293,13 @@ via_get_property (GObject *object, guint property_id, GValue *value, GParamSpec } static gboolean -via_conferma_chiusura (Via *via) +territorio_via_conferma_chiusura (TerritorioVia *territorio_via) { GtkWidget *dialog; gboolean ret; - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); ret = TRUE; if (gtk_form_is_changed (priv->form)) @@ -321,56 +321,56 @@ via_conferma_chiusura (Via *via) /* CALLBACK */ static void -via_on_comune_selezionato (gpointer instance, guint id, gpointer user_data) +territorio_via_on_comune_selezionato (gpointer instance, guint id, gpointer user_data) { - Via *f = (Via *)user_data; - ViaPrivate *priv = VIA_GET_PRIVATE (f); + TerritorioVia *f = (TerritorioVia *)user_data; + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (f); gtk_form_widget_set_value_stringify (gtk_form_get_form_widget_from_name (priv->form, "label46"), g_strdup_printf ("%d", id)); } static gboolean -via_on_w_via_delete_event (GtkWidget *widget, +territorio_via_on_w_via_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { - return !via_conferma_chiusura ((Via *)user_data); + return !territorio_via_conferma_chiusura ((TerritorioVia *)user_data); } static void -via_on_btn_comune_clicked (GtkButton *button, +territorio_via_on_btn_comune_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Via *rf = (Via *)user_data; + TerritorioVia *rf = (TerritorioVia *)user_data; - ViaPrivate *priv = VIA_GET_PRIVATE (rf); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (rf); - Comuni *c = comuni_new (priv->commons, TRUE); + TerritorioComuni *c = territorio_comuni_new (priv->commons, TRUE); g_signal_connect (G_OBJECT (c), "selezionato", - G_CALLBACK (via_on_comune_selezionato), user_data); + G_CALLBACK (territorio_via_on_comune_selezionato), user_data); - w = comuni_get_widget (c); + w = territorio_comuni_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), GTK_WINDOW (priv->w)); gtk_widget_show (w); } static void -via_on_btn_annulla_clicked (GtkButton *button, +territorio_via_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - Via *via = (Via *)user_data; + TerritorioVia *territorio_via = (TerritorioVia *)user_data; - ViaPrivate *priv = VIA_GET_PRIVATE (via); + TerritorioViaPrivate *priv = TERRITORIO_VIA_GET_PRIVATE (territorio_via); - if (via_conferma_chiusura (via)) gtk_widget_destroy (priv->w); + if (territorio_via_conferma_chiusura (territorio_via)) gtk_widget_destroy (priv->w); } static void -via_on_btn_salva_clicked (GtkButton *button, +territorio_via_on_btn_salva_clicked (GtkButton *button, gpointer user_data) { - via_salva ((Via *)user_data); + territorio_via_salva ((TerritorioVia *)user_data); } diff --git a/src/via.h b/src/via.h index 5bc24e5..7a846b8 100644 --- a/src/via.h +++ b/src/via.h @@ -17,8 +17,8 @@ * */ -#ifndef __VIA_H__ -#define __VIA_H__ +#ifndef __TERRITORIO_VIA_H__ +#define __TERRITORIO_VIA_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_VIA (via_get_type ()) -#define VIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_VIA, Via)) -#define VIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_VIA, ViaClass)) -#define IS_VIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_VIA)) -#define IS_VIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_VIA)) -#define VIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_VIA, ViaClass)) +#define TYPE_TERRITORIO_VIA (territorio_via_get_type ()) +#define TERRITORIO_VIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_VIA, TerritorioVia)) +#define TERRITORIO_VIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_VIA, TerritorioViaClass)) +#define IS_TERRITORIO_VIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_VIA)) +#define IS_TERRITORIO_VIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_VIA)) +#define TERRITORIO_VIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_VIA, TerritorioViaClass)) -typedef struct _Via Via; -typedef struct _ViaClass ViaClass; +typedef struct _TerritorioVia TerritorioVia; +typedef struct _TerritorioViaClass TerritorioViaClass; -struct _Via +struct _TerritorioVia { GObject parent; }; -struct _ViaClass +struct _TerritorioViaClass { GObjectClass parent_class; guint aggiornato_signal_id; }; -GType via_get_type (void) G_GNUC_CONST; +GType territorio_via_get_type (void) G_GNUC_CONST; -Via *via_new (Commons *commons, gint id); +TerritorioVia *territorio_via_new (Commons *commons, gint id); -GtkWidget *via_get_widget (Via *via); +GtkWidget *territorio_via_get_widget (TerritorioVia *territorio_via); G_END_DECLS -#endif /* __VIA_H__ */ +#endif /* __TERRITORIO_VIA_H__ */ diff --git a/src/vie.c b/src/vie.c index 2a5b90f..0243739 100644 --- a/src/vie.c +++ b/src/vie.c @@ -20,41 +20,41 @@ #include "vie.h" #include "via.h" -static void vie_class_init (VieClass *klass); -static void vie_init (Vie *vie); +static void territorio_vie_class_init (TerritorioVieClass *klass); +static void territorio_vie_init (TerritorioVie *territorio_vie); -static void vie_carica (Vie *vie); -static void vie_modifica (Vie *vie); +static void territorio_vie_carica (TerritorioVie *territorio_vie); +static void territorio_vie_modifica (TerritorioVie *territorio_vie); -static void vie_selezionato (Vie *vie); -static void vie_on_via_aggiornato (gpointer instance, gpointer user_data); +static void territorio_vie_selezionato (TerritorioVie *territorio_vie); +static void territorio_vie_on_via_aggiornato (gpointer instance, gpointer user_data); -static void vie_set_property (GObject *object, +static void territorio_vie_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); -static void vie_get_property (GObject *object, +static void territorio_vie_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); -static void vie_on_btn_nuovo_clicked (GtkButton *button, +static void territorio_vie_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data); -static void vie_on_btn_modifica_clicked (GtkButton *button, +static void territorio_vie_on_btn_modifica_clicked (GtkButton *button, gpointer user_data); -static void vie_on_btn_elimina_clicked (GtkButton *button, +static void territorio_vie_on_btn_elimina_clicked (GtkButton *button, gpointer user_data); -static void vie_on_trv_vie_row_activated (GtkTreeView *tree_view, +static void territorio_vie_on_trv_vie_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data); -static void vie_on_btn_annulla_clicked (GtkButton *button, +static void territorio_vie_on_btn_annulla_clicked (GtkButton *button, gpointer user_data); -static void vie_on_btn_seleziona_clicked (GtkButton *button, +static void territorio_vie_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data); -#define VIE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_VIE, ViePrivate)) +#define TERRITORIO_VIE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_TERRITORIO_VIE, TerritorioViePrivate)) enum { @@ -62,8 +62,8 @@ enum COL_NOME }; -typedef struct _ViePrivate ViePrivate; -struct _ViePrivate +typedef struct _TerritorioViePrivate TerritorioViePrivate; +struct _TerritorioViePrivate { Commons *commons; @@ -75,21 +75,21 @@ struct _ViePrivate GtkWindow *wtransient; }; -G_DEFINE_TYPE (Vie, vie, G_TYPE_OBJECT) +G_DEFINE_TYPE (TerritorioVie, territorio_vie, G_TYPE_OBJECT) static void -vie_class_init (VieClass *klass) +territorio_vie_class_init (TerritorioVieClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (object_class, sizeof (ViePrivate)); + g_type_class_add_private (object_class, sizeof (TerritorioViePrivate)); - object_class->set_property = vie_set_property; - object_class->get_property = vie_get_property; + object_class->set_property = territorio_vie_set_property; + object_class->get_property = territorio_vie_get_property; /** - * Vie::selezionato: - * @vie: + * TerritorioVie::selezionato: + * @territorio_vie: * */ klass->selezionato_signal_id = g_signal_new ("selezionato", @@ -104,26 +104,26 @@ vie_class_init (VieClass *klass) } static void -vie_init (Vie *vie) +territorio_vie_init (TerritorioVie *territorio_vie) { - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); } /** - * vie_new: + * territorio_vie_new: * @commons: * @selezione: * - * Returns: the newly created #Vie object. + * Returns: the newly created #TerritorioVie object. */ -Vie -*vie_new (Commons *commons, gboolean selezione) +TerritorioVie +*territorio_vie_new (Commons *commons, gboolean selezione) { GError *error; - Vie *a = VIE (g_object_new (vie_get_type (), NULL)); + TerritorioVie *a = TERRITORIO_VIE (g_object_new (territorio_vie_get_type (), NULL)); - ViePrivate *priv = VIE_GET_PRIVATE (a); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (a); priv->commons = commons; priv->selezione = selezione; @@ -154,21 +154,21 @@ Vie } g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button45"), - "clicked", G_CALLBACK (vie_on_btn_nuovo_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_vie_on_btn_nuovo_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button46"), - "clicked", G_CALLBACK (vie_on_btn_modifica_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_vie_on_btn_modifica_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button47"), - "clicked", G_CALLBACK (vie_on_btn_elimina_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_vie_on_btn_elimina_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview7"), - "row-activated", G_CALLBACK (vie_on_trv_vie_row_activated), (gpointer)a); + "row-activated", G_CALLBACK (territorio_vie_on_trv_vie_row_activated), (gpointer)a); if (priv->selezione) { gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "label39"))); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button48"), - "clicked", G_CALLBACK (vie_on_btn_annulla_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_vie_on_btn_annulla_clicked), (gpointer)a); g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button49"), - "clicked", G_CALLBACK (vie_on_btn_seleziona_clicked), (gpointer)a); + "clicked", G_CALLBACK (territorio_vie_on_btn_seleziona_clicked), (gpointer)a); } else { @@ -176,27 +176,27 @@ Vie gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button49"))); } - vie_carica (a); + territorio_vie_carica (a); return a; } /** - * vie_get_widget: - * @vie: + * territorio_vie_get_widget: + * @territorio_vie: * */ GtkWidget -*vie_get_widget (Vie *vie) +*territorio_vie_get_widget (TerritorioVie *territorio_vie) { - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); return priv->widget; } /* PRIVATE */ static void -vie_carica (Vie *vie) +territorio_vie_carica (TerritorioVie *territorio_vie) { GtkTreeIter iter; GdaDataModel *dm; @@ -204,13 +204,13 @@ vie_carica (Vie *vie) gint rows; gint row; - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); gtk_list_store_clear (priv->lstore_vie); dm = gdaex_query (priv->commons->gdaex, "SELECT c.id, c.nome" - " FROM vie AS c" + " FROM territorio_vie AS c" " WHERE c.status <> 'E'" " ORDER BY c.nome"); if (dm != NULL) @@ -231,12 +231,12 @@ vie_carica (Vie *vie) } static void -vie_modifica (Vie *vie) +territorio_vie_modifica (TerritorioVie *territorio_vie) { GtkTreeIter iter; guint id; - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -246,12 +246,12 @@ vie_modifica (Vie *vie) COL_ID, &id, -1); - Via *c = via_new (priv->commons, id); + TerritorioVia *c = territorio_via_new (priv->commons, id); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (vie_on_via_aggiornato), (gpointer)vie); + G_CALLBACK (territorio_vie_on_via_aggiornato), (gpointer)territorio_vie); - w = via_get_widget (c); + w = territorio_via_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } @@ -268,13 +268,13 @@ vie_modifica (Vie *vie) } static void -vie_selezionato (Vie *vie) +territorio_vie_selezionato (TerritorioVie *territorio_vie) { GtkTreeIter iter; guint *id; - VieClass *klass = VIE_GET_CLASS (vie); - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioVieClass *klass = TERRITORIO_VIE_GET_CLASS (territorio_vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -282,10 +282,10 @@ vie_selezionato (Vie *vie) COL_ID, &id, -1); - g_signal_emit (G_OBJECT (vie), klass->selezionato_signal_id, 0, id); + g_signal_emit (G_OBJECT (territorio_vie), klass->selezionato_signal_id, 0, id); gtk_widget_destroy (priv->widget); - g_object_unref (G_OBJECT (vie)); + g_object_unref (G_OBJECT (territorio_vie)); } else { @@ -300,17 +300,17 @@ vie_selezionato (Vie *vie) } static void -vie_on_via_aggiornato (gpointer instance, gpointer user_data) +territorio_vie_on_via_aggiornato (gpointer instance, gpointer user_data) { - vie_carica ((Vie *)user_data); + territorio_vie_carica ((TerritorioVie *)user_data); } static void -vie_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +territorio_vie_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - Vie *vie = VIE (object); + TerritorioVie *territorio_vie = TERRITORIO_VIE (object); - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); switch (property_id) { @@ -321,11 +321,11 @@ vie_set_property (GObject *object, guint property_id, const GValue *value, GPara } static void -vie_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +territorio_vie_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - Vie *vie = VIE (object); + TerritorioVie *territorio_vie = TERRITORIO_VIE (object); - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); switch (property_id) { @@ -337,33 +337,33 @@ vie_get_property (GObject *object, guint property_id, GValue *value, GParamSpec /* CALLBACK */ static void -vie_on_btn_nuovo_clicked (GtkButton *button, +territorio_vie_on_btn_nuovo_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; - Vie *vie = (Vie *)user_data; - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioVie *territorio_vie = (TerritorioVie *)user_data; + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); - Via *c = via_new (priv->commons, 0); + TerritorioVia *c = territorio_via_new (priv->commons, 0); g_signal_connect (G_OBJECT (c), "aggiornato", - G_CALLBACK (vie_on_via_aggiornato), (gpointer)vie); + G_CALLBACK (territorio_vie_on_via_aggiornato), (gpointer)territorio_vie); - w = via_get_widget (c); + w = territorio_via_get_widget (c); gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); gtk_widget_show (w); } static void -vie_on_btn_modifica_clicked (GtkButton *button, +territorio_vie_on_btn_modifica_clicked (GtkButton *button, gpointer user_data) { - vie_modifica ((Vie *)user_data); + territorio_vie_modifica ((TerritorioVie *)user_data); } static void -vie_on_btn_elimina_clicked (GtkButton *button, +territorio_vie_on_btn_elimina_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dialog; @@ -372,8 +372,8 @@ vie_on_btn_elimina_clicked (GtkButton *button, GtkTreeIter iter; guint id; - Vie *vie = (Vie *)user_data; - ViePrivate *priv = VIE_GET_PRIVATE (vie); + TerritorioVie *territorio_vie = (TerritorioVie *)user_data; + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE (territorio_vie); if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) { @@ -392,7 +392,7 @@ vie_on_btn_elimina_clicked (GtkButton *button, gdaex_execute (priv->commons->gdaex, g_strdup_printf ("UPDATE vie SET status = 'E' WHERE id = %d", id)); - vie_carica (vie); + territorio_vie_carica (territorio_vie); } gtk_widget_destroy (dialog); } @@ -409,37 +409,37 @@ vie_on_btn_elimina_clicked (GtkButton *button, } static void -vie_on_trv_vie_row_activated (GtkTreeView *tree_view, +territorio_vie_on_trv_vie_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path, GtkTreeViewColumn *column, gpointer user_data) { - ViePrivate *priv = VIE_GET_PRIVATE ((Vie *)user_data); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE ((TerritorioVie *)user_data); if (priv->selezione) { - vie_selezionato ((Vie *)user_data); + territorio_vie_selezionato ((TerritorioVie *)user_data); } else { - vie_modifica ((Vie *)user_data); + territorio_vie_modifica ((TerritorioVie *)user_data); } } static void -vie_on_btn_annulla_clicked (GtkButton *button, +territorio_vie_on_btn_annulla_clicked (GtkButton *button, gpointer user_data) { - ViePrivate *priv = VIE_GET_PRIVATE ((Vie *)user_data); + TerritorioViePrivate *priv = TERRITORIO_VIE_GET_PRIVATE ((TerritorioVie *)user_data); gtk_widget_destroy (priv->widget); g_object_unref (G_OBJECT (user_data)); } static void -vie_on_btn_seleziona_clicked (GtkButton *button, +territorio_vie_on_btn_seleziona_clicked (GtkButton *button, gpointer user_data) { - vie_selezionato ((Vie *)user_data); + territorio_vie_selezionato ((TerritorioVie *)user_data); } diff --git a/src/vie.h b/src/vie.h index 359b755..b470f23 100644 --- a/src/vie.h +++ b/src/vie.h @@ -17,8 +17,8 @@ * */ -#ifndef __VIE_H__ -#define __VIE_H__ +#ifndef __TERRITORIO_VIE_H__ +#define __TERRITORIO_VIE_H__ #include #include @@ -31,36 +31,36 @@ G_BEGIN_DECLS -#define TYPE_VIE (vie_get_type ()) -#define VIE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_VIE, Vie)) -#define VIE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_VIE, VieClass)) -#define IS_VIE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_VIE)) -#define IS_VIE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_VIE)) -#define VIE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_VIE, VieClass)) +#define TYPE_TERRITORIO_VIE (territorio_vie_get_type ()) +#define TERRITORIO_VIE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TERRITORIO_VIE, TerritorioVie)) +#define TERRITORIO_VIE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TERRITORIO_VIE, TerritorioVieClass)) +#define IS_TERRITORIO_VIE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TERRITORIO_VIE)) +#define IS_TERRITORIO_VIE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TERRITORIO_VIE)) +#define TERRITORIO_VIE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TERRITORIO_VIE, TerritorioVieClass)) -typedef struct _Vie Vie; -typedef struct _VieClass VieClass; +typedef struct _TerritorioVie TerritorioVie; +typedef struct _TerritorioVieClass TerritorioVieClass; -struct _Vie +struct _TerritorioVie { GObject parent; }; -struct _VieClass +struct _TerritorioVieClass { GObjectClass parent_class; guint selezionato_signal_id; }; -GType vie_get_type (void) G_GNUC_CONST; +GType territorio_vie_get_type (void) G_GNUC_CONST; -Vie *vie_new (Commons *commons, gboolean selezione); +TerritorioVie *territorio_vie_new (Commons *commons, gboolean selezione); -GtkWidget *vie_get_widget (Vie *vie); +GtkWidget *territorio_vie_get_widget (TerritorioVie *territorio_vie); G_END_DECLS -#endif /* __VIE_H__ */ +#endif /* __TERRITORIO_VIE_H__ */ -- 2.49.0