kitlistgui.cpp

Go to the documentation of this file.

/*

    This file is part of Kitlist, a program to maintain a simple list
    of items and assign items to one or more categories.

    Copyright (C) 2008-2021 Frank Dean

    Kitlist 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 3 of the License, or
    (at your option) any later version.

    Kitlist 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 Kitlist.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "kitlistgui.hpp"
#include "printing.hpp"
#include "yamlconfig.hpp"
#include <cassert>
// #include <gtk/gtk.h>
// #include <gtkmm.h>
#include <glibmm/i18n.h>
#include <glibmm/refptr.h>
#include <glibmm/ustring.h>
#include <gtkmm/aboutdialog.h>
#include <gtkmm/cellrenderertoggle.h>
#include <gtkmm/clipboard.h>
#include <gtkmm/filechooserdialog.h>
#include <gtkmm/menuitem.h>
#include <gtkmm/messagedialog.h>
#include <gtkmm/stock.h>
#include <gtkmm/targetentry.h>
#include <gtkmm/window.h>
#include <libglademm/xml.h>
#include <libxml++/libxml++.h>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <sys/stat.h>
#include <config.h>


using namespace std;

namespace {

    const string GLADE_APP_FILE = "kitlist.glade";

    const guint SB_ITEM_COUNT = 1000;
    const guint SB_SAVE = SB_ITEM_COUNT + 1;
    const guint SB_MSG = SB_SAVE + 1;

    const guint SB_PRINT = SB_MSG + 1;

    const char item_target_custom[] = "kitlistclipboard";
    const char item_target_text[] = "text/plain";

    const char XML_ELEMENT_ID[] = "id";

    const Glib::ustring DEFAULT_FILENAME_EXTENSION = ".kit";

    const Glib::ustring PDF_FILENAME_EXTENSION = ".pdf";

    const Glib::ustring DEFAULT_FILENAME = "kitlist" + DEFAULT_FILENAME_EXTENSION;

    const Glib::ustring GCONF_KEY = "/apps/kitlist";

    const Glib::ustring GCONF_KEY_CURRENT_FILENAME = GCONF_KEY + "/current_filename";

    const Glib::ustring GCONF_KEY_PAGE_TITLE = GCONF_KEY + "/page_title";

#ifdef KITLIST_DEBUG
#ifdef GCONF
    const Glib::ustring GCONF_KEY_DEBUG_LOG = GCONF_KEY + "/debug_log_filename";
#endif
#endif

    const Glib::ustring GCONF_KEY_RECENT_FILES = GCONF_KEY + "/recent_files";

    const Glib::ustring GCONF_KEY_MAX_RECENT_FILES = GCONF_KEY + "/max_recent_files";

} // anonymous namespace


#ifdef KITLIST_DEBUG
void my_log_handler(const gchar *log_domain,
                    GLogLevelFlags log_level,
                    const gchar *message,
                    gpointer data) {
    g_print("KITLIST: %s\n", message);
    ofstream* fout = (ofstream*) data;
    if (fout) {
        *fout << message << endl;
    }
}
#endif


typedef Gtk::TreeModel::Children type_children;

const bool file_exists(const Glib::ustring& filename) {
    struct stat fileinfo;
    bool retval;
    retval = !(stat(filename.c_str(), &fileinfo));
    // g_debug("file_exists: %s", retval ? "true" : "false");
    return retval;
}


const string load_resource_glade_file(const Glib::ustring& filename) {
    vector<string> locs;
    locs.push_back(filename);
    locs.push_back("../" + filename);
    locs.push_back("./src/" + filename);
    locs.push_back(string(PACKAGE_DATA_DIR) + "/glade/" + filename);
    for (std::vector<string>::iterator i = locs.begin(); i != locs.end(); ++i) {
        if (file_exists(*i))
            return *i;
    }
    return "";
}

Glib::RefPtr<Gnome::Glade::Xml> get_glade_ref_ptr(const string& filename,
                                               const Glib::ustring& root = Glib::ustring(),
                                               const Glib::ustring& domain = Glib::ustring()) {
    Glib::RefPtr<Gnome::Glade::Xml> refXml;
    try {
#ifdef GLIBMM_EXCEPTIONS_ENABLED
        refXml = Gnome::Glade::Xml::create(load_resource_glade_file(filename), root, domain);
#else
        std::auto_ptr<Gnome::Glade::XmlError> ex;
        refXml = Gnome::Glade::Xml::create(load_resource_glade_file(filename), root, domain, ex);
        if (ex.get())
            g_error(_("Error loading Glade file: %s"), ex->what().c_str());
#endif
    } catch (const Gnome::Glade::XmlError& ex) {
        g_error(_("Error loading Glade file: %s"), ex.what().c_str());
        throw ex;
    }
    return refXml;
}


KitListGui::KitListGui(int argc, char **argv, Service& service)
    : m_kit(argc, argv),
      m_ignore_list_events(false),
      m_window(0),
      m_window_preferences(0),
      m_entry_page_title(0),
      m_window_add_item(0),
      m_window_add_category(0),
      m_entry_add_item(0),
      m_entry_add_category(0),
      m_file_save_menu_item(0),
      m_file_save_tool_button(0),
      m_paste_menu_item(0),
      m_paste_tool_button(0),
      m_checkbutton_add_item(0),
      m_category_combo(0),
      m_item_tree_view(0),
      m_ref_item_tree_model(0),
      m_service(service),
      m_status_bar(0),
      m_state(ADD_CATEGORY),
      m_current_cat_id(-1) {
    m_ref_page_setup = Gtk::PageSetup::create();
    m_ref_printer_settings = Gtk::PrintSettings::create();
    init();
}


KitListGui::~KitListGui() {
#ifdef KITLIST_DEBUG
    if (m_slog) {
        m_slog->close();
        delete m_slog;
    }
#endif
}


void KitListGui::run() {
    m_kit.run(*m_window);
    if (m_service.is_model_dirty()) {
        g_warning("WARNING: Application is closing with unsaved changes");
    }
}


gint KitListGui::get_max_recent_files() {
    gint retval = DEFAULT_MAX_RECENT_FILES;
    return retval;
}


bool KitListGui::confirm_lose_changes(const Glib::ustring& message) {
    // Prompt to abandon changes
    Gtk::MessageDialog dialog(*m_window,
                              message,
                              false,
                              Gtk::MESSAGE_WARNING,
                              Gtk::BUTTONS_NONE);
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_APPLY);
    dialog.add_button(_("_Discard Changes"), Gtk::RESPONSE_CLOSE);
    int result = dialog.run();
    switch (result) {
    case (Gtk::RESPONSE_CANCEL) :
        return false;
    case (Gtk::RESPONSE_APPLY) :
#ifdef XML_DAO
        if (m_filename.length() > 0) {
            m_service.save_as_xml(m_filename);
            m_service.set_model_dirty(false);
            return true;
        }
        return false;
#else
        m_service.save();
        m_service.set_model_dirty(false);
        return true;
#endif
    case (Gtk::RESPONSE_CLOSE) :
        return true;
    default :
        return false;
    }
}


void KitListGui::update_recent_files_menu() {
#ifdef GCONF
    // Get the current list from GConf
    std::deque<Glib::ustring> mru =
        m_ref_gconf_client->get_string_list(GCONF_KEY_RECENT_FILES);
#else
    std::deque<Glib::ustring> mru = m_yaml_config.get_recent_filenames();
#endif // GCONF

    if (m_recent_files_menu_item) {
        if (m_recent_files_menu_item->has_submenu()) {
            m_recent_files_menu_item->remove_submenu();
        }
        Gtk::Menu* recent_menu = Gtk::manage(new Gtk::Menu);
        // g_debug("Creating new recent files submenu");
        m_recent_files_menu_item->set_submenu(*recent_menu);
        for (std::deque<Glib::ustring>::iterator i = mru.begin();
             i != mru.end();
             ++i) {
            Gtk::MenuItem* m = Gtk::manage(new Gtk::MenuItem(*i));
            m->signal_activate().connect(
                sigc::bind<Glib::ustring>(
                    sigc::mem_fun(*this, &KitListGui::on_menu_recent_file), *i)
                );
            recent_menu->add(*m);
            recent_menu->show_all_children();
        }
    } else {
        g_warning("Couldn't find recent files menu item");
    }
}


void KitListGui::update_recent_files(const Glib::ustring& filename) {
#ifdef GCONF
    // g_debug("Adding %s to recent file list", filename.c_str());
    // Get the current list from GConf
    std::deque<Glib::ustring> mru =
        m_ref_gconf_client->get_string_list(GCONF_KEY_RECENT_FILES);
    // Remove filename from list
    for (std::deque<Glib::ustring>::iterator i = mru.begin(); i != mru.end(); ++i) {
        if (*i == filename) {
            mru.erase(i);
            break;
        }
    }
    // Add add to front
    mru.push_front(filename);
    while (mru.size() > get_max_recent_files()) {
        mru.pop_back();
    }

    // Save the updated list
    m_ref_gconf_client->set_string_list(GCONF_KEY_RECENT_FILES, mru);


    update_recent_files_menu();
#else
    m_yaml_config.add_recent_filename(filename.c_str());
    update_recent_files_menu();
#endif // GCONF
}


bool KitListGui::on_delete_event(GdkEventAny* event) {
    if (m_service.is_model_dirty() &&
            !confirm_lose_changes(_("Your changes will be lost if you quit now"))) {
        return true;
    }
    // user has chosen to abandon changes
    // Clear the dirty state so that it can be tested in run().
    // See the notes under KitListGui::run()
    m_service.set_model_dirty(false);
    return false;
}


void KitListGui::on_menu_quit() {
    if (m_service.is_model_dirty() &&
            !confirm_lose_changes(_("Your changes will be lost if you quit now"))) {
        return;
    }
    // user has chosen to abandon changes
    // Clear the dirty state so that it can be tested in run().
    // See the notes under KitListGui::run()
    m_service.set_model_dirty(false);
    m_window->hide();
}


void KitListGui::on_menu_file_new() {
    if (m_status_bar)
        m_status_bar->pop(SB_SAVE);
    if (m_service.is_model_dirty() &&
        !confirm_lose_changes(_("Your changes will be lost if you continue"))) {
        return;
    }
#ifndef TRANSITION_DAO
    if (m_service.require_filename()) {
#endif
        m_filename.clear();
#ifdef GCONF
        if (m_ref_gconf_client) {
#ifdef GLIBMM_EXCEPTIONS_ENABLED
            m_ref_gconf_client->unset(GCONF_KEY_CURRENT_FILENAME);
#else
            std::auto_ptr<Glib::Error> error;
            m_ref_gconf_client->unset(GCONF_KEY_CURRENT_FILENAME, error);
            if (error.get())
                g_warning("GConf error: %s", error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
        }
#else
        m_yaml_config.set_current_filename("");
#endif // GCONF
        m_service.create_default_model();
        // Don't select a category, as it may no longer be relevant,
        // after all, we've just loaded a new model.
        refresh_category_list(-1);
        refresh_item_list();
#ifndef TRANSITION_DAO
    } else {
        if (m_status_bar)
            m_status_bar->push(_("New databases must be created manually"), SB_SAVE);
    }
#endif
}


void KitListGui::on_menu_file_open() {
    if (m_status_bar)
        m_status_bar->pop(SB_SAVE);
    if (m_service.is_model_dirty() &&
            !confirm_lose_changes(_("Your changes will be lost if you continue"))) {
        return;
    }
    // Prompt select file to open
    Gtk::FileChooserDialog dialog(_("Open File"), Gtk::FILE_CHOOSER_ACTION_OPEN);
    dialog.set_transient_for(*m_window);

    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

    Gtk::FileFilter filter_xml;
    filter_xml.set_name(_("Kit files"));
#ifdef WIN32
    filter_xml.add_pattern("*" + DEFAULT_FILENAME_EXTENSION);
#else
    filter_xml.add_pattern("*" + DEFAULT_FILENAME_EXTENSION);
    // filter_xml.add_mime_type("application/xml");
#endif
    dialog.add_filter(filter_xml);

    Gtk::FileFilter filter_any;
    filter_any.set_name(_("Any files"));
    filter_any.add_pattern("*");
    dialog.add_filter(filter_any);

    int result = dialog.run();
    dialog.hide();
    Glib::ustring filename;
    switch(result) {
    case(Gtk::RESPONSE_OK):
        filename = dialog.get_filename();
        break;
    case(Gtk::RESPONSE_CANCEL):
        return;
    default:
        return;
    }
    open_file(filename);
}


void KitListGui::open_file(const Glib::ustring& filename) {
    m_service.open_as_xml(filename);
    m_filename = filename;
    update_recent_files(m_filename);

#ifdef GCONF
    if (m_ref_gconf_client) {
#ifdef GLIBMM_EXCEPTIONS_ENABLED
        m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename);
#else
        std::auto_ptr<Glib::Error> error;
        m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename, error);
        if (error.get())
            g_warning("GConf error: %s", error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
    }
#else // GCONF
    m_yaml_config.set_current_filename(m_filename.c_str());
#endif

    // Don't select a category, as it may no longer be relevant,
    // after all, we've just loaded a new model.
    refresh_category_list(-1);
    refresh_item_list();
}


void KitListGui::safe_open_file(const Glib::ustring& filename) {
    if (m_status_bar)
        m_status_bar->pop(SB_SAVE);
    if (m_service.is_model_dirty() &&
            !confirm_lose_changes(_("Your changes will be lost if you continue"))) {
        return;
    }
    open_file(filename);
}


void KitListGui::on_menu_save() {
    if (m_status_bar)
        m_status_bar->pop(SB_SAVE);
    if (m_service.is_model_dirty()) {
        // Some persistence models may require a filename to be
        // chosen, others (e.g. database) may be defined through
        // another mechanism.  If a filename has not been set, then
        // fire up save-as instead.
        if (m_service.require_filename() && m_filename.size() == 0) {
            on_menu_save_as();
        } else {
            Glib::ustring msg = _("Saving changes...");
            if (m_status_bar)
                m_status_bar->push(msg, SB_SAVE);
#ifndef XML_DAO
            m_service.save();
#else
            m_service.save_as_xml(m_filename);
            update_recent_files(m_filename);
#ifdef GCONF
            if (m_ref_gconf_client) {
#ifdef GLIBMM_EXCEPTIONS_ENABLED
                m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME,
                                        m_filename);
#else
                std::auto_ptr<Glib::Error> error;
                m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename, error);
                if (error.get())
                    g_warning("GConf error: %s", error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
            }
#else // GCONF
            m_yaml_config.set_current_filename(m_filename.c_str());
#endif // GCONF
#endif // !XML_DAO
            if (m_status_bar)
                m_status_bar->pop(SB_SAVE);
            msg = _("Saved");
            if (m_status_bar)
                m_status_bar->push(msg, SB_SAVE);
        }
    } else {
        if (m_status_bar)
            m_status_bar->push(Glib::ustring(_("Nothing to save")), SB_SAVE);
    }
}


void KitListGui::on_menu_save_as() {
    if (m_status_bar) {
        m_status_bar->pop(SB_SAVE);
        m_status_bar->push(_("Choosing target filename"), SB_SAVE);
    }
    if (choose_filename(m_filename)) {
        if (m_status_bar) {
            m_status_bar->pop(SB_SAVE);
            m_status_bar->push(_("Saving..."), SB_SAVE);
        }

        m_service.save_as_xml(m_filename);
        update_recent_files(m_filename);

        if (m_status_bar) {
            m_status_bar->pop(SB_SAVE);
            m_status_bar->push(_("Saved"), SB_SAVE);
        }
#ifdef GCONF
        if (m_ref_gconf_client) {
#ifdef GLIBMM_EXCEPTIONS_ENABLED
            m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename);
#else
            std::auto_ptr<Glib::Error> error;
            m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename, error);
            if (error.get())
                g_warning("GConf error: %s", error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
        }
#else // GCONF
        m_yaml_config.set_current_filename(m_filename.c_str());
#endif // GCONF

        // Disable save if we're using a database otherwise we'll be
        // trying to save to the database, not the file with the model
        // being potentially inconsistent with the database.

// Don't think we need this as we've now disabled NEW and OPEN
// #ifndef XML_DAO
//         m_file_save_menu_item->set_sensitive(false);
//         m_file_save_tool_button->set_sensitive(false);
// #endif
    } else {
        if (m_status_bar) {
            m_status_bar->pop(SB_SAVE);
            m_status_bar->push(_("Save cancelled"), SB_SAVE);
        }
    }
}


void KitListGui::on_printoperation_status_changed(const Glib::RefPtr<Gtk::PrintOperation>& op) {
    if (m_status_bar)
        m_status_bar->pop(SB_PRINT);
    Glib::ustring status_msg;
    if (op->is_finished())
        status_msg = _("Print job completed");
    else
        status_msg = op->get_status_string();

    m_status_bar->push(status_msg, SB_PRINT);
}

void KitListGui::on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr<Gtk::PrintOperation>& op) {
    if (result == Gtk::PRINT_OPERATION_RESULT_ERROR) {
        Gtk::MessageDialog err_dialog(*this->m_window, _("Error printing list"), false,
                                      Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
        err_dialog.run();
    } else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
        m_ref_printer_settings = op->get_print_settings();;
    if (! op->is_finished())
        op->signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this, &KitListGui::on_printoperation_status_changed), op));
}


void KitListGui::on_menu_print() {
    Glib::RefPtr<KitPrintOperation> op = KitPrintOperation::create();
    ItemContainer *items = m_service.get_filtered_items(get_selected_category());
    op->set_items(items);
    op->set_track_print_status();
    op->set_default_page_setup(m_ref_page_setup);
    op->set_print_settings(m_ref_printer_settings);
    op->set_page_title(m_page_title);
    op->signal_done().connect(sigc::bind(sigc::mem_fun(*this, &KitListGui::on_printoperation_done), op));

#ifdef GLIBMM_EXCEPTIONS_ENABLED
    try {
        op->run();
    } catch (const Gtk::PrintError& ex) {
        g_error("An error occured while trying to run a print operation: %s", ex.what().c_str());
    }
#else
    std::auto_ptr<Glib::Error> error;
    op->run(Gtk::PRINT_OPERATION_ACTION_PRINT_DIALOG, error);
    if (error.get())
        g_warning("Error running print job: %s",
                  error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
}


void KitListGui::on_menu_export_to_pdf() {
    if (m_status_bar) {
        m_status_bar->pop(SB_SAVE);
        m_status_bar->push(_("Choosing export filename"), SB_SAVE);
    }
    Glib::ustring pdf_filename;
    if (choose_pdf_filename(pdf_filename)) {
        if (m_status_bar) {
            m_status_bar->pop(SB_SAVE);
            m_status_bar->push(_("Exporting..."), SB_SAVE);
        }
        Glib::RefPtr<KitPrintOperation> op = KitPrintOperation::create();
        ItemContainer *items = m_service.get_filtered_items(get_selected_category());
        op->set_items(items);
        op->set_track_print_status();
        op->set_default_page_setup(m_ref_page_setup);
        op->set_print_settings(m_ref_printer_settings);
        op->set_page_title(m_page_title);
        // op->signal_done().connect(sigc::bind(sigc::mem_fun(*this, &KitListGui::on_printoperation_done), op));
        op->set_export_filename(pdf_filename);

    #ifdef GLIBMM_EXCEPTIONS_ENABLED
        try {
            op->run(Gtk::PRINT_OPERATION_ACTION_EXPORT);
        } catch (const Gtk::PrintError& ex) {
            g_error("An error occured while trying to run a print operation: %s", ex.what().c_str());
        }
    #else
        std::auto_ptr<Glib::Error> error;
        op->run(Gtk::PRINT_OPERATION_ACTION_EXPORT, error);
        if (error.get())
            g_warning("Error running print job: %s",
                      error->what().c_str());
    #endif //GLIBMM_EXCEPTIONS_ENABLED

        if (m_status_bar) {
            m_status_bar->pop(SB_SAVE);
            m_status_bar->push(_("PDF exported"), SB_SAVE);
        }
    } else {
        if (m_status_bar) {
            m_status_bar->pop(SB_SAVE);
            m_status_bar->push(_("Export cancelled"), SB_SAVE);
        }
    }
}

void KitListGui::on_menu_recent_file(const Glib::ustring& filename) {
    // g_debug("Most recent files menu clicked: %s", filename.c_str());
    if (m_service.is_model_dirty() &&
            !confirm_lose_changes(_("Your changes will be lost if you continue"))) {
        return;
    }
    m_service.open_as_xml(filename);
    m_filename = filename;
    update_recent_files(m_filename);

#ifdef GCONF
    if (m_ref_gconf_client) {
#ifdef GLIBMM_EXCEPTIONS_ENABLED
        m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename);
#else
        std::auto_ptr<Glib::Error> error;
        m_ref_gconf_client->set(GCONF_KEY_CURRENT_FILENAME, m_filename, error);
        if (error.get())
            g_warning("GConf error: %s", error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
    }
#else // GCONF
    m_yaml_config.set_current_filename(m_filename.c_str());
#endif // GCONF

    // Don't select a category, as it may no longer be relevant,
    // after all, we've just loaded a new model.
    refresh_category_list(-1);
    refresh_item_list();
}


ModelItemContainer* KitListGui::get_selected_items() {
    ModelItemContainer* retval = new ModelItemContainer;
    Glib::RefPtr<Gtk::TreeSelection> ref_tree_selection =
        m_item_tree_view->get_selection();
    if (ref_tree_selection) {
        if (ref_tree_selection->get_mode() == Gtk::SELECTION_MULTIPLE) {
            Gtk::TreeSelection::ListHandle_Path rows = ref_tree_selection->get_selected_rows();
            for (Glib::Container_Helpers::ListHandleIterator<Gtk::TreePath_Traits> path = rows.begin(); path != rows.end(); ++path) {
                Gtk::TreeModel::iterator iter = m_ref_item_tree_model->get_iter(*path);
                Gtk::TreeModel::Row row = *iter;
                int id = row[m_item_cols.m_col_num];
                ModelItem* item = m_service.find_item(id);
                if (item) {
                    retval->push_back(item);
                } else {
                    g_warning("Failed to find item to delete in model");
                }
            } // for
        } else {
            Gtk::TreeModel::iterator iter = ref_tree_selection->get_selected();
            if (iter) {
                Gtk::TreeModel::Row row = *iter;
                int id = row[m_item_cols.m_col_num];
                ModelItem* item = m_service.find_item(id);
                if (item) {
                    retval->push_back(item);
                } else {
                    g_warning("Failed to find item to delete in model");
                }
            } else {
                g_warning("Couldn't find the selected item or items");
            }
        } // else {Single Selection}
    } else {
        g_warning("Couldn't identify selection");
    }
    return retval;
}


void KitListGui::delete_selected_items() {
    Glib::RefPtr<Gtk::TreeSelection> ref_tree_selection =
        m_item_tree_view->get_selection();
    if (ref_tree_selection) {
        if (ref_tree_selection->get_mode() == Gtk::SELECTION_MULTIPLE) {
            ref_tree_selection->selected_foreach_iter( sigc::mem_fun(*this, &KitListGui::selected_row_callback));
            refresh_item_list();
        } else {
            Gtk::TreeModel::iterator iter = ref_tree_selection->get_selected();
            if (iter) {
                Gtk::TreeModel::Row row = *iter;
                int id = row[m_item_cols.m_col_num];
                m_ref_item_tree_model->erase(iter);
                if (!m_service.delete_item(id))
                    g_warning("Failed to find the item to delete in the model");
            } else {
                g_warning("Couldn't find the selected item or items");
            }
        } // else {Single Selection}
    } else {
        g_warning("Couldn't identify selection");
    }
}


void KitListGui::on_menu_delete() {
    Gtk::MessageDialog dialog(*m_window,
                              _("Delete the selected items?"),
                              false,
                              Gtk::MESSAGE_QUESTION,
                              Gtk::BUTTONS_YES_NO);
    int result = dialog.run();
    switch (result) {
    case (Gtk::RESPONSE_YES) :
        delete_selected_items();
        break;
    case (Gtk::RESPONSE_NO) :
        break;
    default:
        g_warning("Unexpected button");
        break;
    }
}


ModelItemContainer* KitListGui::copy_selected_items_to_clipboard() {
    xmlpp::Document document;
    xmlpp::Element* nodeRoot = document.create_root_node("kitlist");
    assert(nodeRoot);
    nodeRoot->add_child_text("\n");
    ModelItemContainer* items = get_selected_items();
    for (ModelItemIter i = items->begin(); i != items->end(); ++i) {
        xmlpp::Element* nodeChild = nodeRoot->add_child("item");
        ostringstream os;
        os << (*i)->get_id();
        nodeChild->set_attribute(XML_ELEMENT_ID, os.str());
        // Enable the following lines to create a more readable XML document
        nodeChild->set_child_text((*i)->get_description());
        nodeRoot->add_child_text("\n");
    }
    m_clipboard_items = document.write_to_string();

    Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get(/*gdk_atom_intern("CLIPBOARD", false)*/);
    std::list<Gtk::TargetEntry> listTargets;
    listTargets.push_back( Gtk::TargetEntry(item_target_custom) );
    listTargets.push_back( Gtk::TargetEntry(item_target_text) );
    refClipboard->set( listTargets,
                       sigc::mem_fun(*this, &KitListGui::on_clipboard_get),
                       sigc::mem_fun(*this, &KitListGui::on_clipboard_clear) );
    update_paste_status();
    return items;
}


