Instigate Open Source Documentation

---

src/toolkit/window.hpp

Go to the documentation of this file.

/*
 *
 * Copyright (c) 2005-2009 Instigate cjsc, Yerevan, Armenia.
 * All rights reserved.
 * 
 */


#ifndef INSTIGATE_TOOLKIT_WINDOW
#define INSTIGATE_TOOLKIT_WINDOW

// Headers from this project


// Headers from other projects

// Headers from standard libraries
#include <cassert>
#include <gtkmm.h>
#include <gtksourceviewmm.h>
#include <libgnomecanvasmm.h>
#include <libgtkhtml/gtkhtml.h>
#include <list>
#include <map>
#include <QtGui>
#include <stdint.h>
#include <set>

// forward declarations
namespace instigate {
       namespace toolkit {
               enum toolkit_type {gtk, qt};
        extern toolkit_type toolkit_mode;
               class window;
               class qt_graphics_view;
               class item;
               class gtk_key_event;
               template <typename T>
               class qt_item;
               template <typename T>
               class qt_widget;
       }
}

class instigate::toolkit::window
{
        friend class application;
        friend class qt_graphics_view;
        friend class item;
        template <typename T> 
        friend class qt_widget;
        friend class qt_event_handler;
        friend class gtk_key_event;

public:
        enum widget_type {
                layout = 0,
                button = 1,
                edit_box = 2,
                text_box = 3,
                combo_box = 4,
                main_window = 5,
                label = 6,
                menu_bar = 7,
                menu_item = 8,
                menu = 9,
                sub_menu = 10,
                notebook = 11,
                notebook_page = 12,
                check_box = 13,
                toolbar = 14,
                toolitem = 15,
                action = 16,
                check_menu_item = 17,
                tool_button = 18,
                action_group = 19,
                radio_menu_item = 20,
                tree = 21,
                statusbar = 22,
                scrollwindow = 23,
                chooser_button = 24,
                file_chooser = 25,
                paned_window = 26,
                color_button = 27,
                list = 28,
                frame = 29,
                image = 30,
                table = 31,
                html_view = 32,
                progressbar = 33
        };


        typedef std::vector<std::string> rows;

        typedef std::vector<std::string> widget_children;

        void replace_all_occurrences(std::string&, const std::string&, 
                const std::string&) const throw();

private:
        class gtk_radio_group;

        struct tree_view_column
                : public Gtk::TreeModel::ColumnRecord
        {
                void add_sub_column(Gtk::TreeModelColumnBase* b) throw()
                {
                        assert(0 != b);
                        add(*b);
                }
        };

        struct gtk_tree_view_base
        {
                enum column_type {
                        label_column = 0,
                        icon_column = 1,
                        check_column = 2
                };

                struct gtk_column_properties
                {
                        std::string m_column_path;
                        bool m_editable;
                        bool m_enable;
                        std::string m_title;
                        gtk_column_properties(const std::string& s,
                                        bool b, bool n, std::string& t)  throw()
                                : m_column_path(s)
                                , m_editable(b)
                                , m_enable(n)
                                , m_title(t)
                        {}
                };

                typedef std::vector<gtk_column_properties> columns_properties;

                typedef std::map<std::string, Gtk::TreeModel::Row> tree_rows;

                typedef std::map<std::string, Gtk::TreeView::Column*>
                        tree_columns;
               
                typedef std::vector<std::pair<column_type, 
                        Gtk::TreeModelColumnBase*> > base_types;

                typedef std::map<std::string, base_types> column_records;

                typedef std::map<std::string, std::pair<column_type,
                        Gtk::TreeModelColumnBase*> > tree_fields;

                typedef std::map<std::string, std::string> 
                        gtk_row_path_to_toolkit_row_path;

                typedef std::map<std::string, std::string> 
                        toolkit_row_path_to_gtk_row_path;
                
                typedef std::map<std::string, std::string> colors;

                tree_view_column* m_tree_view_column;
                tree_rows m_tree_rows;
                columns_properties m_columns_properties;
                tree_columns m_tree_columns;
                column_records m_column_records;
                tree_fields m_tree_fields;
                gtk_row_path_to_toolkit_row_path 
                        m_gtk_row_path_to_toolkit_row_path;
                toolkit_row_path_to_gtk_row_path 
                        m_toolkit_row_path_to_gtk_row_path;
                std::string m_last_expanded_row;
                std::string m_last_collapsed_row;
                colors m_colors;

                gtk_tree_view_base() throw();

                virtual ~gtk_tree_view_base() throw(); 
        };

        struct gtk_tree_view : public gtk_tree_view_base
        {
                Glib::RefPtr<Gtk::TreeStore> m_tree_view_model;

                gtk_tree_view() throw();

                ~gtk_tree_view() throw() { }
        };

        struct gtk_list_view : public gtk_tree_view_base
        {
                Glib::RefPtr<Gtk::ListStore> m_list_view_model;

                gtk_list_view() throw();

                ~gtk_list_view() throw() { }
        };

        struct qt_tree_view
        {
                typedef std::pair<QStandardItem*, int> standard_item;

                typedef std::map<std::string, standard_item> rows;

                typedef std::map<int, QModelIndex> model_index;

                typedef std::map<std::string, model_index> row_index;

                typedef std::map<QStandardItem*, std::string> tree_row_paths;

                typedef std::multimap<std::string, QStandardItem*> 
                        path_to_row_items;
                
                struct qt_column_properties 
                {
                        std::string m_column_path;
                        bool m_editable;
                        bool m_enable;
                        std::string m_title;

                        qt_column_properties(const std::string& s, 
                                   bool b, bool n, std::string& t)  throw()
                                : m_column_path(s), 
                                  m_editable(b), 
                                  m_enable(n),
                                  m_title(t){} 

                };                          

                typedef std::vector<qt_column_properties> columns_properties;

                typedef std::map<std::string, columns_properties::size_type> 
                        tree_columns;

                typedef std::map<int, std::string> tree_column_paths;
                
                QStandardItemModel* m_tree_model;
                rows m_rows;
                row_index m_row_index;
                tree_row_paths m_tree_row_paths;
                tree_columns m_tree_columns;
                columns_properties m_columns_properties;
                std::vector<int> m_fields;
                std::string m_last_expanded_row;
                std::string m_last_collapsed_row;
                path_to_row_items m_path_to_row_items;
                tree_column_paths m_tree_column_paths;

                qt_tree_view() throw();

                ~qt_tree_view() throw();
        };
        
        typedef gtk_tree_view_base::gtk_row_path_to_toolkit_row_path::iterator
                gtk_row_path_iterator;
        
private:
        class qt_notebook : public QTabWidget
        {
        public:
                void set_tab_text_color(int i, const std::string& s) throw();
                qt_notebook(QWidget* p = 0)
                        : QTabWidget(p)
                {}
        };

        struct qt_notebook_page {
                int position;
                std::string tab_text;
                std::string tab_text_color;
                std::string tab_font_style;
                bool is_current;
                bool is_hide;
                qt_notebook_page() 
                        : position(0)
                          , tab_text("")
                          , tab_text_color("")
                          , tab_font_style("")
                          , is_current(false)
                          , is_hide(false)
                {}
        };

private:
       typedef std::pair<QObject*, widget_type> qt_widget_types;  

       typedef std::pair<Gtk::Widget*, widget_type> gtk_widget_types;  

       typedef std::map<std::string, qt_widget_types> qt_widgets;

       typedef std::map<std::string, gtk_widget_types> gtk_widgets;

       typedef std::map<std::string, const std::string> stock_ids;

       typedef std::map<std::string, gtk_tree_view_base*> gtk_tree_views;

       typedef std::map<std::string, qt_tree_view*> qt_tree_views;

       typedef std::map<std::string, Gtk::PackOptions> gtk_pack_options;

       typedef std::map<std::string, std::string> qt_pack_options;

       typedef std::map<std::string, int> notebook_page_ids;  

       typedef std::map<std::string, qt_notebook_page>
                                               qt_notebook_page_properties;

       typedef std::pair<std::string, QLineEdit*> qt_dialog_edit_box;

       typedef std::map<std::string, qt_dialog_edit_box> qt_dialogs;

public:
        struct callback
        {
                virtual void call() throw() = 0;
        };
        
private:
        template <typename T>
        struct template_callback : public callback
        {
                T m_function;

                void call() throw()
                {
                        m_function();
                }

                template_callback(T t) throw()
                        : m_function(t)
                {}
        };

        typedef std::map<std::string, callback*> actions;
        
        typedef std::pair<sigc::connection, std::string> gtk_connections;

        typedef std::multimap<std::string, gtk_connections> 
                gtk_connections_path;
        
        typedef std::multimap<std::string, std::string> 
                qt_connections_path;

private:
        static std::string m_close_action_name;
        static std::string m_path; 
        Gtk::Window* m_gtk_window;
        QWidget* m_qt_window;
        qt_widgets m_qt_widgets;
        gtk_widgets m_gtk_widgets;
        notebook_page_ids m_gtk_notebook_page_ids;
        std::string m_context;
        std::string m_style;
        Glib::RefPtr<Gtk::IconFactory> m_icon_factory;
        stock_ids m_gtk_stock_ids;
        stock_ids m_qt_standard_icons;
        actions m_actions;
        gtk_tree_views m_gtk_tree_views;
        qt_tree_views m_qt_tree_views;
        tree_view_column* m_tree_view_column;
        gtk_pack_options m_gtk_pack_options;
        qt_pack_options m_qt_pack_options;
        std::string m_qt_context_menu;
        std::map<std::string, std::string> m_filenames;
        gtk_connections_path m_gtk_connections_path;
        qt_connections_path m_qt_connections_path;
        std::map<std::string, int> m_paned_widget_count;
        qt_dialogs m_qt_dialogs; 
        qt_notebook_page_properties m_qt_notebook_page_properties;

private:
        void add_window() throw();

        void remove_window() throw();

        void close_window_event() throw();

        void close_qt_window_event() throw();

        bool close_gtk_window_event(GdkEventAny* e) throw();


public:
        void set_position(const std::string& s) throw();

        void resize(size_t w, size_t h) throw();

        void set_style(const std::string& s) throw();

        void set_modal(bool m) throw();

public:
        void add_horizontal_layout(const std::string& s) throw();

        void add_vertical_layout(const std::string& s) throw();

public:
        void set_spacing(const std::string& s, int t) throw();

        void add_spacer(const std::string& s) throw();
                
        void set_size_policy(const std::string& s, const std::string& t) 
                throw();
        
        std::string get_size_policy(const std::string& s) const throw();

private:
        typedef std::map<std::string, QSpacerItem*> qt_spacer_of_layouts;

        qt_spacer_of_layouts m_qt_spacer_of_layouts;

public:
        void add_horizontal_paned(const std::string& s) throw();

        void add_vertical_paned(const std::string& s) throw();

        void set_paned_position(const std::string& s, int i) throw();

        void add_frame(const std::string& s) throw();

public:
        void add_label(const std::string& s) throw();

        void add_image(const std::string& s, const std::string& p = "") throw();

        void add_html_view(const std::string& s) throw();

        template <typename T>
        void add_action(const std::string& s, T f) throw()
        {
                assert(!s.empty());
                callback* p = new template_callback<T>(f);
                assert(0 != p);
                actions::iterator i = m_actions.find(s);
                if (m_actions.end() != i) {
                        assert(0 != i->second);
                        delete i->second;
                        i->second = 0;
                        m_actions.erase(i);
                }
                m_actions.insert(std::make_pair(s, p));
        }

public: 
        void add_edit_box(const std::string& s) throw();

        int get_edit_box_cursor_position(const std::string& s) throw();

        void set_edit_box_cursor_position(const std::string& s, int i) throw();

        void set_language(const std::string& s, const std::string& p) throw();

        void set_accelerator(const std::string& s,
                        const std::string& p) throw();

        void add_text_box(const std::string& s) throw();

        void move_cursor(const std::string& s) throw();
        
        void add_scroll_window(const std::string& s) throw();

