table.h

/* $Id: table.h 2940 2013-04-01 13:55:58Z roma $ */
#ifndef __FFL_WX_TABLE__
#define __FFL_WX_TABLE__

#include <wx/panel.h>
#include <wx/dialog.h>
#include <wx/grid.h>
#include <wx/toolbar.h>
#include <wx/statusbr.h>

#include <co.h>

#include <vector>
#include <list>

#include "xpm.h"

namespace ffl
{

        namespace wx
        {

                class table:public wxPanel
                {
                public:

                        class command:public wxObject
                        {
                        public:

                                command(table& _t, int _group) throw(...);

                                virtual wxString label() const throw() = 0;

                                virtual wxString help() const throw() = 0;

                                virtual wxBitmap image() const throw() = 0;

                                virtual void execute() throw() = 0;

                                const int Id;           

                                const int Group;        

                        protected:

                                table& Table;   

                        };

                        typedef std::vector<command*> menu;

                        class command_alter_table:public command
                        {
                        public:

                                command_alter_table(table& _t, int _group) throw(...):command(_t, _group)
                                {
                                }

                                wxString label() const throw(){return "&Изменить структуру таблицы";}

                                wxString help() const throw(){return "Изменить структуру таблицы.";}

                                wxBitmap image() const throw(){return wxBitmap(XPM_data_table);}

                                void execute() throw(){Table.alter();}

                        };

                        class command_save_table:public command
                        {
                        public:

                                command_save_table(table& _t, int _group) throw(...):command(_t, _group){}

                                wxString label() const throw(){return "&Сохранить таблицу";}

                                wxString help() const throw(){return "Сохранить структуру и данные таблицы в файл.";}

                                wxBitmap image() const throw(){return wxBitmap(XPM_table_save);}

                                void execute() throw();

                        };

                        class command_open_table:public command
                        {
                        public:

                                command_open_table(table& _t, int _group) throw(...):command(_t, _group){}

                                wxString label() const throw(){return "&Открыть таблицу";}

                                wxString help() const throw(){return "Открыть файл с таблицей.";}

                                wxBitmap image() const throw(){return wxBitmap(XPM_folder_table);}

                                void execute() throw();

                        };

                        class command_edit_profile:public command
                        {
                        public:

                                command_edit_profile(table& _t, int _group) throw(...):command(_t, _group){}

                                wxString label() const throw(){return "&Редактировать профиль";}

                                wxString help() const throw(){return "Редактировать настройки табличного редактора.";}

                                wxBitmap image() const throw(){return wxBitmap(XPM_cog_edit);}

                                void execute() throw(){profile(Table).edit(&Table);}


                        };

                        class lock
                        {
                        public:

                                lock(table& _t, bool _f) throw();

                                virtual ~lock() throw();

                        protected:

                                table& Table;           

                                const bool Flip;        

                        };

                        friend class lock;

                        class profile:public lock
                        {
                        public:

                                profile(table& _t) throw():lock(_t, false){}

                                ~profile() throw();

                                bool edit(wxWindow* _parent) throw();   

                                void show(wxWindow* _parent) throw();   

                                void set_toolbar(bool _f) throw();

                                bool get_toolbar() throw();

                                void set_statusbar(bool _f) throw();

                                bool get_statusbar() throw();

                                void set_drag_column_move(bool _f) throw();

                                bool get_drag_column_move() throw();

                                menu Menu;                              

                        private:

                                class dialog:public wxDialog
                                {
                                public:

                                        dialog(ffl::wx::table::profile& _profile, wxWindow* _parent, bool _edit = true) throw();

                                private:

                                        profile& Profile;       //<! Профиль таблицы.

                                        wxCheckBox* HasToolBar;                 
                                                
                                        wxCheckBox* HasStatusBar;               

                                        wxCheckBox* EnableDragColumn;   

                                        DECLARE_EVENT_TABLE()

                                        void on_ok(wxCommandEvent& _e) throw();

                                };


                        };

                        class format:public lock
                        {
                        };

                        class designer:public wxDialog
                        {
                        public:

                                designer(co_table& _t, wxWindow* _parent, wxWindowID _id = wxID_ANY, const wxString& _title = wxString("Структура таблицы"), const wxPoint& _pos = wxDefaultPosition, const wxSize& _size = wxDefaultSize, long _style = wxDEFAULT_DIALOG_STYLE, const wxString& _name = "ffl::wx::table::designer") throw();

                        private:

                                class header:public wxGrid
                                {
                                public:

                                        header(int _n, const co_column* _c, wxWindow* _parent, wxWindowID _Id = wxID_ANY, const wxPoint& _pos = wxDefaultPosition, const wxSize& _size = wxSize(-1, 200), long _style = wxWANTS_CHARS, const wxString& _name = "ffl::wx::table::designer::header") throw();

                                        void describe(co_table& _t, int _occurs = 1) throw();

                                private:

                                        enum
                                        {
                                                JNAME = 0,      
                                                JDOMAIN,        
                                                JWIDTH,         
                                                JINF = JNAME,   
                                                JSUP = JWIDTH   
                                        };

                                        class storage:public wxGridTableBase
                                        {
                                        public:

                                                storage(int _n, const co_column* _c) throw(...);

                                                void describe(co_table& _t, int _occurs) throw();

                                                int GetNumberRows() throw();

                                                int GetNumberCols() throw()
                                                {
                                                        return JSUP - JINF + 1;
                                                }

                                                bool IsEmptyCell(int _i, int _j) throw();

                                                wxString GetValue(int _i, int _j) throw();

                                                long GetValueAsLong(int _i, int _j) throw();

                                                void SetValueAsLong(int _i, int _j, long _v) throw();