void KitListGui::on_menu_cut() {
    long cat_id = get_selected_category();
    if (cat_id != -1) {
        ModelItemContainer* items = copy_selected_items_to_clipboard();
        if (items) {
            ModelCategory* category = m_service.find_category(cat_id);
            if (category) {
                m_service.set_model_dirty();
                category->remove_items(items);
                category->set_dirty(true);
            }
            refresh_item_list();
        }
        delete items;
    } else {
        if (m_status_bar) {
            m_status_bar->pop(SB_MSG);
            m_status_bar->push(_("Items can only be cut when a category is selected"), SB_MSG);
        }
    }
}


void KitListGui::on_menu_copy() {
    ModelItemContainer* items = copy_selected_items_to_clipboard();
    delete items;
}


void KitListGui::on_menu_paste() {
    // Tell the clipboard to call our method when it is ready
    Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get(/*gdk_atom_intern("CLIPBOARD", false)*/);
    refClipboard->request_contents(item_target_text, sigc::mem_fun(
                                       *this,
                                       &KitListGui::on_clipboard_received) );
    paste_from_xml(m_clipboard_items);
    update_paste_status();
}


void KitListGui::on_menu_select_all() {
    //m_item_tree_view->select_all();
    Glib::RefPtr<Gtk::TreeSelection> selection =
        m_item_tree_view->get_selection();
    if (selection)
        selection->select_all();
    m_item_tree_view->grab_focus();
}


