/*------------------------------------------------------------------------- * Copyright (c) 1999-2005 Kenneth W. Sodemann (stuffle@mac.com) *------------------------------------------------------------------------- * query_dlg * * Synopsis: * Create and edit problem report queries. * * $Id: query_dlg.c,v 1.59 2005/02/22 02:12:14 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 #include #include #include "db_utils.h" #include "defs.h" #include "error_chks.h" #include "gstr_utils.h" #include "gtkutils.h" #include "mainwin.h" #include "prq_utils.h" #include "sqlstr.h" #include "util.h" #define QUERY_LIST_VIEW "query_list_view" #define OK_BUTTON "ok_button" #define CAN_BUTTON "can_button" #define DESCR_TEXT "descr_text" #define NAME_ENTRY "name_entry" #define SEVR_LIST_VIEW "sevr_list_view" #define STAT_LIST_VIEW "stat_list_view" #define PT_LIST_VIEW "pt_list_view" #define SUB_LIST_VIEW "sub_list_view" #define RESP_LIST_VIEW "resp_list_view" #define ORDER_BY_ENTRY "order_by_entry" #define IS_SYS_QUERY_LIST "is_sys_query_list" #define RAW_SQL_TEXT "raw_sql_text" #define RESPONSE_NEW 1 #define RESPONSE_NEW_RAW 2 #define RESPONSE_OPEN 3 #define RESPONSE_REMOVE 4 #define NAME_COL 0 #define RAW_YN_COL 1 #define DESCR_COL 2 #define NUM_COLS 3 #define YN_BUFF_SIZE 4 #define YES "yes" #define NO "no" #define STD_COL_WIDTH 120 #define QUERY_NUM_POS 0 #define NAME_POS 1 #define DESCR_POS 2 #define IS_RAW_POS 3 #define ORDER_NUM_POS 4 #define RAW_SQL_POS 4 #define ORDER_BY_POS 5 #define GET_QUERY " \ SELECT query_num, name, descr, is_raw_sql, raw_sql, order_by, order_num \ FROM pr_query \ WHERE query_num = %d " #define SYSTEM_QUERIES " \ SELECT query_num, name, descr, is_raw_sql, order_num \ FROM pr_query \ WHERE is_system_query = TRUE \ ORDER BY order_num" #define USER_QUERIES " \ SELECT query_num, name, descr, is_raw_sql, order_num \ FROM pr_query \ WHERE is_system_query = FALSE \ AND creator = getpgusername () \ ORDER BY order_num " #define SELECT_PEOPLE "\ SELECT p.login_id, \ p.last_name || ', ' || p.first_name || ' (' || p.login_id || ')' \ FROM person p \ WHERE 1 = 1 " #define DELETE_QUERY "\ DELETE \ FROM pr_query \ WHERE query_num = %d " #define UPDATE_ORDER_NUM "\ UPDATE pr_query \ SET order_num = %d \ WHERE query_num = %d " #define ORDER_BY_NUM " ORDER BY order_num " #define SUB_RESP_ORDER_BY " ORDER BY 2, 1 " enum { ATTRIB_NAME = 0, ATTRIB_PK, NUM_ATTRIB_COLS }; enum { QUERY_NAME = 0, QUERY_IS_RAW, QUERY_DESCR, QUERY_PK, QUERY_ORDER, NUM_QUERY_COLS }; static const gchar *my_child_list = "CHILD_LIST"; /* * At any given time, up to two query list dialog may be present (one * for system level queries, one for user level queries). */ static GtkWidget *user_dlg = NULL; static GtkWidget *sys_dlg = NULL; /* * pk_order_num stores the primary key (pk) and order_num for * a given row in the query list. */ typedef struct pk_order_num { gint pk; gint order_num; } pk_order_num; typedef struct xtra_data_struct { PGconn *conn; gint pk; gboolean is_sys; } xtra_data_struct; static gboolean edit_dlg_dirty (GtkWidget *dlg); static void draw_query_list (GtkWidget *parent, PGconn *conn, gboolean is_system); /* * This is just a convenience thing to allow calling g_free from * g_list_foreach... */ static void my_free_2 (gpointer data, gpointer user_data) { g_free (data); } /* * Both types of queries have some stuff that must not be NULL. Make sure * it is not NULL. For raw SQL queries there is an additional sanity * check. */ static gboolean validate_query_data (GtkDialog *dlg, gboolean is_raw) { GtkEntry *name_entry; GtkTextView *descr_text; GtkTextView *raw_sql_text; GtkTextBuffer *buff; GtkWidget *msg_dlg; gint response; name_entry = GTK_ENTRY (lookup_widget (GTK_WIDGET (dlg), NAME_ENTRY)); g_assert (name_entry != NULL); descr_text = GTK_TEXT_VIEW (lookup_widget (GTK_WIDGET (dlg), DESCR_TEXT)); g_assert (descr_text != NULL); if (strlen (gtk_entry_get_text (name_entry)) == 0) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (dlg), 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("You must supply a filter name.")); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); return FALSE; } buff = gtk_text_view_get_buffer (descr_text); if (gtk_text_buffer_get_char_count (buff) == 0) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (dlg), 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("You have not filled in a description for the filter.\n" "Are you sure you want a blank description?")); gtk_dialog_set_default_response (GTK_DIALOG (msg_dlg), GTK_RESPONSE_YES); response = gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); return (response == GTK_RESPONSE_YES); } if (is_raw) { raw_sql_text = GTK_TEXT_VIEW (lookup_widget (GTK_WIDGET (dlg), RAW_SQL_TEXT)); g_assert (raw_sql_text != NULL); buff = gtk_text_view_get_buffer (raw_sql_text); if (gtk_text_buffer_get_char_count (buff) == 0) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (dlg), 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("You have not added anything to the WHERE clause.\n" "Are you sure this is what you want?")); gtk_dialog_set_default_response (GTK_DIALOG (msg_dlg), GTK_RESPONSE_NO); response = gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); return (response == GTK_RESPONSE_YES); } } return TRUE; } /* * Build a list of the keys for the selected items in the clist. * * For the text based key list, the keys need to be g_free'ed as * follows: * g_list_foreach (list, my_free_2, NULL); * g_list_free (list); */ static void build_key_list (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { gint pk; GList **list = data; gtk_tree_model_get (model, iter, ATTRIB_PK, &pk, -1); *list = g_list_append (*list, GINT_TO_POINTER (pk)); } static void build_txt_key_list (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { gchar *pk; GList **list = data; gtk_tree_model_get (model, iter, ATTRIB_PK, &pk, -1); *list = g_list_append (*list, pk); } static GString * build_insert_string(GtkDialog *dlg, gboolean is_raw) { GtkEntry *name_entry; GtkTextView *descr_text; GtkTextView *raw_sql_text; GtkTextBuffer *txt_buff; GtkTextIter start; GtkTextIter end; GtkTreeView *sevr_list_view; GtkTreeView *stat_list_view; GtkTreeView *pt_list_view; GtkTreeView *sub_list_view; GtkTreeView *resp_list_view; GtkEntry *order_by_entry; GString *str; GString *tmp; GString *list_str; GList *tmp_list = NULL; gchar *buff; gboolean is_sys; GtkTreeSelection *sel; name_entry = GTK_ENTRY (lookup_widget (GTK_WIDGET (dlg), NAME_ENTRY)); g_assert (name_entry != NULL); descr_text = GTK_TEXT_VIEW (lookup_widget (GTK_WIDGET (dlg), DESCR_TEXT)); g_assert (descr_text != NULL); tmp = g_string_new (""); str = g_string_new ("INSERT INTO pr_query (query_num, name, descr, "); str = g_string_append (str, "is_system_query, is_raw_sql, raw_sql, "); str = g_string_append (str, "severity_nums, status_nums, "); str = g_string_append (str, "problem_type_nums, submitter_ids, "); str = g_string_append (str, "responsible_ids, order_by) "); str = g_string_append (str, "VALUES (nextval ('pr_query_seq'), "); tmp = g_string_assign (tmp, gtk_entry_get_text (name_entry)); g_string_prepare_db_instr (tmp); str = g_string_append (str, tmp->str); str = g_string_append (str, ", "); txt_buff = gtk_text_view_get_buffer (descr_text); gtk_text_buffer_get_bounds (txt_buff, &start, &end); buff = gtk_text_buffer_get_text (txt_buff, &start, &end, FALSE); tmp = g_string_assign (tmp, buff); g_free (buff); g_string_prepare_db_instr (tmp); str = g_string_append (str, tmp->str); str = g_string_append (str, ", "); is_sys = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); if (is_sys) { str = g_string_append (str, "TRUE, "); } else { str = g_string_append (str, "FALSE, "); } if (is_raw) { str = g_string_append (str, "TRUE, "); raw_sql_text = GTK_TEXT_VIEW (lookup_widget (GTK_WIDGET (dlg), RAW_SQL_TEXT)); g_assert (raw_sql_text != NULL); txt_buff = gtk_text_view_get_buffer (raw_sql_text); gtk_text_buffer_get_bounds (txt_buff, &start, &end); buff = gtk_text_buffer_get_text (txt_buff, &start, &end, FALSE); tmp = g_string_assign (tmp, buff); g_free (buff); g_string_prepare_db_instr (tmp); str = g_string_append (str, tmp->str); str = g_string_append (str, ", "); str = g_string_append (str, "NULL, NULL, NULL, NULL, NULL, NULL)"); } else { str = g_string_append (str, "FALSE, NULL, "); sevr_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), SEVR_LIST_VIEW)); g_assert (sevr_list_view != NULL); stat_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), STAT_LIST_VIEW)); g_assert (stat_list_view != NULL); pt_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), PT_LIST_VIEW)); g_assert (pt_list_view != NULL); sub_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), SUB_LIST_VIEW)); g_assert (sub_list_view != NULL); resp_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), RESP_LIST_VIEW)); g_assert (resp_list_view != NULL); order_by_entry = GTK_ENTRY (lookup_widget (GTK_WIDGET (dlg), ORDER_BY_ENTRY)); g_assert (order_by_entry != NULL); sel = gtk_tree_view_get_selection (sevr_list_view); gtk_tree_selection_selected_foreach (sel, build_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_int_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); str = g_string_append (str, ", "); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL, "); } sel = gtk_tree_view_get_selection (stat_list_view); gtk_tree_selection_selected_foreach (sel, build_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_int_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); str = g_string_append (str, ", "); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL, "); } sel = gtk_tree_view_get_selection (pt_list_view); gtk_tree_selection_selected_foreach (sel, build_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_int_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); str = g_string_append (str, ", "); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL, "); } sel = gtk_tree_view_get_selection (sub_list_view); gtk_tree_selection_selected_foreach (sel, build_txt_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_txt_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); str = g_string_append (str, ", "); g_list_foreach (tmp_list, my_free_2, NULL); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL, "); } sel = gtk_tree_view_get_selection (resp_list_view); gtk_tree_selection_selected_foreach (sel, build_txt_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_txt_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); str = g_string_append (str, ", "); g_list_foreach (tmp_list, my_free_2, NULL); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL, "); } tmp = g_string_assign (tmp, gtk_entry_get_text (order_by_entry)); g_string_prepare_db_instr (tmp); str = g_string_append (str, tmp->str); str = g_string_append (str, ")"); } /* end else (not raw) */ g_string_free (tmp, TRUE); return str; } static GString * build_update_string (GtkDialog *dlg, gint pk, gboolean is_raw) { GtkEntry *name_entry; GtkTextView *descr_text; GtkTextView *raw_sql_text; GtkTextBuffer *txt_buff; GtkTextIter start; GtkTextIter end; GtkTreeView *sevr_list_view; GtkTreeView *stat_list_view; GtkTreeView *pt_list_view; GtkTreeView *sub_list_view; GtkTreeView *resp_list_view; GtkEntry *order_by_entry; GString *str; GString *tmp; GString *list_str; GList *tmp_list = NULL; gboolean first = TRUE; gchar *buff; GtkTreeSelection *sel; name_entry = GTK_ENTRY (lookup_widget (GTK_WIDGET (dlg), NAME_ENTRY)); g_assert (name_entry != NULL); descr_text = GTK_TEXT_VIEW (lookup_widget (GTK_WIDGET (dlg), DESCR_TEXT)); g_assert (descr_text != NULL); str = g_string_new ("UPDATE pr_query SET "); tmp = g_string_new (""); if (object_is_dirty (G_OBJECT (name_entry))) { tmp = g_string_assign (tmp, gtk_entry_get_text (name_entry)); g_string_prepare_db_instr (tmp); if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "name = "); str = g_string_append (str, tmp->str); } txt_buff = gtk_text_view_get_buffer (descr_text); if (gtk_text_buffer_get_modified (txt_buff)) { gtk_text_buffer_get_bounds (txt_buff, &start, &end); buff = gtk_text_buffer_get_text (txt_buff, &start, &end, FALSE); tmp = g_string_assign (tmp, buff); g_free (buff); g_string_prepare_db_instr (tmp); if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "descr = "); str = g_string_append (str, tmp->str); } if (is_raw) { raw_sql_text = GTK_TEXT_VIEW (lookup_widget (GTK_WIDGET (dlg), RAW_SQL_TEXT)); g_assert (raw_sql_text != NULL); txt_buff = gtk_text_view_get_buffer (raw_sql_text); if (gtk_text_buffer_get_modified (txt_buff)) { gtk_text_buffer_get_bounds (txt_buff, &start, &end); buff = gtk_text_buffer_get_text (txt_buff, &start, &end, FALSE); tmp = g_string_assign (tmp, buff); g_free (buff); g_string_prepare_db_instr (tmp); if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "raw_sql = "); str = g_string_append (str, tmp->str); } } /* end is_raw */ else { sevr_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), SEVR_LIST_VIEW)); g_assert (sevr_list_view != NULL); stat_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), STAT_LIST_VIEW)); g_assert (stat_list_view != NULL); pt_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), PT_LIST_VIEW)); g_assert (pt_list_view != NULL); sub_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), SUB_LIST_VIEW)); g_assert (sub_list_view != NULL); resp_list_view = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), RESP_LIST_VIEW)); g_assert (resp_list_view != NULL); order_by_entry = GTK_ENTRY (lookup_widget (GTK_WIDGET (dlg), ORDER_BY_ENTRY)); g_assert (order_by_entry != NULL); sel = gtk_tree_view_get_selection (sevr_list_view); if (object_is_dirty (G_OBJECT (sel))) { if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "severity_nums = "); gtk_tree_selection_selected_foreach (sel, build_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_int_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL"); } } sel = gtk_tree_view_get_selection (stat_list_view); if (object_is_dirty (G_OBJECT (sel))) { if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "status_nums = "); gtk_tree_selection_selected_foreach (sel, build_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_int_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL"); } } sel = gtk_tree_view_get_selection (pt_list_view); if (object_is_dirty (G_OBJECT (sel))) { if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "problem_type_nums = "); gtk_tree_selection_selected_foreach (sel, build_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_int_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL"); } } sel = gtk_tree_view_get_selection (sub_list_view); if (object_is_dirty (G_OBJECT (sel))) { if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "submitter_ids = "); gtk_tree_selection_selected_foreach (sel, build_txt_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_txt_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); g_list_foreach (tmp_list, my_free_2, NULL); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL"); } } sel = gtk_tree_view_get_selection (resp_list_view); if (object_is_dirty (G_OBJECT (sel))) { if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "responsible_ids = "); gtk_tree_selection_selected_foreach (sel, build_txt_key_list, &tmp_list); if (tmp_list != NULL) { list_str = create_txt_arr_str (tmp_list); g_string_prepare_db_instr (list_str); str = g_string_append (str, list_str->str); g_list_foreach (tmp_list, my_free_2, NULL); g_list_free (tmp_list); tmp_list = NULL; g_string_free (list_str, TRUE); } else { str = g_string_append (str, "NULL"); } } if (object_is_dirty (G_OBJECT (order_by_entry))) { tmp = g_string_assign (tmp, gtk_entry_get_text (order_by_entry)); g_string_prepare_db_instr (tmp); if (!first) { str = g_string_append (str, ", "); } first = FALSE; str = g_string_append (str, "order_by = "); str = g_string_append (str, tmp->str); } } /* end else (not is_raw) */ g_string_printf (tmp, "%d", pk); str = g_string_append (str, " WHERE query_num = "); str = g_string_append (str, tmp->str); g_string_free (tmp, TRUE); return str; } static void on_ok_button_clicked (GtkDialog *dlg, gboolean is_raw) { GtkWidget *parent; /* the parent query list dialog */ GtkWidget *main_win; /* the main window of the application */ GString *sql_buffer; gint pk; gboolean is_sys; gboolean is_update; gboolean in_error = FALSE; PGconn *conn; PGresult *res; conn = g_object_get_data (G_OBJECT (dlg), MY_DB_CONN); g_assert (conn != NULL); is_sys = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); is_update = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_UPDATE)) == 1); parent = lookup_widget (GTK_WIDGET (dlg), MY_PARENT); main_win = lookup_widget (parent, MY_PARENT); if (validate_query_data (dlg, is_raw)) { START_TRANSACTION (conn); if (is_update) { if (edit_dlg_dirty (GTK_WIDGET (dlg))) { pk = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), PK_NUM)); sql_buffer = build_update_string (dlg, pk, is_raw); res = PQexec (conn, sql_buffer->str); in_error = !chk_sql_error (res, "Updating Problem Report Filter."); PQclear (res); g_string_free (sql_buffer, TRUE); } } else { sql_buffer = build_insert_string (dlg, is_raw); res = PQexec (conn, sql_buffer->str); in_error = !chk_sql_error (res, "Inserting Problem Report Filter."); PQclear (res); g_string_free (sql_buffer, TRUE); } /* * The COMMIT and ROLLBACK are called here manually instead of a * finalize_transaction() because we may not have an acutual * result to deal with. */ if (!in_error) { COMMIT (conn); gtk_widget_destroy (GTK_WIDGET (dlg)); draw_query_list (parent, conn, is_sys); refresh_query_combo (main_win); } else { ROLLBACK (conn); } } return; } static void on_cancel_button_clicked (GtkDialog *dlg) { gtk_widget_destroy (GTK_WIDGET (dlg)); } /*--------------------------------------------------------------------------- * Raw SQL Edit Dialog Box *--------------------------------------------------------------------------- */ static void on_raw_sql_edit_dlg_show (GtkWidget *widget, gpointer user_data) { GtkEntry *name_entry; GtkTextView *descr_text; GtkTextView *raw_sql_text; GtkTextBuffer *buff; GString *sql_buffer; PGconn *conn; PGresult *res; gint pk; GString *title_str = g_string_new (_("Raw SQL Filter")); gboolean in_error = FALSE; /* * Get the PK first, since we only really need to do something here * if we have a valid (non-neg) PK. */ pk = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), PK_NUM)); if (pk >= 0) { conn = g_object_get_data (G_OBJECT (widget), MY_DB_CONN); g_assert (conn != NULL); sql_buffer = g_string_new (""); g_string_printf (sql_buffer, GET_QUERY, pk); res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting raw SQL filter information")) { name_entry = GTK_ENTRY (lookup_widget (widget, NAME_ENTRY)); descr_text = GTK_TEXT_VIEW (lookup_widget (widget, DESCR_TEXT)); raw_sql_text = GTK_TEXT_VIEW (lookup_widget (widget, RAW_SQL_TEXT)); g_assert (name_entry != NULL); g_assert (descr_text != NULL); g_assert (raw_sql_text != NULL); gtk_entry_set_text (name_entry, PQgetvalue (res, 0, NAME_POS)); g_string_append_printf (title_str, " - %s", PQgetvalue (res, 0, NAME_POS)); buff = gtk_text_view_get_buffer (descr_text); gtk_text_buffer_set_text (buff, PQgetvalue (res, 0, DESCR_POS), -1); gtk_text_buffer_set_modified (buff, FALSE); buff = gtk_text_view_get_buffer (raw_sql_text); gtk_text_buffer_set_text (buff, PQgetvalue (res, 0, RAW_SQL_POS), -1); gtk_text_buffer_set_modified (buff, FALSE); set_all_clean (G_OBJECT (widget)); } else { in_error = TRUE; } } if (!in_error) { gtk_window_set_title (GTK_WINDOW (widget), title_str->str); } else { gtk_widget_destroy (widget); } g_string_free (title_str, TRUE); } static void on_raw_sql_edit_dlg_destroy (GObject *object, gpointer user_data) { destroy_dirty_list (object); } static void on_raw_sql_edit_dlg_clicked (GtkDialog *dlg, gint btn_cd, gpointer user_data) { switch (btn_cd) { case GTK_RESPONSE_OK: on_ok_button_clicked (dlg, TRUE); break; case GTK_RESPONSE_CANCEL: on_cancel_button_clicked (dlg); break; case GTK_RESPONSE_DELETE_EVENT: break; default: g_assert_not_reached(); } } static GtkWidget * create_raw_sql_edit_dlg (GtkWidget *parent, PGconn *conn, gint query_num, gboolean is_update, gboolean is_system, gboolean user_is_admin) { GtkWidget *raw_sql_edit_dlg; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hbox2; GtkWidget *name_entry; GtkWidget *scrolledwindow2; GtkWidget *descr_text; GtkWidget *hseparator1; GtkWidget *label; GtkWidget *table1; GtkWidget *scrolledwindow1; GtkWidget *raw_sql_text; 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); raw_sql_edit_dlg = gtk_dialog_new_with_buttons (NULL, GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); GLADE_HOOKUP_OBJECT_NO_REF (raw_sql_edit_dlg, raw_sql_edit_dlg, "raw_sql_edit_dlg"); gtk_container_set_border_width (GTK_CONTAINER (raw_sql_edit_dlg), 5); g_signal_connect (raw_sql_edit_dlg, "show", G_CALLBACK (on_raw_sql_edit_dlg_show), NULL); g_signal_connect (raw_sql_edit_dlg, "destroy", G_CALLBACK (on_raw_sql_edit_dlg_destroy), NULL); g_signal_connect (raw_sql_edit_dlg, "response", G_CALLBACK (on_raw_sql_edit_dlg_clicked), NULL); if (is_system && !user_is_admin) { gtk_dialog_set_response_sensitive (GTK_DIALOG (raw_sql_edit_dlg), GTK_RESPONSE_OK, FALSE); gtk_dialog_set_default_response (GTK_DIALOG (raw_sql_edit_dlg), GTK_RESPONSE_CANCEL); } else { gtk_dialog_set_default_response (GTK_DIALOG (raw_sql_edit_dlg), GTK_RESPONSE_OK); } g_object_set_data (G_OBJECT (raw_sql_edit_dlg), TOP_DOG, raw_sql_edit_dlg); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), MY_PARENT, parent); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), MY_DB_CONN, conn); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), MY_GCONF_CLIENT, client); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), IS_SYS_QUERY_LIST, GINT_TO_POINTER (is_system ? 1 : 0)); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), IS_UPDATE, GINT_TO_POINTER (is_update ? 1 : 0)); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), PK_NUM, GINT_TO_POINTER (query_num)); dialog_vbox1 = GTK_DIALOG (raw_sql_edit_dlg)->vbox; gtk_box_set_spacing (GTK_BOX (dialog_vbox1), 5); gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, vbox1, "vbox1"); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, hbox2, "hbox2"); gtk_widget_show (hbox2); gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0); label = gtk_label_new (_("Filter Name:")); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label1"); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); name_entry = gtk_entry_new (); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, name_entry, NAME_ENTRY); gtk_widget_show (name_entry); gtk_box_pack_start (GTK_BOX (hbox2), name_entry, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, name_entry, _("All good filters must have a name."), NULL); gtk_widget_set_sensitive (name_entry, user_is_admin || !is_system); g_signal_connect (name_entry, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (raw_sql_edit_dlg), G_OBJECT (name_entry)); label = gtk_label_new (_("Description")); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label2"); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (vbox1), label, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, scrolledwindow2, "scrolledwindow2"); gtk_widget_show (scrolledwindow2); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow2, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_ETCHED_IN); descr_text = gtk_text_view_new (); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, descr_text, DESCR_TEXT); gtk_widget_show (descr_text); gtk_container_add (GTK_CONTAINER (scrolledwindow2), descr_text); gtk_text_view_set_editable (GTK_TEXT_VIEW (descr_text), TRUE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (descr_text), GTK_WRAP_WORD); gtk_widget_set_sensitive (descr_text, user_is_admin || !is_system); hseparator1 = gtk_hseparator_new (); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, hseparator1, "hsep1"); gtk_widget_show (hseparator1); gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, FALSE, FALSE, 5); label = gtk_label_new (_("SQL:")); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label3"); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (vbox1), label, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); table1 = gtk_table_new (9, 2, FALSE); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, table1, "table1"); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0); gtk_table_set_col_spacings (GTK_TABLE (table1), 5); label = gtk_label_new ("SELECT"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label4"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 0, 1, 0, 1, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); label = gtk_label_new ("prj.name, stat.name, pt.name, sevr.name,"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label5"); gtk_widget_show (label); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 0, 1, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("pr.title, stat.order_num, sevr.order_num,"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label6"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 1, 2, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("pr.problem_num"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label7"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 2, 3, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("project prj, status stat, problem_type pt,"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label8"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 3, 4, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("severity sevr, problem_report pr"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label9"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 4, 5, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("prj.project_num = pr.project_num"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label10"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 5, 6, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("stat.status_num = pr.status_num"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label11"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 6, 7, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("sevr.severity_num = pr.severity_num"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label12"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 7, 8, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("pt.type_num = pr.type_num"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label13"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 8, 9, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new ("FROM"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label14"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 0, 1, 3, 4, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); label = gtk_label_new ("WHERE"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label15"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 0, 1, 5, 6, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); label = gtk_label_new ("AND"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label16"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 0, 1, 6, 7, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); label = gtk_label_new ("AND"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label17"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 0, 1, 7, 8, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); label = gtk_label_new ("AND"); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, label, "label18"); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table1), label, 0, 1, 8, 9, (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, scrolledwindow1, "scrolledwindow1"); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_SHADOW_ETCHED_IN); raw_sql_text = gtk_text_view_new (); GLADE_HOOKUP_OBJECT (raw_sql_edit_dlg, raw_sql_text, RAW_SQL_TEXT); gtk_widget_show (raw_sql_text); gtk_container_add (GTK_CONTAINER (scrolledwindow1), raw_sql_text); gtk_widget_set_size_request (raw_sql_text, -1, 100); gtk_tooltips_set_tip (tooltips, raw_sql_text, _("Use this area to complete the SQL statement started above."), NULL); gtk_text_view_set_editable (GTK_TEXT_VIEW (raw_sql_text), TRUE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (raw_sql_text), GTK_WRAP_WORD); gtk_widget_set_sensitive (raw_sql_text, user_is_admin || !is_system); g_object_set_data (G_OBJECT (raw_sql_edit_dlg), TOOLTIPS, tooltips); return raw_sql_edit_dlg; } /*--------------------------------------------------------------------------- * Regular Query Edit Dialog *--------------------------------------------------------------------------- */ static void fill_single_col_tree (GtkTreeView *tree, PGresult *res, gboolean key_is_numeric) { gint i, n; GtkListStore *store; GtkTreeIter iter; store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); n = PQntuples (res); for (i = 0; i < n; i++) { gtk_list_store_append (store, &iter); if (key_is_numeric) { gtk_list_store_set (store, &iter, ATTRIB_NAME, PQgetvalue (res, i, SQLSTR_NAME_POS), ATTRIB_PK, atoi (PQgetvalue (res, i, SQLSTR_PK_POS)), -1); } else { gtk_list_store_set (store, &iter, ATTRIB_NAME, PQgetvalue (res, i, SQLSTR_NAME_POS), ATTRIB_PK, PQgetvalue (res, i, SQLSTR_PK_POS), -1); } } } /* * Given a clist and a list of keys to select, select the given rows * by matching row data and keys. */ static void draw_tree (GtkTreeView *tree, GList *sel_list) { GList *list_iter; GtkTreeSelection *sel; GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; gint pk; gboolean first = TRUE; list_iter = g_list_first (sel_list); model = gtk_tree_view_get_model (tree); sel = gtk_tree_view_get_selection (tree); while (list_iter) { if (gtk_tree_model_get_iter_first (model, &iter)) { do { gtk_tree_model_get (model, &iter, ATTRIB_PK, &pk, -1); if (pk == GPOINTER_TO_INT (list_iter->data)) { gtk_tree_selection_select_iter (sel, &iter); if (first) { first = FALSE; path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_scroll_to_cell (tree, path, NULL, TRUE, 0.5, 0.0); gtk_tree_path_free (path); } break; } } while (gtk_tree_model_iter_next (model, &iter)); } list_iter = list_iter->next; } } /* * Same idea as "draw_sel", but works with text keys. */ static void draw_tree_txt_key (GtkTreeView *tree, GList *sel_list) { GList *list_iter; GtkTreeSelection *sel; GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; gchar *pk; gboolean first = TRUE; list_iter = g_list_first (sel_list); model = gtk_tree_view_get_model (tree); sel = gtk_tree_view_get_selection (tree); while (list_iter) { if (gtk_tree_model_get_iter_first (model, &iter)) { do { gtk_tree_model_get (model, &iter, ATTRIB_PK, &pk, -1); if (strcmp (pk, list_iter->data) == 0) { gtk_tree_selection_select_iter (sel, &iter); if (first) { first = FALSE; path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_scroll_to_cell (tree, path, NULL, TRUE, 0.5, 0.0); gtk_tree_path_free (path); } break; } g_free (pk); } while (gtk_tree_model_iter_next (model, &iter)); } list_iter = list_iter->next; } } /* * Fill in the 5 lists on the query edit dlg. */ static gboolean draw_tree_lists (GtkWidget *main_widget, PGconn *conn, GConfClient *client) { GtkTreeView *tree; PGresult *res; gboolean in_error = FALSE; GString *sql_buffer; sql_buffer = g_string_new (""); /* * status list */ if (!in_error) { stat_sql_str (sql_buffer, ALL_ITEMS, client, 0); res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting status data")) { tree = GTK_TREE_VIEW (lookup_widget (main_widget, STAT_LIST_VIEW)); g_assert (tree != NULL); fill_single_col_tree (tree, res, TRUE); } else { in_error = TRUE; } PQclear (res); } /* * problem type list */ if (!in_error) { pr_type_sql_str (sql_buffer, ALL_ITEMS, client, 0); res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting problem type data")) { tree = GTK_TREE_VIEW (lookup_widget (main_widget, PT_LIST_VIEW)); g_assert (tree != NULL); fill_single_col_tree (tree, res, TRUE); } else { in_error = TRUE; } PQclear (res); } /* * severity list */ if (!in_error) { sevr_sql_str (sql_buffer, ALL_ITEMS, client, 0); res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting severity data")) { tree = GTK_TREE_VIEW (lookup_widget (main_widget, SEVR_LIST_VIEW)); g_assert (tree != NULL); fill_single_col_tree (tree, res, TRUE); } else { in_error = TRUE; } PQclear (res); } /* * submitter list */ if (!in_error) { sql_buffer = g_string_assign (sql_buffer, SELECT_PEOPLE); sql_buffer = g_string_append (sql_buffer, SUB_RESP_ORDER_BY); res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting submitters")) { tree = GTK_TREE_VIEW (lookup_widget (main_widget, SUB_LIST_VIEW)); g_assert (tree != NULL); fill_single_col_tree (tree, res, FALSE); } else { in_error = TRUE; } PQclear (res); } /* * responsible list */ if (!in_error) { sql_buffer = g_string_assign (sql_buffer, SELECT_PEOPLE); sql_buffer = g_string_append (sql_buffer, SUB_RESP_ORDER_BY); res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting responsible users")) { tree = GTK_TREE_VIEW (lookup_widget (main_widget, RESP_LIST_VIEW)); g_assert (tree != NULL); fill_single_col_tree (tree, res, FALSE); } else { in_error = TRUE; } PQclear (res); } return !in_error; } static void on_sql_edit_dlg_clicked (GtkDialog *dlg, gint btn_cd, gpointer user_data) { switch (btn_cd) { case GTK_RESPONSE_OK: on_ok_button_clicked (dlg, FALSE); break; case GTK_RESPONSE_CANCEL: on_cancel_button_clicked (dlg); break; case GTK_RESPONSE_DELETE_EVENT: break; default: g_assert_not_reached (); } } static void on_sql_edit_dlg_show (GtkWidget *widget, gpointer user_data) { GtkEntry *name_entry; GtkEntry *order_by_entry; GtkTextView *descr_text; GtkTextBuffer *buff; GtkTreeView *sevr_list_view; GtkTreeView *stat_list_view; GtkTreeView *pt_list_view; GtkTreeView *sub_list_view; GtkTreeView *resp_list_view; GString *sql_buffer; GList *sevr_sel = NULL; GList *stat_sel = NULL; GList *pt_sel = NULL; GList *sub_sel = NULL; GList *resp_sel = NULL; PGconn *conn; PGresult *res; gboolean in_error = FALSE; gint pk; GConfClient *client; GString *title_str = g_string_new (_("Filter")); client = g_object_get_data (G_OBJECT (widget), MY_GCONF_CLIENT); g_assert (client != NULL); conn = g_object_get_data (G_OBJECT (widget), MY_DB_CONN); g_assert (conn != NULL); pk = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), PK_NUM)); in_error = !draw_tree_lists (widget, conn, client); if (!in_error) { /* * A negative pk would indicate that this is an insert rather than * an update (new vs. edit). */ if (pk >= 0) { name_entry = GTK_ENTRY (lookup_widget (widget, NAME_ENTRY)); descr_text = GTK_TEXT_VIEW (lookup_widget (widget, DESCR_TEXT)); sevr_list_view = GTK_TREE_VIEW (lookup_widget (widget, SEVR_LIST_VIEW)); stat_list_view = GTK_TREE_VIEW (lookup_widget (widget, STAT_LIST_VIEW)); pt_list_view = GTK_TREE_VIEW (lookup_widget (widget, PT_LIST_VIEW)); sub_list_view = GTK_TREE_VIEW (lookup_widget (widget, SUB_LIST_VIEW)); resp_list_view = GTK_TREE_VIEW (lookup_widget (widget, RESP_LIST_VIEW)); order_by_entry = GTK_ENTRY (lookup_widget (widget, ORDER_BY_ENTRY)); g_assert (name_entry != NULL); g_assert (descr_text != NULL); g_assert (sevr_list_view != NULL); g_assert (stat_list_view != NULL); g_assert (pt_list_view != NULL); g_assert (sub_list_view != NULL); g_assert (resp_list_view != NULL); g_assert (order_by_entry != NULL); sql_buffer = g_string_new (""); g_string_printf (sql_buffer, GET_QUERY, pk); res = PQexec (conn, sql_buffer->str); in_error = !chk_sql_error (res, "Getting filter information"); if (!in_error) { gtk_entry_set_text (name_entry, PQgetvalue (res, 0, NAME_POS)); g_string_append_printf (title_str, " - %s", PQgetvalue (res, 0, NAME_POS)); gtk_entry_set_text (order_by_entry, PQgetvalue (res, 0, ORDER_BY_POS)); buff = gtk_text_view_get_buffer (descr_text); gtk_text_buffer_set_text (buff, PQgetvalue (res, 0, DESCR_POS), -1); gtk_text_buffer_set_modified (buff, FALSE); sevr_sel = create_num_list (conn, pk, SEVR_NUMS); stat_sel = create_num_list (conn, pk, STAT_NUMS); pt_sel = create_num_list (conn, pk, TYPE_NUMS); sub_sel = create_txt_list (conn, pk, SUB_IDS); resp_sel = create_txt_list (conn, pk, RESP_IDS); draw_tree (sevr_list_view, sevr_sel); draw_tree (stat_list_view, stat_sel); draw_tree (pt_list_view, pt_sel); draw_tree_txt_key (sub_list_view, sub_sel); draw_tree_txt_key (resp_list_view, resp_sel); g_list_free (sevr_sel); g_list_free (stat_sel); g_list_free (pt_sel); g_list_foreach (sub_sel, my_free_2, NULL); g_list_free (sub_sel); g_list_foreach (resp_sel, my_free_2, NULL); g_list_free (resp_sel); } PQclear (res); } } if (in_error) { gtk_widget_destroy (widget); } else { set_all_clean (G_OBJECT (widget)); gtk_window_set_title (GTK_WINDOW (widget), title_str->str); } g_string_free (title_str, TRUE); } static void on_sql_edit_dlg_destroy (GObject *object, gpointer user_data) { destroy_dirty_list (object); } static GtkWidget * create_sql_edit_dlg (GtkWidget *parent, PGconn *conn, gint query_num, gboolean is_update, gboolean is_system, gboolean user_is_admin) { GtkWidget *sql_edit_dlg; GtkWidget *dialog_vbox2; GtkWidget *vbox2; GtkWidget *hbox3; GtkWidget *label29; GtkWidget *name_entry; GtkWidget *label30; GtkWidget *scrolledwindow3; GtkWidget *descr_text; GtkWidget *hseparator2; GtkWidget *table2; GtkWidget *table3; GtkWidget *label31; GtkWidget *label32; GtkWidget *label33; GtkWidget *label34; GtkWidget *label35; GtkWidget *label36; GtkWidget *scrolledwindow4; GtkWidget *scrolledwindow5; GtkWidget *scrolledwindow6; GtkWidget *scrolledwindow7; GtkWidget *scrolledwindow8; GtkWidget *order_by_entry; GtkTooltips *tooltips; GtkWidget *sevr_list_view; GtkWidget *stat_list_view; GtkWidget *pt_list_view; GtkWidget *sub_list_view; GtkWidget *resp_list_view; GtkListStore *sevr_list_store; GtkListStore *stat_list_store; GtkListStore *pt_list_store; GtkListStore *sub_list_store; GtkListStore *resp_list_store; GtkTreeViewColumn *col; GtkTreeSelection *sel; GtkCellRenderer *rend; 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); sql_edit_dlg = gtk_dialog_new_with_buttons (NULL, GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); GLADE_HOOKUP_OBJECT_NO_REF (sql_edit_dlg, sql_edit_dlg, "sql_edit_dlg"); gtk_container_set_border_width (GTK_CONTAINER (sql_edit_dlg), 5); g_signal_connect (sql_edit_dlg, "show", G_CALLBACK (on_sql_edit_dlg_show), NULL); g_signal_connect (sql_edit_dlg, "destroy", G_CALLBACK (on_sql_edit_dlg_destroy), NULL); g_signal_connect (sql_edit_dlg, "response", G_CALLBACK (on_sql_edit_dlg_clicked), NULL); if (is_system && !user_is_admin) { gtk_dialog_set_response_sensitive (GTK_DIALOG (sql_edit_dlg), GTK_RESPONSE_OK, FALSE); gtk_dialog_set_default_response (GTK_DIALOG (sql_edit_dlg), GTK_RESPONSE_CANCEL); } else { gtk_dialog_set_default_response (GTK_DIALOG (sql_edit_dlg), GTK_RESPONSE_OK); } g_object_set_data (G_OBJECT (sql_edit_dlg), TOP_DOG, sql_edit_dlg); g_object_set_data (G_OBJECT (sql_edit_dlg), MY_PARENT, parent); g_object_set_data (G_OBJECT (sql_edit_dlg), MY_DB_CONN, conn); g_object_set_data (G_OBJECT (sql_edit_dlg), MY_GCONF_CLIENT, client); g_object_set_data (G_OBJECT (sql_edit_dlg), PK_NUM, GINT_TO_POINTER (query_num)); g_object_set_data (G_OBJECT (sql_edit_dlg), IS_SYS_QUERY_LIST, GINT_TO_POINTER (is_system ? 1 : 0)); g_object_set_data (G_OBJECT (sql_edit_dlg), IS_UPDATE, GINT_TO_POINTER (is_update ? 1 : 0)); dialog_vbox2 = GTK_DIALOG (sql_edit_dlg)->vbox; gtk_box_set_spacing (GTK_BOX (dialog_vbox2), 5); gtk_widget_show (dialog_vbox2); vbox2 = gtk_vbox_new (FALSE, 0); GLADE_HOOKUP_OBJECT (sql_edit_dlg, vbox2, "vbox2"); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (dialog_vbox2), vbox2, TRUE, TRUE, 0); hbox3 = gtk_hbox_new (FALSE, 0); GLADE_HOOKUP_OBJECT (sql_edit_dlg, hbox3, "hbox3"); gtk_widget_show (hbox3); gtk_box_pack_start (GTK_BOX (vbox2), hbox3, FALSE, FALSE, 0); label29 = gtk_label_new (_("Filter Name:")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label29, "label29"); gtk_widget_show (label29); gtk_box_pack_start (GTK_BOX (hbox3), label29, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label29), 0, 0.5); name_entry = gtk_entry_new (); GLADE_HOOKUP_OBJECT (sql_edit_dlg, name_entry, NAME_ENTRY); gtk_widget_show (name_entry); gtk_box_pack_start (GTK_BOX (hbox3), name_entry, TRUE, TRUE, 0); gtk_widget_set_sensitive (name_entry, user_is_admin || !is_system); g_signal_connect (name_entry, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (name_entry)); label30 = gtk_label_new (_("Description:")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label30, "label30"); gtk_widget_show (label30); gtk_box_pack_start (GTK_BOX (vbox2), label30, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label30), 0, 0.5); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (sql_edit_dlg, scrolledwindow3, "scrolledwindow3"); gtk_widget_show (scrolledwindow3); gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow3, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_ETCHED_IN); descr_text = gtk_text_view_new (); GLADE_HOOKUP_OBJECT (sql_edit_dlg, descr_text, DESCR_TEXT); gtk_widget_show (descr_text); gtk_container_add (GTK_CONTAINER (scrolledwindow3), descr_text); gtk_text_view_set_editable (GTK_TEXT_VIEW (descr_text), TRUE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (descr_text), GTK_WRAP_WORD); gtk_widget_set_sensitive (descr_text, user_is_admin || !is_system); hseparator2 = gtk_hseparator_new (); GLADE_HOOKUP_OBJECT (sql_edit_dlg, hseparator2, "hsep2"); gtk_widget_show (hseparator2); gtk_box_pack_start (GTK_BOX (vbox2), hseparator2, FALSE, FALSE, 5); table2 = gtk_table_new (2, 3, FALSE); GLADE_HOOKUP_OBJECT (sql_edit_dlg, table2, "table2"); gtk_widget_show (table2); gtk_box_pack_start (GTK_BOX (vbox2), table2, TRUE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table2), 5); label31 = gtk_label_new (_("Severity")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label31, "label31"); gtk_widget_show (label31); gtk_table_attach (GTK_TABLE (table2), label31, 0, 1, 0, 1, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label31), 0, 0.5); label32 = gtk_label_new (_("Status")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label32, "label32"); gtk_widget_show (label32); gtk_table_attach (GTK_TABLE (table2), label32, 1, 2, 0, 1, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label32), 0, 0.5); label33 = gtk_label_new (_("Problem Type")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label33, "label33"); gtk_widget_show (label33); gtk_table_attach (GTK_TABLE (table2), label33, 2, 3, 0, 1, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label33), 0, 0.5); table3 = gtk_table_new (2, 2, FALSE); GLADE_HOOKUP_OBJECT (sql_edit_dlg, table3, "table3"); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (vbox2), table3, TRUE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table3), 5); label34 = gtk_label_new (_("Submitter")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label34, "label34"); gtk_widget_show (label34); gtk_table_attach (GTK_TABLE (table3), label34, 0, 1, 0, 1, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5); label35 = gtk_label_new (_("Responsible")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label35, "label35"); gtk_widget_show (label35); gtk_table_attach (GTK_TABLE (table3), label35, 1, 2, 0, 1, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (label35), 0, 0.5); scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (sql_edit_dlg, scrolledwindow4, "scrolledwindow4"); gtk_widget_show (scrolledwindow4); gtk_table_attach (GTK_TABLE (table2), scrolledwindow4, 0, 1, 1, 2, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_SHADOW_ETCHED_IN); sevr_list_store = gtk_list_store_new (NUM_ATTRIB_COLS, G_TYPE_STRING, G_TYPE_INT); sevr_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (sevr_list_store)); GLADE_HOOKUP_OBJECT (sql_edit_dlg, sevr_list_view, SEVR_LIST_VIEW); gtk_widget_set_sensitive (sevr_list_view, user_is_admin || !is_system); gtk_widget_show (sevr_list_view); gtk_container_add (GTK_CONTAINER (scrolledwindow4), sevr_list_view); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (sevr_list_view)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE); g_signal_connect (sel, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (sel)); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_set_attributes (col, rend, "text", ATTRIB_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (sevr_list_view), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (sevr_list_view), FALSE); scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (sql_edit_dlg, scrolledwindow5, "scrolledwindow5"); gtk_widget_show (scrolledwindow5); gtk_table_attach (GTK_TABLE (table2), scrolledwindow5, 1, 2, 1, 2, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_SHADOW_ETCHED_IN); stat_list_store = gtk_list_store_new (NUM_ATTRIB_COLS, G_TYPE_STRING, G_TYPE_INT); stat_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (stat_list_store)); GLADE_HOOKUP_OBJECT (sql_edit_dlg, stat_list_view, STAT_LIST_VIEW); gtk_widget_set_sensitive (stat_list_view, user_is_admin || !is_system); gtk_widget_show (stat_list_view); gtk_container_add (GTK_CONTAINER (scrolledwindow5), stat_list_view); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (stat_list_view)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE); g_signal_connect (sel, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (sel)); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_set_attributes (col, rend, "text", ATTRIB_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (stat_list_view), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (stat_list_view), FALSE); scrolledwindow6 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (sql_edit_dlg, scrolledwindow6, "scrolledwindow6"); gtk_widget_show (scrolledwindow6); gtk_table_attach (GTK_TABLE (table2), scrolledwindow6, 2, 3, 1, 2, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow6), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow6), GTK_SHADOW_ETCHED_IN); pt_list_store = gtk_list_store_new (NUM_ATTRIB_COLS, G_TYPE_STRING, G_TYPE_INT); pt_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (pt_list_store)); GLADE_HOOKUP_OBJECT (sql_edit_dlg, pt_list_view, PT_LIST_VIEW); gtk_widget_set_sensitive (pt_list_view, user_is_admin || !is_system); gtk_widget_show (pt_list_view); gtk_container_add (GTK_CONTAINER (scrolledwindow6), pt_list_view); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (pt_list_view)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE); g_signal_connect (sel, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (sel)); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_set_attributes (col, rend, "text", ATTRIB_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (pt_list_view), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pt_list_view), FALSE); scrolledwindow7 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (sql_edit_dlg, scrolledwindow7, "scrolledwindow7"); gtk_widget_show (scrolledwindow7); gtk_table_attach (GTK_TABLE (table3), scrolledwindow7, 0, 1, 1, 2, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow7), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow7), GTK_SHADOW_ETCHED_IN); sub_list_store = gtk_list_store_new (NUM_ATTRIB_COLS, G_TYPE_STRING, G_TYPE_STRING); sub_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (sub_list_store)); GLADE_HOOKUP_OBJECT (sql_edit_dlg, sub_list_view, SUB_LIST_VIEW); gtk_widget_set_sensitive (sub_list_view, user_is_admin || !is_system); gtk_widget_show (sub_list_view); gtk_container_add (GTK_CONTAINER (scrolledwindow7), sub_list_view); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (sub_list_view)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE); g_signal_connect (sel, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (sel)); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_set_attributes (col, rend, "text", ATTRIB_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (sub_list_view), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (sub_list_view), FALSE); scrolledwindow8 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (sql_edit_dlg, scrolledwindow8, "scrolledwindow8"); gtk_widget_show (scrolledwindow8); gtk_table_attach (GTK_TABLE (table3), scrolledwindow8, 1, 2, 1, 2, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, (GtkAttachOptions) GTK_EXPAND | GTK_FILL, 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow8), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow8), GTK_SHADOW_ETCHED_IN); resp_list_store = gtk_list_store_new (NUM_ATTRIB_COLS, G_TYPE_STRING, G_TYPE_STRING); resp_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (resp_list_store)); GLADE_HOOKUP_OBJECT (sql_edit_dlg, resp_list_view, RESP_LIST_VIEW); gtk_widget_set_sensitive (resp_list_view, user_is_admin || !is_system); gtk_widget_show (resp_list_view); gtk_container_add (GTK_CONTAINER (scrolledwindow8), resp_list_view); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (resp_list_view)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE); g_signal_connect (sel, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (sel)); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_set_attributes (col, rend, "text", ATTRIB_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (resp_list_view), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (resp_list_view), FALSE); label36 = gtk_label_new (_("Order By:")); GLADE_HOOKUP_OBJECT (sql_edit_dlg, label36, "label36"); gtk_widget_show (label36); gtk_box_pack_start (GTK_BOX (vbox2), label36, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label36), 0, 0.5); order_by_entry = gtk_entry_new (); GLADE_HOOKUP_OBJECT (sql_edit_dlg, order_by_entry, ORDER_BY_ENTRY); gtk_widget_show (order_by_entry); gtk_box_pack_start (GTK_BOX (vbox2), order_by_entry, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, order_by_entry, _("You may use any of the following: prj.name, stat.name, pt.name, \ sevr.name, pr.title, stat.order_num, sevr.order_num, pr.problem_num"), NULL); gtk_widget_set_sensitive (order_by_entry, user_is_admin || !is_system); g_signal_connect (order_by_entry, "changed", G_CALLBACK (set_dirty), NULL); add_object_to_dirty_list (G_OBJECT (sql_edit_dlg), G_OBJECT (order_by_entry)); g_object_set_data (G_OBJECT (sql_edit_dlg), TOOLTIPS, tooltips); return sql_edit_dlg; } static void raise_or_create_edit_dlg (GtkWidget *parent, PGconn *conn, gint query_num, gboolean is_system, gboolean user_is_admin, gboolean query_is_raw) { GtkWidget *dlg; GList *child_list; GList *list_iter; /* * Go through the existing list of children first. If we have a * child that already uses this query's PK, just bring that one * to the top. */ child_list = g_object_get_data (G_OBJECT (parent), my_child_list); for (list_iter = g_list_first (child_list); list_iter != NULL; list_iter = list_iter->next) { if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (list_iter->data), PK_NUM)) == query_num) { gdk_window_show (GTK_WIDGET (list_iter->data)->window); gdk_window_raise (GTK_WIDGET (list_iter->data)->window); return; } } /* * Didn't find a child already displaying this query, so we need to * create one. */ if (query_is_raw) { dlg = create_raw_sql_edit_dlg (parent, conn, query_num, TRUE, is_system, user_is_admin); } else { dlg = create_sql_edit_dlg (parent, conn, query_num, TRUE, is_system, user_is_admin); } gtk_widget_show (dlg); /* * Setup the child_dead() callback to remove the child from the * child_list when the child dies. */ g_signal_connect (dlg, "destroy", G_CALLBACK (child_dead), (gpointer)my_child_list); child_list = g_list_append (child_list, dlg); g_object_set_data (G_OBJECT (parent), my_child_list, child_list); } /*-------------------------------------------------------------------------- * Main query list window *-------------------------------------------------------------------------- */ static void draw_query_list (GtkWidget *parent, PGconn *conn, gboolean is_system) { GtkTreeView *tree; GtkListStore *store; GtkTreeIter iter; GString *sql_buffer; PGresult *res; gint i, n; gint order_num; gint pk; gboolean is_raw; tree = GTK_TREE_VIEW (lookup_widget (parent, QUERY_LIST_VIEW)); if (is_system) { sql_buffer = g_string_new (SYSTEM_QUERIES); } else { sql_buffer = g_string_new (USER_QUERIES); } res = PQexec (conn, sql_buffer->str); if (chk_sql_error (res, "Getting list of filters")) { store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); n = PQntuples (res); for (i = 0; i < n; i++) { is_raw = (toupper (PQgetvalue (res, i, IS_RAW_POS)[0]) == 'T'); pk = atoi (PQgetvalue (res, i, QUERY_NUM_POS)); if (PQgetisnull (res, i, ORDER_NUM_POS)) { order_num = -1; } else { order_num = atoi (PQgetvalue (res, i, ORDER_NUM_POS)); } gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, QUERY_NAME, PQgetvalue (res, i, NAME_POS), QUERY_IS_RAW, is_raw, QUERY_DESCR, PQgetvalue (res, i, DESCR_POS), QUERY_PK, pk, QUERY_ORDER, order_num, -1); } } else { gtk_widget_destroy (parent); } PQclear (res); g_string_free (sql_buffer, TRUE); } static void on_query_dlg_show (GtkWidget *widget, gpointer user_data) { PGconn *conn; gboolean is_system; conn = g_object_get_data (G_OBJECT (widget), MY_DB_CONN); g_assert (conn); is_system = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), IS_SYS_QUERY_LIST)) == 1); draw_query_list (widget, conn, is_system); } static void on_query_dlg_destroy (GObject *object, gpointer user_data) { GList *child_list; GList *list_iter; /* * Kill all of the children */ child_list = g_object_get_data (G_OBJECT (object), my_child_list); for (list_iter = g_list_first (child_list); list_iter != NULL; list_iter = list_iter->next) { g_signal_handlers_block_by_func (list_iter->data, G_CALLBACK (child_dead), (gpointer)my_child_list); gtk_widget_destroy (GTK_WIDGET (list_iter->data)); } g_list_free (child_list); } static void on_new_button_clicked (GtkDialog *dlg) { GtkWidget *child_dlg; PGconn *conn; gboolean is_system; gboolean admin_user; GList *child_list; conn = g_object_get_data (G_OBJECT (dlg), MY_DB_CONN); g_assert (conn); is_system = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); admin_user = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), ADMIN_USER)) == 1); child_dlg = create_sql_edit_dlg (GTK_WIDGET (dlg), conn, -1, FALSE, is_system, admin_user); gtk_widget_show (child_dlg); /* * Setup the child_dead() callback to remove the child from the * child_list when the child dies. */ g_signal_connect (child_dlg, "destroy", G_CALLBACK (child_dead), (gpointer)my_child_list); child_list = g_object_get_data (G_OBJECT (dlg), my_child_list); child_list = g_list_append (child_list, child_dlg); g_object_set_data (G_OBJECT (dlg), my_child_list, child_list); } static void on_new_raw_button_clicked (GtkDialog *dlg) { GtkWidget *child_dlg; PGconn *conn; gboolean is_system; gboolean admin_user; GList *child_list; conn = g_object_get_data (G_OBJECT (dlg), MY_DB_CONN); g_assert (conn); is_system = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); admin_user = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), ADMIN_USER)) == 1); child_dlg = create_raw_sql_edit_dlg (GTK_WIDGET (dlg), conn, -1, FALSE, is_system, admin_user); gtk_widget_show (child_dlg); /* * Setup the child_dead() callback to remove the child from the * child_list when the child dies. */ g_signal_connect (child_dlg, "destroy", G_CALLBACK (child_dead), (gpointer)my_child_list); child_list = g_object_get_data (G_OBJECT (dlg), my_child_list); child_list = g_list_append (child_list, child_dlg); g_object_set_data (G_OBJECT (dlg), my_child_list, child_list); } static void on_modify_button_clicked (GtkDialog *dlg) { GtkTreeView *tree; GtkTreeSelection *sel; GtkTreeModel *model; GtkTreeIter iter; PGconn *conn; gboolean is_system; gboolean admin_user; gboolean is_raw; gint pk; GtkWidget *msg_dlg; conn = g_object_get_data (G_OBJECT (dlg), MY_DB_CONN); g_assert (conn); is_system = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); admin_user = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), ADMIN_USER)) == 1); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), QUERY_LIST_VIEW)); sel = gtk_tree_view_get_selection (tree); if (!gtk_tree_selection_get_selected (sel, &model, &iter)) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (dlg), 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("In order to modify a filter,\n" "you must first select a filter to modify.")); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); } else { gtk_tree_model_get (model, &iter, QUERY_PK, &pk, QUERY_IS_RAW, &is_raw, -1); raise_or_create_edit_dlg (GTK_WIDGET (dlg), conn, pk, is_system, admin_user, is_raw); } } static void on_delete_button_clicked (GtkDialog *dlg) { GtkTreeView *tree; GtkTreeSelection *sel; GtkTreeModel *model; GtkTreeIter iter; PGresult *res; PGconn *conn; GString *sql_buffer; gboolean is_system; gint pk; GtkWidget *msg_dlg; GtkWidget *main_win; /* application main window */ conn = g_object_get_data (G_OBJECT (dlg), MY_DB_CONN); g_assert (conn); is_system = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), QUERY_LIST_VIEW)); sel = gtk_tree_view_get_selection (tree); if (!gtk_tree_selection_get_selected (sel, &model, &iter)) { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (dlg), 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("In order to delete a filter,\n" "you must first select a filter to delete.")); gtk_dialog_run (GTK_DIALOG (msg_dlg)); gtk_widget_destroy (msg_dlg); } else { msg_dlg = gtk_message_dialog_new (GTK_WINDOW (dlg), 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("This will perminently delete the selected filter.\n" "Are you sure that this is what you want to do?")); gtk_dialog_set_default_response (GTK_DIALOG (msg_dlg), GTK_RESPONSE_NO); if (gtk_dialog_run (GTK_DIALOG (msg_dlg)) == GTK_RESPONSE_YES) { gtk_tree_model_get (model, &iter, QUERY_PK, &pk, -1); sql_buffer = g_string_new (""); g_string_printf (sql_buffer, DELETE_QUERY, pk); START_TRANSACTION (conn); res = PQexec (conn, sql_buffer->str); chk_sql_error (res, _("Deleting Filter")); finalize_transaction (conn, res); PQclear (res); g_string_free (sql_buffer, TRUE); draw_query_list (GTK_WIDGET (dlg), conn, is_system); main_win = lookup_widget (GTK_WIDGET (dlg), MY_PARENT); g_assert (main_win != NULL); refresh_query_combo (main_win); } gtk_widget_destroy (msg_dlg); } } static void on_dismiss_button_clicked (GtkDialog *dlg) { GtkWidget *main_win; GtkTreeView *tree; GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; gint pk; PGconn *conn; PGresult *res; GString *sql_buffer; gint idx; gint order; gboolean user_is_admin; gboolean is_sys_query_list; gboolean in_error = FALSE; gboolean in_trans = FALSE; GConfClient *client; client = g_object_get_data (G_OBJECT (dlg), MY_GCONF_CLIENT); g_assert (client != NULL); main_win = lookup_widget (GTK_WIDGET (dlg), MY_PARENT); g_assert (main_win != NULL); user_is_admin = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), ADMIN_USER)) == 1); is_sys_query_list = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dlg), IS_SYS_QUERY_LIST)) == 1); /* * Only check the order_num info if the user has the access to * modify it. Then only change records that absolutely need it. */ if (user_is_admin || !is_sys_query_list) { tree = GTK_TREE_VIEW (lookup_widget (GTK_WIDGET (dlg), QUERY_LIST_VIEW)); g_assert (tree != NULL); conn = g_object_get_data (G_OBJECT (dlg), MY_DB_CONN); g_assert (conn != NULL); model = gtk_tree_view_get_model (tree); if (gtk_tree_model_get_iter_first (model, &iter)) { sql_buffer = g_string_new (""); do { path = gtk_tree_model_get_path (model, &iter); idx = (gtk_tree_path_get_indices (path)[0]) + 1; gtk_tree_path_free (path); gtk_tree_model_get (model, &iter, QUERY_PK, &pk, QUERY_ORDER, &order, -1); if (order != idx) { if (!in_trans) { START_TRANSACTION (conn); in_trans = TRUE; } g_string_printf (sql_buffer, UPDATE_ORDER_NUM, idx, pk); res = PQexec (conn, sql_buffer->str); if (!chk_sql_error (res, "Updating filter order_num")) { PQclear (res); in_error = TRUE; break; } PQclear (res); } } while (gtk_tree_model_iter_next (model, &iter)); if (in_trans) { if (in_error) { ROLLBACK (conn); } else { refresh_query_combo (main_win); COMMIT (conn); } } } } if (is_sys_query_list) { save_dlg_size (client, GTK_WIDGET (dlg), QRY_SYS_SEC); } else { save_dlg_size (client, GTK_WIDGET (dlg), QRY_USR_SEC); } gtk_widget_destroy (GTK_WIDGET (dlg)); } /* * These functions are callbacks used in a menu to make the menu * items behave just like the associated button presses. */ static void on_new_menu_sel (GtkWidget *widget, gpointer user_data) { on_new_button_clicked (GTK_DIALOG (user_data)); } static void on_new_raw_menu_sel (GtkWidget *widget, gpointer user_data) { on_new_raw_button_clicked (GTK_DIALOG (user_data)); } static void on_mod_menu_sel (GtkWidget *widget, gpointer user_data) { on_modify_button_clicked (GTK_DIALOG (user_data)); } static void on_del_menu_sel (GtkWidget *widget, gpointer user_data) { on_delete_button_clicked (GTK_DIALOG (user_data)); } static void on_query_dlg_clicked (GtkDialog *dlg, gint btn_cd, gpointer user_data) { switch (btn_cd) { case RESPONSE_NEW: on_new_button_clicked (dlg); break; case RESPONSE_NEW_RAW: on_new_raw_button_clicked (dlg); break; case RESPONSE_OPEN: on_modify_button_clicked (dlg); break; case RESPONSE_REMOVE: on_delete_button_clicked (dlg); break; case GTK_RESPONSE_CLOSE: on_dismiss_button_clicked (dlg); break; case GTK_RESPONSE_DELETE_EVENT: break; default: g_assert_not_reached (); } } static gboolean on_button_press_event (GtkWidget *widget, GdkEventButton *event, gpointer user_data) { static GtkMenu *popup = NULL; static GtkWidget *new_item; static GtkWidget *new_raw_item; static GtkWidget *del_item; static GtkWidget *open_item; GtkTreeModel *model; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreePath *path; GtkWidget *main_win = GTK_WIDGET (user_data); gboolean admin_user; gboolean is_sys; gboolean is_raw; gboolean active; gboolean handled = FALSE; PGconn *conn; gint pk_num; if (popup == NULL) { popup = GTK_MENU (gtk_menu_new()); gtk_widget_show (GTK_WIDGET (popup)); new_item = gtk_menu_item_new_with_label (_("New Filter...")); g_signal_connect (new_item, "activate", G_CALLBACK (on_new_menu_sel), user_data); gtk_menu_shell_append (GTK_MENU_SHELL (popup), new_item); gtk_widget_show (new_item); new_raw_item = gtk_menu_item_new_with_label (_("New Raw SQL Filter...")); g_signal_connect (new_raw_item, "activate", G_CALLBACK (on_new_raw_menu_sel), user_data); gtk_menu_shell_append (GTK_MENU_SHELL (popup), new_raw_item); gtk_widget_show (new_raw_item); open_item = gtk_menu_item_new_with_label (_("Open Filter...")); g_signal_connect (open_item, "activate", G_CALLBACK (on_mod_menu_sel), user_data); gtk_menu_shell_append (GTK_MENU_SHELL (popup), open_item); gtk_widget_show (open_item); del_item = gtk_menu_item_new_with_label (_("Delete Filter")); g_signal_connect (del_item, "activate", G_CALLBACK (on_del_menu_sel), user_data); gtk_menu_shell_append (GTK_MENU_SHELL (popup), del_item); gtk_widget_show (del_item); } admin_user = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (main_win), ADMIN_USER)) == 1); is_sys = (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (main_win), IS_SYS_QUERY_LIST)) == 1); conn = g_object_get_data (G_OBJECT (main_win), MY_DB_CONN); g_assert (conn != NULL); if (event) { switch (event->button) { case 1: switch (event->type) { case GDK_2BUTTON_PRESS: handled = TRUE; model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { gtk_tree_model_get (model, &iter, QUERY_PK, &pk_num, QUERY_IS_RAW, &is_raw, -1); raise_or_create_edit_dlg (main_win, conn, pk_num, is_sys, admin_user, is_raw); } break; default: break; } break; case 2: break; case 3: switch (event->type) { case GDK_BUTTON_PRESS: handled = TRUE; if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, &path, NULL, NULL, NULL)) { sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); gtk_tree_selection_select_path (sel, path); active = !is_sys || admin_user; gtk_widget_set_sensitive (new_item, active); gtk_widget_set_sensitive (new_raw_item, active); gtk_widget_set_sensitive (open_item, TRUE); gtk_widget_set_sensitive (del_item, active); gtk_menu_popup (popup, NULL, NULL, NULL, NULL, event->button, event->time); gtk_tree_path_free (path); } break; default: break; } default: break; } } return handled; } static GtkWidget * create_query_dlg (GtkWidget *parent, PGconn *conn, gboolean is_system, gboolean user_is_admin) { GtkWidget *query_dlg; GtkWidget *dialog_vbox3; GtkWidget *scrolledwindow10; GtkWidget *query_list_view; GtkWidget *warn_hbox; GtkWidget *warn_icon; GtkWidget *warn_lbl; GtkListStore *query_list_store; GtkTreeViewColumn *col; GtkCellRenderer *rend; 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); query_dlg = gtk_dialog_new (); if (is_system) { gtk_window_set_title (GTK_WINDOW (query_dlg), _("System Defined Display Filters")); set_dlg_size (client, query_dlg, QRY_SYS_SEC, 500, 235); } else { gtk_window_set_title (GTK_WINDOW (query_dlg), _("User Defined Display Filters")); set_dlg_size (client, query_dlg, QRY_USR_SEC, 500, 235); } GLADE_HOOKUP_OBJECT_NO_REF (query_dlg, query_dlg, "query_dlg"); gtk_container_set_border_width (GTK_CONTAINER (query_dlg), 5); g_signal_connect (query_dlg, "show", G_CALLBACK (on_query_dlg_show), NULL); g_signal_connect (query_dlg, "destroy", G_CALLBACK (on_query_dlg_destroy), NULL); g_signal_connect (query_dlg, "response", G_CALLBACK (on_query_dlg_clicked), NULL); gtk_window_set_resizable (GTK_WINDOW (query_dlg), TRUE); gtk_dialog_add_buttons(GTK_DIALOG (query_dlg), GTK_STOCK_NEW, RESPONSE_NEW, _("New Raw"), RESPONSE_NEW_RAW, GTK_STOCK_OPEN, RESPONSE_OPEN, GTK_STOCK_REMOVE, RESPONSE_REMOVE, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); g_object_set_data (G_OBJECT (query_dlg), MY_PARENT, parent); g_object_set_data (G_OBJECT (query_dlg), MY_DB_CONN, conn); g_object_set_data (G_OBJECT (query_dlg), MY_GCONF_CLIENT, client); g_object_set_data (G_OBJECT (query_dlg), ADMIN_USER, GINT_TO_POINTER (user_is_admin ? 1 : 0)); g_object_set_data (G_OBJECT (query_dlg), IS_SYS_QUERY_LIST, GINT_TO_POINTER (is_system ? 1 : 0)); dialog_vbox3 = GTK_DIALOG (query_dlg)->vbox; GLADE_HOOKUP_OBJECT (query_dlg, dialog_vbox3, "dialog_vbox3"); gtk_box_set_spacing (GTK_BOX (dialog_vbox3), STD_BOX_SPACING); gtk_widget_show (dialog_vbox3); scrolledwindow10 = gtk_scrolled_window_new (NULL, NULL); GLADE_HOOKUP_OBJECT (query_dlg, scrolledwindow10, "scrolledwindow10"); gtk_widget_show (scrolledwindow10); gtk_box_pack_start (GTK_BOX (dialog_vbox3), scrolledwindow10, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow10), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow10), GTK_SHADOW_ETCHED_IN); query_list_store = gtk_list_store_new (NUM_QUERY_COLS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); query_list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (query_list_store)); GLADE_HOOKUP_OBJECT (query_dlg, query_list_view, QUERY_LIST_VIEW); if (user_is_admin || !is_system) { gtk_tree_view_set_reorderable (GTK_TREE_VIEW (query_list_view), TRUE); } gtk_widget_show (query_list_view); gtk_container_add (GTK_CONTAINER (scrolledwindow10), query_list_view); g_signal_connect (query_list_view, "button_press_event", G_CALLBACK (on_button_press_event), query_dlg); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Name"), rend, "text", QUERY_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (query_list_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Description"), rend, "text", QUERY_DESCR, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (query_list_view), col); if (is_system && !user_is_admin) { gtk_dialog_set_response_sensitive (GTK_DIALOG (query_dlg), RESPONSE_NEW, FALSE); gtk_dialog_set_response_sensitive (GTK_DIALOG (query_dlg), RESPONSE_NEW_RAW, FALSE); gtk_dialog_set_response_sensitive (GTK_DIALOG (query_dlg), RESPONSE_REMOVE, FALSE); warn_hbox = gtk_hbox_new (FALSE, STD_BOX_SPACING); GLADE_HOOKUP_OBJECT (query_dlg, warn_hbox, "warn1_hbox"); gtk_box_pack_start (GTK_BOX (dialog_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 (query_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 (query_dlg, warn_lbl, "warn1_lbl"); gtk_label_set_markup (GTK_LABEL (warn_lbl), _("Editing Disabled: Only PRepS administrators can edit system wide display filters.")); gtk_box_pack_start (GTK_BOX (warn_hbox), warn_lbl, FALSE, FALSE, 0); gtk_widget_show (warn_lbl); } g_object_set_data (G_OBJECT (query_dlg), TOOLTIPS, tooltips); return query_dlg; } void destroy_query_dlg (void) { if (sys_dlg != NULL) { gtk_widget_destroy (sys_dlg); sys_dlg = NULL; } if (user_dlg != NULL) { gtk_widget_destroy (user_dlg); user_dlg = NULL; } } void show_query_dlg (GtkWidget *parent, PGconn *conn, gboolean is_system, gboolean user_is_admin) { GtkWidget **the_dlg; if (is_system) { the_dlg = &user_dlg; } else { the_dlg = &sys_dlg; } /* * If the dialog box exists, just make sure it is visable, otherwise * create it. */ if (*the_dlg != NULL) { gdk_window_show ((*the_dlg)->window); gdk_window_raise ((*the_dlg)->window); } else { *the_dlg = create_query_dlg (parent, conn, is_system, user_is_admin); /* * When the dialog is destroyed, call gtk_widget_destroyed(), * which will set the "user_data" (&person_dlg in this case) to * NULL. */ g_signal_connect (*the_dlg, "destroy", G_CALLBACK (gtk_widget_destroyed), the_dlg); gtk_widget_show (*the_dlg); } } /* * Determine if the edit dlg is "dirty". Note that this function is * used for both types of edit dlg's (regular, and raw). */ static gboolean edit_dlg_dirty (GtkWidget *dlg) { gpointer obj; GtkTextView *view; GtkTextBuffer *buff; /* * We will only have a RAW_SQL_TEXT text view if this is a raw sql * query edit dlg. * * lookup_widget will give a warning if it cannot find the widget. * Thus, I call g_object_get_data directly (this will break if * dlg is not the parent...) */ obj = g_object_get_data (G_OBJECT (dlg), RAW_SQL_TEXT); if (obj != NULL) { buff = gtk_text_view_get_buffer (GTK_TEXT_VIEW (obj)); if (gtk_text_buffer_get_modified (buff)) { return TRUE; } } view = GTK_TEXT_VIEW (lookup_widget (dlg, DESCR_TEXT)); g_assert (view != NULL); buff = gtk_text_view_get_buffer (view); if (gtk_text_buffer_get_modified (buff)) { return TRUE; } return objects_children_are_dirty (G_OBJECT (dlg)); } gboolean query_dlg_dirty (void) { GList *list; if (sys_dlg != NULL) { list = g_object_get_data (G_OBJECT (sys_dlg), my_child_list); list = g_list_first (list); while (list != NULL) { if (edit_dlg_dirty (GTK_WIDGET (list->data))) { return TRUE; } list = list->next; } } if (user_dlg != NULL) { list = g_object_get_data (G_OBJECT (user_dlg), my_child_list); list = g_list_first (list); while (list != NULL) { if (edit_dlg_dirty (GTK_WIDGET (list->data))) { return TRUE; } list = list->next; } } return FALSE; }