From 603a687ac69ebeb51ce80446d4407914b092290d Mon Sep 17 00:00:00 2001 From: Andrea Zagli Date: Tue, 24 Aug 2010 17:30:29 +0200 Subject: [PATCH] Gestione aggregazioni territoriali. --- data/territorio/form/Makefile.am | 1 + .../form/aggregazione_territoriale.form | 27 ++ data/territorio/gui/territorio.gui | 299 +++++++++++- src/Makefile.am | 4 + src/aggregazioneterritoriale.c | 339 +++++++++++++ src/aggregazioneterritoriale.h | 66 +++ src/aggregazioniterritoriali.c | 445 ++++++++++++++++++ src/aggregazioniterritoriali.h | 66 +++ src/main.c | 14 + 9 files changed, 1260 insertions(+), 1 deletion(-) create mode 100644 data/territorio/form/aggregazione_territoriale.form create mode 100644 src/aggregazioneterritoriale.c create mode 100644 src/aggregazioneterritoriale.h create mode 100644 src/aggregazioniterritoriali.c create mode 100644 src/aggregazioniterritoriali.h diff --git a/data/territorio/form/Makefile.am b/data/territorio/form/Makefile.am index b3208a4..c051a3a 100644 --- a/data/territorio/form/Makefile.am +++ b/data/territorio/form/Makefile.am @@ -1,6 +1,7 @@ formdir = $(datadir)/$(PACKAGE)/form form_DATA = \ + aggregazione_territoriale.form \ comune.form \ provincia.form \ regione.form \ diff --git a/data/territorio/form/aggregazione_territoriale.form b/data/territorio/form/aggregazione_territoriale.form new file mode 100644 index 0000000..9525285 --- /dev/null +++ b/data/territorio/form/aggregazione_territoriale.form @@ -0,0 +1,27 @@ + + + + aggregazioni_territoriali
+ + + + t + t + + + + + 0 + + SELECT id, nome FROM tipi_aggregazione_territoriale WHERE status <> 'E' ORDER BY nome + + + t + + + + + + + + diff --git a/data/territorio/gui/territorio.gui b/data/territorio/gui/territorio.gui index dc8732a..c77353f 100644 --- a/data/territorio/gui/territorio.gui +++ b/data/territorio/gui/territorio.gui @@ -108,6 +108,7 @@ True _Aggregazioni territoriali True + @@ -378,6 +379,14 @@ + + + + + + + + Stato - Territorio True @@ -1508,7 +1517,7 @@ - + Tipi aggregazioni territoriali - Territorio True center-on-parent @@ -1764,4 +1773,292 @@ + + Aggregazioni territoriali - Territorio + True + center-on-parent + 550 + 400 + True + + + True + 5 + vertical + 5 + + + True + <b>Aggregazioni territoriali</b> + True + + + False + 0 + + + + + True + True + automatic + automatic + etched-in + + + True + True + lstore_aggregazioni_territoriali + False + 0 + + + Nome + + + + 1 + + + + + + + + + 1 + + + + + True + 5 + end + + + gtk-new + True + True + True + True + + + False + False + 0 + + + + + gtk-edit + True + True + True + True + + + False + False + 1 + + + + + gtk-delete + True + True + True + True + + + False + False + 2 + + + + + gtk-cancel + True + True + True + True + + + False + False + 3 + + + + + gtk-ok + True + True + True + True + + + False + False + 4 + + + + + False + 2 + + + + + + + Aggregazione territoriale - Territorio + True + center-on-parent + True + + + True + 5 + vertical + 5 + + + True + 3 + 2 + 5 + 5 + + + True + 0 + ID + + + GTK_FILL + GTK_FILL + + + + + True + 0 + lbl_id + + + 1 + 2 + GTK_FILL + + + + + True + 0 + Nome + + + 2 + 3 + GTK_FILL + GTK_FILL + + + + + True + True + 150 + ● + + + 1 + 2 + 2 + 3 + GTK_FILL + + + + + True + 0 + Tipo + + + 1 + 2 + GTK_FILL + GTK_FILL + + + + + True + lstore_tipi_aggregazione_territoriale + + + + 1 + + + + + 1 + 2 + 1 + 2 + GTK_FILL + + + + + 0 + + + + + True + 5 + end + + + gtk-cancel + True + True + True + True + + + False + False + 0 + + + + + gtk-save + True + True + True + True + + + False + False + 1 + + + + + False + 1 + + + + + diff --git a/src/Makefile.am b/src/Makefile.am index 05f541e..6ea9f91 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -11,6 +11,10 @@ LIBS = $(TERRITORIO_LIBS) \ bin_PROGRAMS = territorio territorio_SOURCES = \ + aggregazioneterritoriale.c \ + aggregazioneterritoriale.h \ + aggregazioniterritoriali.c \ + aggregazioniterritoriali.h \ commons.h \ comune.c \ comune.h \ diff --git a/src/aggregazioneterritoriale.c b/src/aggregazioneterritoriale.c new file mode 100644 index 0000000..088eacc --- /dev/null +++ b/src/aggregazioneterritoriale.c @@ -0,0 +1,339 @@ +/* + * Copyright (C) 2010 Andrea Zagli + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include + +#include "aggregazioneterritoriale.h" + +static void aggregazione_territoriale_class_init (AggregazioneTerritorialeClass *klass); +static void aggregazione_territoriale_init (AggregazioneTerritoriale *aggregazione_territoriale); + +static void aggregazione_territoriale_carica (AggregazioneTerritoriale *aggregazione_territoriale); +static void aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territoriale); + +static gboolean aggregazione_territoriale_conferma_chiusura (AggregazioneTerritoriale *aggregazione_territoriale); + +static void aggregazione_territoriale_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void 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, + GdkEvent *event, + gpointer user_data); + +static void aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, + gpointer user_data); +static void 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)) + +enum +{ + LBL_ID +}; + +typedef struct _AggregazioneTerritorialePrivate AggregazioneTerritorialePrivate; +struct _AggregazioneTerritorialePrivate + { + Commons *commons; + + GtkForm *form; + + GtkWidget *w; + + GObject **objects; + + gint id; + }; + +G_DEFINE_TYPE (AggregazioneTerritoriale, aggregazione_territoriale, G_TYPE_OBJECT) + +static void +aggregazione_territoriale_class_init (AggregazioneTerritorialeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (object_class, sizeof (AggregazioneTerritorialePrivate)); + + object_class->set_property = aggregazione_territoriale_set_property; + object_class->get_property = aggregazione_territoriale_get_property; + + /** + * AggregazioneTerritoriale::aggiornato: + * @aggregazione_territoriale: + * + */ + klass->aggiornato_signal_id = g_signal_new ("aggiornato", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); +} + +static void +aggregazione_territoriale_init (AggregazioneTerritoriale *aggregazione_territoriale) +{ + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); +} + +/** + * aggregazione_territoriale_new: + * @commons: + * @id: + * + * Returns: the newly created #AggregazioneTerritoriale object. + */ +AggregazioneTerritoriale +*aggregazione_territoriale_new (Commons *commons, gint id) +{ + GError *error; + + AggregazioneTerritoriale *a = AGGREGAZIONE_TERRITORIALE (g_object_new (aggregazione_territoriale_get_type (), NULL)); + + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (a); + + priv->commons = commons; + + error = NULL; + gtk_builder_add_objects_from_file (priv->commons->gtkbuilder, priv->commons->guifile, + g_strsplit (g_strconcat ("lstore_tipi_aggregazione_territoriale" + "|w_aggregazione_territoriale", NULL), "|", -1), + &error); + if (error != NULL) + { + g_warning ("Errore: %s.", error->message); + return NULL; + } + + priv->form = gtk_form_new (); + g_object_set (G_OBJECT (priv->form), "gdaex", priv->commons->gdaex, NULL); + gtk_form_load_from_file (priv->form, g_build_filename (priv->commons->formdir, "aggregazione_territoriale.form", NULL), priv->commons->gtkbuilder); + + priv->w = GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "w_aggregazione_territoriale")); + + priv->objects = gtk_form_get_objects_by_name (priv->form, + "label32", + NULL); + + g_signal_connect (priv->w, + "delete-event", G_CALLBACK (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); + g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button42"), + "clicked", G_CALLBACK (aggregazione_territoriale_on_btn_salva_clicked), (gpointer *)a); + + priv->id = id; + + if (priv->id == 0) + { + gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), ""); + + gtk_form_set_as_origin (priv->form); + } + else + { + gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), g_strdup_printf ("%d", priv->id)); + aggregazione_territoriale_carica (a); + } + + return a; +} + +/** + * aggregazione_territoriale_get_widget: + * @aggregazione_territoriale: + * + */ +GtkWidget +*aggregazione_territoriale_get_widget (AggregazioneTerritoriale *aggregazione_territoriale) +{ + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + return priv->w; +} + +/* PRIVATE */ +static void +aggregazione_territoriale_carica (AggregazioneTerritoriale *aggregazione_territoriale) +{ + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + if (gtk_form_fill_from_table (priv->form)) + { + } +} + +static void +aggregazione_territoriale_salva (AggregazioneTerritoriale *aggregazione_territoriale) +{ + GError *error = NULL; + gchar *sql; + GtkWidget *dialog; + + GDate *da; + GDate *a; + + AggregazioneTerritorialeClass *klass = AGGREGAZIONE_TERRITORIALE_GET_CLASS (aggregazione_territoriale); + + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + if (!gtk_form_check (priv->form, (priv->id != 0), NULL, TRUE, priv->w, TRUE)) + { + return; + } + + if (priv->id == 0) + { + sql = gtk_form_get_sql (priv->form, GTK_FORM_SQL_INSERT); + } + else + { + sql = gtk_form_get_sql (priv->form, GTK_FORM_SQL_UPDATE); + } + + if (gdaex_execute (priv->commons->gdaex, sql) == 1) + { + g_signal_emit (aggregazione_territoriale, klass->aggiornato_signal_id, 0); + + gtk_form_set_as_origin (priv->form); + + if (priv->id == 0) + { + priv->id = strtol (gtk_label_get_text (GTK_LABEL (priv->objects[LBL_ID])), NULL, 10); + } + + dialog = gtk_message_dialog_new (GTK_WINDOW (priv->w), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_INFO, + GTK_BUTTONS_OK, + "Salvataggio eseguito con successo."); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } + else + { + if (priv->id == 0) + { + gtk_label_set_text (GTK_LABEL (priv->objects[LBL_ID]), ""); + } + + dialog = gtk_message_dialog_new (GTK_WINDOW (priv->w), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "Errore durante il salvataggio."); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } +} + +static void +aggregazione_territoriale_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + AggregazioneTerritoriale *aggregazione_territoriale = AGGREGAZIONE_TERRITORIALE (object); + + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + switch (property_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +aggregazione_territoriale_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + AggregazioneTerritoriale *aggregazione_territoriale = AGGREGAZIONE_TERRITORIALE (object); + + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + switch (property_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static gboolean +aggregazione_territoriale_conferma_chiusura (AggregazioneTerritoriale *aggregazione_territoriale) +{ + GtkWidget *dialog; + + gboolean ret; + + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + ret = TRUE; + if (gtk_form_is_changed (priv->form)) + { + dialog = gtk_message_dialog_new (GTK_WINDOW (priv->w), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + "Sicuro di voler chiudere senza salvare?"); + if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_NO) + { + ret = FALSE; + } + gtk_widget_destroy (dialog); + } + + return ret; +} + +/* CALLBACK */ +static gboolean +aggregazione_territoriale_on_w_aggregazione_territoriale_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data) +{ + return !aggregazione_territoriale_conferma_chiusura ((AggregazioneTerritoriale *)user_data); +} + +static void +aggregazione_territoriale_on_btn_annulla_clicked (GtkButton *button, + gpointer user_data) +{ + AggregazioneTerritoriale *aggregazione_territoriale = (AggregazioneTerritoriale *)user_data; + + AggregazioneTerritorialePrivate *priv = AGGREGAZIONE_TERRITORIALE_GET_PRIVATE (aggregazione_territoriale); + + if (aggregazione_territoriale_conferma_chiusura (aggregazione_territoriale)) gtk_widget_destroy (priv->w); +} + +static void +aggregazione_territoriale_on_btn_salva_clicked (GtkButton *button, + gpointer user_data) +{ + aggregazione_territoriale_salva ((AggregazioneTerritoriale *)user_data); +} diff --git a/src/aggregazioneterritoriale.h b/src/aggregazioneterritoriale.h new file mode 100644 index 0000000..c9fe59d --- /dev/null +++ b/src/aggregazioneterritoriale.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2010 Andrea Zagli + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __AGGREGAZIONE_TERRITORIALE_H__ +#define __AGGREGAZIONE_TERRITORIALE_H__ + +#include +#include + +#include +#include + +#include "commons.h" + +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)) + + +typedef struct _AggregazioneTerritoriale AggregazioneTerritoriale; +typedef struct _AggregazioneTerritorialeClass AggregazioneTerritorialeClass; + +struct _AggregazioneTerritoriale + { + GObject parent; + }; + +struct _AggregazioneTerritorialeClass + { + GObjectClass parent_class; + + guint aggiornato_signal_id; + }; + +GType aggregazione_territoriale_get_type (void) G_GNUC_CONST; + +AggregazioneTerritoriale *aggregazione_territoriale_new (Commons *commons, gint id); + +GtkWidget *aggregazione_territoriale_get_widget (AggregazioneTerritoriale *aggregazione_territoriale); + + +G_END_DECLS + +#endif /* __AGGREGAZIONE_TERRITORIALE_H__ */ diff --git a/src/aggregazioniterritoriali.c b/src/aggregazioniterritoriali.c new file mode 100644 index 0000000..9fe32d9 --- /dev/null +++ b/src/aggregazioniterritoriali.c @@ -0,0 +1,445 @@ +/* + * Copyright (C) 2010 Andrea Zagli + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "aggregazioniterritoriali.h" +#include "aggregazioneterritoriale.h" + +static void aggregazioni_territoriali_class_init (AggregazioniTerritorialiClass *klass); +static void aggregazioni_territoriali_init (AggregazioniTerritoriali *aggregazioni_territoriali); + +static void aggregazioni_territoriali_carica (AggregazioniTerritoriali *aggregazioni_territoriali); +static void aggregazioni_territoriali_modifica (AggregazioniTerritoriali *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 aggregazioni_territoriali_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void aggregazioni_territoriali_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + +static void aggregazioni_territoriali_on_btn_nuovo_clicked (GtkButton *button, + gpointer user_data); +static void aggregazioni_territoriali_on_btn_modifica_clicked (GtkButton *button, + gpointer user_data); +static void aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, + gpointer user_data); +static void aggregazioni_territoriali_on_trv_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, + gpointer user_data); +static void 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)) + +enum +{ + COL_ID, + COL_NOME +}; + +typedef struct _AggregazioniTerritorialiPrivate AggregazioniTerritorialiPrivate; +struct _AggregazioniTerritorialiPrivate + { + Commons *commons; + + GtkWidget *widget; + GtkTreeSelection *selection; + GtkListStore *lstore_aggregazioni_territoriali; + + gboolean selezione; + GtkWindow *wtransient; + }; + +G_DEFINE_TYPE (AggregazioniTerritoriali, aggregazioni_territoriali, G_TYPE_OBJECT) + +static void +aggregazioni_territoriali_class_init (AggregazioniTerritorialiClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (object_class, sizeof (AggregazioniTerritorialiPrivate)); + + object_class->set_property = aggregazioni_territoriali_set_property; + object_class->get_property = aggregazioni_territoriali_get_property; + + /** + * AggregazioniTerritoriali::selezionato: + * @aggregazioni_territoriali: + * + */ + klass->selezionato_signal_id = g_signal_new ("selezionato", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__UINT, + G_TYPE_NONE, + 1, G_TYPE_UINT); +} + +static void +aggregazioni_territoriali_init (AggregazioniTerritoriali *aggregazioni_territoriali) +{ + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); +} + +/** + * aggregazioni_territoriali_new: + * @commons: + * @selezione: + * + * Returns: the newly created #AggregazioniTerritoriali object. + */ +AggregazioniTerritoriali +*aggregazioni_territoriali_new (Commons *commons, gboolean selezione) +{ + GError *error; + + AggregazioniTerritoriali *a = AGGREGAZIONI_TERRITORIALI (g_object_new (aggregazioni_territoriali_get_type (), NULL)); + + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (a); + + priv->commons = commons; + priv->selezione = selezione; + + error = NULL; + gtk_builder_add_objects_from_file (priv->commons->gtkbuilder, priv->commons->guifile, + g_strsplit (g_strconcat ("lstore_aggregazioni_territoriali|", + (selezione ? "w_aggregazioni_territoriali" : "vbox12"), + NULL), "|", -1), + &error); + if (error != NULL) + { + g_warning ("Errore: %s.", error->message); + return NULL; + } + + priv->widget = GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, (selezione ? "w_aggregazioni_territoriali" : "vbox12"))); + priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (gtk_builder_get_object (priv->commons->gtkbuilder, "treeview6"))); + priv->lstore_aggregazioni_territoriali = GTK_LIST_STORE (gtk_builder_get_object (priv->commons->gtkbuilder, "lstore_aggregazioni_territoriali")); + + if (priv->selezione) + { + priv->wtransient = GTK_WINDOW (priv->widget); + } + else + { + priv->wtransient = GTK_WINDOW (gtk_builder_get_object (priv->commons->gtkbuilder, "w_main")); + } + + g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button36"), + "clicked", G_CALLBACK (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); + g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button38"), + "clicked", G_CALLBACK (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); + + 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); + g_signal_connect (gtk_builder_get_object (priv->commons->gtkbuilder, "button40"), + "clicked", G_CALLBACK (aggregazioni_territoriali_on_btn_seleziona_clicked), (gpointer)a); + } + else + { + gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button39"))); + gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->commons->gtkbuilder, "button40"))); + } + + aggregazioni_territoriali_carica (a); + + return a; +} + +/** + * aggregazioni_territoriali_get_widget: + * @aggregazioni_territoriali: + * + */ +GtkWidget +*aggregazioni_territoriali_get_widget (AggregazioniTerritoriali *aggregazioni_territoriali) +{ + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + + return priv->widget; +} + +/* PRIVATE */ +static void +aggregazioni_territoriali_carica (AggregazioniTerritoriali *aggregazioni_territoriali) +{ + GtkTreeIter iter; + GdaDataModel *dm; + + gint rows; + gint row; + + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (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" + " WHERE c.status <> 'E'" + " ORDER BY c.nome"); + if (dm != NULL) + { + rows = gda_data_model_get_n_rows (dm); + for (row = 0; row < rows; row++) + { + gtk_list_store_append (priv->lstore_aggregazioni_territoriali, &iter); + + gtk_list_store_set (priv->lstore_aggregazioni_territoriali, &iter, + COL_ID, gdaex_data_model_get_field_value_stringify_at (dm, row, "id"), + COL_NOME, gdaex_data_model_get_field_value_stringify_at (dm, row, "nome"), + -1); + } + + g_object_unref (dm); + } +} + +static void +aggregazioni_territoriali_modifica (AggregazioniTerritoriali *aggregazioni_territoriali) +{ + GtkTreeIter iter; + gchar *id; + + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + + if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) + { + GtkWidget *w; + + gtk_tree_model_get (GTK_TREE_MODEL (priv->lstore_aggregazioni_territoriali), &iter, + COL_ID, &id, + -1); + + AggregazioneTerritoriale *c = 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); + + w = aggregazione_territoriale_get_widget (c); + gtk_window_set_transient_for (GTK_WINDOW (w), priv->wtransient); + gtk_widget_show (w); + } + else + { + GtkWidget *dialog = gtk_message_dialog_new (priv->wtransient, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "Occorre prima selezionare un'aggregazione territoriale"); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } +} + +static void +aggregazioni_territoriali_selezionato (AggregazioniTerritoriali *aggregazioni_territoriali) +{ + GtkTreeIter iter; + gchar *id; + + AggregazioniTerritorialiClass *klass = AGGREGAZIONI_TERRITORIALI_GET_CLASS (aggregazioni_territoriali); + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + + if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) + { + gtk_tree_model_get (GTK_TREE_MODEL (priv->lstore_aggregazioni_territoriali), &iter, + COL_ID, &id, + -1); + + g_signal_emit (G_OBJECT (aggregazioni_territoriali), klass->selezionato_signal_id, 0, strtol (id, NULL, 10)); + + gtk_widget_destroy (priv->widget); + g_object_unref (G_OBJECT (aggregazioni_territoriali)); + } + else + { + GtkWidget *dialog = gtk_message_dialog_new (priv->wtransient, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "Occorre prima selezionare un'aggregazione territoriale"); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } +} + +static void +aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato (gpointer instance, gpointer user_data) +{ + aggregazioni_territoriali_carica ((AggregazioniTerritoriali *)user_data); +} + +static void +aggregazioni_territoriali_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + AggregazioniTerritoriali *aggregazioni_territoriali = AGGREGAZIONI_TERRITORIALI (object); + + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + + switch (property_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +aggregazioni_territoriali_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + AggregazioniTerritoriali *aggregazioni_territoriali = AGGREGAZIONI_TERRITORIALI (object); + + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + + switch (property_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +/* CALLBACK */ +static void +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); + + AggregazioneTerritoriale *c = aggregazione_territoriale_new (priv->commons, 0); + + g_signal_connect (G_OBJECT (c), "aggiornato", + G_CALLBACK (aggregazioni_territoriali_on_aggregazione_territoriale_aggiornato), (gpointer)aggregazioni_territoriali); + + w = 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, + gpointer user_data) +{ + aggregazioni_territoriali_modifica ((AggregazioniTerritoriali *)user_data); +} + +static void +aggregazioni_territoriali_on_btn_elimina_clicked (GtkButton *button, + gpointer user_data) +{ + GtkWidget *dialog; + gboolean risp; + + GtkTreeIter iter; + gchar *id; + + AggregazioniTerritoriali *aggregazioni_territoriali = (AggregazioniTerritoriali *)user_data; + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE (aggregazioni_territoriali); + + if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter)) + { + dialog = gtk_message_dialog_new (priv->wtransient, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + "Sicuro di voler eliminare l'aggregazione territoriale selezionata?"); + risp = gtk_dialog_run (GTK_DIALOG (dialog)); + if (risp == GTK_RESPONSE_YES) + { + gtk_tree_model_get (GTK_TREE_MODEL (priv->lstore_aggregazioni_territoriali), &iter, + COL_ID, &id, + -1); + + gdaex_execute (priv->commons->gdaex, + g_strdup_printf ("UPDATE aggregazioni_territoriali SET status = 'E' WHERE id = %s", id)); + + aggregazioni_territoriali_carica (aggregazioni_territoriali); + } + gtk_widget_destroy (dialog); + } + else + { + dialog = gtk_message_dialog_new (priv->wtransient, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "Occorre prima selezionare un'aggregazione territoriale"); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } +} + +static void +aggregazioni_territoriali_on_trv_aggregazioni_territoriali_row_activated (GtkTreeView *tree_view, + GtkTreePath *tree_path, + GtkTreeViewColumn *column, + gpointer user_data) +{ + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE ((AggregazioniTerritoriali *)user_data); + + if (priv->selezione) + { + aggregazioni_territoriali_selezionato ((AggregazioniTerritoriali *)user_data); + } + else + { + aggregazioni_territoriali_modifica ((AggregazioniTerritoriali *)user_data); + } +} + + +static void +aggregazioni_territoriali_on_btn_annulla_clicked (GtkButton *button, + gpointer user_data) +{ + AggregazioniTerritorialiPrivate *priv = AGGREGAZIONI_TERRITORIALI_GET_PRIVATE ((AggregazioniTerritoriali *)user_data); + + gtk_widget_destroy (priv->widget); + g_object_unref (G_OBJECT (user_data)); +} + +static void +aggregazioni_territoriali_on_btn_seleziona_clicked (GtkButton *button, + gpointer user_data) +{ + aggregazioni_territoriali_selezionato ((AggregazioniTerritoriali *)user_data); +} diff --git a/src/aggregazioniterritoriali.h b/src/aggregazioniterritoriali.h new file mode 100644 index 0000000..b3773ca --- /dev/null +++ b/src/aggregazioniterritoriali.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2010 Andrea Zagli + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __AGGREGAZIONI_TERRITORIALI_H__ +#define __AGGREGAZIONI_TERRITORIALI_H__ + +#include +#include + +#include +#include + +#include "commons.h" + +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)) + + +typedef struct _AggregazioniTerritoriali AggregazioniTerritoriali; +typedef struct _AggregazioniTerritorialiClass AggregazioniTerritorialiClass; + +struct _AggregazioniTerritoriali + { + GObject parent; + }; + +struct _AggregazioniTerritorialiClass + { + GObjectClass parent_class; + + guint selezionato_signal_id; + }; + +GType aggregazioni_territoriali_get_type (void) G_GNUC_CONST; + +AggregazioniTerritoriali *aggregazioni_territoriali_new (Commons *commons, gboolean selezione); + +GtkWidget *aggregazioni_territoriali_get_widget (AggregazioniTerritoriali *aggregazioni_territoriali); + + +G_END_DECLS + +#endif /* __AGGREGAZIONI_TERRITORIALI_H__ */ diff --git a/src/main.c b/src/main.c index 5f338b9..9d5ff1c 100644 --- a/src/main.c +++ b/src/main.c @@ -27,6 +27,7 @@ #include #include +#include "aggregazioniterritoriali.h" #include "commons.h" #include "comuni.h" #include "province.h" @@ -120,6 +121,19 @@ on_mnu_tables_tipi_aggregazione_territoriale_activate (GtkMenuItem *menuitem, main_set_vbx_body_child (vbx); } +G_MODULE_EXPORT void +on_mnu_tables_aggregazioni_territoriali_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + GtkWidget *vbx; + + AggregazioniTerritoriali *m = aggregazioni_territoriali_new (commons, FALSE); + + vbx = aggregazioni_territoriali_get_widget (m); + + main_set_vbx_body_child (vbx); +} + G_MODULE_EXPORT void on_mnu_help_about_activate (GtkMenuItem *menuitem, gpointer user_data) -- 2.49.0