void KitListGui::on_menu_create_category() {
    m_state = ADD_CATEGORY;
    m_current_cat_id = -1;
    if (m_window_add_category) {
        m_window_add_category->set_title(_("Add Category"));
        if (m_entry_add_category) {
            m_entry_add_category->set_text("");
        }
        m_entry_add_category->grab_focus();
        m_window_add_category->show();
    } else {
        g_warning("\"window_add_category\" resource is missing");
    }
}


void KitListGui::close_add_category_window() {
    m_window_add_category->hide();
    if (m_entry_add_category) {
        Category* category = NULL;
        if (m_state == ADD_CATEGORY) {
            category = m_service.create_category();
        } else {
            category = m_service.find_category(m_current_cat_id);
        }
        if (category != NULL) {
            category->set_name(m_entry_add_category->get_text());
            m_service.set_model_dirty();
            ((ModelCategory*) category)->set_dirty(true);
            refresh_category_list(category->get_id());
            refresh_item_list();
        }
    }
}



void KitListGui::cancel_add_category_window() {
    m_window_add_category->hide();
}


void KitListGui::on_menu_delete_category() {
    long cat_id = get_selected_category();
    if (cat_id == -1) {
        if (m_status_bar) {
            m_status_bar->pop(SB_MSG);
            m_status_bar->push(_("No category selected"), SB_MSG);
        }
    } else {
        Gtk::MessageDialog dialog(*m_window,
                                  _("Delete the current category?"),
                                  false,
                                  Gtk::MESSAGE_QUESTION,
                                  Gtk::BUTTONS_YES_NO);
        int result = dialog.run();
        switch (result) {
        case (Gtk::RESPONSE_YES) :
            m_service.delete_category(cat_id);
            refresh_category_list();
            refresh_item_list();
            break;
        case (Gtk::RESPONSE_NO) :
            break;
        default:
            g_warning("Unexpected button");
            break;
        }
    }
}