        void set_syntax(const std::string& s, const std::string& l) throw();
        
        void set_background_color(const std::string& s, 
                        const std::string& c) throw();

public:
        void create_snapshot(const std::string& n) const throw();

public:
        void add_check_box(const std::string& s) throw();

        void add_toggle_button(const std::string& s) throw();

public:
        void remove_widget(const std::string& s) throw();

public:
        void add_radio_button_group(const std::string& s) throw();

        void add_combo_box(const std::string& s) throw();

        void add_combo_box_item(const std::string& s, const std::string& t)
                throw();

public:
        void add_grid(const std::string& s) throw();

        void add_table(const std::string& s, size_t r, size_t c) throw();

        void add_item(const std::string& s, const std::string& t) throw();


public:
        void add_handler(const std::string& s, const std::string& e, 
                        const std::string& a) throw();

        void remove_all_handlers(const std::string& s) throw();

private:
        struct event_handler
        {
                virtual void handle_event() throw() = 0;
                virtual ~event_handler() throw()
                {}
        };

        template <typename T>
        struct q_event_handler 
                : public QObject
                , public event_handler
        {
                T m_callback;
              
                bool event(QEvent*) throw()
                {
                        m_callback();
                        return true;
                }
                
                virtual void handle_event() throw()
                {
                        QEvent* q = new QEvent(QEvent::User);
                        assert(0 != q);
                        QApplication::postEvent(this, q);
                }
                
                q_event_handler(T t) throw()
                        : event_handler()
                        , m_callback(t)
                {}

                virtual ~q_event_handler() throw()
                {}
        };
        
        template <typename T>
        struct g_event_handler
                : public event_handler
        {
                T m_callback;
                
                virtual void handle_event() throw()
                {
                        m_callback();
                }

                g_event_handler(T t) throw()
                        : event_handler()
                        , m_callback(t)
                {}
                
                virtual ~g_event_handler() throw()
                {}
        };

public:
        void add_event(const std::string& n) throw();
      
private:
        template <typename T>
        void add_qt_listener(const std::string& n, T l) throw()
        {
                assert(!n.empty());
                event_handler* e = new q_event_handler<T>(l);
                assert(0 != e);
                events::iterator i = m_events.find(n);
                assert(m_events.end() != i);
                i->second = e;
        }
        
        template <typename T>
        void add_gtk_listener(const std::string& n, T f) throw()
        {
                assert(!n.empty());
                event_handler* e = new g_event_handler<T>(f);
                assert(0 != e);
                events::iterator i = m_events.find(n);
                assert(m_events.end() != i);
                i->second = e;
        }
public:
        template <typename T>
        void add_listener(const std::string& n, T f) throw()
        {
                assert(!n.empty());
                switch (toolkit_mode) {
                        case gtk: add_gtk_listener(n, f); break; 
                        case qt: add_qt_listener(n, f); break;
                        default: assert(! "Unsupported Toolkit");
                };
        }

        void emit_event(const std::string& n) throw();

private:
        typedef std::map<std::string, event_handler*> events;
        events m_events;
        
        typedef std::deque<event_handler*> pending_events;
        pending_events m_gtk_pending_events;

public:
        std::string get_pressed_key() const throw();

        std::string get_released_key() const throw();

private:
        void set_released_key(const std::string&) throw();

        void set_pressed_key(const std::string&) throw();

        std::string m_pressed_key;
        std::string m_released_key;
        

public:
        void set_text(const std::string& s, const std::string& t) throw();


public:
        void set_value(const std::string& s, const std::string& t) throw();

        void set_value(const std::string& s, const char* t) throw();

        void set_value(const std::string& s, int v) throw();
        
        void set_value(const std::string& s, bool t) throw();
        
public:
        void set_color(const std::string& s, const std::string& t) throw();

public:
        void set_font_style(const std::string& s, const std::string& t) throw();

public:
        /*
         * @brief Sets focus to the widget. 
         *
         * @param s Widget path.
         * @pre The specified widget is focusable.
         */
        void set_focus(const std::string& s) throw();
        
        /*
         * @brief Checks if the widget is focusable. 
         * Focusable widgets are line_edit, text_box, button and check_box.
         *
         * @param s Widget path.
         */
        bool is_focusable(const std::string& s) const throw();
        
public: 
        void set_markup(const std::string& s, const std::string& t) throw();

        void append_text(const std::string& s, const std::string& t) throw();

        std::string get_text(const std::string& s) const throw();

        void collect_children(const std::string& s, widget_children& c)
                                                                const throw();

        std::string get_tooltip_text(const std::string& s) const throw();

        void set_html_content(const std::string& s, 
                        const std::string& h) throw();

public: 
        void set_context(const std::string& s) throw();

        bool is_exist_item_with_name(const std::string& s) const throw();

        std::string get_context() const throw();

public:
        void add_button(const std::string& s) throw();

        void add_icon(const std::string& s, const std::string& n) throw();

        void add_color_button(const std::string& s) throw();

        std::string get_color(const std::string& s) const throw();

public:
        void set_action_caption(const std::string& s, const std::string& n) 
                throw();
        void set_action_accelerator(const std::string& s, const std::string& n)
                throw();
        
public:
        std::string get_selected_item_text(const std::string& s) const throw();

        size_t get_selected_item_index(const std::string& s) throw();

        rows get_selected_rows(const std::string& s) const throw();

        std::string get_selected_item_column(
                        const std::string& s) const throw();
        
        void select_row(const std::string& s) const throw();
        
        void deselect_row(const std::string& s) throw();

public: 
        void add_tree(const std::string& s) throw();

        void add_list(const std::string& s) throw();

        void add_column(const std::string& s) throw();

        void add_row(const std::string& s) throw();
        
        void set_title(const std::string& s, const std::string& t) throw();
        
        void add_check_field(const std::string& s) throw();

        void add_label_field(const std::string& s) throw();
        
        void add_icon_field(const std::string& s) throw();

        bool is_checked(const std::string& s) const throw();

        std::string get_expanded_row(const std::string& s) const throw();
        
        std::string get_collapsed_row(const std::string& s) const throw();
        
        rows get_tree_row_children(const std::string& s) const throw();

        void expand_row(const std::string& s) const throw();

        void clear_rows(const std::string& s) throw();

        void set_selection_mode(const std::string& s, 
                        const std::string& m) throw();
        
        std::string get_selection_mode(const std::string& s) const throw();
public:
        size_t get_item_id(const std::string& s) throw();

public:
        void set_multiselection_mode(const std::string& s) throw();

        void set_singleselection_mode(const std::string& s) throw();

        bool is_selection_mode_single(const std::string& s) throw();

public:
        void add_menu_bar(const std::string& s) throw();

        void add_menu(const std::string& s) throw();

        void add_context_menu(const std::string& s) throw();

        void run_context_menu(const std::string& s) throw();

        void add_menu_item(const std::string& s) throw();


        void add_toggle_menu_item(const std::string& s) throw();

public: 
        void add_statusbar(const std::string& s) throw();

public: 
        void add_toolbar(const std::string& s) throw();

        void add_toolbar_item(const std::string& s) throw();

        void add_toggle_toolbar_item(const std::string& s) throw();

public: 

        void add_separator(const std::string& s) throw();

public:
        void set_enable(const std::string& s) throw();

        void set_disable(const std::string& s) throw();

        bool is_enable(const std::string& s) const throw();

        void hide(const std::string& s) throw();

        void set_editable(const std::string& s) throw();

        void set_read_only(const std::string& s) throw();

        void show(const std::string& s) throw();

        bool is_visible(const std::string& s) const throw();

        bool is_editable(const std::string& s) const throw();

public: 
        void add_notebook(const std::string& s) throw();
        
        void add_notebook_page(const std::string& s) throw();

        void set_current_page(const std::string& s) throw();

        int get_current_page(const std::string& s) const throw();

public:
        void set_tooltip_text(const std::string& s, const std::string& t) 
                throw();
        
public: 
        void add_progress_bar(const std::string& s) throw();

        int get_value(const std::string& s) const throw();
        
public:

        void add_radio_menu(const std::string& s) throw();

        void add_radio_menu_item(const std::string& s) throw();
        
public:
        enum mode {
                antialiased = 0,
                simple = 1
        };
       
private:
        enum item_type {
                rectangle = 0,
                ellipse = 1,
                line = 2,
                group = 3,
                text = 4,
                canvas_image = 5
        };
public:
        void add_canvas(const std::string& s, mode m) throw();

public:
        void add_graphic_context(const std::string& s) throw();
        
        void set_line_color(const std::string& s, const std::string& c) throw();
        
        void set_fill_color(const std::string& s, const std::string& c) throw();
        
        void set_font(const std::string& s, const std::string& f) throw();
        
        void set_font_size(const std::string& s, double d) throw();
       
        void set_italic(const std::string& s, bool b) throw();

        void set_bold(const std::string& s, bool b) throw();
        
        void set_fill_transparency(const std::string& s, int a) throw();
        
        void set_line_transparency(const std::string& s, int a) throw();
        
        void set_line_width(const std::string& s, int w) throw();
        
        void set_graphic_context(const std::string& s) throw();
        
        
        void set_graphic_context(const std::string& s, 
                        const std::string& c) throw();
private:
        struct gtk_graphic_context
        {
                std::string m_fill_color;
                std::string m_line_color;
                uint32_t  m_fill_color_rgba;
                uint32_t  m_line_color_rgba;
                int m_line_width;
                std::string m_font;
                double m_font_size;
                Pango::Style m_italic;
                Pango::Weight m_bold;
        };
        
        struct qt_graphic_context
        {
                QBrush m_brush;
                QPen m_pen;
                QFont m_font;
        };
        
public: 
        void set_user_data(const std::string& s, void* d) throw();
        
        void* get_user_data(const std::string& s) const throw();
       
public: 
        void add_line(const std::string& s, double x1, double y1, double x2, 
                        double y2) throw();
        
        void add_rectangle(const std::string& s, double x1, double y1, 
                        double x2, double y2) throw();
        
        void add_text(const std::string& s, double x1, double y1, 
                                const std::string& c) throw();
        void add_ellipse(const std::string& s, double x1, double y1, 
                        double x2, double y2) throw();

public:
        void remove_item(const std::string& s) throw();

public:
        void add_group(const std::string& s) throw();

public:
        double get_x1_coordinate(const std::string& s) const throw();
        
        double get_x2_coordinate(const std::string& s) const throw();
        
        double get_y1_coordinate(const std::string& s) const throw();
        
        double get_y2_coordinate(const std::string& s) const throw();

        uint32_t get_width(const std::string& s) const throw();

       uint32_t get_height(const std::string& s) const throw();

        void set_x1_coordinate(const std::string& s, double c) throw();
        
        void set_x2_coordinate(const std::string& s, double c) throw();
        
        void set_y1_coordinate(const std::string& s, double c) throw();
        
        void set_y2_coordinate(const std::string& s, double c) throw();

public:
        void move_item_by(const std::string& s, double x, double y) throw();

        void rotate(const std::string& s, double a) throw();
        
        void zoom(const std::string& s, double a, double b) throw();

public:
        std::string get_item_at(const std::string& s, double x, double y) const
                throw();
        
public:
        void zoom_canvas(const std::string& s, double f) throw();

        void reset_canvas_zoom_factor(const std::string& s) throw();

public:
        void add_file_chooser_dialog(const std::string& s) throw();

        void add_file_chooser_button(const std::string& s,
                const std::string& p) throw();

        void run_file_chooser_dialog(const std::string& s) throw();

        void set_name_filter(const std::string& s, const std::string& t)
                throw();

        void set_file_chooser_mode(const std::string& s, const std::string& t)
                throw();

        std::string get_filename(const std::string& s) const throw();

public:
        void raise_to_top(const std::string& s) throw();

        void lower_to_bottom(const std::string& s) throw();
        
public:
        double get_mouse_x_coordinate() const throw();
        
        double get_mouse_y_coordinate() const throw();

public:
        void get_group_items(const std::string& s, std::vector<std::string>& v)
                                          throw();

private:

        void get_qt_group_items(const std::string&,
                std::vector<std::string>&) throw();
        
        void get_gtk_group_items(const std::string&, std::vector<std::string>&)
                                        throw();
                
        bool is_item_in_group(const std::string& s, const std::string& g)
                                                 throw();

        // @name Select item
public:
        void toggle_selection(const std::string& s) throw();

        void select_item(const std::string& s) throw();
        
        bool is_item_selected(const std::string& s) throw();

        bool is_item_exist(const std::string& s) throw();


        void select_all() throw();

        void deselect_item(const std::string& s) throw();

        void deselect_all() throw();

private:

        void select_qt_item(const std::string&) throw();

        void select_gtk_item(const std::string&) throw();


public:
        bool is_control_pressed() const throw();
        
        bool is_shift_pressed() const throw();

public:
        std::string get_event_emitter() const throw();

private:
        enum coordinate_number {
                first = 0,
                second = 1,
                third = 2,
                fourth = 3
        };
        
        struct line_coordinates
        {
                double x1;
                double y1;
                double x2;
                double y2;

                line_coordinates(double a1 = 0, double b1 = 0, double a2 = 0, 
                                double b2 = 0) throw()
                        : x1(a1)
                        , y1(b1)
                        , x2(a2)
                        , y2(b2)
                {}
        };


private:
        typedef std::pair<QGraphicsItem*, item_type> qt_item_types;  

        typedef std::pair<Gnome::Canvas::Item*, item_type> gtk_item_types;  
        
        typedef std::pair<QGraphicsScene*, QGraphicsView*> qt_canvas;  

        typedef std::map<const std::string,std::pair< const std::string, QImage*> > qt_images;
        
        typedef std::map<const std::string, qt_item_types> qt_items;

        typedef std::pair<const std::string, Glib::RefPtr<Gdk::Pixbuf> > m_image_path; 
        typedef std::map<const std::string, m_image_path > gtk_images;

        typedef std::map<const std::string, gtk_item_types> gtk_items;
        
        typedef std::map<const std::string, Gnome::Canvas::Canvas*> 
                gtk_canvases;
        
        typedef std::map<const std::string, qt_canvas> qt_canvases;
        
        typedef std::map<const std::string, gtk_graphic_context> 
                gtk_graphic_contexts;
        
        typedef std::map<const std::string, qt_graphic_context> 
                qt_graphic_contexts;
        
        typedef std::map<Gnome::Canvas::Line*, line_coordinates> 
                gtk_line_coordinates;

        typedef std::map<Gnome::Canvas::Item*, std::string> 
                gtk_item_paths;
        
        typedef std::map<QGraphicsItem*, std::string> 
                qt_item_paths;

        typedef std::map<std::string, std::string> colors; 

        typedef std::map<Gnome::Canvas::Canvas*, double> 
                gtk_canvas_zoom_factors;

        typedef std::map<Gnome::Canvas::Item*, std::string> 
                gtk_canvas_items_tooltips;

        typedef std::set<std::string> selected_items;

private:
        gtk_images m_gtk_images;
        qt_images m_qt_images;
        gtk_items m_gtk_items;
        qt_items m_qt_items;
        gtk_canvases m_gtk_canvases;
        qt_canvases m_qt_canvases;
        gtk_graphic_contexts m_gtk_graphic_contexts;
        qt_graphic_contexts m_qt_graphic_contexts;
        gtk_graphic_context m_gtk_current_graphic_context;
        qt_graphic_context m_qt_current_graphic_context;
        gtk_line_coordinates m_gtk_line_coordinates;
        gtk_item_paths m_gtk_item_paths;
        qt_item_paths m_qt_item_paths;
        colors m_colors;
        gtk_canvas_zoom_factors m_gtk_canvas_zoom_factors;
        double m_mouse_x;
        double m_mouse_y;
        std::string m_event_emitter;
        double m_top_index;
        double m_bottom_index;
        bool m_control_pressed;
        bool m_shift_pressed;
        gtk_canvas_items_tooltips m_gtk_canvas_items_tooltips;
        std::string m_window_close_action_name;
        selected_items m_selected_items;
public:
        widget_type get_widget_type(const std::string& s) throw();

        std::string get_substring(const std::string&, const std::string& = "/")
                const throw();

private:
        std::string get_the_last_part(const std::string&, 
                        const std::string& = "/") throw();

        bool is_exist_qt_item_with_name(const std::string& s) const throw();

        bool is_exist_gtk_item_with_name(const std::string& s) const throw();

        bool is_relative_path(const std::string&) const throw();

        bool is_begin_with_dot_dot(const std::string&) const throw();

        bool is_root(const std::string&) const throw();

        void remove_dots (std::string&) throw();

        void set_context_for_relative_path(const std::string&) throw();

        void set_context_for_absolute_path(const std::string&) throw();

        void run_gtk_file_chooser_dialog(const std::string&) throw();

        Gtk::FileFilter* create_gtk_name_filter(const std::string&) throw();

        std::string get_gtk_filename(const std::string&) const throw();

        void set_gtk_position(const std::string&) throw();

        void set_qt_position(const std::string&) throw();

        void set_gtk_background_color(const std::string&, 
                        const std::string&) throw();

        void set_qt_background_color(const std::string&, 
                        const std::string&) throw();

        void set_background_color_to_qt_tree_row(const std::string&, 
                const std::string&) throw();

        void set_background_color_to_qt_widget(QObject*, 
                        const std::string&) throw();
        
        void set_background_color_to_gtk_tree_row(const std::string&, 
                const std::string&) throw();

        void set_background_color_to_gtk_widget(Gtk::Widget*,
                        const std::string&) throw();

        void resize_qt_window(size_t, size_t) throw();

        void resize_gtk_window(size_t, size_t) throw();

        void create_qt_snapshot(const std::string&) const throw();

        void create_gtk_snapshot(const std::string&) const throw();

        void gtk_scroll_down(const std::string& s) throw();

        void qt_scroll_down(const std::string& s) throw();
      
        void set_qt_language_to_text_box(const std::string& s,                                   const std::string& p) throw();
        
        void set_gtk_language_to_source_view(gtksourceview::SourceView* v,
                                                 const std::string& s) throw();
        
        void set_gtk_language_to_text_box(const std::string& s,                                  const std::string& p) throw();

        std::string parse_gtk_string(const std::string&) throw();

        void set_gtk_accelerator(const std::string&,
                        const std::string&) throw();

        void set_qt_accelerator(const std::string&,
                        const std::string&) throw();

        void set_gtk_file_chooser_mode(const std::string&,
                        const std::string&) throw();

        void add_gtk_file_chooser_dialog(const std::string&) throw();

        void set_gtk_name_filter(const std::string&,
                        const std::string&) throw();

        void add_gtk_file_chooser_button_to_layout(const std::string&,
                const std::string&, Gtk::Widget*) throw();

        void add_gtk_file_chooser_button_to_window(const std::string&,
                const std::string&, Gtk::Widget*) throw();

        void set_qt_file_chooser_mode(const std::string&, const std::string&)
                throw();

        void add_qt_file_chooser_dialog(const std::string&) throw();

        void connect_qt_file_chooser_button_action(const std::string&) throw();

        void add_qt_file_chooser_button_to_widget(const std::string&,
                const std::string&) throw();

        void add_qt_file_chooser_button_to_layout(const std::string&,
                const std::string&, QObject*) throw();

        void add_qt_file_chooser_button_to_window(const std::string&,
                const std::string&, QObject*) throw();

        void run_qt_file_chooser_dialog(const std::string&) throw();

        void set_qt_name_filter(const std::string&, const std::string&)
                throw();

        std::string create_qt_name_filter(const std::string&) throw();

        std::string get_qt_filename(const std::string&) const throw();

        void add_gtk_frame_to_widget(const std::string&) throw();

        void add_gtk_frame_to_layout(const std::string&, Gtk::Widget*) throw();

        void add_gtk_frame_to_paned_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_frame_to_window(const std::string&, Gtk::Widget*) throw();

        void add_qt_frame_to_layout(const std::string&, QObject*) throw();

        void add_qt_frame_to_paned_window(const std::string&, QObject*) throw();

        void add_qt_frame_to_window(const std::string&, QObject*) throw();

        void add_qt_frame_to_widget(const std::string&) throw();

        void add_gtk_edit_box_to_widget(const std::string&) throw();

        void add_qt_edit_box_to_widget(const std::string&) throw();

        void add_gtk_edit_box_to_layout(const std::string&, Gtk::Widget*) 
                throw();
        
        void add_gtk_edit_box_to_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_edit_box_to_paned_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_qt_edit_box_to_layout(const std::string&, QObject*) throw();

        void add_qt_edit_box_to_window(const std::string&, QObject*) throw();

        void add_qt_edit_box_to_paned_window(const std::string&, QObject*)
                throw();

        int get_gtk_edit_box_cursor_position(const std::string&) throw();

        int get_qt_edit_box_cursor_position(const std::string&) throw();

        void set_gtk_edit_box_cursor_position(const std::string&, int) throw();

        void set_qt_edit_box_cursor_position(const std::string&, int) throw();

        void add_qt_column(const std::string&) throw();
        
        void add_qt_row(const std::string&) throw();

        void add_gtk_row(const std::string&) throw();

        void add_gtk_row_to_tree(const std::string&, gtk_tree_view*) throw();

        void add_gtk_row_to_list(const std::string&, gtk_list_view*) throw();

        void append_gtk_row_to_tree(const std::string&, gtk_tree_view*) throw();

        void append_gtk_row_to_list(const std::string&, gtk_list_view*) throw();

        void add_gtk_column_to_list(const std::string&) throw();

        void add_gtk_column_to_tree(const std::string&) throw();

        void connect_gtk_events(Gtk::TreeView*, gtk_tree_view*) throw();

        void connect_qt_events(QTreeView*, qt_tree_view*) throw();

        void add_gtk_column(const std::string&) throw();

        Gtk::ScrolledWindow* add_additional_gtk_scroll_window_to_widget(
                        const std::string&) throw();

        std::string get_additional_gtk_scroll_window_path(
                        const std::string&) throw();

        void add_gtk_text_box_to_widget(const std::string&)
                throw();

        void add_gtk_text_box_to_scroll_window(const std::string&) throw();

        void set_gtk_html_view_content(const std::string&, 
                        const std::string&) throw();

        void add_gtk_html_view(const std::string&) throw();

        void add_gtk_html_view_to_widget(const std::string&) throw();
        

        void add_gtk_html_view_to_scroll_window(const std::string&, 
                        Gtk::Widget*) throw();


        void add_gtk_scroll_window_to_widget(const std::string&) throw();