                                                void SetValue(int _i, int _j, const wxString& _v) throw();

                                                wxString GetRowLabelValue(int _i) throw();

                                                wxString GetColLabelValue(int _j) throw();

                                                bool CanGetValueAs(int _i, int _j, const wxString& _type) throw();

                                        private:

                                                struct column
                                                {
                                                        wxString Name;                  
                                                        co_domain Domain;               
                                                        size_t Width;                   
                                                };

                                                std::vector<column> Header;

                                                class attribute:public wxGridCellAttrProvider
                                                {
                                                public:

                                                        attribute(const std::vector<column>& _h) throw();

                                                        ~attribute();

                                                        wxGridCellAttr* GetAttr(int _i, int _j, wxGridCellAttr::wxAttrKind _k) const throw();

                                                private:

                                                        const std::vector<column>& Header;

                                                        wxGridCellAttr* Name;   
                                                        wxGridCellAttr* Type;   
                                                        wxGridCellAttr* Size;   
                                                        wxGridCellAttr* DefSize;

                                                };

                                        };

                                };

                                co_table& Table;        

                                header* Header;         

                                DECLARE_EVENT_TABLE()

                                
                                void on_ok(wxCommandEvent& _e) throw();

                        };

                        table
                        (
                                wxWindow* _parent, 
                                wxWindowID _id = wxID_ANY, 
                                int _start_menu_id = wxID_HIGHEST + 1,
                                const wxPoint& _pos = wxDefaultPosition, 
                                const wxSize& _size = wxDefaultSize,
                                long _style = wxTAB_TRAVERSAL,
                                const wxString& _name = "ffl::wx::table"
                        ) throw();

                        table(int _start_menu_id = wxID_HIGHEST + 1) throw():StartMenuId(_start_menu_id){}

                        void set(const co_table& _t) throw();

                        void get(co_table& _t) throw();

                        void alter(int _occurs = 1) throw(){Grid->alter(_occurs);}

                        void save(const wxString& _file) throw(...){Grid->save(_file);}

                        wxString save() throw(...);

                        void open(const wxString& _file) throw(...){Grid->open(_file);}

                        void open() throw(...);

                private:

                        void on_create(wxWindowCreateEvent& _e) throw();

                        void on_command(wxCommandEvent& _e) throw();

                        class toolbar:public wxToolBar
                        {
                        public:

                                toolbar(wxWindow* _parent, const std::vector<command*>& _menu) throw();

                        private:

                                void add(const command& _c) throw();
                                
                        }       *ToolBar;       

                        class statusbar:public wxStatusBar
                        {
                        public:

                                statusbar(wxWindow* _parent, wxWindowID _id = wxID_ANY, long _style = wxST_SIZEGRIP, const wxString& _name = "ffl::wx::table::statusbar") throw():wxStatusBar(_parent, _id, _style, _name)
                                {
                                }

                        }       *StatusBar;     

                        class storage:public co_table, public wxGridTableBase
                        {
                        public:

                                int GetNumberRows() throw()
                                {
                                        return getnrows();
                                }

                                int GetNumberCols() throw()
                                {
                                        int n;
                                        describe(&n);
                                        return n;
                                }

                                bool IsEmptyCell(int _i, int _j) throw()
                                {
                                        int n;
                                        describe(&n);
                                        if(_i < getnrows() && _j < n)
                                                return getflag(_i, _j) == 0;
                                        return true;
                                }

                                wxString GetValue(int _i, int _j) throw()
                                {
                                        int n;
                                        describe(&n);
                                        if(_i < getnrows() && _j < n)
                                                return wxString(getstring(_i, _j));
                                        else
                                                return wxEmptyString;
                                }

                                void SetValue(int _i, int _j, const wxString& _v) throw()
                                {
                                        int n;
                                        describe(&n);
                                        if(_i < getnrows() && _j < n)
                                                setstring(_i, _j, _v.c_str());
                                }

                                void set(const co_table& _t) throw();

                                void get(co_table& _t) throw();

                                void alter(int _occurs = 1) throw();

                                void save(const wxString& _file) throw(...);

                                void open(const wxString& _file) throw(...);

                        private:

                        };

                        class grid:public wxGrid
                        {
                        public:

                                grid(wxWindow* _parent, wxWindowID _id = wxID_ANY, const wxPoint& _pos = wxDefaultPosition, const wxSize& _size = wxDefaultSize, long _style = wxWANTS_CHARS, const wxString& _name = "ffl::wx::table::grid") throw(...):wxGrid(_parent, _id, _pos, _size, _style, _name)
                                {
                                        SetTable(new storage(), true);
                                }

                                void alter(int _occurs = 1) throw()
                                {
                                        ((storage*)GetTable())->alter(_occurs);
                                }

                                void save(const wxString& _file) throw(...){((storage*)GetTable())->save(_file);}

                                void open(const wxString& _file) throw(...){((storage*)GetTable())->open(_file);}

                                class batch
                                {
                                public:

                                        batch(wxGrid* _g) throw():Grid(_g)
                                        {
                                                Grid->BeginBatch();
                                        }

                                        virtual ~batch() throw()
                                        {
                                                Grid->EndBatch();
                                        }

                                protected:

                                        wxGrid* Grid;   

                                };

                                class batch_and_refresh:public batch
                                {
                                public:

                                        batch_and_refresh(wxGrid* _g) throw();

                                        ~batch_and_refresh() throw();

                                private:

                                        wxGridTableBase* Storage;       

                                };

                        }       *Grid;  

                        std::vector<command*> Menu;

                        const int StartMenuId;

                        DECLARE_EVENT_TABLE();

                };

        }

}

#endif