void KitListGui::on_menu_rename_category() {
    m_state = RENAME_CATEGORY;
    m_current_cat_id = get_selected_category();
    if (m_window_add_category) {
        m_window_add_category->set_title(_("Rename Category"));
        if (m_current_cat_id != -1) {
            ModelCategory* category = m_service.find_category(m_current_cat_id);
            if (category != NULL && m_entry_add_category) {
                m_entry_add_category->set_text(category->get_name());
            }
            m_entry_add_category->grab_focus();
            m_window_add_category->show();
        } else {
            if (m_status_bar) {
                m_status_bar->pop(SB_MSG);
                m_status_bar->push(_("No category selected"), SB_MSG);
            }
        }
    } else {
        g_warning("\"window_add_category\" resource is missing");
    }
}


void KitListGui::on_menu_help_about() {
    Gtk::AboutDialog dialog;
    dialog.set_name(PACKAGE_NAME);
    dialog.set_copyright("(c) 2008-2021 Frank Dean");
    dialog.set_version(PACKAGE_VERSION);
    std::vector<Glib::ustring> authors;
    authors.push_back("frank.dean@fdsd.co.uk");
    dialog.set_authors(authors);
    dialog.run();
}


void KitListGui::set_selected(bool checked) {
    ModelItemContainer* items = get_selected_items();
    m_service.select_items(items, checked);
    refresh_item_list();
    delete items;
}