        void add_gtk_scroll_window_to_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_scroll_window_to_layout(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_scroll_window_to_paned_window(const std::string&,
                        Gtk::Widget*) throw();

        void move_gtk_cursor(const std::string&) throw();

        void move_qt_cursor(const std::string&) throw();

        std::string convert_to_qt_mnemonics(const std::string&) const throw();

        std::string convert_from_qt_mnemonics(const std::string&) const throw();

        void set_text_to_qt_menu(QObject*, const std::string&) throw();

        void set_text_to_qt_tool_button(QObject*, const std::string&) throw();

        void set_text_to_qt_main_window(QObject*, const std::string&) throw();

        void set_text_to_gtk_menu_item(Gtk::Widget*, const std::string&)
                throw();

        void set_text_to_gtk_tool_button(Gtk::Widget*, const std::string&)
                throw();

        void set_text_to_gtk_main_window(Gtk::Widget*, const std::string&)
                throw();

        void set_spacing_to_gtk_widget(const std::string&, int) throw();

        void set_spacing_to_qt_widget(const std::string&, int) throw();

        void add_qt_widget_to_layout(const std::string&, QWidget*, QBoxLayout*) 
                throw();

        void add_qt_text_box_to_widget(const std::string&) throw();

        void add_qt_text_box_to_layout(const std::string&, QObject*) throw();

        void add_qt_text_box_to_window(const std::string&, QObject*) throw();

        void add_qt_text_box_to_paned_window(const std::string&, QObject*)
                throw();

        QTextEdit* create_qt_text_box() const throw();

        void add_qt_scroll_window_to_widget(const std::string&) throw();

        void add_qt_scroll_window_to_window(const std::string&, QObject*)
                throw();

        void add_qt_scroll_window_to_layout(const std::string&, QObject*)
                throw();
        

        void add_qt_combo_box_to_widget(const std::string&) throw();

        void add_qt_combo_box_to_window(const std::string&, QObject*) throw();

        void add_qt_combo_box_to_layout(const std::string&, QObject*) throw();

        void add_gtk_combo_box_to_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_combo_box_to_layout(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_combo_box_to_widget(const std::string&) throw();
        
        void add_gtk_vertical_layout_to_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_vertical_layout_to_widget(const std::string&) throw();

        void add_qt_vertical_layout_to_window(const std::string&, QObject*)
                throw();

        void add_qt_vertical_layout_to_widget(const std::string&) throw();

        void add_qt_vertical_layout_to_layout(const std::string&, QObject*)
                throw();

        void add_qt_vertical_layout_to_paned_window(const std::string&,
                QObject*) throw();

        void add_gtk_vertical_layout_to_layout(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_file_chooser_button_to_widget(const std::string&,
                const std::string&) throw();

        void add_gtk_color_button_to_layout(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_color_button_to_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_color_button_to_paned_window(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_color_button_to_widget(const std::string&) throw();

        std::string get_color_from_gtk_color_button(
                        const std::string&) const throw();
        
        void add_qt_color_button_to_widget(const std::string&) throw();

        void add_qt_color_button_to_layout(const std::string&, QObject*)
                throw();

        void add_qt_color_button_to_window(const std::string&, QObject*)
                throw();

        void add_qt_color_button_to_paned_window(const std::string&, QObject*)
                throw();

        std::string get_color_from_qt_color_button(
                        const std::string&) const throw();

        void connect_qt_color_button_action(QPushButton*, const std::string&)
                throw();

        void update_qt_color_buttons_color(const std::string&,
                const std::string&) throw();
        
        void on_qt_color_button(std::string) throw();

        void add_gtk_button_to_widget(const std::string&) throw();
        
        void add_gtk_button_to_layout(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_button_to_window(const std::string&, Gtk::Widget*) throw();

        void add_gtk_button_to_paned_window(const std::string&, Gtk::Widget*)
                throw();

        void add_qt_button_to_widget(const std::string&) throw();
        
        void add_qt_button_to_window(const std::string&, QObject*) throw();

        void add_qt_button_to_layout(const std::string&, QObject*) throw();

        void add_qt_button_to_paned_window(const std::string&, QObject*)
                throw();

        void create_color_button() throw();

        void add_qt_radio_menu_item_to_widget(const std::string&) throw();

        void add_gtk_radio_menu_item_to_widget(const std::string&) throw();

        void add_gtk_horizontal_layout_to_widget(const std::string&) throw();
        
        void add_qt_horizontal_layout_to_widget(const std::string&) throw();
        
        void add_qt_horizontal_layout_to_layout(const std::string&, QObject*) 
                throw();
        
        void add_qt_horizontal_layout_to_window(const std::string&, QObject*) 
                throw();
        
        void add_qt_horizontal_layout_to_paned_window(const std::string&,
                QObject*) throw();
        
        void add_gtk_label_to_layout(const std::string&, Gtk::Widget*) throw();
        
        void add_gtk_label_to_window(const std::string&, Gtk::Widget*) throw();

        void add_gtk_label_to_paned_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_horizontal_layout_to_layout(const std::string&,
                        Gtk::Widget*) throw();

        void add_gtk_horizontal_layout_to_window(const std::string&,
                        Gtk::Widget*) throw();

        void add_gtk_label_to_widget(const std::string&) throw();
        
        void add_qt_label_to_widget(const std::string&) throw();
        
        void add_qt_label_to_layout(const std::string& s, QObject* w) 
                throw();
        
        void add_qt_label_to_window(const std::string&, QObject*) throw();

        void add_qt_label_to_paned_window(const std::string&, QObject*) throw();
        
        void add_gtk_context_menu_to_widget(const std::string&) throw();

        void run_gtk_context_menu(const std::string&) throw();

        void add_gtk_menu_bar_to_layout(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_menu_bar_to_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_menu_bar(const std::string&) throw();

        void add_qt_menu_bar_to_layout(const std::string&, QObject*) throw();

        void add_qt_menu_bar_to_window(const std::string&, QObject*) throw();

        void add_qt_menu_bar(const std::string&) throw();

        void add_qt_context_menu_to_widget(const std::string&) throw();

        void run_qt_context_menu(const std::string&) throw();

        void add_qt_menu_to_widget(const std::string&) throw();

        void add_qt_menu_item_to_widget(const std::string&) throw();

        void add_qt_menu_item_to_context_menu(const std::string&, QAction*&)
                throw();

        void add_qt_menu_to_menu_bar(const std::string&) throw();

        void add_qt_submenu_to_menu(const std::string&) throw();

        void add_gtk_menu_to_widget(const std::string&) throw();

        void add_gtk_menu_item_to_widget(const std::string&) throw();

        void add_gtk_toggle_menu_item_to_widget(const std::string&) throw();

        void add_qt_toggle_menu_item_to_widget(const std::string&) throw();

        void add_gtk_menu_to_menu_bar(const std::string&) throw();

        void add_gtk_submenu_to_menu(const std::string&) throw();

        void add_gtk_separator(const std::string&) throw();

        void add_qt_separator(const std::string&) throw();
        
        int get_qt_current_page(const std::string&) const throw();

        int get_gtk_current_page(const std::string&) const throw();

        void set_gtk_current_page(const std::string&) throw();

        void set_qt_current_page(const std::string&) throw();

        void add_gtk_notebook_to_widget(const std::string&) throw();

        void add_qt_notebook_to_widget(const std::string&) throw();

        void add_gtk_notebook_to_layout(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_notebook_to_paned_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_qt_notebook_to_layout(const std::string&, QObject*) throw();

        void add_qt_notebook_to_window(const std::string&, QObject*) throw();

        void add_qt_notebook_to_paned_window(const std::string&, QObject*)
                throw();

        void add_gtk_notebook_to_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_notebook_page_to_notebook(const std::string&)throw();

        void add_gtk_notebook_page_to_notebook(const std::string&) throw();

        void add_gtk_label_field(const std::string&) throw();

        void add_gtk_icon_field(const std::string&) throw();

        void add_gtk_check_field(const std::string&) throw();

        void add_qt_check_field(const std::string&) throw();

        void add_qt_image_to_canvas(const std::string&, const std::string&,
                                                QGraphicsScene* c) throw();
        
        void add_qt_image_to_widget(const std::string&, const std::string&) 
                                                                        throw();

        void add_gtk_image_to_canvas(const std::string&, const std::string&,
                                                Gnome::Canvas::Canvas*) throw();

        void add_gtk_image_to_widget(const std::string&, const std::string&) 
                                                                        throw();
        void add_gtk_image_to_layout(const std::string&, 
                        const std::string&, Gtk::Widget*) throw();

        void add_qt_image_to_layout(const std::string&, const std::string&, 
                QObject*) throw();

        void add_qt_image_to_paned_window(const std::string&, 
                        const std::string&, QObject*) throw();

        void add_qt_image_to_window(const std::string&, 
                        const std::string&, QObject*) throw();

        void add_gtk_image_to_window(const std::string&, 
                        const std::string&, Gtk::Widget*) throw();

        void add_gtk_image_to_paned_window(const std::string&, 
                        const std::string&, Gtk::Widget*) throw();

        void add_gtk_table_to_widget(const std::string&, size_t, size_t)
                throw();

        void add_qt_table_to_widget(const std::string&, size_t, size_t)
                throw();

        void add_gtk_table_to_layout(const std::string&, size_t, size_t,
                        Gtk::Widget*) throw();

        void add_gtk_table_to_paned_window(const std::string&, size_t, size_t,
                        Gtk::Widget*) throw();

        void add_gtk_table_to_window(const std::string&, size_t, size_t,
                        Gtk::Widget*) throw();

        void add_qt_table_to_layout(const std::string&, size_t, size_t,
                        QObject*) throw();

        void add_qt_table_to_paned_window(const std::string&, size_t, size_t,
                        QObject*) throw();

        void add_qt_table_to_window(const std::string&, size_t, size_t,
                        QObject*) throw();

        void add_qt_notebook_page_to_notebook(const std::string&) throw();

        void set_qt_tree_cell_checked(const std::string&, bool) throw();

        void set_gtk_tree_cell_checked(const std::string&, const std::string&,
                bool) throw();

        void set_checked_property_to_gtk_tree(const std::string&, bool) throw();

        void set_qt_checked(const std::string&, bool) throw();

        void set_gtk_checked(const std::string&, bool) throw();

        bool is_digit(const std::string&) throw();

        bool is_qt_check_box_checked(QObject*) const throw();

        bool is_qt_check_menu_item_checked(QObject*) const throw();

        bool is_qt_toggle_toolbar_item_checked(QObject*) const throw();

        bool is_qt_toggle_button_checked(QObject*) const throw();

        bool is_qt_checked(const std::string&) const throw();

        bool is_gtk_check_box_checked(Gtk::Widget*)  const throw();

        bool is_gtk_check_menu_item_checked(Gtk::Widget*) const throw();

        bool is_gtk_toggle_toolbar_item_checked(Gtk::Widget*) const throw();

        bool is_gtk_toggle_button_checked(Gtk::Widget*) const throw();

        bool is_gtk_checked(const std::string&) const throw();

        void set_qt_title(const std::string&, const std::string&) throw();

        void set_qt_title_to_widget(QObject*, const std::string&) throw();

        void set_qt_title_to_tree(const std::string&, const std::string&)
                throw();

        void set_gtk_title(const std::string&, const std::string&) throw();

        void set_gtk_title_to_widget(Gtk::Widget*, const std::string&) throw();

        void set_gtk_title_to_tree(const std::string&, const std::string&)
                throw();

        void set_gtk_value(const std::string&, const std::string&) throw();

        void set_gtk_value(const std::string&, int) throw();

        void set_gtk_text(const std::string&, const std::string&) throw();
        
        void set_text_to_gtk_widget(Gtk::Widget*, widget_type, const
                        std::string&) throw();

        void set_gtk_font_style(const std::string&, const std::string&) throw();

        void set_font_style_to_gtk_notebook_page(Gtk::Widget*, 
                        const std::string&, const std::string&) throw();

        void set_font_style_to_gtk_label(Gtk::Widget*, const std::string&) 
                throw();

        void set_font_style_to_gtk_check_box(Gtk::Widget*, const std::string&) 
                throw();

        void set_gtk_color(const std::string&, const std::string&) throw();

        void set_color_to_gtk_notebook_page(Gtk::Widget*, const std::string&, 
                        const std::string&) throw();

        void set_color_to_gtk_label(Gtk::Widget*, const std::string&) throw();

        void set_color_to_gtk_check_box(Gtk::Widget*, const std::string&) 
                throw();
        
        void set_qt_font_style(const std::string&, const std::string&) throw();

        void set_font_style_to_qt_label(QObject*, const std::string&) throw();

        void set_font_style_to_qt_check_box(QObject*, const std::string&) 
                throw();
        
        void set_qt_color(const std::string&, const std::string&) throw();

        void set_color_to_qt_label(QObject*, const std::string&) throw();

        void set_color_to_qt_check_box(QObject*, const std::string&) throw();

        void set_color_to_qt_notebook_page(QObject* w, const std::string& s, 
                const std::string& k) throw();

        void set_current_file_to_gtk_file_chooser_button(Gtk::Widget* w,
                        const std::string&) throw();

        void set_text_to_gtk_tree(const std::string&, const std::string&)
                                                                        throw();
        void set_text_to_gtk_tree_cell(const std::string&, const std::string&,
                                                const std::string&) throw();
        void set_text_to_gtk_edit_box(Gtk::Widget*, const std::string&) throw();

        void set_text_to_gtk_text_box(Gtk::Widget*, const std::string&) throw();

        void set_text_to_gtk_button(Gtk::Widget*, const std::string&) throw();

        void set_text_to_gtk_label(Gtk::Widget*, const std::string&) throw();

        void set_text_to_gtk_check_box(Gtk::Widget*, const std::string&) 
                throw();

        void set_text_to_gtk_action(Gtk::Widget*, const std::string&) throw();

        void set_color_to_qt_color_button(const std::string&,
                const std::string&) throw();
        
        void set_color_to_gtk_color_button(Gtk::Widget* w,
                const std::string&) throw();

        void set_current_file_to_qt_file_chooser_button(const std::string&, 
                        const std::string&) throw();

        void set_text_to_qt_check_box(QObject*, const std::string&) throw();
        
        void set_text_to_qt_menu_action(QObject*, const std::string&) throw();

        void set_text_to_gtk_menu(Gtk::Widget*, const std::string&) throw();

        void set_text_to_gtk_text_item(gtk_item_types, const std::string) 
                throw();

        void set_qt_text(const std::string&, const std::string&) throw();

        void set_text_to_qt_widget(QObject*, widget_type, 
                        const std::string&, const std::string&) throw();
        
        void set_qt_value(const std::string&, const std::string&) throw();

        void set_qt_value(const std::string& s, int v) throw();

        void set_text_to_qt_tree_cell(const std::string&, const std::string&,
                                                const std::string&) throw();

        void set_text_to_qt_tree(const std::string&, const std::string&) 
                throw();

        void set_text_to_qt_edit_box(QObject*, const std::string&) 
                throw();

        void set_text_to_qt_text_box(QObject*, const std::string&)
                throw();
        
        void set_text_to_qt_button(QObject*, const std::string&) throw();

        void set_text_to_qt_label(QObject*, const std::string&) throw();

        void set_text_to_qt_notebook_page(QObject*, 
                        const std::string&, const std::string&) throw();
        
        void set_text_to_qt_text_item(qt_item_types, const std::string) throw();

        void set_text_to_gtk_notebook_page(Gtk::Widget*, const std::string&)
                throw();

        void set_text_to_gtk_statusbar(Gtk::Widget*, const std::string&)
                throw();

        void set_text_to_qt_statusbar(QObject*, const std::string&) throw();

        void set_gtk_tooltip_text(const std::string&, const std::string&) 
                throw();

        void set_qt_tooltip_text(const std::string&, const std::string&) 
                throw();

        void set_qt_markup_to_label(const std::string&, const std::string&) 
                throw();

        void set_gtk_markup_to_label(const std::string&, const std::string&) 
                                                                        throw();

        void append_qt_text(const std::string&, const std::string&) throw();

        void append_text_to_qt_text_box(const std::string&, const std::string&)
                                                                        throw();

        void append_gtk_text(const std::string&, const std::string&) throw();

        void append_text_to_gtk_text_box(Gtk::Widget*, const std::string&) 
                                                                        throw();

        void add_gtk_toolbar_to_widget(const std::string&) throw();

        void add_qt_toolbar_to_widget(const std::string&) throw();

        void add_gtk_toggle_toolbar_item_to_widget(const std::string&) throw();

        void add_qt_toggle_toolbar_item_to_widget(const std::string&) throw();

        void add_gtk_check_box_to_widget(const std::string&) throw();

        void add_qt_check_box_to_widget(const std::string&) throw();

        void add_gtk_check_box_to_layout(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_check_box_to_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_qt_check_box_to_layout(const std::string&, QObject*) throw();

        void add_qt_check_box_to_window(const std::string&, QObject*) throw();

        void add_gtk_toggle_button_to_widget(const std::string&) throw();

        void add_gtk_toggle_button_to_layout(const std::string&, Gtk::Widget*) 
                throw();

        void add_gtk_toggle_button_to_window(const std::string&, Gtk::Widget*) 
                throw();

        void add_qt_toggle_button_to_widget(const std::string&) throw();

        void add_qt_toggle_button_to_layout(const std::string&, QObject*) 
                throw();

        void add_qt_toggle_button_to_window(const std::string&, QObject*) 
                throw();

        void add_gtk_toolbar(const std::string&) throw();

        void add_gtk_toolbar_to_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_toolbar_to_layout(const std::string&, Gtk::Widget*)
                throw();
        
        void add_qt_toolbar(const std::string&) throw();

        void add_qt_toolbar_to_layout(const std::string&, QObject*) throw();

        void add_qt_toolbar_to_window(const std::string&, QObject*) throw();

        void add_gtk_separator_to_menu(Gtk::Widget*) throw();

        void add_gtk_separator_to_toolitem(Gtk::Widget*) throw();

        void add_qt_separator_to_menu(QObject*) throw();

        void add_qt_separator_to_toolitem(QObject*) throw();

        void add_qt_icon_to_widget(const std::string&, const std::string&)
                throw();

        void add_gtk_icon_to_widget(const std::string&, const std::string&)
                throw();

        void add_qt_icon_to_tree_cell(const std::string&, const std::string&,
                const std::string&) throw(); 

        void add_qt_icon_to_tree(const std::string&, const std::string&)
                throw();

        void add_qt_icon_to_button(const std::string&, QObject*) throw();

        void add_qt_icon_to_main_window(const std::string&, QObject*) throw();

        void add_qt_icon_to_tool_button(const std::string&, QObject*) throw();

        void add_qt_icon_to_menu(const std::string&, QObject*) throw();

        void add_qt_icon_to_menu_action(const std::string&, QObject*) throw();

        void add_gtk_icon_to_button(const std::string&, Gtk::Widget*) throw();

        void add_gtk_icon_to_main_window(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_icon_to_tool_button(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_icon_to_menu_item(const std::string&, Gtk::Widget*)
                throw();

        void add_gtk_icon_to_menu(const std::string&, Gtk::Widget*) throw();

        void add_gtk_tree_column(gtk_tree_view_base::column_records::
                const_iterator, Gtk::TreeViewColumn*) throw();

        bool notify_gtk_button_event_on_widget(GdkEventButton*, callback*,
                unsigned int) throw();

        void add_gtk_handler_to_widget(Gtk::Widget*,
                        const std::string&,
                        callback*,
                        widget_type,
                        const std::string&,
                        const std::string&) throw();

        void add_gtk_handler_to_main_window(const std::string&, 
                        const std::string&) throw();
        void add_gtk_handler_to_chooser_button(Gtk::Widget* , 
                        const std::string& , callback* ) throw();

        void add_gtk_handler_to_button(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_color_button(Gtk::Widget*,
                        const std::string&,
                        callback* c) throw();

        void add_gtk_handler_to_check_box(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_combo_box(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_edit_box(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_text_box(Gtk::Widget*, 
                        const std::string&,
                        callback* c) throw();

        void add_gtk_handler_to_menu_item(Gtk::Widget*, const std::string&, 
                        callback*, const std::string&, 
                        const std::string&) throw();

        void add_gtk_handler_to_check_menu_item(Gtk::Widget*,
                        const std::string&, callback*, const std::string&, 
                        const std::string&) throw();

        void add_gtk_handler_to_tool_button(Gtk::Widget*,
                        const std::string&,
                        callback*) throw();

        void add_gtk_handler_to_tree(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_list(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_notebook(Gtk::Widget*, 
                        const std::string&, 
                        callback*) throw();
        
        void add_qt_handler_to_main_window(const std::string&,
                        const std::string&) throw();

        void add_qt_handler_to_button(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_check_box(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_combo_box(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_edit_box(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_text_box(QObject*,
                        const std::string&,
                        callback*) throw();

        void add_qt_handler_to_action(QObject*, const std::string&, callback*, 
                        const std::string&, const std::string&) throw();

        void add_qt_handler_to_check_menu_item(QObject*, const std::string&,
                        callback*, const std::string&, const std::string&)
                        throw();

        void add_qt_handler_to_tree(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_list(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_notebook(QObject*, 
                        const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_tool_button(QObject*,
                        const std::string&,
                        callback*) throw();

        void add_qt_handler_to_widget(QObject*, const std::string&, 
                        callback*, widget_type, 
                        const std::string&, const std::string&) throw();
        void add_qt_handler_to_chooser_button(const std::string&,
                        const std::string&, callback* ) throw();

        void add_gtk_handler(const std::string&, const std::string&,
                const std::string&) throw();

        void add_qt_handler(const std::string&, const std::string&,
                const std::string&) throw();

        void add_gtk_icon_to_tree(const std::string&, const std::string&)
                throw();

        void add_gtk_icon_to_tree_cell(const std::string&, const std::string&,
                const std::string&) throw();

        const std::string get_attribute_value_by_name(const std::string&, 
                                                const std::string&) throw();

        std::string get_gtk_text(const std::string&) const throw();

        std::string get_qt_text(const std::string&) const throw();

        bool is_editable_for_gtk_column(const std::string&,
                                gtk_tree_view_base*) const throw();

        bool is_editable_for_gtk_widgets(const std::string&) const throw();

        bool is_editable_for_qt_widgets(const std::string&) const throw();

        bool is_editable_for_qt_column(qt_tree_view*, const std::string&) 
                                                                const throw();

        bool is_editable_for_gtk_text_box(Gtk::Widget*) const throw();

        bool is_editable_for_qt_text_box(QObject*) const throw();
        
        bool is_editable_for_gtk_edit_box(Gtk::Widget*) const throw();

        bool is_editable_for_qt_edit_box(QObject*) const throw();

        void create_gtk_list(const std::string&) throw();

        void add_gtk_list_to_layout(const std::string&, Gtk::Widget*) throw();

        void add_gtk_list_to_window(const std::string&, Gtk::Widget*) throw();

        void add_gtk_list_to_paned_window(const std::string&, Gtk::Widget*)
                throw();

        void create_qt_list(const std::string&) throw();

        void add_qt_list_to_layout(const std::string&, QObject*) throw();

        void add_qt_list_to_window(const std::string&, QObject*) throw();

        void add_qt_list_to_paned_window(const std::string&, QObject*) throw();

        void create_gtk_tree(const std::string&) throw();

        void add_gtk_tree_to_layout(const std::string&, Gtk::Widget*) throw();

        void add_gtk_tree_to_scroll_window(const std::string&) throw();

        void add_gtk_tree_to_window(const std::string&, Gtk::Widget*) throw();

        void add_gtk_tree_to_paned_window(const std::string&,
                Gtk::Widget*) throw();

        void create_qt_tree(const std::string&) throw();

        void add_qt_tree_to_layout(const std::string&, QObject*) throw();

        void add_qt_tree_to_window(const std::string&, QObject*) throw();

        void add_qt_tree_to_paned_window(const std::string&, QObject*) throw();

        void create_tree_model(Gtk::Widget*, gtk_tree_view*) throw();

        void create_list_model(const std::string&, Gtk::Widget*,
                gtk_list_view*) throw();
        
        void set_gtk_style(const std::string&) throw();

        void set_qt_style(const std::string&) throw();

        void set_gtk_modal(bool modal) throw();

        void set_qt_modal(bool modal) throw();

        void connect_close_event_for_qt_window() throw();
       
        void connect_close_event_for_gtk_window() throw();
        
        void create_qt_window() throw();

        void create_gtk_window() throw();

        void create_gtk_combo_box_item(const std::string&, const std::string&)
                throw();

        void create_qt_combo_box_item(const std::string&, const std::string&)
                throw();

        void create_gtk_stock_for_button(const std::string&, Gtk::Widget*)
                throw();

        void create_gtk_stock_for_main_window(const std::string&, Gtk::Widget*)
                throw();

        void create_gtk_stock_for_tool_button(const std::string&,
                Gtk::ToolButton*) throw();

        void create_gtk_icon(const std::string&, const std::string&,
                Gtk::TreeModel::Row&, 
                Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> >*) throw();

        void create_gtk_icon_for_tree(Gtk::TreeModel::Row&, 
                        Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> >*, 
                        const std::string&, const std::string&) throw();

        void create_gtk_icon_for_button(const std::string&, Gtk::Widget*)
                throw();

        void create_gtk_icon_for_main_window(const std::string&, Gtk::Widget*)
                throw();

        void create_gtk_icon_for_tool_button(const std::string&,
                Gtk::ToolButton*) throw();

        void create_gtk_stock_for_menu(const std::string&, Gtk::ImageMenuItem*)
                throw();

        void create_gtk_icon_for_menu(const std::string&, Gtk::ImageMenuItem*)
                throw();

        void create_gtk_stock_for_tree(const std::string&, const std::string&,
                Gtk::TreeRow&,
                Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> >*) throw();

        void create_gtk_tree_columns(const std::string&, 
                        gtk_tree_view_base*) throw();

        void create_action_group(const std::string& s) throw();

        void create_qt_action_group(const std::string& s) throw();

        void create_gtk_action_group(const std::string& s) throw();

        Gtk::Widget* get_gtk_widget(const std::string&) throw();

        QObject* get_qt_widget(const std::string&) throw();

        std::string get_qt_combo_box_text(const std::string&) const throw();

        std::string get_gtk_combo_box_text(const std::string&) const throw();

        void set_qt_combo_box_text(QObject*, int) throw();

        void set_gtk_combo_box_text(Gtk::Widget*, int) throw();

        void set_attribute_value_by_name(std::string&, const std::string&, 
                                                const std::string&) throw();

        std::string get_gtk_label_text(Gtk::Widget*) const throw();

        std::string get_gtk_button_text(Gtk::Widget*) const throw();

        std::string get_gtk_edit_box_text(Gtk::Widget*) const throw();

        std::string get_gtk_edit_box_tooltip_text(Gtk::Widget*) const throw();

        std::string get_qt_edit_box_tooltip_text(Gtk::Widget*) const throw();

        std::string get_gtk_menu_text(Gtk::Widget*) const throw();
        
        std::string get_gtk_menu_item_text(Gtk::Widget*) const throw();

        std::string get_gtk_text_box_text(Gtk::Widget*) const throw();

        std::string get_qt_label_text(QObject*) const throw();

        std::string get_qt_button_text(QObject*) const throw();

        std::string get_qt_tooltip_text(const std::string&) const throw();

        std::string get_gtk_tooltip_text(const std::string&) const throw();

        std::string get_qt_edit_box_text(QObject*) const throw();
        
        std::string get_qt_text_item_text(qt_item_types) const throw();

        std::string get_qt_menu_text(QObject*) const throw();

        std::string get_qt_menu_action_text(QObject*) const throw();

        std::string get_qt_edit_box_tooltip_text(QObject*) const throw();

        std::string get_qt_text_box_text(QObject*) const throw();
        
        void collect_gtk_children(const std::string&, widget_children&)
                                                                const throw();

        void collect_qt_children(const std::string&, widget_children&)
                                                                const throw();

        void fill_stock_id() throw();
        
        void collect_gtk_standard_icons() throw();

        void collect_qt_standard_icons() throw();

        void remove_gtk_widget(const std::string&) throw();

        void remove_gtk_widget_handlers(const std::string&, 
                        const std::string&) throw();

        void remove_gtk_tree(const std::string&, Gtk::Widget*) throw();
        
        void remove_gtk_rows(const std::string&) throw();
        
        std::string remove_gtk_row(const std::string&, gtk_tree_view_base*)
                throw();

        void reorder_gtk_row_maps(const std::string&, gtk_tree_view_base*)
                throw();
        
        void fill_unchanged_part_of_tree(gtk_row_path_iterator&,
                        gtk_row_path_iterator&, 
                        std::map<std::string, std::string>&,
                        std::map<std::string, std::string>&) throw();
        
        void fill_changed_part_of_tree(gtk_row_path_iterator&, 
                        gtk_row_path_iterator&,
                        std::map<std::string, std::string>&,
                        std::map<std::string, std::string>&, 
                        size_t) throw();

        void insert_row_path_in_maps(const std::string&, const std::string&, 
                std::map<std::string, std::string>&, 
                std::map<std::string, std::string>&) throw();

        void remove_gtk_row_from_map(const std::string&, gtk_tree_view_base*)
                throw();

        void remove_qt_widget(const std::string&) throw();
        
        void remove_qt_tree(const std::string&, QObject*) throw();
        
        void remove_qt_row(const std::string&) throw();
        
        void remove_qt_row_from_maps(const std::string&, qt_tree_view*)
                        throw();
        
        void remove_from_qt_row_index_map(const std::string&,
                        const std::string&, qt_tree_view*) throw();
        
        void correct_qt_rows_map(const std::string&, qt_tree_view*) throw();
        
        void correct_qt_row_index_map(const std::string&, qt_tree_view*, int)
                        throw();

        void correct_index(qt_tree_view::row_index::iterator b, int n, 
                qt_tree_view* v) throw();

        void add_gtk_canvas(const std::string&, mode) throw();

        bool register_image(const std::string&) throw();

        void add_gtk_canvas_to_layout(const std::string&, Gtk::Widget*, mode) 
                throw();

        void add_gtk_canvas_to_window(const std::string&, Gtk::Widget*, mode) 
                throw();

        void add_qt_canvas(const std::string&, mode) throw();

        void add_qt_canvas_to_layout(const std::string&, QObject*, mode) 
                throw();

        void add_qt_canvas_to_window(const std::string&, QObject*, mode) 
                throw();

        void correct_coordinates_to_gtk_text(Gnome::Canvas::Text*) throw();

        void add_gtk_text(const std::string&, double, double, 
                                const std::string&) throw();

        void add_gtk_text_to_group(const std::string&, Gnome::Canvas::Item*,                            double, double, const std::string&) throw();
        
        void add_gtk_text_to_canvas(const std::string&, Gnome::Canvas::Canvas*, 
                        double, double, const std::string&) throw();
        
        void add_qt_text(const std::string&, double, double,
                        const std::string&) throw(); 
        
        void add_qt_text_to_group(const std::string&, QGraphicsItem*, double, 
                double, const std::string&) throw();
        
        void add_qt_text_to_canvas(const std::string&, QGraphicsScene*, double, 
                double, const std::string&) throw();
        
        void add_gtk_rectangle(const std::string&, double, double, double, 
                        double) throw();

        void add_gtk_rectangle_to_group(const std::string&, 
                Gnome::Canvas::Item*, double, double, double, double) throw();

        void add_gtk_rectangle_to_canvas(const std::string&, 
                Gnome::Canvas::Canvas*, double, double, double, double) throw();
        
        void add_qt_rectangle(const std::string&, double, double, double, 
                        double) throw();

        void add_qt_rectangle_to_group(const std::string&, QGraphicsItem*, 
                        double, double, double, double) throw();

        void add_qt_rectangle_to_canvas(const std::string&, QGraphicsScene*, 
                        double, double, double, double) throw();

        void add_gtk_ellipse(const std::string&, double, double, double, 
                double) throw();

        void add_gtk_ellipse_to_group(const std::string&, Gnome::Canvas::Item*,
                        double, double, double, double) throw();

        void add_gtk_ellipse_to_canvas(const std::string&, 
                Gnome::Canvas::Canvas*, double, double, double, double) throw();

        void add_qt_ellipse(const std::string&, double, double, double, 
                double) throw();

        void add_qt_ellipse_to_group(const std::string&, QGraphicsItem*, 
                        double, double, double, double) throw();

        void add_qt_ellipse_to_canvas(const std::string&, QGraphicsScene*, 
                        double, double, double, double) throw();
        
        void add_gtk_line(const std::string&, double, double, double, double) 
                throw();
        
        void add_gtk_line_to_group(const std::string&, Gnome::Canvas::Item*, 
                        double, double, double, double) throw();

        void add_gtk_line_to_canvas(const std::string&, Gnome::Canvas::Canvas*,
                double, double, double, double) throw();

        void set_gtk_line_properties(const std::string&, Gnome::Canvas::Line*) 
                throw();
        
        void set_gtk_rectangle_properties(const std::string&, 
                        Gnome::Canvas::Rect*) throw();
        
        void set_gtk_ellipse_properties(const std::string&, 
                        Gnome::Canvas::Ellipse*) throw();

        void set_gtk_text_properties(const std::string&, 
                        Gnome::Canvas::Text*) throw();

        void add_qt_line(const std::string&, double, double, double, double) 
                throw();
        
        void add_qt_line_to_group(const std::string&, QGraphicsItem*, double, 
                double, double, double) throw();

        void add_qt_line_to_canvas(const std::string&, QGraphicsScene*, double,
                        double, double, double) throw();
        
        void add_gtk_group(const std::string&) throw();

        void add_gtk_group_to_canvas(const std::string&, 
                        Gnome::Canvas::Canvas*) throw();

        void add_gtk_group_to_group(const std::string&, Gnome::Canvas::Item*) 
                throw();

        void add_qt_group(const std::string& s) throw();

        void add_qt_group_to_canvas(const std::string&, QGraphicsScene*) 
                throw();

        void add_qt_group_to_group(const std::string&, QGraphicsItem*) throw();

        void create_gtk_default_graphic_context() throw();

        void create_qt_default_graphic_context() throw();

        void add_gtk_graphic_context(const std::string&) throw();

        void add_qt_graphic_context(const std::string&) throw();


        void add_check_column(Gtk::TreeViewColumn*, Gtk::TreeModelColumnBase*)
                throw();

        void add_label_column(Gtk::TreeViewColumn*, Gtk::TreeModelColumnBase*)
                throw();

        void add_icon_column(Gtk::TreeViewColumn*, Gtk::TreeModelColumnBase*)
                throw();

        void add_gtk_statusbar_to_layout(const std::string&, Gtk::Box*) throw();

        void add_qt_statusbar_to_layout(const std::string&, QBoxLayout*) 
                throw();

        void add_gtk_statusbar(const std::string&) throw();

        void add_qt_statusbar(const std::string&) throw();

        void add_gtk_horizontal_paned_to_widget(const std::string&) throw();

        void add_gtk_horizontal_paned_to_window(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_horizontal_paned_to_paned_window(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_horizontal_paned_to_layout(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_vertical_layout_to_paned_window(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_horizontal_layout_to_paned_window(const std::string&,
                Gtk::Widget*) throw();

        void add_qt_horizontal_paned_to_widget(const std::string& ) throw();

        void add_qt_horizontal_paned_to_paned_window(const std::string& ,
                 QObject* ) throw();

        void add_qt_horizontal_paned_to_window(const std::string&,
                QObject*) throw();

        void add_qt_horizontal_paned_to_layout(const std::string&,
                QObject*) throw();

        void add_qt_vertical_paned_to_widget(const std::string& ) throw();

        void add_qt_vertical_paned_to_paned_window(const std::string& ,
                 QObject* ) throw();

        void add_qt_vertical_paned_to_window(const std::string&,
                QObject*) throw();

        void add_qt_vertical_paned_to_layout(const std::string&,
                QObject*) throw();

        void add_gtk_vertical_paned_to_widget(const std::string&) throw();

        void add_gtk_vertical_paned_to_window(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_vertical_paned_to_layout(const std::string&,
                Gtk::Widget*) throw();

        void add_gtk_vertical_paned_to_paned_window(const std::string&,
                Gtk::Widget*) throw();

        void set_fill_color_to_gtk_item(const std::string&, const std::string&)
                throw();

        void set_fill_color_to_qt_item(const std::string&, const std::string&) 
                throw();

        void set_line_color_to_gtk_item(const std::string&, const std::string&)
                throw();

        void set_line_color_to_qt_item(const std::string&, const std::string&) 
                throw();

        void set_font_to_gtk_text(const std::string&, const std::string&) 
                throw();

        void set_font_to_qt_text(const std::string&, const std::string&) 
                throw();

        void set_font_size_to_gtk_text(const std::string&, double) throw();

        void set_font_size_to_qt_text(const std::string&, double) throw();

        void set_italic_to_gtk_text(const std::string&, bool) throw();

        void set_italic_to_qt_text(const std::string&, bool) throw();

        void set_bold_to_gtk_text(const std::string&, bool) throw();

        void set_bold_to_qt_text(const std::string&, bool) throw();

        void set_fill_transparency_to_gtk_item(const std::string&, int) throw();
        
        void set_fill_transparency_to_qt_item(const std::string&, int) throw();
        
        void set_line_transparency_to_gtk_item(const std::string&, int) throw();
        
        void set_line_transparency_to_qt_item(const std::string&, int) throw();
        
        uint32_t string_to_uint(const std::string&, int = 255) const throw();

        void set_gtk_graphic_context(const std::string&) throw();

        void set_graphic_context_to_gtk_item(const std::string&, 
                        const std::string&) throw();

        void set_graphic_context_to_gtk_image(const std::string&, 
                        const gtk_graphic_context&) throw();

        void set_graphic_context_to_gtk_rectangle(Gnome::Canvas::Item*, 
                const gtk_graphic_context&) throw();
        
        void set_graphic_context_to_gtk_line(Gnome::Canvas::Item*, 
                const gtk_graphic_context&) throw();
        
        void set_graphic_context_to_gtk_ellipse(Gnome::Canvas::Item*, 
                const gtk_graphic_context&) throw();
        
        void set_graphic_context_to_gtk_text(Gnome::Canvas::Item*, 
                const gtk_graphic_context&) throw();

        void set_graphic_context_to_gtk_group(const std::string&, 
                const std::string&) throw();

        void set_qt_graphic_context(const std::string&) throw();
        
        void set_graphic_context_to_qt_item(const std::string&, 
                        const std::string&) throw();

        void set_graphic_context_to_qt_line(QGraphicsItem*, 
                const qt_graphic_context&) throw();
        
        void set_graphic_context_to_qt_rectangle(QGraphicsItem*, 
                const qt_graphic_context&) throw();
        
        void set_graphic_context_to_qt_ellipse(QGraphicsItem*, 
                const qt_graphic_context&) throw();
        
        void set_graphic_context_to_qt_text(QGraphicsItem*, 
                const qt_graphic_context&) throw();

        void set_graphic_context_to_qt_group(const std::string&, 
                const std::string&) throw();

        void set_line_width_to_gtk_item(const std::string&, int) throw();

        void set_line_width_to_qt_item(const std::string&, int) throw();

        void remove_gtk_item(const std::string&) throw();

        void remove_gtk_items_of_group(const std::string&) throw();

        void remove_qt_item(const std::string&) throw();

        void remove_qt_items_of_group(const std::string&) throw();

        void add_gtk_handler_to_item(Gnome::Canvas::Item*, const std::string&, 
                        callback*) throw();

        void add_gtk_handler_to_canvas(Gnome::Canvas::Canvas*, 
                        const std::string&, callback*) throw();

        void show_gtk_canvas_item_tooltip(Gnome::Canvas::Item*) throw();

        void hide_gtk_canvas_item_tooltip(Gnome::Canvas::Item*) throw();

        bool call_event(GdkEvent*, Gnome::Canvas::Item*) throw();

        bool call_event_on_canvas(GdkEvent*, Gnome::Canvas::Canvas*) throw();

        void add_qt_handler_to_item(QGraphicsItem*, const std::string&, 
                        callback*, item_type) throw();

        void add_qt_handler_to_group(QGraphicsItem*, const std::string&, 
                        callback*) throw();

        void add_qt_handler_to_line(QGraphicsItem*, const std::string&, 
                        callback*) throw(); 

        void add_qt_handler_to_rectangle(QGraphicsItem* i, 
                        const std::string& e, callback*) throw();

        void add_qt_handler_to_ellipse(QGraphicsItem*, const std::string&, 
                callback*) throw();

        void add_qt_handler_to_text(QGraphicsItem*, const std::string&, 
                callback*) throw();

        void add_qt_handler_to_image(QGraphicsItem*, const std::string&,
                callback*) throw();

        void add_qt_handler_to_canvas(QGraphicsView*, const std::string&, 
                       callback*) throw(); 

        void set_coordinate_to_gtk_item(const std::string&, double, 
                        coordinate_number) throw();

        void set_coordinate_to_qt_item(const std::string&, double, 
                        coordinate_number) throw();

        void set_coordinate_to_gtk_rectangle(Gnome::Canvas::Item*, double, 
                coordinate_number) throw();

        void set_coordinate_to_qt_rectangle(QGraphicsItem*, double, 
                        coordinate_number) throw();

        void set_coordinate_to_gtk_ellipse(Gnome::Canvas::Item*, double, 
                        coordinate_number) throw();

        void set_coordinate_to_qt_ellipse(QGraphicsItem*, double, 
                        coordinate_number) throw();

        void set_coordinate_to_gtk_line(Gnome::Canvas::Item*, double, 
                        coordinate_number) throw();

        void set_coordinate_to_qt_line(QGraphicsItem*, double, 
                        coordinate_number) throw();

        void set_coordinate(Gnome::Canvas::Text*, double, double, double,
                coordinate_number) throw();

        void set_coordinate_to_gtk_text(Gnome::Canvas::Item*, double, 
                        coordinate_number) throw();
        
        void set_coordinate_to_qt_text(QGraphicsItem*, double, 
                        coordinate_number) throw();
        
        double get_gtk_item_coordinate(const std::string&, 
                        coordinate_number) const throw();

        double get_gtk_line_coordinate(Gnome::Canvas::Item*, 
                        coordinate_number) const throw();

        double get_gtk_rectangle_coordinate(Gnome::Canvas::Item*, 
                        coordinate_number) const throw();

        double get_gtk_ellipse_coordinate(Gnome::Canvas::Item*, 
                        coordinate_number) const throw();
        
        double get_gtk_group_coordinate(Gnome::Canvas::Item*, 
                        coordinate_number) const throw();

        double get_gtk_text_coordinate(Gnome::Canvas::Item*, 
                        coordinate_number) const throw();

        double get_qt_item_coordinate(const std::string&, 
                        coordinate_number) const throw();

        double get_qt_line_coordinate(QGraphicsItem*, 
                        coordinate_number) const throw();

        double get_qt_rectangle_coordinate(QGraphicsItem*, 
                        coordinate_number) const throw();

        double get_qt_ellipse_coordinate(QGraphicsItem*, 
                        coordinate_number) const throw();
        
        double get_qt_group_coordinate(QGraphicsItem*, 
                        coordinate_number) const throw();

        double get_qt_text_coordinate(QGraphicsItem*, 
                        coordinate_number) const throw();

        std::string get_gtk_text_item_text(gtk_item_types) const throw();

        void rotate_gtk_item(const std::string&, double) throw();
        
        void rotate_qt_item(const std::string&, double) throw();

        void zoom_gtk_item(const std::string&, double, double) throw();

        void zoom_qt_item(const std::string&, double, double) throw();

        std::string get_gtk_item_at(const std::string&, double, double) const 
                throw();
        
        std::string get_qt_item_at(const std::string&, double, double) const 
                throw();

        uint32_t get_qt_image_width(const std::string&) const throw();

        uint32_t get_qt_width(const std::string&) const throw();

        uint32_t get_gtk_image_width(const std::string&) const throw();

        uint32_t get_gtk_width(const std::string&) const throw();

        uint32_t get_qt_image_height(const std::string&) const throw();

        uint32_t get_qt_height(const std::string&) const throw();

        uint32_t get_gtk_image_height(const std::string&) const throw();

        uint32_t get_gtk_height(const std::string&) const throw();

        double get_gtk_image_coordinate(Gnome::Canvas::Item*, 
                        coordinate_number ) const throw();

        double get_qt_image_coordinate(QGraphicsItem*, 
                        coordinate_number) const throw();
        
        void move_gtk_item_by(const std::string&, double, double) throw();

        void move_gtk_line_by(Gnome::Canvas::Item*, double, double) throw();

        void move_gtk_rectangle_by(Gnome::Canvas::Item*, double, double) 
                throw();

        void move_gtk_ellipse_by(Gnome::Canvas::Item*, double, double) throw();

        void move_gtk_text_by(Gnome::Canvas::Item*, double, double) throw();

        void move_gtk_image_by(Gnome::Canvas::Item*, double, double) throw();
        
        void move_qt_item_by(const std::string&, double, double) throw();

        void move_qt_line_by(QGraphicsItem*, double, double) throw();

        void move_qt_rectangle_by(QGraphicsItem*, double, double) throw();

        void move_qt_ellipse_by(QGraphicsItem*, double, double) throw();

        void move_qt_text_by(QGraphicsItem*, double, double) throw();
        
        void move_qt_image_by(QGraphicsItem*, double, double) throw();

        bool notify_button_press(item*, GdkEvent*) throw();

        bool notify_button_release(item*, GdkEvent*) throw();

        bool notify_double_click(item*, GdkEvent*) throw();

        void collect_colors() throw();

        void zoom_gtk_canvas(const std::string&, double) throw();
        
        void zoom_qt_canvas(const std::string&, double) throw();

        void reset_gtk_canvas_zoom_factor(const std::string&) throw();

        void reset_qt_canvas_zoom_factor(const std::string&) throw();

        void gtk_item_raise_to_top(const std::string&) throw();
        
        void qt_item_raise_to_top(const std::string&) throw();

        void gtk_item_lower_to_bottom(const std::string&) throw();

        void qt_item_lower_to_bottom(const std::string&) throw();

        void set_user_data_to_gtk_item(const std::string&, void*) throw();
        
        void set_user_data_to_qt_item(const std::string&, void*) throw();

        void set_user_data_to_qt_line(QGraphicsItem*, void*) throw();

        void set_user_data_to_qt_rectangle(QGraphicsItem*, void*) throw();

        void set_user_data_to_qt_ellipse(QGraphicsItem*, void*) throw();

        void set_user_data_to_qt_text(QGraphicsItem*, void*) throw();

        void set_user_data_to_qt_group(QGraphicsItem*, void*) throw();

        void* get_user_data_from_gtk_item(const std::string&) const throw();
        
        void* get_user_data_from_qt_item(const std::string&) const throw();

        void* get_user_data_from_qt_line(QGraphicsItem*) const throw();
        
        void* get_user_data_from_qt_rectangle(QGraphicsItem*) const throw();
        
        void* get_user_data_from_qt_ellipse(QGraphicsItem*) const throw();
        
        void* get_user_data_from_qt_text(QGraphicsItem*) const throw();

        void* get_user_data_from_qt_group(QGraphicsItem*) const throw();

        void set_key_state(GdkEvent*) throw();

        void set_enable_to_qt_widgets(QObject*) throw();

        void set_enable_to_qt_action(QObject*) throw();

        void set_enable_to_qt_layout(QObject*) throw();

        void hide_qt_layout(const std::string&) throw();

        void show_qt_layout(const std::string&) throw();

        void hide_qt_notebook_page(const std::string&, QWidget*) throw();

        void show_qt_notebook_page(const std::string&, QWidget*) throw();

        void hide_qt_widget(const std::string&) throw();

        void hide_gtk_widget(const std::string&) throw();

        void show_qt_widget(const std::string&) throw();

        void show_gtk_widget(const std::string&) throw();

        bool is_qt_notebook_page_visible(const std::string&, QWidget* ) 
                const throw();
        
        bool is_qt_layout_visible(const std::string&) const throw();

        bool is_qt_widget_visible(const std::string&) const throw();

        bool is_gtk_widget_visible(const std::string&) const throw();

        void set_editable_mode_to_qt_widget(const std::string&) throw();

        void set_read_only_mode_to_gtk_widget(const std::string&) throw();

        void set_read_only_mode_to_qt_widget(const std::string&) throw();

        void set_editable_mode_to_gtk_edit_box(Gtk::Widget*, bool) throw();

        void set_editable_mode_to_gtk_text_box(Gtk::Widget*, bool) throw();

        void set_editable_mode_to_gtk_widget(const std::string&) throw();

        bool column_path_is(const std::string&, 
                        gtk_tree_view::columns_properties::const_reference) 
                const throw();

        void set_editable_mode_to_gtk_column(const std::string&,
                        gtk_tree_view_base*, bool) throw();
        
        void set_gtk_column_enable_property_to_icon(Gtk::CellRenderer*, 
                        bool) throw();
        
        void set_gtk_column_enable_property_to_label(Gtk::CellRenderer*, 
                        bool) throw();

        void set_gtk_column_enable_property_to_check(Gtk::CellRenderer*, 
                        bool) throw();
        
        void set_gtk_column_enable_property(Gtk::TreeViewColumn*,
                        gtk_tree_view_base::column_records::const_iterator,
                        bool) throw();

        void on_tree_cell_edited(const Glib::ustring&, const Glib::ustring&,
                        gtk_tree_view*, Gtk::TreeModelColumnBase*) throw();

        void set_gtk_column_editable_property_to_tree_lable(gtk_tree_view_base*,
                        Gtk::CellRendererText*,
                        Gtk::TreeModelColumnBase*) throw();

        void on_list_cell_edited(const Glib::ustring&, const Glib::ustring&,
                        gtk_list_view*, Gtk::TreeModelColumnBase*) throw();

        void set_gtk_column_editable_property_to_list_lable(gtk_tree_view_base*,
                        Gtk::CellRendererText*,
                        Gtk::TreeModelColumnBase*) throw();

        void set_gtk_column_editable_property_to_label(Gtk::CellRenderer*,
                        std::string&, Gtk::TreeModelColumnBase*,
                        bool, bool) throw();

        void on_tree_cell_toggled(const Glib::ustring&, gtk_tree_view*,
                        Gtk::TreeModelColumnBase*) throw();

        void set_gtk_column_editable_property_to_tree_check(gtk_tree_view_base*,
                        Gtk::CellRendererToggle*,
                        Gtk::TreeModelColumnBase*) throw();

        void on_list_cell_toggled(const Glib::ustring&, gtk_list_view*,
                        Gtk::TreeModelColumnBase*) throw();

        void set_gtk_column_editable_property_to_list_check(gtk_tree_view_base*,
                        Gtk::CellRendererToggle*,
                        Gtk::TreeModelColumnBase*) throw();

        void set_gtk_column_editable_property_to_check(Gtk::CellRenderer*,
                        std::string&, Gtk::TreeModelColumnBase*,
                        bool b, bool d) throw();

        void set_gtk_column_editable_property(Gtk::TreeViewColumn*,
                        gtk_tree_view_base::column_records::const_iterator,
                        bool, bool) throw();

        void set_gtk_column_properties(Gtk::TreeViewColumn*,
                        gtk_tree_view_base::column_records::const_iterator ,
                        gtk_tree_view_base::gtk_column_properties) throw();

        void set_disable_to_qt_widgets(QObject*) throw();

        void set_disable_to_qt_action(QObject*) throw();

        void set_disable_to_qt_layout(QObject*) throw();

        void set_disable_mode_to_qt_widgets(const std::string&) throw();

        void set_enable_mode_to_qt_widgets(const std::string&) throw();

        bool is_enable_for_qt_column(qt_tree_view*, const std::string&)
                                                            const throw();

        bool is_enable_for_qt_widgets(const std::string&) const throw();

        void set_enable_mode_to_gtk_column(const std::string&, 
                        gtk_tree_view_base*, bool) throw();

        void set_enable_to_gtk_widgets(Gtk::Widget*) throw();

        void set_enable_to_gtk_action(Gtk::Widget*) throw();

        void set_enable_to_gtk_layout(Gtk::Widget*) throw();
        
        void set_enable_mode_to_gtk_widgets(const std::string&) throw();

        bool is_enable_for_gtk_column(const std::string&,
                                        gtk_tree_view_base*) const throw();

        bool is_enable_for_gtk_widgets(const std::string&) const throw();

        void set_disable_mode_to_gtk_widgets(const std::string&) throw();

        void set_disable_to_gtk_widgets(Gtk::Widget*) throw();

        void set_disable_to_gtk_action(Gtk::Widget*) throw();

        void set_disable_to_gtk_layout(Gtk::Widget*) throw();

        void set_checked_property(const std::string&, const std::string&,
                bool, qt_widgets::const_iterator) throw();

        void add_gtk_widget_to_layout(const std::string&, Gtk::Widget*, 
                        Gtk::Box*)
                throw();

        void set_gtk_position_to_widget(const std::string&, int) throw();
        
        void set_gtk_position_to_paned_window(Gtk::Widget*, int) throw();
        
        void set_size_policy_to_gtk_layout(const std::string&,
                const std::string&) throw();

        void set_size_policy_to_qt_layout(const std::string&, 
                const std::string&) throw();
        
        std::string get_size_policy_from_gtk_layout(
                        const std::string&) const throw();
        
        std::string get_size_policy_from_qt_layout(
                        const std::string&) const throw();

        void insert_qt_index_to_tree(const std::string&, int, int,
                QModelIndex&, QTreeView*, qt_tree_view*) throw();

        void insert_qt_indexes(const std::string&, int, QModelIndex&,
                        qt_tree_view*) throw();

        void insert_qt_row(const std::string&, const QList<QStandardItem*>&,
                        qt_tree_view*) throw();

        void insert_qt_row_to_tree(const std::string&,
                        const QList<QStandardItem*>&, qt_tree_view*) throw();

        void insert_qt_row_to_list(const std::string&,
                        const QList<QStandardItem*>&, qt_tree_view*) throw();

        std::string get_full_path(const std::string&) const throw();

        void browse(std::string) throw();

        rows get_selected_rows_from_gtk_tree(const std::string&) const throw();
        
        rows get_selected_rows_from_qt_tree(const std::string&) const throw();

        rows get_selected_gtk_row(const std::string&, 
                        Gtk::TreeView*) const throw();
        
        rows get_selected_gtk_rows(const std::string&, 
                        Gtk::TreeView*) const throw();
        
        rows get_selected_qt_row(const std::string&, QTreeView*) const throw();
        
        rows get_selected_qt_rows(const std::string&, QTreeView*) const throw();

        bool on_tree_event(GdkEvent*, Gtk::TreeView*) throw();

        void select_gtk_row(const std::string&) const throw();
        
        void select_qt_row(const std::string&) const throw();
        
        void deselect_gtk_row(const std::string&) throw();
        
        void deselect_qt_row(const std::string&) throw();

        gtk_tree_view_base* get_gtk_parent_tree(const std::string&) const
                throw();

        qt_tree_view* get_qt_parent_tree(const std::string&) const throw();
        
        void remove_all_gtk_handlers(const std::string&) throw();
        
        void remove_all_qt_handlers(const std::string&) throw();

        void remove_actions(const std::string&) throw();

        void run_gtk_window() throw();

        void run_qt_window() throw();

        void on_expanded(const Gtk::TreeModel::iterator&, 
                        const Gtk::TreeModel::Path&, gtk_tree_view*) throw();
        
        void on_collapsed(const Gtk::TreeModel::iterator&, 
                        const Gtk::TreeModel::Path&, gtk_tree_view*) throw();

        std::string get_gtk_expanded_row(const std::string&) const throw();
        
        std::string get_qt_expanded_row(const std::string&) const throw();
        
        std::string get_gtk_collapsed_row(const std::string&) const throw();
        
        std::string get_qt_collapsed_row(const std::string&) const throw();
        
        rows get_gtk_tree_row_children(const std::string&) const throw();
        
        rows get_qt_tree_row_children(const std::string&) const throw();

        void clear_gtk_rows(const std::string&) throw();

        void clear_qt_rows(const std::string&) throw();

        void expand_gtk_row(const std::string&) const throw();

        void expand_qt_row(const std::string&) const throw();

        void set_color_on_row(Gtk::CellRenderer*, 
                        const Gtk::TreeModel::iterator&,
                        gtk_tree_view*) throw();

        void insert_color(gtk_tree_view*, const std::string&, 
                        const std::string&) throw();

        void set_callback_on_columns(gtk_tree_view* v, 
                        Gtk::TreeView* t) throw();
        
        void set_qt_focus(const std::string& s) throw();
        
        void set_gtk_focus(const std::string& s) throw();

        bool is_qt_widget_focusable(const std::string& s) const throw();

        bool is_gtk_widget_focusable(const std::string& s) const throw();

        void set_selection_mode_to_gtk_tree(const std::string&, 
                const std::string&) throw();
        
        void set_selection_mode_to_qt_tree(const std::string&, 
                const std::string&) throw();

        std::string get_selection_mode_of_gtk_tree(
                        const std::string&) const throw();
        
        std::string get_selection_mode_of_qt_tree(
                        const std::string&) const throw();
        
        QSizePolicy get_qt_size_policy_of_layout(QWidget* w, QObject* o,
                                        const std::string& t)throw();

        void add_gtk_spacer(const std::string& s) throw();

        void add_qt_spacer(const std::string& s) throw();
                
        void set_editable_mode_to_qt_column(const std::string&, 
                qt_tree_view*, bool) throw();
        
        void set_editable_mode_to_qt_column_items(qt_tree_view*, 
                     qt_tree_view::columns_properties::size_type, bool) throw();

        void set_editable_mode_to_qt_row_items(qt_tree_view*, QStandardItem*, 
                        qt_tree_view::columns_properties::size_type) throw();

        void set_enable_mode_to_qt_column(const std::string&, 
                qt_tree_view*, bool) throw();

        void set_enable_mode_to_qt_column_items(qt_tree_view*, 
                     qt_tree_view::columns_properties::size_type, bool) throw();

        void set_enable_mode_to_qt_row_items(qt_tree_view*, QStandardItem*, 
                        qt_tree_view::columns_properties::size_type) throw();

        std::string get_selected_qt_item_column(
                        const std::string&) const throw();

        void add_qt_progress_bar(const std::string&) throw();
        
        void add_gtk_progress_bar(const std::string&) throw();

        void add_qt_progress_bar_to_layout(const std::string&, 
                        QObject*) throw();
        
        void add_gtk_progress_bar_to_layout(const std::string&, 
                        Gtk::Widget*) throw();

        void add_qt_progress_bar_to_window(const std::string&, 
                        QObject*) throw();

        void add_qt_progress_bar_to_status_bar(const std::string&, 
                        QObject*) throw();

        void add_gtk_progress_bar_to_window(const std::string&, 
                        Gtk::Widget*) throw();

        void add_gtk_progress_bar_to_status_bar(const std::string&, 
                        Gtk::Widget*) throw();

        void set_value_to_qt_progress_bar(QObject*, int) throw();

        void set_value_to_gtk_progress_bar(Gtk::Widget*, int) throw();

        int get_value_of_qt_progress_bar(const std::string&) const throw();

        int get_value_of_gtk_progress_bar(const std::string&) const throw();
        
        void reparent_widget_by_new_paned(Gtk::Widget* r, Gtk::Widget* w, 
                        Gtk::Paned* p) throw();

        void add_gtk_widget_to_paned(Gtk::Widget* r, Gtk::Widget* w, 
                        Gtk::Paned* p) throw();
        
        Gtk::Paned* get_last_child_paned(Gtk::Paned* p) throw();
        
        void add_widget_to_gtk_paned(const std::string&, Gtk::Widget* w, 
                        Gtk::Widget* e) throw();

        void add_event_to_gtk_queue(event_handler*) throw();
        
        void add_event_to_qt_queue(event_handler*) throw();

private:
        item* get_item_by_name(const std::string&) const throw();

        void emit_select_event(const std::string&) throw();

        void emit_deselect_event(const std::string&) throw();
public:
        std::string get_name() const throw();

private:
        std::string m_name;

public:
        void run() throw();

        
public:
        ~window() throw();

        window(const std::string& n) throw();

private:
        window() throw();
        
        window(const window&) throw();
        
        window& operator= (const window&) throw();

}; // class instigate::toolkit::window

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_TOOLKIT_WINDOW

---

© Instigate CJSC, Open Source