/*------------------------------------------------------------------------- * Copyright (c) 1999-2004 Kenneth W. Sodemann (stuffle@mac.com) *------------------------------------------------------------------------- * attrib_dlg * * Synopsis: * Routines used to display the attributes dialog box, which is used * to edit various attributes within the system. * * $Id: attrib_dlg.c,v 1.62 2004/11/26 01:14:29 stuffle Exp $ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to * Free Software Foundation, Inc. * 59 Temple Place, Suite 330 * Boston, MA 02111-1307 USA * *------------------------------------------------------------------------- */ #ifdef HAVE_CONFIG_H # include #endif #include #include #include #include #include #include "db_utils.h" #include "defs.h" #include "error_chks.h" #include "gstr_utils.h" #include "gtkutils.h" #include "attrib_dlg_db.h" #include "prepsmain.h" #include "util.h" /* * Object names */ #define SEVR_LIST_VIEW "sevr_list_view" #define STAT_LIST_VIEW "stat_list_view" #define TYPE_LIST_VIEW "type_list_view" #define NOTEBOOK "attrib_notebook" #define SEVR_SHOW_INACTIVE "sevr_shinact_cb" #define STAT_SHOW_INACTIVE "stat_shinact_cb" #define TYPE_SHOW_INACTIVE "type_shinact_cb" #define COLUMN_NUM "column" /* * Columns in the list widgets */ typedef enum sevr_cols { SEVR_ACTIVE = 0, SEVR_NAME, SEVR_DESCR, SEVR_PK, SEVR_ORDER, SEVR_EDITABLE, NUM_SEVR_COLS } sevr_cols; typedef enum stat_cols { STAT_ACTIVE = 0, STAT_NAME, STAT_IS_CLOSED, STAT_DESCR, STAT_PK, STAT_ORDER, STAT_EDITABLE, NUM_STAT_COLS } stat_cols; typedef enum type_cols { TYPE_ACTIVE = 0, TYPE_NAME, TYPE_DEF_SEVR, TYPE_DESCR, TYPE_PK, TYPE_ORDER, TYPE_EDITABLE, NUM_TYPE_COLS } type_cols; /* * This application can only have one attribute list dialog visible at * a time. This is the one... */ static GtkWidget *attrib_dlg = NULL; typedef struct pk_order_num { gint pk; gint order_num; } pk_order_num; /* * draw_xxxx_list * * These local functions are used to draw the clist boxes for the * attributes dialog. They also display an error box upon an error * occuring. * * These functions return TRUE upon success, and FALSE upon a * failure. */ static gboolean draw_sevr_list (GtkWindow *parent, PGconn *conn) { gint ntuples; gint i; PGresult *res; GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkCheckButton *cb_widget; /* The "show inactive" check box */ gboolean suppress_inactive; gboolean rtn_val = FALSE; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (parent), SEVR_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); cb_widget = GTK_CHECK_BUTTON (lookup_widget (GTK_WIDGET (parent), SEVR_SHOW_INACTIVE)); g_assert (cb_widget != NULL); suppress_inactive = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cb_widget)); editable = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (parent), ADMIN_USER)) == 1); res = read_sevr_data (conn, suppress_inactive); if (chk_sql_error (res, _("reading severity data"))) { ntuples = PQntuples (res); for (i = 0; i < ntuples; i++) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, SEVR_NAME, get_name (res, i), SEVR_DESCR, get_descr (res, i), SEVR_ACTIVE, get_active (res, i), SEVR_PK, get_pk_num (res, i), SEVR_ORDER, get_rank (res, i), SEVR_EDITABLE, editable, -1); } rtn_val = TRUE; } PQclear (res); return rtn_val; } static gboolean draw_stat_list (GtkWindow *parent, PGconn *conn) { gint ntuples; gint i; PGresult *res; GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkCheckButton *cb_widget; gboolean suppress_inactive; gboolean rtn_val = FALSE; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (parent), STAT_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); cb_widget = GTK_CHECK_BUTTON (lookup_widget (GTK_WIDGET (parent), STAT_SHOW_INACTIVE)); g_assert (cb_widget != NULL); suppress_inactive = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cb_widget)); editable = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (parent), ADMIN_USER)) == 1); res = read_stat_data (conn, suppress_inactive); if (chk_sql_error (res, _("reading status data"))) { ntuples = PQntuples (res); for (i = 0; i < ntuples; i++) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, STAT_NAME, get_name (res, i), STAT_DESCR, get_descr (res, i), STAT_ACTIVE, get_active (res, i), STAT_PK, get_pk_num (res, i), STAT_ORDER, get_rank (res, i), STAT_IS_CLOSED, get_closed_status (res, i), STAT_EDITABLE, editable, -1); } rtn_val = TRUE; } PQclear (res); return rtn_val; } static gboolean draw_type_list (GtkWindow *parent, PGconn *conn) { gint ntuples; gint i; PGresult *res; GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkCheckButton *cb_widget; gboolean suppress_inactive; gboolean rtn_val = FALSE; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (parent), TYPE_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); cb_widget = GTK_CHECK_BUTTON (lookup_widget (GTK_WIDGET (parent), TYPE_SHOW_INACTIVE)); g_assert (cb_widget != NULL); suppress_inactive = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cb_widget)); editable = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (parent), ADMIN_USER)) == 1); res = read_type_data (conn, suppress_inactive); if (chk_sql_error (res, _("reading type data"))) { ntuples = PQntuples (res); for (i = 0; i < ntuples; i++) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, TYPE_NAME, get_name (res, i), TYPE_DESCR, get_descr (res, i), TYPE_ACTIVE, get_active (res, i), TYPE_PK, get_pk_num (res, i), TYPE_ORDER, get_rank (res, i), TYPE_DEF_SEVR, get_def_sevr (res, i), TYPE_EDITABLE, editable, -1); } rtn_val = TRUE; } PQclear (res); return rtn_val; } static void update_sevr_active (GtkCellRendererToggle *cell, gchar *path_str, gpointer data) { GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string (path_str); gboolean active; PGconn *conn; gint pk; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), SEVR_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, SEVR_ACTIVE, &active, SEVR_PK, &pk, SEVR_EDITABLE, &editable, -1); if (editable) { active = (active) ? FALSE : TRUE; gtk_list_store_set (store, &iter, SEVR_ACTIVE, active, -1); set_severity_active (conn, pk, active); } gtk_tree_path_free (path); } static void update_stat_active (GtkCellRendererToggle *cell, gchar *path_str, gpointer data) { GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string (path_str); gboolean active; PGconn *conn; gint pk; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), STAT_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, STAT_ACTIVE, &active, STAT_PK, &pk, STAT_EDITABLE, &editable, -1); if (editable) { active = active ? FALSE : TRUE; gtk_list_store_set (store, &iter, STAT_ACTIVE, active, -1); set_status_active (conn, pk, active); } gtk_tree_path_free (path); } static void update_type_active (GtkCellRendererToggle *cell, gchar *path_str, gpointer data) { GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string (path_str); gboolean active; PGconn *conn; gint pk; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), TYPE_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, TYPE_ACTIVE, &active, TYPE_PK, &pk, TYPE_EDITABLE, &editable, -1); if (editable) { active = active ? FALSE : TRUE; gtk_list_store_set (store, &iter, TYPE_ACTIVE, active, -1); set_type_active (conn, pk, active); } gtk_tree_path_free (path); } static void update_stat_closed (GtkCellRendererToggle *cell, gchar *path_str, gpointer data) { GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string (path_str); gboolean closed; PGconn *conn; gint pk; gboolean editable; tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), STAT_LIST_VIEW)); g_assert (tree != NULL); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, STAT_IS_CLOSED, &closed, STAT_PK, &pk, STAT_EDITABLE, &editable, -1); if (editable) { closed = closed ? FALSE : TRUE; gtk_list_store_set (store, &iter, STAT_IS_CLOSED, closed, -1); set_status_closed (conn, pk, closed); } gtk_tree_path_free (path); } static void sevr_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer data) { GtkTreeView *tree; GtkListStore *store; gint column; GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; gint pk; PGconn *conn; GString *str; /* * Examine the new text, if it is empty, do nothing. Do not * even set the item in the list store. */ str = g_string_new (new_text); str = g_string_strip (str); if (str->len > 0) { conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), COLUMN_NUM)); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), SEVR_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, SEVR_PK, &pk, -1); switch (column) { case SEVR_NAME: if (set_severity_name (conn, pk, new_text)) { gtk_list_store_set (store, &iter, SEVR_NAME, new_text, -1); } break; case SEVR_DESCR: if (set_severity_descr (conn, pk, new_text)) { gtk_list_store_set (store, &iter, SEVR_DESCR, new_text, -1); } break; default: g_assert_not_reached(); } } g_string_free (str, TRUE); gtk_tree_path_free (path); } static void stat_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer data) { GtkTreeView *tree; GtkListStore *store; gint column; GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; gint pk; PGconn *conn; GString *str; /* * Examine the new text, if it is empty, do nothing. Do not * even set the item in the list store. */ str = g_string_new (new_text); str = g_string_strip (str); if (str->len > 0) { conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), COLUMN_NUM)); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), STAT_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, STAT_PK, &pk, -1); switch (column) { case STAT_NAME: if (set_status_name (conn, pk, new_text)) { gtk_list_store_set (store, &iter, STAT_NAME, new_text, -1); } break; case STAT_DESCR: if (set_status_descr (conn, pk, new_text)) { gtk_list_store_set (store, &iter, STAT_DESCR, new_text, -1); } break; default: g_assert_not_reached(); } } g_string_free (str, TRUE); gtk_tree_path_free (path); } static void type_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer data) { GtkTreeView *tree; GtkListStore *store; gint column; GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; gint pk; gint sevr_pk; PGconn *conn; GString *str; GtkWidget *msg_dlg; /* * Examine the new text, if it is empty, do nothing. Do not * even set the item in the list store. */ str = g_string_new (new_text); str = g_string_strip (str); if (str->len > 0) { conn = g_object_get_data (G_OBJECT (data), MY_DB_CONN); g_assert (conn != NULL); column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), COLUMN_NUM)); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (data), TYPE_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, TYPE_PK, &pk, -1); switch (column) { case TYPE_NAME: if (set_type_name (conn, pk, new_text)) { gtk_list_store_set (store, &iter, TYPE_NAME, new_text, -1); } break; case TYPE_DEF_SEVR: sevr_pk = get_severity_pk (conn, new_text); if (sevr_pk != -1) { if (set_type_sevr (conn, pk, sevr_pk)) { gtk_list_store_set (store, &iter, TYPE_DEF_SEVR, new_text, -1); } } else { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("'%s' is not a valid severity."), new_text); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); } break; case TYPE_DESCR: if (set_type_descr (conn, pk, new_text)) { gtk_list_store_set (store, &iter, TYPE_DESCR, new_text, -1); } break; default: g_assert_not_reached(); } } g_string_free (str, TRUE); gtk_tree_path_free (path); } /*------------------------------------------------------------------------ * attributes dialog signal handlers * * Signal handler functions for the attributes dialog box. *------------------------------------------------------------------------ */ static void on_sevr_drag_end (GtkWidget *widget, GdkDragContext *drag_context, gpointer user_data) { GtkTreeModel *treemodel; GtkTreeIter iter; GtkTreePath *path; PGconn *conn; gint idx; gint order; gint pk; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); /* * On a drag and drop, we are pretty much doing a brute force loop * through all of them items. */ if (gtk_tree_model_get_iter_first (treemodel, &iter)) { do { path = gtk_tree_model_get_path (treemodel, &iter); idx = (gtk_tree_path_get_indices (path)[0]) + 1; gtk_tree_path_free (path); gtk_tree_model_get (treemodel, &iter, SEVR_ORDER, &order, SEVR_PK, &pk, -1); if (order != idx) { gtk_list_store_set (GTK_LIST_STORE (treemodel), &iter, SEVR_ORDER, idx, -1); set_severity_order (conn, pk, idx); } } while (gtk_tree_model_iter_next (treemodel, &iter)); } } static void on_stat_drag_end (GtkWidget *widget, GdkDragContext *drag_context, gpointer user_data) { GtkTreeModel *treemodel; GtkTreeIter iter; GtkTreePath *path; PGconn *conn; gint idx; gint order; gint pk; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (gtk_tree_model_get_iter_first (treemodel, &iter)) { do { path = gtk_tree_model_get_path (treemodel, &iter); idx = (gtk_tree_path_get_indices (path)[0]) + 1; gtk_tree_path_free (path); gtk_tree_model_get (treemodel, &iter, STAT_ORDER, &order, STAT_PK, &pk, -1); if (order != idx) { gtk_list_store_set (GTK_LIST_STORE (treemodel), &iter, STAT_ORDER, idx, -1); set_status_order (conn, pk, idx); } } while (gtk_tree_model_iter_next (treemodel, &iter)); } } static void on_type_drag_end (GtkWidget *widget, GdkDragContext *drag_context, gpointer user_data) { GtkTreeModel *treemodel; GtkTreeIter iter; GtkTreePath *path; PGconn *conn; gint idx; gint order; gint pk; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (gtk_tree_model_get_iter_first (treemodel, &iter)) { do { path = gtk_tree_model_get_path (treemodel, &iter); idx = (gtk_tree_path_get_indices (path)[0]) + 1; gtk_tree_path_free (path); gtk_tree_model_get (treemodel, &iter, TYPE_ORDER, &order, TYPE_PK, &pk, -1); if (order != idx) { gtk_list_store_set (GTK_LIST_STORE (treemodel), &iter, TYPE_ORDER, idx, -1); set_type_order (conn, pk, idx); } } while (gtk_tree_model_iter_next (treemodel, &iter)); } } static void on_attributes_dlg_show (GtkWidget *widget, gpointer user_data) { gboolean in_error = TRUE; /* Set FALSE if we do not encounter an error at any step. */ PGconn *conn = (PGconn *)user_data; GtkToggleButton *cb; GtkNotebook *notebk; GString *config_str; gint page; gboolean flag; GConfClient *client; GError *error = NULL; config_str = g_string_new (""); client = g_object_get_data (G_OBJECT (widget), MY_GCONF_CLIENT); g_assert (client != NULL); notebk = GTK_NOTEBOOK (lookup_widget (widget, NOTEBOOK)); g_assert (notebk != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, ACTIVE_TAB); page = gconf_client_get_int (client, config_str->str, &error); if (error != NULL) { g_warning (error->message); g_error_free (error); error = NULL; page = 0; } gtk_notebook_set_current_page (notebk, page); cb = GTK_TOGGLE_BUTTON (lookup_widget (widget, SEVR_SHOW_INACTIVE)); g_assert (cb != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, SEVR_SH_INACT); flag = gconf_client_get_bool (client, config_str->str, &error); if (error != NULL) { g_warning (error->message); g_error_free (error); error = NULL; flag = FALSE; } gtk_toggle_button_set_active (cb, flag); cb = GTK_TOGGLE_BUTTON (lookup_widget (widget, STAT_SHOW_INACTIVE)); g_assert (cb != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, STAT_SH_INACT); flag = gconf_client_get_bool (client, config_str->str, &error); if (error != NULL) { g_warning (error->message); g_error_free (error); error = NULL; flag = FALSE; } gtk_toggle_button_set_active (cb, flag); cb = GTK_TOGGLE_BUTTON (lookup_widget (widget, TYPE_SHOW_INACTIVE)); g_assert (cb != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, TYPE_SH_INACT); flag = gconf_client_get_bool (client, config_str->str, &error); if (error != NULL) { g_warning (error->message); g_error_free (error); error = NULL; flag = FALSE; } gtk_toggle_button_set_active (cb, flag); g_string_free (config_str, TRUE); if (draw_sevr_list (GTK_WINDOW (widget), conn)) { if (draw_stat_list (GTK_WINDOW (widget), conn)) { if (draw_type_list (GTK_WINDOW (widget), conn)) { in_error = FALSE; } } } if (in_error) { gtk_widget_destroy (GTK_WIDGET (widget)); } return; } static void on_attributes_dlg_destroy (GObject *object, gpointer user_data) { GtkNotebook *notebook; GtkToggleButton *cb; GString *config_str; GConfClient *client; /* * Save the state of the dialog for the next time we open it. */ client = g_object_get_data (object, MY_GCONF_CLIENT); g_assert (client != NULL); config_str = g_string_new (""); notebook = GTK_NOTEBOOK (lookup_widget (GTK_WIDGET (object), NOTEBOOK)); g_assert (notebook != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, ACTIVE_TAB); gconf_client_set_int (client, config_str->str, gtk_notebook_get_current_page (notebook), NULL); cb = GTK_TOGGLE_BUTTON (lookup_widget (GTK_WIDGET (object), SEVR_SHOW_INACTIVE)); g_assert (cb != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, SEVR_SH_INACT); gconf_client_set_bool (client, config_str->str, gtk_toggle_button_get_active (cb), NULL); cb = GTK_TOGGLE_BUTTON (lookup_widget (GTK_WIDGET (object), STAT_SHOW_INACTIVE)); g_assert (cb != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, STAT_SH_INACT); gconf_client_set_bool (client, config_str->str, gtk_toggle_button_get_active (cb), NULL); cb = GTK_TOGGLE_BUTTON (lookup_widget (GTK_WIDGET (object), TYPE_SHOW_INACTIVE)); g_assert (cb != NULL); g_string_printf (config_str, "%s/%s/%s/%s", BASE_KEY, WINSTATES, ATTR_DLG_SEC, TYPE_SH_INACT); gconf_client_set_bool (client, config_str->str, gtk_toggle_button_get_active (cb), NULL); g_string_free (config_str, TRUE); } static void on_attributes_dlg_clicked (GtkDialog *dlg, gint response, gpointer user_data) { GConfClient *client; client = g_object_get_data (G_OBJECT (dlg), MY_GCONF_CLIENT); g_assert (client != NULL); save_dlg_size (client, GTK_WIDGET (dlg), ATTR_DLG_SEC); gtk_widget_destroy (GTK_WIDGET (dlg)); } static void on_sevr_add (GtkWidget *widget, gpointer user_data) { PGconn *conn; gint pk; GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (user_data), SEVR_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); if (create_severity (conn, _("new_sevr"), _("Generic Description"), &pk)) { GtkTreePath *path; gint idx; gtk_list_store_append (store, &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); idx = gtk_tree_path_get_indices (path)[0] + 1; gtk_tree_path_free (path); gtk_list_store_set (store, &iter, SEVR_NAME, _("new_sevr"), SEVR_DESCR, _("Generic Description"), SEVR_ACTIVE, TRUE, SEVR_PK, pk, SEVR_ORDER, idx, SEVR_EDITABLE, TRUE, -1); set_severity_order (conn, pk, idx); } } static void on_sevr_del (GtkWidget *widget, gpointer user_data) { gint pk_num; PGconn *conn; GtkWidget *msg_dlg; GtkTreeIter iter; GtkTreeView *tree; GtkListStore *store; GtkTreeSelection *sel; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (user_data), SEVR_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); sel = gtk_tree_view_get_selection (tree); if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("Deleting a severity is not reversable.\nAre you sure you want to continue?")); if (gtk_dialog_run (GTK_DIALOG (msg_dlg)) == GTK_RESPONSE_YES) { gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, SEVR_PK, &pk_num, -1); if (delete_severity (conn, pk_num)); { gtk_list_store_remove (store, &iter); } } gtk_widget_destroy (msg_dlg); } else { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("To delete a severity, you must select a severity to delete.")); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); } } static void on_sevr_show_inactive_toggled (GtkToggleButton *togglebutton, gpointer user_data) { PGconn *conn; /* * Just redraw the stuff in the box. The draw routine will * take care it the rest. */ conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); draw_sevr_list (GTK_WINDOW (user_data), conn); } static void on_stat_add (GtkWidget *widget, gpointer user_data) { PGconn *conn; gint pk; GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (user_data), STAT_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); if (create_status (conn, _("new_status"), _("Generic Description"), FALSE, &pk)) { GtkTreePath *path; gint idx; gtk_list_store_append (store, &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); idx = gtk_tree_path_get_indices (path)[0] + 1; gtk_tree_path_free (path); gtk_list_store_set (store, &iter, STAT_NAME, _("new_status"), STAT_DESCR, _("Generic Description"), STAT_ACTIVE, TRUE, STAT_IS_CLOSED, FALSE, STAT_PK, pk, STAT_ORDER, idx, STAT_EDITABLE, TRUE, -1); set_status_order (conn, pk, idx); } } static void on_stat_del (GtkWidget *widget, gpointer user_data) { gint pk_num; PGconn *conn; GtkWidget *msg_dlg; GtkTreeIter iter; GtkTreeView *tree; GtkListStore *store; GtkTreeSelection *sel; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (user_data), STAT_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); sel = gtk_tree_view_get_selection (tree); if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("Deleting a status is not reversable.\nAre you sure you want to continue?")); if (gtk_dialog_run (GTK_DIALOG (msg_dlg)) == GTK_RESPONSE_YES) { gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, STAT_PK, &pk_num, -1); if (delete_status (conn, pk_num)) { gtk_list_store_remove (store, &iter); } } gtk_widget_destroy (msg_dlg); } else { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("To deleta a status, you must select a status to delete.")); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); } } static void on_stat_show_inactive_toggled (GtkToggleButton *togglebutton, gpointer user_data) { PGconn *conn; /* * Just redraw the stuff in the box. The draw routine will * take care it the rest. */ conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); draw_stat_list (GTK_WINDOW (user_data), conn); } static void on_type_add (GtkWidget *widget, gpointer user_data) { PGconn *conn; PGresult *res; gint pk; GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GString *sevr_str; gint sevr_pk; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (user_data), TYPE_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); res = read_sevr_data (conn, TRUE); if (chk_sql_error (res, _("Get Default Severity"))) { sevr_str = g_string_new (get_name (res, 0)); sevr_pk = get_pk_num (res, 0); if (create_type (conn, _("new_type"), _("Generic Description"), sevr_pk, &pk)) { GtkTreePath *path; gint idx; gtk_list_store_append (store, &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); idx = gtk_tree_path_get_indices (path)[0] + 1; gtk_tree_path_free (path); gtk_list_store_set (store, &iter, TYPE_NAME, _("new_type"), TYPE_DESCR, _("Generic Description"), TYPE_ACTIVE, TRUE, TYPE_DEF_SEVR, sevr_str->str, TYPE_PK, pk, TYPE_ORDER, idx, TYPE_EDITABLE, TRUE, -1); set_severity_order (conn, pk, idx); } g_string_free (sevr_str, TRUE); } PQclear (res); } static void on_type_del (GtkWidget *widget, gpointer user_data) { gint pk_num; PGconn *conn; GtkWidget *msg_dlg; GtkTreeIter iter; GtkTreeView *tree; GtkListStore *store; GtkTreeSelection *sel; conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (user_data), TYPE_LIST_VIEW)); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); sel = gtk_tree_view_get_selection (tree); if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("Deleting a type is not reversable.\nAre you sure you want to continue?")); if (gtk_dialog_run (GTK_DIALOG (msg_dlg)) == GTK_RESPONSE_YES) { gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, TYPE_PK, &pk_num, -1); if (delete_type (conn, pk_num)) { gtk_list_store_remove (store, &iter); } } gtk_widget_destroy (msg_dlg); } else { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("To deleta a type, you must select a type to delete.")); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); } } static void on_type_show_inactive_toggled (GtkToggleButton *togglebutton, gpointer user_data) { PGconn *conn; /* * Just redraw the stuff in the box. The draw routine will * take care it the rest. */ conn = g_object_get_data (G_OBJECT (user_data), MY_DB_CONN); g_assert (conn != NULL); draw_type_list (GTK_WINDOW (user_data), conn); } static GtkWidget * create_attrib_dlg (GtkWidget *parent, PGconn *conn, gboolean user_is_admin) { GtkWidget *attributes_dlg; GtkWidget *vbox3; GtkWidget *notebook1; GtkWidget *vbox4; GtkWidget *sevr_scroll; GtkWidget *sevr_list_view; GtkListStore *sevr_list_store; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkWidget *hbox6; GtkWidget *sevr_add_butt; GtkWidget *sevr_del_butt; GtkWidget *sevr_show_inactive; GtkWidget *vbox5; GtkWidget *stat_scroll; GtkWidget *stat_list_view; GtkListStore *stat_list_store; GtkWidget *hbox4; GtkWidget *stat_add_butt; GtkWidget *stat_del_butt; GtkWidget *stat_show_inactive; GtkWidget *vbox7; GtkWidget *type_scroll; GtkWidget *type_list_view; GtkListStore *type_list_store; GtkWidget *hbox7; GtkWidget *type_add_butt; GtkWidget *type_del_butt; GtkWidget *type_show_inactive; GtkWidget *sevr_label; GtkWidget *stat_label; GtkWidget *type_label; GtkWidget *warn_hbox; GtkWidget *warn_icon; GtkWidget *warn_lbl; GtkTooltips *tooltips; GConfClient *client; tooltips = g_object_get_data (G_OBJECT (parent), TOOLTIPS); g_assert (tooltips != NULL); client = g_object_get_data (G_OBJECT (parent), MY_GCONF_CLIENT); g_assert (client != NULL); attributes_dlg = gtk_dialog_new_with_buttons (_("Problem Report Attributes"), GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); GLADE_HOOKUP_OBJECT_NO_REF (attributes_dlg, attributes_dlg, "attributes_dlg"); g_signal_connect (attributes_dlg, "show", G_CALLBACK (on_attributes_dlg_show), conn); g_signal_connect (attributes_dlg, "response", G_CALLBACK (on_attributes_dlg_clicked), NULL); gtk_window_set_resizable (GTK_WINDOW (attributes_dlg), TRUE); g_signal_connect (attributes_dlg, "destroy", G_CALLBACK (on_attributes_dlg_destroy), NULL); g_object_set_data (G_OBJECT (attributes_dlg), MY_DB_CONN, conn); g_object_set_data (G_OBJECT (attributes_dlg), MY_GCONF_CLIENT, client); g_object_set_data (G_OBJECT (attributes_dlg), ADMIN_USER, GINT_TO_POINTER (user_is_admin ? 1 : 0)); set_dlg_size (client, attributes_dlg, ATTR_DLG_SEC, 525, 300); vbox3 = GTK_DIALOG (attributes_dlg)->vbox; gtk_box_set_spacing (GTK_BOX (vbox3), STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, vbox3, "vbox3"); gtk_widget_show (vbox3); notebook1 = gtk_notebook_new (); GLADE_HOOKUP_OBJECT (attributes_dlg, notebook1, NOTEBOOK); gtk_widget_show (notebook1); gtk_box_pack_start (GTK_BOX (vbox3), notebook1, TRUE, TRUE, 0); vbox4 = gtk_vbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, vbox4, "vbox4"); gtk_widget_show (vbox4); gtk_container_add (GTK_CONTAINER (notebook1), vbox4); gtk_container_set_border_width (GTK_CONTAINER (vbox4), 5); sevr_scroll = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (attributes_dlg, sevr_scroll, "sevr_scroll"); gtk_widget_show (sevr_scroll); gtk_box_pack_start (GTK_BOX (vbox4), sevr_scroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sevr_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sevr_scroll), GTK_SHADOW_ETCHED_IN); sevr_list_store = gtk_list_store_new (NUM_SEVR_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN); sevr_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (sevr_list_store)); GLADE_HOOKUP_OBJECT (attributes_dlg, sevr_list_view, SEVR_LIST_VIEW); gtk_widget_show (sevr_list_view); if (user_is_admin) { gtk_tree_view_set_reorderable (GTK_TREE_VIEW (sevr_list_view), TRUE); g_signal_connect (sevr_list_view, "drag-end", G_CALLBACK (on_sevr_drag_end), attributes_dlg); } gtk_container_add (GTK_CONTAINER (sevr_scroll), sevr_list_view); rend = gtk_cell_renderer_toggle_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (SEVR_ACTIVE)); g_signal_connect (rend, "toggled", G_CALLBACK (update_sevr_active), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Active?"), rend, "active", SEVR_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (sevr_list_view), col); rend = gtk_cell_renderer_text_new (); g_signal_connect (rend, "edited", G_CALLBACK (sevr_edited), attributes_dlg); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (SEVR_NAME)); col = gtk_tree_view_column_new_with_attributes (_("Name"), rend, "text", SEVR_NAME, "editable", SEVR_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (sevr_list_view), col); rend = gtk_cell_renderer_text_new (); g_signal_connect (rend, "edited", G_CALLBACK (sevr_edited), attributes_dlg); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (SEVR_DESCR)); col = gtk_tree_view_column_new_with_attributes (_("Description"), rend, "text", SEVR_DESCR, "editable", SEVR_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (sevr_list_view), col); hbox6 = gtk_hbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, hbox6, "hbox6"); gtk_widget_show (hbox6); gtk_box_pack_start (GTK_BOX (vbox4), hbox6, FALSE, FALSE, 0); sevr_add_butt = gtk_button_new_from_stock (GTK_STOCK_ADD); GLADE_HOOKUP_OBJECT (attributes_dlg, sevr_add_butt, "sevr_add_butt"); gtk_widget_show (sevr_add_butt); gtk_box_pack_start (GTK_BOX (hbox6), sevr_add_butt, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, sevr_add_butt, "Add a severity to the list.", NULL); g_signal_connect (sevr_add_butt, "clicked", G_CALLBACK (on_sevr_add), attributes_dlg); gtk_widget_set_sensitive (sevr_add_butt, user_is_admin); sevr_del_butt = gtk_button_new_from_stock (GTK_STOCK_REMOVE); GLADE_HOOKUP_OBJECT (attributes_dlg, sevr_del_butt, "sevr_del_butt"); gtk_widget_show (sevr_del_butt); gtk_box_pack_start (GTK_BOX (hbox6), sevr_del_butt, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, sevr_del_butt, _("Delete the currently selected severity. Note that this will only work if the severity is not used. If the severity is used, you may deactivate it using the \"Modify\" button."), NULL); g_signal_connect (sevr_del_butt, "clicked", G_CALLBACK (on_sevr_del), attributes_dlg); gtk_widget_set_sensitive (sevr_del_butt, user_is_admin); sevr_show_inactive = gtk_check_button_new_with_label ("Show Inactive Severities"); GLADE_HOOKUP_OBJECT (attributes_dlg, sevr_show_inactive, SEVR_SHOW_INACTIVE); gtk_widget_show (sevr_show_inactive); gtk_box_pack_start (GTK_BOX (hbox6), sevr_show_inactive, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, sevr_show_inactive, "Toggle the display of severities that are not active", NULL); g_signal_connect (sevr_show_inactive, "toggled", G_CALLBACK (on_sevr_show_inactive_toggled), attributes_dlg); vbox5 = gtk_vbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, vbox5, "vbox5"); gtk_widget_show (vbox5); gtk_container_add (GTK_CONTAINER (notebook1), vbox5); gtk_container_set_border_width (GTK_CONTAINER (vbox5), 5); stat_scroll = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (attributes_dlg, stat_scroll, "stat_scroll"); gtk_widget_show (stat_scroll); gtk_box_pack_start (GTK_BOX (vbox5), stat_scroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (stat_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (stat_scroll), GTK_SHADOW_ETCHED_IN); stat_list_store = gtk_list_store_new (NUM_STAT_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN); stat_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (stat_list_store)); GLADE_HOOKUP_OBJECT (attributes_dlg, stat_list_view, STAT_LIST_VIEW); gtk_widget_show (stat_list_view); if (user_is_admin) { gtk_tree_view_set_reorderable (GTK_TREE_VIEW (stat_list_view), TRUE); g_signal_connect (stat_list_view, "drag-end", G_CALLBACK (on_stat_drag_end), attributes_dlg); } gtk_container_add (GTK_CONTAINER (stat_scroll), stat_list_view); rend = gtk_cell_renderer_toggle_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (STAT_ACTIVE)); g_signal_connect (rend, "toggled", G_CALLBACK (update_stat_active), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Active?"), rend, "active", STAT_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (stat_list_view), col); rend = gtk_cell_renderer_text_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (STAT_NAME)); g_signal_connect (rend, "edited", G_CALLBACK (stat_edited), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Name"), rend, "text", STAT_NAME, "editable", STAT_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (stat_list_view), col); rend = gtk_cell_renderer_toggle_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (STAT_IS_CLOSED)); g_signal_connect (rend, "toggled", G_CALLBACK (update_stat_closed), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Closed?"), rend, "active", STAT_IS_CLOSED, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (stat_list_view), col); rend = gtk_cell_renderer_text_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (STAT_DESCR)); g_signal_connect (rend, "edited", G_CALLBACK (stat_edited), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Description"), rend, "text", STAT_DESCR, "editable", STAT_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (stat_list_view), col); hbox4 = gtk_hbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, hbox4, "hbox4"); gtk_widget_show (hbox4); gtk_box_pack_start (GTK_BOX (vbox5), hbox4, FALSE, FALSE, 0); stat_add_butt = gtk_button_new_from_stock (GTK_STOCK_ADD); GLADE_HOOKUP_OBJECT (attributes_dlg, stat_add_butt, "stat_add_butt"); gtk_widget_show (stat_add_butt); gtk_box_pack_start (GTK_BOX (hbox4), stat_add_butt, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, stat_add_butt, _("Add a status to the list."), NULL); g_signal_connect (stat_add_butt, "clicked", G_CALLBACK(on_stat_add), attributes_dlg); gtk_widget_set_sensitive (stat_add_butt, user_is_admin); stat_del_butt = gtk_button_new_from_stock (GTK_STOCK_REMOVE); GLADE_HOOKUP_OBJECT (attributes_dlg, stat_del_butt, "stat_del_butt"); gtk_widget_show (stat_del_butt); gtk_box_pack_start (GTK_BOX (hbox4), stat_del_butt, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, stat_del_butt, _("Delete the currently selected status. Note that this will only work if the status is not used. If the status is used, you may deactivate it using the \"Modify\" button."), NULL); g_signal_connect (stat_del_butt, "clicked", G_CALLBACK (on_stat_del), attributes_dlg); gtk_widget_set_sensitive (stat_del_butt, user_is_admin); stat_show_inactive = gtk_check_button_new_with_label (_("Show Inactive Statuses")); GLADE_HOOKUP_OBJECT (attributes_dlg, stat_show_inactive, STAT_SHOW_INACTIVE); gtk_widget_show (stat_show_inactive); gtk_box_pack_start (GTK_BOX (hbox4), stat_show_inactive, TRUE, TRUE, 0); g_signal_connect (stat_show_inactive, "toggled", G_CALLBACK (on_stat_show_inactive_toggled), attributes_dlg); vbox7 = gtk_vbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, vbox7, "vbox7"); gtk_widget_show (vbox7); gtk_container_add (GTK_CONTAINER (notebook1), vbox7); gtk_container_set_border_width (GTK_CONTAINER (vbox7), 5); type_scroll = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (attributes_dlg, type_scroll, "type_scroll"); gtk_widget_show (type_scroll); gtk_box_pack_start (GTK_BOX (vbox7), type_scroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (type_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (type_scroll), GTK_SHADOW_ETCHED_IN); type_list_store = gtk_list_store_new (NUM_TYPE_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN); type_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (type_list_store)); GLADE_HOOKUP_OBJECT (attributes_dlg, type_list_view, TYPE_LIST_VIEW); gtk_widget_show (type_list_view); if (user_is_admin) { gtk_tree_view_set_reorderable (GTK_TREE_VIEW (type_list_view), TRUE); g_signal_connect (type_list_view, "drag-end", G_CALLBACK (on_type_drag_end), attributes_dlg); } gtk_container_add (GTK_CONTAINER (type_scroll), type_list_view); rend = gtk_cell_renderer_toggle_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (TYPE_ACTIVE)); g_signal_connect (rend, "toggled", G_CALLBACK (update_type_active), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Active?"), rend, "active", TYPE_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (type_list_view), col); rend = gtk_cell_renderer_text_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (TYPE_NAME)); g_signal_connect (rend, "edited", G_CALLBACK (type_edited), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Name"), rend, "text", TYPE_NAME, "editable", TYPE_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (type_list_view), col); rend = gtk_cell_renderer_text_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (TYPE_DEF_SEVR)); g_signal_connect (rend, "edited", G_CALLBACK (type_edited), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Def Severity"), rend, "text", TYPE_DEF_SEVR, "editable", TYPE_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (type_list_view), col); rend = gtk_cell_renderer_text_new (); g_object_set_data (G_OBJECT (rend), COLUMN_NUM, GINT_TO_POINTER (TYPE_DESCR)); g_signal_connect (rend, "edited", G_CALLBACK (type_edited), attributes_dlg); col = gtk_tree_view_column_new_with_attributes (_("Description"), rend, "text", TYPE_DESCR, "editable", TYPE_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (type_list_view), col); hbox7 = gtk_hbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, hbox7, "hbox7"); gtk_widget_show (hbox7); gtk_box_pack_start (GTK_BOX (vbox7), hbox7, FALSE, FALSE, 0); type_add_butt = gtk_button_new_from_stock (GTK_STOCK_ADD); GLADE_HOOKUP_OBJECT (attributes_dlg, type_add_butt, "type_add_butt"); gtk_widget_show (type_add_butt); gtk_box_pack_start (GTK_BOX (hbox7), type_add_butt, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, type_add_butt, _("Add a type to the list."), NULL); g_signal_connect (type_add_butt, "clicked", G_CALLBACK (on_type_add), attributes_dlg); gtk_widget_set_sensitive (type_add_butt, user_is_admin); type_del_butt = gtk_button_new_from_stock (GTK_STOCK_REMOVE); GLADE_HOOKUP_OBJECT (attributes_dlg, type_del_butt, "type_del_butt"); gtk_widget_show (type_del_butt); gtk_box_pack_start (GTK_BOX (hbox7), type_del_butt, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, type_del_butt, _("Delete the currently selected type. Note that this will only work if the type is not used. If the type is used, you may deactivate it using the \"Modify\" button."), NULL); g_signal_connect (type_del_butt, "clicked", G_CALLBACK (on_type_del), attributes_dlg); gtk_widget_set_sensitive (type_del_butt, user_is_admin); type_show_inactive = gtk_check_button_new_with_label (_("Show Inactive Types")); GLADE_HOOKUP_OBJECT (attributes_dlg, type_show_inactive, TYPE_SHOW_INACTIVE); gtk_widget_show (type_show_inactive); gtk_box_pack_start (GTK_BOX (hbox7), type_show_inactive, TRUE, TRUE, 0); g_signal_connect (type_show_inactive, "toggled", G_CALLBACK (on_type_show_inactive_toggled), attributes_dlg); sevr_label = gtk_label_new (_("Severity")); GLADE_HOOKUP_OBJECT (attributes_dlg, sevr_label, "sevr_label"); gtk_widget_show (sevr_label); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), sevr_label); gtk_label_set_justify (GTK_LABEL (sevr_label), GTK_JUSTIFY_LEFT); stat_label = gtk_label_new (_("Status")); GLADE_HOOKUP_OBJECT (attributes_dlg, stat_label, "stat_label"); gtk_widget_show (stat_label); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), stat_label); gtk_label_set_justify (GTK_LABEL (stat_label), GTK_JUSTIFY_LEFT); type_label = gtk_label_new (_("Type")); GLADE_HOOKUP_OBJECT (attributes_dlg, type_label, "type_label"); gtk_widget_show (type_label); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), type_label); gtk_label_set_justify (GTK_LABEL (type_label), GTK_JUSTIFY_LEFT); if (!user_is_admin) { warn_hbox = gtk_hbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (attributes_dlg, warn_hbox, "warn1_hbox"); gtk_box_pack_start (GTK_BOX (vbox3), warn_hbox, FALSE, FALSE, 0); gtk_widget_show (warn_hbox); warn_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_SMALL_TOOLBAR); GLADE_HOOKUP_OBJECT (attributes_dlg, warn_icon, "warn1_icon"); gtk_box_pack_start (GTK_BOX (warn_hbox), warn_icon, FALSE, FALSE, 0); gtk_widget_show (warn_icon); warn_lbl = gtk_label_new (NULL); GLADE_HOOKUP_OBJECT (attributes_dlg, warn_lbl, "warn1_lbl"); gtk_label_set_markup (GTK_LABEL (warn_lbl), _("Editing Disabled: only administrators can edit the attributes.")); gtk_box_pack_start (GTK_BOX (warn_hbox), warn_lbl, FALSE, FALSE, 0); gtk_widget_show (warn_lbl); } g_object_set_data (G_OBJECT (attributes_dlg), TOOLTIPS, tooltips); return attributes_dlg; } void destroy_attrib_dlg (void) { if (attrib_dlg != NULL) { gtk_widget_destroy (attrib_dlg); attrib_dlg = NULL; } } void show_attrib_dlg (GtkWidget *parent, PGconn *conn, gboolean user_is_admin) { /* * If the dialog box exists, just make sure it is visable, otherwise * create it. */ if (attrib_dlg != NULL) { gdk_window_show (attrib_dlg->window); gdk_window_raise (attrib_dlg->window); } else { attrib_dlg = create_attrib_dlg (parent, conn, user_is_admin); /* * When the dialog is destroyed, call gtk_widget_destroyed(), * which will set the "user_data" (&attrib_dlg in this case) to * NULL. */ g_signal_connect (attrib_dlg, "destroy", G_CALLBACK (gtk_widget_destroyed), &attrib_dlg); gtk_widget_show (attrib_dlg); } } /* * TODO: Delete this.... */ gboolean attrib_dlg_dirty (void) { return FALSE; }