void KitListGui::toggle_selected() {
    ModelItemContainer* items = get_selected_items();
    m_service.toggle_selected_items(items);
    refresh_item_list();
    delete items;
}


void KitListGui::on_clipboard_get(Gtk::SelectionData& selection_data, guint) {
    const std::string target = selection_data.get_target();

    if (target == item_target_custom) {
        selection_data.set_text(m_clipboard_items);
    } else if (target == item_target_text) {
        selection_data.set_text(m_clipboard_items);
    } else {
        g_warning("KitList::on_clipboard_get(): Unexpected clipboard target format");
    }
}


void KitListGui::on_clipboard_clear() {
}


void KitListGui::add_items(const ModelItemContainer& items) {
    long cat_id = get_selected_category();
    if (cat_id != -1) {
        m_service.copy_items(items, cat_id);
        refresh_item_list();
    }
}


void KitListGui::paste_from_xml(const Glib::ustring& document) {
    try {
        if (document.length() > 0) {
            xmlpp::DomParser parser;
            parser.set_substitute_entities();
            parser.parse_memory(document);
            const xmlpp::Node* nodeRoot = parser.get_document()->get_root_node();
            ModelItemContainer items;
            xmlpp::Node::NodeList nodes = nodeRoot->get_children();
            for (xmlpp::Node::NodeList::iterator iter = nodes.begin(); iter != nodes.end(); ++iter) {
                const xmlpp::Node* node = (*iter);
                // const xmlpp::ContentNode* nodeContent = dynamic_cast<const xmlpp::ContentNode*>(node);
                const xmlpp::Element* nodeElement = dynamic_cast<const xmlpp::Element*>(node);
                if (nodeElement && node->get_name() == "item") {
                    xmlpp::Attribute* attribute = nodeElement->get_attribute(XML_ELEMENT_ID);
                    if (attribute) {
                        Glib::ustring s = attribute->get_value();
                        long id = atol(s.c_str());
                        ModelItem* item = m_service.find_item(id);
                        if (item) {
                            items.push_back(item);
                        }
                    }
                }
            }
            add_items(items);
        }
    } catch (std::exception ex) {
        g_warning("Error pasting clipboard - perhaps it was empty");
    }
}


void KitListGui::on_clipboard_received(const Gtk::SelectionData& selection_data) {
    const std::string target = selection_data.get_target();
    Glib::ustring s;
    if (target == item_target_custom || target == item_target_text) {
        m_clipboard_items = selection_data.get_data_as_string();
    } else {
        g_warning("KitList::on_clipboard_get(): Unexpected clipboard target format");
    }
}


void KitListGui::update_item_count(size_t n) {
    // use the user's locale for this stream
    ostringstream os;
    os.imbue(std::locale(""));
    os << n << " " << (n == 1 ? _("item") : _("items"));
    if (m_status_bar) {
        m_status_bar->pop(SB_ITEM_COUNT);
#ifdef GLIBMM_EXCEPTIONS_ENABLED
        m_status_bar->push(Glib::locale_to_utf8(os.str()), SB_ITEM_COUNT);
#else
        std::auto_ptr<Glib::Error> ex;
        m_status_bar->push(Glib::locale_to_utf8(os.str(), ex), SB_ITEM_COUNT);

        if (ex.get())
            g_warning("Error updating the status bar: %s", ex->what().c_str());
#endif // GLIBMM_EXCEPTIONS_ENABLED
    }
}


void KitListGui::on_cell_edit(const Glib::ustring s) {
    if (m_ignore_list_events)
        return;
    m_service.set_model_dirty(true);
}


bool KitListGui::choose_filename(Glib::ustring& filename) {
    bool retval = false;
    bool loop = true;
    while (loop) {
        Gtk::FileChooserDialog dialog(_("Save File"), Gtk::FILE_CHOOSER_ACTION_SAVE);
        dialog.set_transient_for(*m_window);

        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
        dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);

        Gtk::FileFilter filter_xml;
        filter_xml.set_name(_("XML files"));

#ifdef WIN32
        filter_xml.add_pattern("*" + DEFAULT_FILENAME_EXTENSION);
#else
        filter_xml.add_pattern("*" + DEFAULT_FILENAME_EXTENSION);
        // filter_xml.add_mime_type("application/xml");
#endif

        dialog.add_filter(filter_xml);

        Gtk::FileFilter filter_any;
        filter_any.set_name(_("Any files"));
        filter_any.add_pattern("*");
        dialog.add_filter(filter_any);

        int result = dialog.run();
        dialog.hide();

        switch(result) {
        case(Gtk::RESPONSE_OK):
            filename = dialog.get_filename();
            retval = true;
            break;
        case(Gtk::RESPONSE_CANCEL):
            break;
        default:
            break;
        }
        if (retval) {
            // Add file default extension if no extension
            Glib::ustring::size_type i = filename.find(".");
            if (i < 0 || i > filename.length()) {
                filename += DEFAULT_FILENAME_EXTENSION;

            }
            // Prompt for overwrite if the file exists
            if (file_exists(filename)) {
                Gtk::MessageDialog dialog(*m_window,
                                          _("Overwrite existing file?"),
                                          false,
                                          Gtk::MESSAGE_WARNING,
                                          Gtk::BUTTONS_NONE);
                dialog.add_button(Gtk::Stock::NO, Gtk::RESPONSE_NO);
                dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
                dialog.add_button(Gtk::Stock::YES, Gtk::RESPONSE_YES);
                dialog.set_default_response(Gtk::RESPONSE_NO);
                int result = dialog.run();
                switch (result) {
                case (Gtk::RESPONSE_CANCEL) :
                    retval = false;
                    loop = false;
                    break;
                case (Gtk::RESPONSE_NO) :
                    retval = false;
                    loop = true;
                    break;
                case (Gtk::RESPONSE_YES) :
                    loop = false;
                    break;
                default :
                    retval = false;
                    loop = false;
                    break;
                }

            } else {
                loop = false;
            }
        } else {
            loop = false;
        }
    } // while loop
    return retval;
}


bool KitListGui::choose_pdf_filename(Glib::ustring& filename) {
    bool retval = false;
    bool loop = true;
    while (loop) {
        Gtk::FileChooserDialog dialog(_("Export to PDF"), Gtk::FILE_CHOOSER_ACTION_SAVE);
        dialog.set_transient_for(*m_window);

        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
        dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);

        Gtk::FileFilter filter_pdf;
        filter_pdf.set_name(_("PDF files"));
        filter_pdf.add_pattern("*" + PDF_FILENAME_EXTENSION);
        dialog.add_filter(filter_pdf);

        Gtk::FileFilter filter_any;
        filter_any.set_name(_("Any files"));
        filter_any.add_pattern("*");
        dialog.add_filter(filter_any);

        int result = dialog.run();
        dialog.hide();

        switch(result) {
        case(Gtk::RESPONSE_OK):
            filename = dialog.get_filename();
            retval = true;
            break;
        case(Gtk::RESPONSE_CANCEL):
            break;
        default:
            break;
        }
        if (retval) {
            // Add file default extension if no extension
            Glib::ustring::size_type i = filename.find(".");
            if (i < 0 || i > filename.length()) {
                filename += PDF_FILENAME_EXTENSION;

            }
            // Prompt for overwrite if the file exists
            if (file_exists(filename)) {
                Gtk::MessageDialog dialog(*m_window,
                                          _("Overwrite existing file?"),
                                          false,
                                          Gtk::MESSAGE_WARNING,
                                          Gtk::BUTTONS_NONE);
                dialog.add_button(Gtk::Stock::NO, Gtk::RESPONSE_NO);
                dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
                dialog.add_button(Gtk::Stock::YES, Gtk::RESPONSE_YES);
                dialog.set_default_response(Gtk::RESPONSE_NO);
                int result = dialog.run();
                switch (result) {
                case (Gtk::RESPONSE_CANCEL) :
                    retval = false;
                    loop = false;
                    break;
                case (Gtk::RESPONSE_NO) :
                    retval = false;
                    loop = true;
                    break;
                case (Gtk::RESPONSE_YES) :
                    loop = false;
                    break;
                default :
                    retval = false;
                    loop = false;
                    break;
                }
                
            } else {
                loop = false;
            }
        } else {
            loop = false;
        }
    } // while loop
    return retval;
}


void KitListGui::update_paste_status() {
    Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();
    refClipboard->request_targets( sigc::mem_fun(*this, &KitListGui::paste_status_received) );
}


void KitListGui::paste_status_received(const Glib::StringArrayHandle& targets_array) {
    std::list<std::string> targets = targets_array;
    bool can_paste = false;
    for (std::list<std::string>::iterator i = targets.begin(); i != targets.end(); ++i) {
        if ( *i == item_target_custom || *i == item_target_text) {
            can_paste = true;
            break;
        }
    }
    // Enable/disable paste button appropriately
    if (m_paste_menu_item)
        m_paste_menu_item->set_sensitive(can_paste);

    if (m_paste_tool_button)
        m_paste_tool_button->set_sensitive(can_paste);
}



void KitListGui::on_row_changed(const Gtk::TreeModel::Path path, const Gtk::TreeModel::iterator iter) {
    if (m_ignore_list_events)
        return;
    m_service.set_model_dirty(true);
    Gtk::TreeModel::Row row = *iter;
    int id = row[m_item_cols.m_col_num];
    Glib::ustring us = row[m_item_cols.m_col_text];
    string s(us);
    if (!m_service.update_item(id, s, row[m_item_cols.m_col_checked]))
        g_warning("Unable to find the item in the model: %d", id);
}


void KitListGui::selected_row_callback(const Gtk::TreeModel::iterator& iter) {
    Gtk::TreeModel::Row row = *iter;
    int id = row[m_item_cols.m_col_num];
    if (!m_service.delete_item(id))
        g_warning("Failed to find item to delete in model");
}


// void KitListGui::on_row_deleted(Gtk::TreeModel::Path path) {
//     m_dirty = true;
//     Gtk::TreeModel::iterator iter = m_ref_item_tree_model->get_iter(path);
//     if (iter) {
//         Gtk::TreeModel::Row row = *iter;
//         int id = row[m_item_cols.m_col_num];
//         ModelItem* item = m_model->findItem(id);
//         if (item) {
//             item->setDirty(true);
//             item->setDeleted(true);
//         } else {
//             cerr << _("Couldn't find item with id ") << id << endl;
//         }
//     } else {
//         cerr << _("Couldn't find model row being deleted") << endl;
//     }
// }


void KitListGui::refresh_item_list() {
    m_ignore_list_events = true;
    int cat_id = get_selected_category();
    // Fetch new list of items
    m_ref_item_tree_model->clear();
    ItemContainer *items = m_service.get_items(cat_id);
    if (items)
        sort(items->begin(), items->end(), ItemCompareName());

    // Rebuild the model for the list view
    size_t count = 0;
    if (items && !items->empty()) {
        for (ItemIter i = items->begin(); i != items->end(); ++i) {
            if (m_service.filter((*i)->get_checked())) {
                // Add a row to the model
                count++;
                Gtk::TreeModel::iterator item_iter = m_ref_item_tree_model->append();
                Gtk::TreeModel::Row row = *item_iter;
                row[m_item_cols.m_col_text] = (*i)->get_description();
                row[m_item_cols.m_col_num] = (*i)->get_id();
                row[m_item_cols.m_col_checked] = (*i)->get_checked();
            }
        }
    }
    if (items)
        delete items;
    update_item_count(count);
    m_ignore_list_events = false;
}


void KitListGui::refresh_category_list(long cat_id) {
    m_ignore_list_events = true;

    if (cat_id == -2)
        cat_id = get_selected_category();
    CategoryContainer* c = m_service.get_categories();
    sort(c->begin(), c->end(), CategoryCompareName());
    m_ref_category_list_store->clear();
    Gtk::TreeModel::iterator iter = m_ref_category_list_store->append();
    Gtk::TreeModel::iterator active; // the row containing our category id
    Gtk::TreeModel::Row row = *iter;
    ostringstream os;
    // use the user's locale for this stream
    os.imbue(std::locale(""));
    os << "-- " << _("Show all items") << " --";
#ifdef GLIBMM_EXCEPTIONS_ENABLED
    row[m_category_cols.m_col_text] = Glib::locale_to_utf8(os.str());
#else
    std::auto_ptr<Glib::Error> ex;
    row[m_category_cols.m_col_text] = Glib::locale_to_utf8(os.str(), ex);
    if (ex.get()) {
        g_warning("Failed to add item to category combo model: %s", ex->what().c_str());
    }
#endif
    row[m_category_cols.m_col_num] = -1;
    if (!c->empty()) {
        for (CategoryIter i = c->begin(); i != c->end(); ++i) {
            ModelCategory* category = (ModelCategory*) *i;
            if ( !category->is_deleted() ) {
                // Add a row to the model
                iter = m_ref_category_list_store->append();
                row = *iter;
                row[m_category_cols.m_col_text] = category->get_name();
                row[m_category_cols.m_col_num] = category->get_id();
                if (category->get_id() == cat_id)
                    active = iter;
            }
        }
    }
    delete c;
    if (!active || cat_id == -1)
        m_category_combo->set_active(0);
    else
        m_category_combo->set_active(active);
    m_ignore_list_events = false;
}


void KitListGui::on_menu_preferences() {
    if (m_window_preferences) {
        if (m_entry_page_title) {
            m_entry_page_title->set_text(m_page_title);
            m_entry_page_title->grab_focus();
            m_window_preferences->show();
        } else {
            g_warning("\"entry_page_title\" resource is missing");
        }
    } else {
        g_warning("\"window_preferences\" resource is missing");
    }
}

void KitListGui::set_page_title(const Glib::ustring page_title) {
    m_page_title = page_title;
#ifdef GCONF
#ifdef GLIBMM_EXCEPTIONS_ENABLED
    m_ref_gconf_client->set(GCONF_KEY_PAGE_TITLE, m_page_title);
#else
    std::auto_ptr<Glib::Error> error;
    m_ref_gconf_client->set(GCONF_KEY_PAGE_TITLE, m_page_title, error);
    if (error.get())
        g_warning("GConf error setting page title: %s",
                  error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
#else
    m_yaml_config.set_page_title(m_page_title.c_str());
#endif //GCONF
}

void KitListGui::close_preferences_window() {
    set_page_title(m_entry_page_title->get_text());
    m_window_preferences->hide();
}


void KitListGui::cancel_preferences_window() {
    m_window_preferences->hide();
}


void KitListGui::on_menu_add() {
    if (m_window_add_item) {
        init_add_item_window();
        m_entry_add_item->grab_focus();
        m_window_add_item->show();
    } else {
        g_warning("\"window_add_item\" resource is missing");
    }
}


void KitListGui::init_add_item_window() {
    if (m_entry_add_item) {
        m_entry_add_item->set_text("");
    }
}


long KitListGui::get_selected_category() {
    long retval = -1;
    Gtk::TreeModel::iterator iter = m_category_combo->get_active();
    if (iter) {
        Gtk::TreeModel::Row row = *iter;
        if (row) {
            retval = row[m_category_cols.m_col_num];
        }
    }
    return retval;
}


void KitListGui::close_add_item_window() {
    m_window_add_item->hide();

    // Find the current category
    long cat_id = get_selected_category();

    Item* item = m_service.create_item(cat_id);
    if (m_entry_add_item)
        item->set_description(m_entry_add_item->get_text());
    if (m_checkbutton_add_item)
        item->set_checked(m_checkbutton_add_item->get_active());

    refresh_item_list();
}


void KitListGui::cancel_add_item_window() {
    m_window_add_item->hide();
}


void KitListGui::on_category_change() {
    if (m_ignore_list_events)
        return;
    refresh_item_list();
}


void KitListGui::raise() {
    m_window->present();
}

void KitListGui::init() {

    // Fetch startup preferences
#ifdef XML_DAO
    Glib::ustring filename;
#endif //XML_DAO

#ifdef KITLIST_DEBUG
    Glib::ustring log_filename;
#endif //KITLIST_DEBUB

#ifdef GCONF
#ifdef GLIBMM_EXCEPTIONS_ENABLED
    try {
#endif //GLIBMM_EXCEPTIONS_ENABLED
        Gnome::Conf::init();
        m_ref_gconf_client = Gnome::Conf::Client::get_default_client();

#ifdef XML_DAO
        Gnome::Conf::Value value = Gnome::Conf::VALUE_INVALID;
#ifdef GLIBMM_EXCEPTIONS_ENABLED
        m_ref_gconf_client->add_dir(GCONF_KEY);
        value = m_ref_gconf_client->get(GCONF_KEY_CURRENT_FILENAME);
#else
        std::auto_ptr<Glib::Error> error;
        m_ref_gconf_client->add_dir(GCONF_KEY,
                                    Gnome::Conf::CLIENT_PRELOAD_NONE,
                                    error);
        if (error.get())
            g_warning("GConf error: %s", error->what().c_str());
        value = m_ref_gconf_client->get(GCONF_KEY_CURRENT_FILENAME, error);
        if (error.get())
            g_warning("GConf error getting current filename: %s",
                      error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
        if (value.get_type() == Gnome::Conf::VALUE_STRING) {
            filename = value.to_string();
        }
#endif //XML_DAO

#ifdef GLIBMM_EXCEPTIONS_ENABLED
        value = m_ref_gconf_client->get(GCONF_KEY_PAGE_TITLE);
#else
        value = m_ref_gconf_client->get(GCONF_KEY_PAGE_TITLE, error);
        if (error.get())
            g_warning("GConf error getting page title: %s",
                      error->what().c_str());
#endif // GLIBMM_EXCEPTIONS_ENABLED
        if (value.get_type() == Gnome::Conf::VALUE_STRING) {
            m_page_title = value.to_string();
        } else if (value.get_type() == Gnome::Conf::VALUE_INVALID) {
            // The default page title for printing
            m_page_title = DEFAULT_PAGE_TITLE;
        }

        // Get default logfile name from GConf
#ifdef KITLIST_DEBUG
#ifdef GLIBMM_EXCEPTIONS_ENABLED
        value = m_ref_gconf_client->get(GCONF_KEY_DEBUG_LOG);
#else
        value = m_ref_gconf_client->get(GCONF_KEY_DEBUG_LOG, error);
        if (error.get())
            g_warning("GConf error getting log filename: %s",
                      error->what().c_str());
#endif // GLIBMM_EXCEPTIONS_ENABLED
        if (value.get_type() == Gnome::Conf::VALUE_STRING) {
            log_filename = value.to_string();
        } else if (value.get_type() == Gnome::Conf::VALUE_INVALID) {
            log_filename = "/tmp/kitlist.log";
#ifdef GLIBMM_EXCEPTIONS_ENABLED
            m_ref_gconf_client->set(GCONF_KEY_DEBUG_LOG, log_filename);
#else
    std::auto_ptr<Glib::Error> error;
    m_ref_gconf_client->set(GCONF_KEY_DEBUG_LOG, log_filename, error);
    if (error.get())
        g_warning("GConf error setting log filename: %s",
                  error->what().c_str());
#endif //GLIBMM_EXCEPTIONS_ENABLED
        }
#endif //KITLIST_DEBUG

#ifdef GLIBMM_EXCEPTIONS_ENABLED
    } catch (const Glib::Error& ex) {
        g_warning("GConf error: %s", ex.what().c_str());
    }
#endif //GLIBMM_EXCEPTIONS_ENABLED
#else // GCONF
    // Try getting the value from XDG config file
    m_page_title = m_yaml_config.get_page_title();
    filename = m_yaml_config.get_current_filename();
#ifdef KITLIST_DEBUG
    log_filename = m_yaml_config.get_debug_log_filename();
#endif //KITLIST_DEBUG
#endif // GCONF

#ifdef KITLIST_DEBUG
    m_slog = new ofstream(log_filename.c_str(), ios_base::trunc);
    g_log_set_handler(NULL, (GLogLevelFlags) (G_LOG_LEVEL_MASK | 
                      G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION),
                      my_log_handler, m_slog);
#endif //KITLIST_DEBUG

    Glib::RefPtr<Gnome::Glade::Xml> refXml = get_glade_ref_ptr(GLADE_APP_FILE);
    refXml->get_widget("main", m_window);
    refXml->get_widget("statusbar", m_status_bar);
    refXml->get_widget("window_preferences", m_window_preferences);
    refXml->get_widget("entry_page_title", m_entry_page_title);
    refXml->get_widget("window_add_item", m_window_add_item);
    refXml->get_widget("window_add_category", m_window_add_category);
    m_window->signal_delete_event().connect( sigc::mem_fun(*this, &KitListGui::on_delete_event) );

    // Handle quit
    Gtk::MenuItem* p_menu_item = 0;
    refXml->get_widget("menu_file_quit", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_quit) );
    Gtk::ToolButton* p_tool_button = 0;
    refXml->get_widget("tool_button_quit", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_quit) );

    // Handle preferences
    p_menu_item = 0;
    refXml->get_widget("menu_preferences", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_preferences) );

    // Handle delete item
    p_menu_item = 0;
    refXml->get_widget("menu_delete_item", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_delete) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_delete", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_delete) );

    // Handle add item
    p_menu_item = 0;
    refXml->get_widget("menu_add_item", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_add) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_add", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_add) );

    Gtk::Button* p_button = 0;
    refXml->get_widget("preferences_ok_button", p_button);
    if (p_button)
        p_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::close_preferences_window) );
    refXml->get_widget("preferences_cancel_button", p_button);
    if (p_button)
        p_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::cancel_preferences_window) );
    refXml->get_widget("add_item_ok_button", p_button);
    if (p_button)
        p_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::close_add_item_window) );
    p_button = 0;
    refXml->get_widget("add_item_cancel_button", p_button);
    if (p_button)
        p_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::cancel_add_item_window) );
    refXml->get_widget("entry_item_desc", m_entry_add_item);
    assert(m_entry_add_item);
    refXml->get_widget("item_checkbutton", m_checkbutton_add_item);
    assert(m_checkbutton_add_item);

    // Handle file new
    p_menu_item = 0;
    refXml->get_widget("menu_new", p_menu_item);
    if (p_menu_item) {
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_file_new) );
        p_menu_item->set_sensitive(m_service.require_filename());
    }
    p_tool_button = 0;
    refXml->get_widget("tool_button_new", p_tool_button);
    if (p_tool_button) {
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_file_new) );
        p_tool_button->set_sensitive(m_service.require_filename());
    }

    // Handle file open
    p_menu_item = 0;
    refXml->get_widget("menu_open", p_menu_item);
    if (p_menu_item) {
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_file_open) );
        p_menu_item->set_sensitive(m_service.require_filename());
    }
    p_tool_button = 0;
    refXml->get_widget("tool_button_open", p_tool_button);
    if (p_tool_button) {
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_file_open) );
        p_tool_button->set_sensitive(m_service.require_filename());
    }

    // Handle save
    refXml->get_widget("menu_save", m_file_save_menu_item);
    if (m_file_save_menu_item)
        m_file_save_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_save) );
    refXml->get_widget("tool_button_save", m_file_save_tool_button);
    if (m_file_save_tool_button) {
        m_file_save_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_save) );
    }

    // Handle save_as
    p_menu_item = 0;
    refXml->get_widget("menu_save_as", p_menu_item);
    if (p_menu_item) {
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_save_as) );
#ifdef TRANSITION_DAO
        p_menu_item->set_sensitive(true);
#else
        p_menu_item->set_sensitive(m_service.require_filename());
#endif
    }

    // Handle print
    p_menu_item = 0;
    refXml->get_widget("menu_print", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_print) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_print", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_print) );
    // Export to PDF
    p_menu_item = 0;
    refXml->get_widget("menu_export_pdf", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_export_to_pdf) );

    // Recent files
    refXml->get_widget("menu_recent", m_recent_files_menu_item);

    // Handle cut
    p_menu_item = 0;
    refXml->get_widget("menu_cut", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_cut) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_cut", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_cut) );

    // Handle copy
    p_menu_item = 0;
    refXml->get_widget("menu_copy", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_copy) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_copy", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_copy) );

    // Handle paste
    refXml->get_widget("menu_paste", m_paste_menu_item);
    if (m_paste_menu_item)
        m_paste_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_paste) );
    refXml->get_widget("tool_button_paste", m_paste_tool_button);
    if (m_paste_tool_button)
        m_paste_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_paste) );

    // Handle menu show_all
    p_menu_item = 0;
    refXml->get_widget("show_all", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_show_all) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_show_all", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_show_all) );

    // Handle menu show_checked
    p_menu_item = 0;
    refXml->get_widget("show_checked", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_show_checked) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_show_checked", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_show_checked) );

    // Handle menu show_unchecked
    p_menu_item = 0;
    refXml->get_widget("show_unchecked", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_show_unchecked) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_show_unchecked", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_show_unchecked) );

    // Handle menu refresh_view
    p_menu_item = 0;
    refXml->get_widget("refresh_view", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect ( sigc::mem_fun(*this, &KitListGui::refresh_item_list) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_refresh", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::refresh_item_list) );

    // Handle menu select_all
    p_menu_item = 0;
    refXml->get_widget("select_all", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_select_all) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_select_all", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_select_all) );

    // Handle menu check_selected
    p_menu_item = 0;
    refXml->get_widget("check_selected", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_check_selected) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_check_selected", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_check_selected) );

    // Handle menu uncheck_selected
    p_menu_item = 0;
    refXml->get_widget("uncheck_selected", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_uncheck_selected) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_uncheck_selected", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::on_menu_uncheck_selected) );

    // Handle menu toggle_selected
    p_menu_item = 0;
    refXml->get_widget("toggle_selected", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::toggle_selected) );
    p_tool_button = 0;
    refXml->get_widget("tool_button_toggle_selected", p_tool_button);
    if (p_tool_button)
        p_tool_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::toggle_selected) );

    // Handle create_category
    p_menu_item = 0;
    refXml->get_widget("create_category", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_create_category) );

#ifdef XML_DAO
    update_recent_files_menu();
#else
    m_recent_files_menu_item->set_sensitive(false);
#endif

    p_button = 0;
    refXml->get_widget("add_category_ok_button", p_button);
    if (p_button)
        p_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::close_add_category_window) );
    p_button = 0;
    refXml->get_widget("add_category_cancel_button", p_button);
    if (p_button)
        p_button->signal_clicked().connect( sigc::mem_fun(*this, &KitListGui::cancel_add_category_window) );
    refXml->get_widget("entry_category_name", m_entry_add_category);
    assert(m_entry_add_category);

    // Handle delete_category
    p_menu_item = 0;
    refXml->get_widget("delete_category", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_delete_category) );

    // Handle rename_category
    p_menu_item = 0;
    refXml->get_widget("rename_category", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_rename_category) );

    // Handle menu help_about
    p_menu_item = 0;
    refXml->get_widget("help_about", p_menu_item);
    if (p_menu_item)
        p_menu_item->signal_activate().connect( sigc::mem_fun(*this, &KitListGui::on_menu_help_about) );

    // Populate categories
    m_ref_category_list_store = Gtk::ListStore::create(m_category_cols);
    // Link the model to the category combo
    refXml->get_widget("categoryCombo", m_category_combo);
    m_category_combo->set_model(m_ref_category_list_store);

    refresh_category_list();
    m_category_combo->signal_changed().connect( sigc::mem_fun(*this, &KitListGui::on_category_change) );

    // Populate items
    m_ref_item_tree_model = Gtk::ListStore::create(m_item_cols);
    refXml->get_widget("item_treeview", m_item_tree_view);
    // Link the model to the item list
    m_item_tree_view->set_model(m_ref_item_tree_model);
    ItemContainer* items = m_service.get_items();
    if (!items->empty()) {
        sort(items->begin(), items->end(), ItemCompareName());
        for (ItemIter i = items->begin(); i != items->end(); ++i) {
            // Add a row to the model
            Gtk::TreeModel::iterator itemIter = m_ref_item_tree_model->append();
            Gtk::TreeModel::Row row = *itemIter;
            row[m_item_cols.m_col_text] = (*i)->get_description();
            row[m_item_cols.m_col_num] = (*i)->get_id();
            row[m_item_cols.m_col_checked] = (*i)->get_checked();
        }
    }
    m_ref_item_tree_model->signal_row_changed().connect( sigc::mem_fun(*this, &KitListGui::on_row_changed) );
//    m_ref_item_tree_model->signal_row_deleted().connect( sigc::mem_fun(*this, &KitListGui::on_row_deleted) );
    update_item_count(items->size());
    delete items;
    // Column heading
    m_item_tree_view->append_column_editable(_("Checked"), m_item_cols.m_col_checked);
    // Column heading
    m_item_tree_view->append_column_editable(_("Item"), m_item_cols.m_col_text);
//     Gtk::CellRendererToggle* cr = (Gtk::CellRendererToggle*) m_item_tree_view->get_column_cell_renderer(CHECKED_COL_POSITION);
//     assert(cr);
//     if (cr)
//         cr->signal_toggled().connect( sigc::mem_fun(*this, &KitListGui::on_cell_edit) );
//     else
//         cerr << _("Error: Can't find toggle cell renderer for column ")
//              << CHECKED_COL_POSITION << endl;
    Glib::RefPtr<Gtk::TreeSelection> ref_tree_selection =
        m_item_tree_view->get_selection();
    ref_tree_selection->set_mode(Gtk::SELECTION_MULTIPLE);
    m_ignore_list_events = false;
    m_service.set_model_dirty(false);
#ifdef XML_DAO
    if (filename.length() == 0 || !file_exists(filename)) {
        // Use default filename
        filename = Glib::build_filename(
            Glib::get_home_dir(),
            DEFAULT_FILENAME);
        // g_debug("Set filename to: %s", filename.c_str());
        m_filename = filename;
    }
    if (filename.length() > 0 && file_exists(filename)) {
        // g_debug("Loading %s", filename.c_str());
        m_filename = filename;
        m_service.open_as_xml(m_filename);
        refresh_category_list(-1);
        refresh_item_list();
    }
#endif
}