From 49560b4f090284c996f5fb6dea3f145fabc374ab Mon Sep 17 00:00:00 2001 From: Maxime WACK Date: Tue, 28 Aug 2012 09:28:17 +0200 Subject: [PATCH] Commit initial Signed-off-by: Maxime WACK --- CosMoS/CosMoS.project | 202 +++ CosMoS/bdd.cpp | 39 + CosMoS/bdd.h | 33 + CosMoS/config.cpp | 75 + CosMoS/config.h | 40 + CosMoS/cosmos.cpp | 60 + CosMoS/cosmos.fbp | 517 +++++++ CosMoS/cosmos.h | 37 + CosMoS/cosmosGUI.cpp | 162 +++ CosMoS/cosmosGUI.h | 64 + CosMoS/main.cpp | 17 + CosMoS/options.cpp | 67 + CosMoS/options.fbp | 656 +++++++++ CosMoS/options.h | 34 + CosMoS/optionsGUI.cpp | 90 ++ CosMoS/optionsGUI.h | 61 + Sante_Pub.workspace | 38 + Sante_Pub.workspace.maxime_wack | 6 + Sante_Pub.workspace.session | 9 + Sante_Pub.workspace.wack | 10 + grid/bitmap1.bmp | Bin 0 -> 406 bytes grid/bitmap2.bmp | Bin 0 -> 238 bytes grid/grid.project | 161 +++ grid/griddemo.cpp | 2263 +++++++++++++++++++++++++++++++ grid/griddemo.h | 303 +++++ testcurl/main.cpp | 18 + testcurl/testcurl.cpp | 78 ++ testcurl/testcurl.h | 49 + testcurl/testcurl.project | 181 +++ testcurl/testcurlGUI.cpp | 63 + testcurl/testcurlGUI.fbp | 511 +++++++ testcurl/testcurlGUI.h | 54 + testsqlite/main.c | 76 ++ testsqlite/testsqlite.project | 172 +++ 34 files changed, 6146 insertions(+) create mode 100644 CosMoS/CosMoS.project create mode 100644 CosMoS/bdd.cpp create mode 100644 CosMoS/bdd.h create mode 100644 CosMoS/config.cpp create mode 100644 CosMoS/config.h create mode 100644 CosMoS/cosmos.cpp create mode 100644 CosMoS/cosmos.fbp create mode 100644 CosMoS/cosmos.h create mode 100644 CosMoS/cosmosGUI.cpp create mode 100644 CosMoS/cosmosGUI.h create mode 100644 CosMoS/main.cpp create mode 100644 CosMoS/options.cpp create mode 100644 CosMoS/options.fbp create mode 100644 CosMoS/options.h create mode 100644 CosMoS/optionsGUI.cpp create mode 100644 CosMoS/optionsGUI.h create mode 100644 Sante_Pub.workspace create mode 100644 Sante_Pub.workspace.maxime_wack create mode 100644 Sante_Pub.workspace.session create mode 100644 Sante_Pub.workspace.wack create mode 100644 grid/bitmap1.bmp create mode 100644 grid/bitmap2.bmp create mode 100644 grid/grid.project create mode 100644 grid/griddemo.cpp create mode 100644 grid/griddemo.h create mode 100644 testcurl/main.cpp create mode 100644 testcurl/testcurl.cpp create mode 100644 testcurl/testcurl.h create mode 100644 testcurl/testcurl.project create mode 100644 testcurl/testcurlGUI.cpp create mode 100644 testcurl/testcurlGUI.fbp create mode 100644 testcurl/testcurlGUI.h create mode 100644 testsqlite/main.c create mode 100644 testsqlite/testsqlite.project diff --git a/CosMoS/CosMoS.project b/CosMoS/CosMoS.project new file mode 100644 index 0000000..1507d14 --- /dev/null +++ b/CosMoS/CosMoS.project @@ -0,0 +1,202 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + diff --git a/CosMoS/bdd.cpp b/CosMoS/bdd.cpp new file mode 100644 index 0000000..5369b7f --- /dev/null +++ b/CosMoS/bdd.cpp @@ -0,0 +1,39 @@ +#include "bdd.h" + +class_bdd::class_bdd(const wxString& path_in) +{ + path = path_in + slash + "cosmos.db"; + if (!wxFileExists(path)) + createEmpty(); + else if ((rc=sqlite3_open_v2(_C(path), &db, SQLITE_OPEN_READWRITE, NULL)) != SQLITE_OK) + { + wxMessageBox("Erreur lors de l'ouverture de la base de données", "Erreur", wxICON_ERROR | wxOK); + exit(0); + } +} + +class_bdd::~class_bdd() +{ + sqlite3_close(db); //check RC (busy ?) +} + +void class_bdd::createEmpty() +{ + rc = 0; + rc += sqlite3_open_v2(_C(path), &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL); + rc += sqlite3_exec(db, "CREATE TABLE Consult(id INTEGER PRIMARY KEY ASC AUTOINCREMENT, n_dossier INTEGER UNIQUE, nom VARCHAR(50), prenom VARCHAR(50), responsable VARCHAR(100), consultant VARCHAR(50), theme TEXT, etablissement VARCHAR(100), travail VARCHAR(50), date_cs DATE, publi_prevue BOOLEAN, publi BOOLEAN, cs_associe BOOLEAN, publi_CHU BOOLEAN, nb_result INT, id_results TEXT);", NULL, NULL, NULL); + rc += sqlite3_exec(db, "CREATE TABLE Result(id INTEGER PRIMARY KEY, titre TEXT, auteurs TEXT, lien VARCHAR(50), date_publi DATE);", NULL, NULL, NULL); + rc += sqlite3_exec(db, "CREATE TABLE Correc(orig TEXT PRIMARY KEY, dest TEXT);", NULL, NULL, NULL); + if (rc) + { + wxMessageBox("Erreur lors de la création de la base de données", "Erreur", wxICON_ERROR | wxOK); + exit(0); + } + + wxMessageBox("La base de données est vide,\nveuillez importer des données !"); +} + +void class_bdd::import(const wxString& importfile) +{ + +} \ No newline at end of file diff --git a/CosMoS/bdd.h b/CosMoS/bdd.h new file mode 100644 index 0000000..40dae61 --- /dev/null +++ b/CosMoS/bdd.h @@ -0,0 +1,33 @@ +#ifndef __bdd__ +#define __bdd__ + +#include +#include +#include +#include + +#ifdef __WXGTK__ + #define slash "/" + #define _C(string) string.fn_str() +#elif defined( __WXMSW__ ) + #define slash "\\" + #define _C(string) (const char*) string.c_str() +#endif + +class class_bdd +{ + private: + sqlite3* db; + sqlite3_stmt* stmt; + int rc; + wxString path; + + void createEmpty(); + public: + class_bdd(const wxString& path_in); + ~class_bdd(); + void import(const wxString& importfile); +}; + + +#endif //__bdd__ \ No newline at end of file diff --git a/CosMoS/config.cpp b/CosMoS/config.cpp new file mode 100644 index 0000000..396082f --- /dev/null +++ b/CosMoS/config.cpp @@ -0,0 +1,75 @@ +#include "config.h" + +config::config(dialog_Options* parent) +{ + this->parent = parent; + if (!wxFileExists("cosmos.cfg")) + createDefault(); + else + load(); +} + +void config::createDefault() +{ + dbpath = wxGetCwd(); + useproxy = true; + proxyurl = "www-proxy.chu-nancy.fr"; + proxyport = 8080; + + fichier_config = new wxXmlDocument(); + wxXmlNode* rootnode = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, "CosMoS_config"); + wxXmlNode* proxynode = new wxXmlNode(rootnode, wxXML_ELEMENT_NODE, "proxy"); + if (useproxy) + proxynode->AddAttribute("set", "true"); + else + proxynode->AddAttribute("set", "false"); + wxXmlNode* proxyportnode = new wxXmlNode(proxynode, wxXML_ELEMENT_NODE, "port"); + wxXmlNode* proxyporttext = new wxXmlNode(proxyportnode, wxXML_TEXT_NODE, "", wxString::Format("%i",proxyport)); + wxXmlNode* proxyurlnode = new wxXmlNode(proxynode, wxXML_ELEMENT_NODE, "url"); + wxXmlNode* proxyurltext = new wxXmlNode(proxyurlnode, wxXML_TEXT_NODE, "", proxyurl); + wxXmlNode* dbpathnode = new wxXmlNode(rootnode, wxXML_ELEMENT_NODE, "dbpath"); + wxXmlNode* dbpathtext = new wxXmlNode(dbpathnode, wxXML_TEXT_NODE, "", dbpath); + fichier_config->SetRoot(rootnode); + + wxMessageBox("Vous lancez CosMoS pour la première fois,\nveuillez configurer le chemin de la base\nainsi que les paramètres de connexion"); + first_time = true; +} + +config::~config() +{ + delete fichier_config; +} + + +void config::save() +{ + wxXmlNode* parcours = fichier_config->GetRoot()->GetChildren(); + parcours->GetChildren()->SetContent(dbpath); + parcours = parcours->GetNext(); + if (useproxy) + parcours->GetAttributes()->SetValue("true"); + else + parcours->GetAttributes()->SetValue("false"); + parcours = parcours->GetChildren(); + parcours->GetChildren()->SetContent(proxyurl); + parcours = parcours->GetNext(); + parcours->GetChildren()->SetContent(wxString::Format("%i",proxyport)); + fichier_config->Save("cosmos.cfg"); +} + +void config::load() +{ + fichier_config = new wxXmlDocument("cosmos.cfg"); + wxXmlNode* parcours = fichier_config->GetRoot()->GetChildren(); + dbpath = parcours->GetNodeContent(); + parcours = parcours->GetNext(); + if (parcours->GetAttribute("set") == "true") + useproxy = true; + else + useproxy = false; + parcours = parcours->GetChildren(); + proxyurl = parcours->GetNodeContent(); + parcours = parcours->GetNext(); + proxyport = wxAtoi(parcours->GetNodeContent()); + first_time = false; +} diff --git a/CosMoS/config.h b/CosMoS/config.h new file mode 100644 index 0000000..9f5779e --- /dev/null +++ b/CosMoS/config.h @@ -0,0 +1,40 @@ +#ifndef __config__ +#define __config__ + +#include +#include +#include +#include + +#include "optionsGUI.h" + +class config +{ +protected: + dialog_Options* parent; + wxXmlDocument* fichier_config; + bool first_time; + wxString dbpath; + bool useproxy; + wxString proxyurl; + int proxyport; + +public: + config(dialog_Options* parent); + ~config(); + void createDefault(); + void load(); + void save(); + + void SetDbpath(const wxString& dbpath) {this->dbpath = dbpath;} + void SetProxyport(int proxyport) {this->proxyport = proxyport;} + void SetProxyurl(const wxString& proxyurl) {this->proxyurl = proxyurl;} + void SetUseproxy(bool useproxy) {this->useproxy = useproxy;} + const wxString& GetDbpath() const {return dbpath;} + int GetProxyport() const {return proxyport;} + const wxString& GetProxyurl() const {return proxyurl;} + bool IsUseproxy() const {return useproxy;} + bool IsFirstTime() const {return first_time;} +}; + +#endif // __config__ diff --git a/CosMoS/cosmos.cpp b/CosMoS/cosmos.cpp new file mode 100644 index 0000000..297099f --- /dev/null +++ b/CosMoS/cosmos.cpp @@ -0,0 +1,60 @@ +#include "cosmos.h" + +cosmos::cosmos( wxWindow* parent ) +: +cosmosGUI( parent ) +{ + fenetre_options = new options(this); + if (fenetre_options->GetConfiguration()->IsFirstTime()) + fenetre_options->ShowModal(); + bdd = new class_bdd(fenetre_options->GetConfiguration()->GetDbpath()); +} + +void cosmos::OnImport( wxCommandEvent& event ) +{ + wxFileDialog * opendialog = new wxFileDialog(this, "Importer", "", "", "*.csv", wxFD_OPEN | wxFD_FILE_MUST_EXIST); + + if (opendialog->ShowModal() == wxID_CANCEL) + return; + else + bdd->import(opendialog->GetPath()); + + delete opendialog; +} + +void cosmos::OnExport( wxCommandEvent& event ) +{ +// TODO: Implement OnExport +} + +void cosmos::OnQuit( wxCommandEvent& event ) +{ + delete bdd; + delete fenetre_options; + this->Close(); +} + +void cosmos::OnStart( wxCommandEvent& event ) +{ +// TODO: Implement OnStart +} + +void cosmos::OnOptionsRche( wxCommandEvent& event ) +{ +// TODO: Implement OnOptionsRche +} + +void cosmos::OnCorrections( wxCommandEvent& event ) +{ +// TODO: Implement OnCorrections +} + +void cosmos::OnSearch( wxCommandEvent& event ) +{ +// TODO: Implement OnSearch +} + +void cosmos::OnOptionsProg( wxCommandEvent& event ) +{ + fenetre_options->Show(true); +} diff --git a/CosMoS/cosmos.fbp b/CosMoS/cosmos.fbp new file mode 100644 index 0000000..f42ae50 --- /dev/null +++ b/CosMoS/cosmos.fbp @@ -0,0 +1,517 @@ + + + + + + C++ + 1 + source_name + 0 + UTF-8 + connect + cosmosGUI + 1000 + none + 0 + cosmos + + . + + 1 + 1 + 0 + 0 + + + wxBOTH + + 1 + 1 + impl_virtual + + + + 0 + wxID_ANY + + + cosmosGUI + + 1191,473 + wxDEFAULT_FRAME_STYLE|wxMAXIMIZE + + CosMoS + + + wxFILTER_NONE + wxDefaultValidator + + + + wxTAB_TRAVERSAL + 1 + + + + OnQuit + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + + + 0 + wxID_ANY + MyMenuBar + + + menubar + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Fichier + menu_Fichier + protected + + icons/import.png; Load From File + 0 + 1 + + wxID_OPEN + wxITEM_NORMAL + Importer base + menuitem_Import + none + + + OnImport + + + + icons/export.png; Load From File + 0 + 1 + + wxID_SAVE + wxITEM_NORMAL + Exporter base + menuitem_Export + none + + + OnExport + + + + m_separator1 + none + + + + 0 + 1 + + wxID_EXIT + wxITEM_NORMAL + Quitter + menuitem_Quit + none + + + OnQuit + + + + + Edition + menu_Edit + protected + + icons/optionsgales.png; Load From File + 0 + 1 + + wxID_PROPERTIES + wxITEM_NORMAL + Options générales + menuitem_Optionsprog + none + + + OnOptionsProg + + + + + Aide + menu_Aide + protected + + + + + + + 1 + 1 + + + 0 + wxID_ANY + + + + toolbar + 1 + protected + + 5 + + wxTB_FLAT|wxTB_HORIZONTAL + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + icons/import.png; Load From File + wxID_OPEN + wxITEM_NORMAL + Importer base + tool_Import + + + + OnImport + + + + + + icons/export.png; Load From File + wxID_SAVE + wxITEM_NORMAL + Exporter base + tool_Export + + + + OnExport + + + + + + + icons/play.png; Load From File + wxID_NEW + wxITEM_NORMAL + Lancer + tool_Start + + Lancer la recherche + + OnStart + + + + + + icons/optionsrche.png; Load From File + wxID_FIND + wxITEM_NORMAL + Options + tool_Options + + Options de recherche + + OnOptionsRche + + + + + + + icons/correc.png; Load From File + wxID_DUPLICATE + wxITEM_NORMAL + Corrections + tool_Corrections + + + + OnCorrections + + + + + + + + 1 + + 1 + 1 + + + 0 + wxID_ANY + + + searchctrl + protected + + 1 + + wxTE_PROCESS_ENTER + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + OnSearch + + + + + + bSizer2 + wxVERTICAL + none + + 5 + wxALL|wxEXPAND + 1 + + 0 + 0 + + + + wxALIGN_LEFT + + wxALIGN_TOP + wxALIGN_CENTRE + 30 + "Publication ?" "Consultant associé ?" "Publication CHU ?" "N° Dossier" "Nom(s) demandeur(s)" "Prénom(s) demandeur(s)" "Nom(s) responsable(s)" "Thème" "Date dernière consultation" "Résultats" + wxALIGN_CENTRE + 10 + 83,125,107,68,135,154,139,49,161,64 + + 1 + 0 + 1 + 1 + 0 + 1 + 1 + + + + 1 + 0 + wxID_ANY + + + + 0 + 0 + + + grid_Consults + protected + + wxALIGN_CENTRE + 80 + + wxALIGN_CENTRE + + 0 + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CosMoS/cosmos.h b/CosMoS/cosmos.h new file mode 100644 index 0000000..dd6f88c --- /dev/null +++ b/CosMoS/cosmos.h @@ -0,0 +1,37 @@ +#ifndef __cosmos__ +#define __cosmos__ + +/** +@file +Subclass of cosmosGUI, which is generated by wxFormBuilder. +*/ + +#include "cosmosGUI.h" +#include "options.h" +#include "bdd.h" + +//// end generated include + +/** Implementing cosmosGUI */ +class cosmos : public cosmosGUI +{ + protected: + options* fenetre_options; + class_bdd* bdd; + // Handlers for cosmosGUI events. + void OnImport( wxCommandEvent& event ); + void OnExport( wxCommandEvent& event ); + void OnQuit( wxCommandEvent& event ); + void OnStart( wxCommandEvent& event ); + void OnOptionsRche( wxCommandEvent& event ); + void OnOptionsProg( wxCommandEvent& event ); + void OnCorrections( wxCommandEvent& event ); + void OnSearch( wxCommandEvent& event ); + public: + /** Constructor */ + cosmos( wxWindow* parent ); + //// end generated class members + +}; + +#endif // __cosmos__ diff --git a/CosMoS/cosmosGUI.cpp b/CosMoS/cosmosGUI.cpp new file mode 100644 index 0000000..d63f970 --- /dev/null +++ b/CosMoS/cosmosGUI.cpp @@ -0,0 +1,162 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Sep 15 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#include "cosmosGUI.h" + +/////////////////////////////////////////////////////////////////////////// + +cosmosGUI::cosmosGUI( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style ) +{ + this->SetSizeHints( wxDefaultSize, wxDefaultSize ); + + menubar = new wxMenuBar( 0 ); + menu_Fichier = new wxMenu(); + wxMenuItem* menuitem_Import; + menuitem_Import = new wxMenuItem( menu_Fichier, wxID_OPEN, wxString( wxT("Importer base") ) , wxEmptyString, wxITEM_NORMAL ); + #ifdef __WXMSW__ + menuitem_Import->SetBitmaps( wxBitmap( wxT("icons/import.png"), wxBITMAP_TYPE_ANY ) ); + #elif defined( __WXGTK__ ) + menuitem_Import->SetBitmap( wxBitmap( wxT("icons/import.png"), wxBITMAP_TYPE_ANY ) ); + #endif + menu_Fichier->Append( menuitem_Import ); + + wxMenuItem* menuitem_Export; + menuitem_Export = new wxMenuItem( menu_Fichier, wxID_SAVE, wxString( wxT("Exporter base") ) , wxEmptyString, wxITEM_NORMAL ); + #ifdef __WXMSW__ + menuitem_Export->SetBitmaps( wxBitmap( wxT("icons/export.png"), wxBITMAP_TYPE_ANY ) ); + #elif defined( __WXGTK__ ) + menuitem_Export->SetBitmap( wxBitmap( wxT("icons/export.png"), wxBITMAP_TYPE_ANY ) ); + #endif + menu_Fichier->Append( menuitem_Export ); + + wxMenuItem* m_separator1; + m_separator1 = menu_Fichier->AppendSeparator(); + + wxMenuItem* menuitem_Quit; + menuitem_Quit = new wxMenuItem( menu_Fichier, wxID_EXIT, wxString( wxT("Quitter") ) , wxEmptyString, wxITEM_NORMAL ); + menu_Fichier->Append( menuitem_Quit ); + + menubar->Append( menu_Fichier, wxT("Fichier") ); + + menu_Edit = new wxMenu(); + wxMenuItem* menuitem_Optionsprog; + menuitem_Optionsprog = new wxMenuItem( menu_Edit, wxID_PROPERTIES, wxString( wxT("Options générales") ) , wxEmptyString, wxITEM_NORMAL ); + #ifdef __WXMSW__ + menuitem_Optionsprog->SetBitmaps( wxBitmap( wxT("icons/optionsgales.png"), wxBITMAP_TYPE_ANY ) ); + #elif defined( __WXGTK__ ) + menuitem_Optionsprog->SetBitmap( wxBitmap( wxT("icons/optionsgales.png"), wxBITMAP_TYPE_ANY ) ); + #endif + menu_Edit->Append( menuitem_Optionsprog ); + + menubar->Append( menu_Edit, wxT("Edition") ); + + menu_Aide = new wxMenu(); + menubar->Append( menu_Aide, wxT("Aide") ); + + this->SetMenuBar( menubar ); + + toolbar = this->CreateToolBar( wxTB_FLAT|wxTB_HORIZONTAL, wxID_ANY ); + toolbar->AddTool( wxID_OPEN, wxT("Importer base"), wxBitmap( wxT("icons/import.png"), wxBITMAP_TYPE_ANY ), wxNullBitmap, wxITEM_NORMAL, wxEmptyString, wxEmptyString ); + toolbar->AddTool( wxID_SAVE, wxT("Exporter base"), wxBitmap( wxT("icons/export.png"), wxBITMAP_TYPE_ANY ), wxNullBitmap, wxITEM_NORMAL, wxEmptyString, wxEmptyString ); + toolbar->AddSeparator(); + toolbar->AddTool( wxID_NEW, wxT("Lancer"), wxBitmap( wxT("icons/play.png"), wxBITMAP_TYPE_ANY ), wxNullBitmap, wxITEM_NORMAL, wxT("Lancer la recherche"), wxEmptyString ); + toolbar->AddTool( wxID_FIND, wxT("Options"), wxBitmap( wxT("icons/optionsrche.png"), wxBITMAP_TYPE_ANY ), wxNullBitmap, wxITEM_NORMAL, wxT("Options de recherche"), wxEmptyString ); + toolbar->AddSeparator(); + toolbar->AddTool( wxID_DUPLICATE, wxT("Corrections"), wxBitmap( wxT("icons/correc.png"), wxBITMAP_TYPE_ANY ), wxNullBitmap, wxITEM_NORMAL, wxEmptyString, wxEmptyString ); + toolbar->AddSeparator(); + searchctrl = new wxSearchCtrl( toolbar, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER ); + #ifndef __WXMAC__ + searchctrl->ShowSearchButton( true ); + #endif + searchctrl->ShowCancelButton( true ); + toolbar->AddControl( searchctrl ); + toolbar->Realize(); + + wxBoxSizer* bSizer2; + bSizer2 = new wxBoxSizer( wxVERTICAL ); + + grid_Consults = new wxGrid( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 ); + + // Grid + grid_Consults->CreateGrid( 0, 10 ); + grid_Consults->EnableEditing( true ); + grid_Consults->EnableGridLines( true ); + grid_Consults->EnableDragGridSize( true ); + grid_Consults->SetMargins( 0, 0 ); + + // Columns + grid_Consults->SetColSize( 0, 83 ); + grid_Consults->SetColSize( 1, 125 ); + grid_Consults->SetColSize( 2, 107 ); + grid_Consults->SetColSize( 3, 68 ); + grid_Consults->SetColSize( 4, 135 ); + grid_Consults->SetColSize( 5, 154 ); + grid_Consults->SetColSize( 6, 139 ); + grid_Consults->SetColSize( 7, 49 ); + grid_Consults->SetColSize( 8, 161 ); + grid_Consults->SetColSize( 9, 64 ); + grid_Consults->EnableDragColMove( false ); + grid_Consults->EnableDragColSize( true ); + grid_Consults->SetColLabelSize( 30 ); + grid_Consults->SetColLabelValue( 0, wxT("Publication ?") ); + grid_Consults->SetColLabelValue( 1, wxT("Consultant associé ?") ); + grid_Consults->SetColLabelValue( 2, wxT("Publication CHU ?") ); + grid_Consults->SetColLabelValue( 3, wxT("N° Dossier") ); + grid_Consults->SetColLabelValue( 4, wxT("Nom(s) demandeur(s)") ); + grid_Consults->SetColLabelValue( 5, wxT("Prénom(s) demandeur(s)") ); + grid_Consults->SetColLabelValue( 6, wxT("Nom(s) responsable(s)") ); + grid_Consults->SetColLabelValue( 7, wxT("Thème") ); + grid_Consults->SetColLabelValue( 8, wxT("Date dernière consultation") ); + grid_Consults->SetColLabelValue( 9, wxT("Résultats") ); + grid_Consults->SetColLabelAlignment( wxALIGN_CENTRE, wxALIGN_CENTRE ); + + // Rows + grid_Consults->EnableDragRowSize( false ); + grid_Consults->SetRowLabelSize( 80 ); + grid_Consults->SetRowLabelAlignment( wxALIGN_CENTRE, wxALIGN_CENTRE ); + + // Label Appearance + + // Cell Defaults + grid_Consults->SetDefaultCellAlignment( wxALIGN_LEFT, wxALIGN_TOP ); + bSizer2->Add( grid_Consults, 1, wxALL|wxEXPAND, 5 ); + + this->SetSizer( bSizer2 ); + this->Layout(); + + this->Centre( wxBOTH ); + + // Connect Events + this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( cosmosGUI::OnQuit ) ); + this->Connect( menuitem_Import->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnImport ) ); + this->Connect( menuitem_Export->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnExport ) ); + this->Connect( menuitem_Quit->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnQuit ) ); + this->Connect( menuitem_Optionsprog->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnOptionsProg ) ); + this->Connect( wxID_OPEN, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnImport ) ); + this->Connect( wxID_SAVE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnExport ) ); + this->Connect( wxID_NEW, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnStart ) ); + this->Connect( wxID_FIND, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnOptionsRche ) ); + this->Connect( wxID_DUPLICATE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnCorrections ) ); + searchctrl->Connect( wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( cosmosGUI::OnSearch ), NULL, this ); +} + +cosmosGUI::~cosmosGUI() +{ + // Disconnect Events + this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( cosmosGUI::OnQuit ) ); + this->Disconnect( wxID_OPEN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnImport ) ); + this->Disconnect( wxID_SAVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnExport ) ); + this->Disconnect( wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnQuit ) ); + this->Disconnect( wxID_PROPERTIES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( cosmosGUI::OnOptionsProg ) ); + this->Disconnect( wxID_OPEN, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnImport ) ); + this->Disconnect( wxID_SAVE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnExport ) ); + this->Disconnect( wxID_NEW, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnStart ) ); + this->Disconnect( wxID_FIND, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnOptionsRche ) ); + this->Disconnect( wxID_DUPLICATE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( cosmosGUI::OnCorrections ) ); + searchctrl->Disconnect( wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( cosmosGUI::OnSearch ), NULL, this ); + +} diff --git a/CosMoS/cosmosGUI.h b/CosMoS/cosmosGUI.h new file mode 100644 index 0000000..2f6c4c8 --- /dev/null +++ b/CosMoS/cosmosGUI.h @@ -0,0 +1,64 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Sep 15 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#ifndef __cosmosGUI__ +#define __cosmosGUI__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +/// Class cosmosGUI +/////////////////////////////////////////////////////////////////////////////// +class cosmosGUI : public wxFrame +{ + private: + + protected: + wxMenuBar* menubar; + wxMenu* menu_Fichier; + wxMenu* menu_Edit; + wxMenu* menu_Aide; + wxToolBar* toolbar; + wxSearchCtrl* searchctrl; + wxGrid* grid_Consults; + + // Virtual event handlers, overide them in your derived class + virtual void OnQuit( wxCloseEvent& event ) { event.Skip(); } + virtual void OnImport( wxCommandEvent& event ) { event.Skip(); } + virtual void OnExport( wxCommandEvent& event ) { event.Skip(); } + virtual void OnQuit( wxCommandEvent& event ) { event.Skip(); } + virtual void OnOptionsProg( wxCommandEvent& event ) { event.Skip(); } + virtual void OnStart( wxCommandEvent& event ) { event.Skip(); } + virtual void OnOptionsRche( wxCommandEvent& event ) { event.Skip(); } + virtual void OnCorrections( wxCommandEvent& event ) { event.Skip(); } + virtual void OnSearch( wxCommandEvent& event ) { event.Skip(); } + + + public: + + cosmosGUI( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxT("CosMoS"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 1191,473 ), long style = wxDEFAULT_FRAME_STYLE|wxMAXIMIZE|wxTAB_TRAVERSAL ); + ~cosmosGUI(); + +}; + +#endif //__cosmosGUI__ diff --git a/CosMoS/main.cpp b/CosMoS/main.cpp new file mode 100644 index 0000000..6bdafb3 --- /dev/null +++ b/CosMoS/main.cpp @@ -0,0 +1,17 @@ +#include "wx/app.h" +#include "cosmos.h" + +class cosmosApp: public wxApp +{ +public : + bool OnInit(); +}; + +IMPLEMENT_APP (cosmosApp) + +bool cosmosApp::OnInit() +{ + cosmos* fenetre = new cosmos(NULL); + fenetre -> Show(TRUE); + return TRUE; +} \ No newline at end of file diff --git a/CosMoS/options.cpp b/CosMoS/options.cpp new file mode 100644 index 0000000..1046417 --- /dev/null +++ b/CosMoS/options.cpp @@ -0,0 +1,67 @@ +#include "options.h" + +options::options( wxWindow* parent ) +: +dialog_Options( parent ) +{ + configuration = new config(this); + dirpicker_dbpath->SetPath(configuration->GetDbpath()); + checkbox_proxy->SetValue(configuration->IsUseproxy()); + textctrl_url->SetValue(configuration->GetProxyurl()); + spinctrl_port->SetValue(configuration->GetProxyport()); + updatefields(); +} + +options::~options() +{ + delete configuration; +} + +void options::OnCancel( wxCloseEvent& event ) +{ + dirpicker_dbpath->SetPath(configuration->GetDbpath()); + checkbox_proxy->SetValue(configuration->IsUseproxy()); + textctrl_url->SetValue(configuration->GetProxyurl()); + spinctrl_port->SetValue(configuration->GetProxyport()); + this->Hide(); + updatefields(); +} + +void options::OnCancel( wxCommandEvent& event ) +{ + dirpicker_dbpath->SetPath(configuration->GetDbpath()); + checkbox_proxy->SetValue(configuration->IsUseproxy()); + textctrl_url->SetValue(configuration->GetProxyurl()); + spinctrl_port->SetValue(configuration->GetProxyport()); + this->Hide(); + updatefields(); +} + +void options::OnOk( wxCommandEvent& event ) +{ + configuration->SetDbpath(dirpicker_dbpath->GetPath()); + configuration->SetUseproxy(checkbox_proxy->GetValue()); + configuration->SetProxyurl(textctrl_url->GetValue()); + configuration->SetProxyport(spinctrl_port->GetValue()); + configuration->save(); + this->Hide(); +} + +void options::OnToggleProxy( wxCommandEvent& event ) +{ + updatefields(); +} + +void options::updatefields() +{ + if (!checkbox_proxy->GetValue()) + { + textctrl_url->Disable(); + spinctrl_port->Disable(); + } + else + { + textctrl_url->Enable(); + spinctrl_port->Enable(); + } +} diff --git a/CosMoS/options.fbp b/CosMoS/options.fbp new file mode 100644 index 0000000..a098210 --- /dev/null +++ b/CosMoS/options.fbp @@ -0,0 +1,656 @@ + + + + + + C++ + 1 + source_name + 0 + UTF-8 + connect + optionsGUI + 1000 + none + 0 + CosMoS + + . + + 1 + 1 + 0 + 0 + + + wxBOTH + + 1 + 1 + impl_virtual + + + + 0 + wxID_ANY + + + dialog_Options + + 441,238 + wxDEFAULT_DIALOG_STYLE|wxSTAY_ON_TOP + + Options + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + OnCancel + + + + + + + + + + + + + + + + + + + + + + + + + + + + + verticalsizer + wxVERTICAL + none + + 5 + wxEXPAND + 1 + + wxID_ANY + Base de données + + sizer_db + wxVERTICAL + none + + + 5 + wxALL|wxEXPAND + 0 + + + + 1 + 1 + + + 0 + wxID_ANY + Chemin vers la base de données + + + statictext_dbpath + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + -1 + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL|wxEXPAND + 0 + + + + 1 + 1 + + + 0 + wxID_ANY + + Choisir le répertoire + + dirpicker_dbpath + protected + + + wxDIRP_DEFAULT_STYLE|wxDIRP_USE_TEXTCTRL + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxEXPAND + 1 + + wxID_ANY + Connexion + + sizer_connexion + wxVERTICAL + none + + + 5 + wxALL + 0 + + + 1 + + 1 + 1 + + + 0 + wxID_ANY + Utiliser un proxy ? + + + checkbox_proxy + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + OnToggleProxy + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_CENTER|wxEXPAND + 1 + + + horizontalsizer_proxy + wxHORIZONTAL + none + + 5 + wxALIGN_CENTER_VERTICAL|wxALL + 0 + + + + 1 + 1 + + + 0 + wxID_ANY + Adresse + + + statictext_url + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + -1 + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_CENTER_VERTICAL + 1 + + + + 1 + 1 + + + 0 + wxID_ANY + + 0 + + textctrl_url + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + www-proxy.chu-nancy.fr + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_CENTER_VERTICAL|wxALL + 0 + + + + 1 + 1 + + + 0 + wxID_ANY + Port + + + statictext_port + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + -1 + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_CENTER_VERTICAL|wxALL + 1 + + + + 1 + 1 + + + 0 + wxID_ANY + 8080 + 65536 + + 0 + + spinctrl_port + protected + + + wxSP_ARROW_KEYS + + + + wxFILTER_NONE + wxDefaultValidator + + 8080 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_RIGHT + 0 + + + horizontalsizer_boutons + wxHORIZONTAL + none + + 5 + wxALL|wxALIGN_CENTER_VERTICAL + 0 + + + + 1 + 0 + 1 + + + 0 + wxID_ANY + Annuler + + + bouton_annuler + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + OnCancel + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL|wxALIGN_CENTER_VERTICAL + 0 + + + + 1 + 0 + 1 + + + 0 + wxID_ANY + Valider + + + bouton_ok + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + OnOk + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CosMoS/options.h b/CosMoS/options.h new file mode 100644 index 0000000..dd80f22 --- /dev/null +++ b/CosMoS/options.h @@ -0,0 +1,34 @@ +#ifndef __options__ +#define __options__ + +/** +@file +Subclass of dialog_Options, which is generated by wxFormBuilder. +*/ + +#include "optionsGUI.h" +#include "config.h" + +//// end generated include + +/** Implementing dialog_Options */ +class options : public dialog_Options +{ +protected: + config* configuration; + // Handlers for dialog_Options events. + void OnToggleProxy( wxCommandEvent& event ); + void OnCancel( wxCloseEvent& event ); + void OnCancel( wxCommandEvent& event ); + void OnOk( wxCommandEvent& event ); + void updatefields(); +public: + /** Constructor */ + options( wxWindow* parent ); + ~options(); + config* GetConfiguration() {return configuration;} + //// end generated class members + +}; + +#endif // __options__ diff --git a/CosMoS/optionsGUI.cpp b/CosMoS/optionsGUI.cpp new file mode 100644 index 0000000..e5c1bb0 --- /dev/null +++ b/CosMoS/optionsGUI.cpp @@ -0,0 +1,90 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Sep 8 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#include "optionsGUI.h" + +/////////////////////////////////////////////////////////////////////////// + +dialog_Options::dialog_Options( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style ) +{ + this->SetSizeHints( wxDefaultSize, wxDefaultSize ); + + wxBoxSizer* verticalsizer; + verticalsizer = new wxBoxSizer( wxVERTICAL ); + + wxStaticBoxSizer* sizer_db; + sizer_db = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxT("Base de données") ), wxVERTICAL ); + + statictext_dbpath = new wxStaticText( this, wxID_ANY, wxT("Chemin vers la base de données"), wxDefaultPosition, wxDefaultSize, 0 ); + statictext_dbpath->Wrap( -1 ); + sizer_db->Add( statictext_dbpath, 0, wxALL|wxEXPAND, 5 ); + + dirpicker_dbpath = new wxDirPickerCtrl( this, wxID_ANY, wxEmptyString, wxT("Choisir le répertoire"), wxDefaultPosition, wxDefaultSize, wxDIRP_DEFAULT_STYLE|wxDIRP_USE_TEXTCTRL ); + sizer_db->Add( dirpicker_dbpath, 0, wxALL|wxEXPAND, 5 ); + + verticalsizer->Add( sizer_db, 1, wxEXPAND, 5 ); + + wxStaticBoxSizer* sizer_connexion; + sizer_connexion = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxT("Connexion") ), wxVERTICAL ); + + checkbox_proxy = new wxCheckBox( this, wxID_ANY, wxT("Utiliser un proxy ?"), wxDefaultPosition, wxDefaultSize, 0 ); + checkbox_proxy->SetValue(true); + sizer_connexion->Add( checkbox_proxy, 0, wxALL, 5 ); + + wxBoxSizer* horizontalsizer_proxy; + horizontalsizer_proxy = new wxBoxSizer( wxHORIZONTAL ); + + statictext_url = new wxStaticText( this, wxID_ANY, wxT("Adresse"), wxDefaultPosition, wxDefaultSize, 0 ); + statictext_url->Wrap( -1 ); + horizontalsizer_proxy->Add( statictext_url, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 ); + + textctrl_url = new wxTextCtrl( this, wxID_ANY, wxT("www-proxy.chu-nancy.fr"), wxDefaultPosition, wxDefaultSize, 0 ); + horizontalsizer_proxy->Add( textctrl_url, 1, wxALIGN_CENTER_VERTICAL, 5 ); + + statictext_port = new wxStaticText( this, wxID_ANY, wxT("Port"), wxDefaultPosition, wxDefaultSize, 0 ); + statictext_port->Wrap( -1 ); + horizontalsizer_proxy->Add( statictext_port, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 ); + + spinctrl_port = new wxSpinCtrl( this, wxID_ANY, wxT("8080"), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 65536, 8080 ); + horizontalsizer_proxy->Add( spinctrl_port, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5 ); + + sizer_connexion->Add( horizontalsizer_proxy, 1, wxALIGN_CENTER|wxEXPAND, 5 ); + + verticalsizer->Add( sizer_connexion, 1, wxEXPAND, 5 ); + + wxBoxSizer* horizontalsizer_boutons; + horizontalsizer_boutons = new wxBoxSizer( wxHORIZONTAL ); + + bouton_annuler = new wxButton( this, wxID_ANY, wxT("Annuler"), wxDefaultPosition, wxDefaultSize, 0 ); + horizontalsizer_boutons->Add( bouton_annuler, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 ); + + bouton_ok = new wxButton( this, wxID_ANY, wxT("Valider"), wxDefaultPosition, wxDefaultSize, 0 ); + horizontalsizer_boutons->Add( bouton_ok, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 ); + + verticalsizer->Add( horizontalsizer_boutons, 0, wxALIGN_RIGHT, 5 ); + + this->SetSizer( verticalsizer ); + this->Layout(); + + this->Centre( wxBOTH ); + + // Connect Events + this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( dialog_Options::OnCancel ) ); + checkbox_proxy->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( dialog_Options::OnToggleProxy ), NULL, this ); + bouton_annuler->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( dialog_Options::OnCancel ), NULL, this ); + bouton_ok->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( dialog_Options::OnOk ), NULL, this ); +} + +dialog_Options::~dialog_Options() +{ + // Disconnect Events + this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( dialog_Options::OnCancel ) ); + checkbox_proxy->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( dialog_Options::OnToggleProxy ), NULL, this ); + bouton_annuler->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( dialog_Options::OnCancel ), NULL, this ); + bouton_ok->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( dialog_Options::OnOk ), NULL, this ); + +} diff --git a/CosMoS/optionsGUI.h b/CosMoS/optionsGUI.h new file mode 100644 index 0000000..0339620 --- /dev/null +++ b/CosMoS/optionsGUI.h @@ -0,0 +1,61 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Sep 8 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#ifndef __optionsGUI__ +#define __optionsGUI__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +/// Class dialog_Options +/////////////////////////////////////////////////////////////////////////////// +class dialog_Options : public wxDialog +{ + private: + + protected: + wxStaticText* statictext_dbpath; + wxDirPickerCtrl* dirpicker_dbpath; + wxCheckBox* checkbox_proxy; + wxStaticText* statictext_url; + wxTextCtrl* textctrl_url; + wxStaticText* statictext_port; + wxSpinCtrl* spinctrl_port; + wxButton* bouton_annuler; + wxButton* bouton_ok; + + // Virtual event handlers, overide them in your derived class + virtual void OnCancel( wxCloseEvent& event ) { event.Skip(); } + virtual void OnToggleProxy( wxCommandEvent& event ) { event.Skip(); } + virtual void OnCancel( wxCommandEvent& event ) { event.Skip(); } + virtual void OnOk( wxCommandEvent& event ) { event.Skip(); } + + + public: + + dialog_Options( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxT("Options"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 441,238 ), long style = wxDEFAULT_DIALOG_STYLE|wxSTAY_ON_TOP ); + ~dialog_Options(); + +}; + +#endif //__optionsGUI__ diff --git a/Sante_Pub.workspace b/Sante_Pub.workspace new file mode 100644 index 0000000..52ceecf --- /dev/null +++ b/Sante_Pub.workspace @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Sante_Pub.workspace.maxime_wack b/Sante_Pub.workspace.maxime_wack new file mode 100644 index 0000000..1076c72 --- /dev/null +++ b/Sante_Pub.workspace.maxime_wack @@ -0,0 +1,6 @@ + + + + + + diff --git a/Sante_Pub.workspace.session b/Sante_Pub.workspace.session new file mode 100644 index 0000000..cd2e966 --- /dev/null +++ b/Sante_Pub.workspace.session @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/Sante_Pub.workspace.wack b/Sante_Pub.workspace.wack new file mode 100644 index 0000000..22b1c76 --- /dev/null +++ b/Sante_Pub.workspace.wack @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/grid/bitmap1.bmp b/grid/bitmap1.bmp new file mode 100644 index 0000000000000000000000000000000000000000..a9a567613347e3e32dca66a9a630df9cbfefe561 GIT binary patch literal 406 zcmZ?royN!j24z4}1BfM{n2~`6EUo~R2XO?T7%aiCp8BkSv2S Jq1IE40stId_;>&S literal 0 HcmV?d00001 diff --git a/grid/bitmap2.bmp b/grid/bitmap2.bmp new file mode 100644 index 0000000000000000000000000000000000000000..1d34142bc5493c5bc20951c5893ffee597b7707a GIT binary patch literal 238 zcmb7+F%H8Z5CjiIm%@-IP^GlQ2P~U5--%M@#rXoB1vhr*6?-FYVb}NHhCbkhBc8Cc zz%={f=VMrzEdBayX037H4b_YI8np5`hea2$l(};gSwf#(ijWs6lGh4}#MB$yL6xZS FtQ~A*9HRgL literal 0 HcmV?d00001 diff --git a/grid/grid.project b/grid/grid.project new file mode 100644 index 0000000..4143630 --- /dev/null +++ b/grid/grid.project @@ -0,0 +1,161 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + diff --git a/grid/griddemo.cpp b/grid/griddemo.cpp new file mode 100644 index 0000000..a999bad --- /dev/null +++ b/grid/griddemo.cpp @@ -0,0 +1,2263 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: griddemo.cpp +// Purpose: Grid control wxWidgets sample +// Author: Michael Bedward +// Modified by: Santiago Palacios +// RCS-ID: $Id$ +// Copyright: (c) Michael Bedward, Julian Smart, Vadim Zeitlin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + +// For compilers that support precompilation, includes "wx/wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#include "wx/colordlg.h" +#include "wx/fontdlg.h" +#include "wx/numdlg.h" +#include "wx/aboutdlg.h" + +#include "wx/grid.h" +#include "wx/headerctrl.h" +#include "wx/generic/gridctrl.h" +#include "wx/generic/grideditors.h" + +#include "griddemo.h" + +#ifndef wxHAS_IMAGES_IN_RESOURCES + #include "../sample.xpm" +#endif + +// Custom renderer that renders column header cells without borders and in +// italic +class CustomColumnHeaderRenderer : public wxGridColumnHeaderRenderer +{ +public: + CustomColumnHeaderRenderer(const wxColour& colFg, const wxColour& colBg) + : m_colFg(colFg), + m_colBg(colBg) + { + } + + virtual void DrawLabel(const wxGrid& WXUNUSED(grid), + wxDC& dc, + const wxString& value, + const wxRect& rect, + int horizAlign, + int vertAlign, + int WXUNUSED(textOrientation)) const + { + dc.SetTextForeground(m_colFg); + dc.SetFont(wxITALIC_FONT->Bold()); + dc.DrawLabel(value, rect, horizAlign | vertAlign); + } + + virtual void DrawBorder(const wxGrid& WXUNUSED(grid), + wxDC& dc, + wxRect& rect) const + { + dc.SetPen(*wxTRANSPARENT_PEN); + dc.SetBrush(wxBrush(m_colBg)); + dc.DrawRectangle(rect); + } + +private: + const wxColour m_colFg, m_colBg; + + wxDECLARE_NO_COPY_CLASS(CustomColumnHeaderRenderer); +}; + +// And a custom attributes provider which uses custom column header renderer +// defined above +class CustomColumnHeadersProvider : public wxGridCellAttrProvider +{ +public: + // by default custom column renderer is not used, call + // UseCustomColHeaders() to enable it + CustomColumnHeadersProvider() + : m_customOddRenderer(*wxYELLOW, *wxBLUE), + m_customEvenRenderer(*wxWHITE, *wxBLACK), + m_useCustom(false) + { + } + + // enable or disable the use of custom renderer for column headers + void UseCustomColHeaders(bool use = true) { m_useCustom = use; } + +protected: + virtual const wxGridColumnHeaderRenderer& GetColumnHeaderRenderer(int col) + { + // if enabled, use custom renderers + if ( m_useCustom ) + { + // and use different ones for odd and even columns -- just to show + // that we can + return col % 2 ? m_customOddRenderer : m_customEvenRenderer; + } + + return wxGridCellAttrProvider::GetColumnHeaderRenderer(col); + } + +private: + CustomColumnHeaderRenderer m_customOddRenderer, + m_customEvenRenderer; + + bool m_useCustom; + + wxDECLARE_NO_COPY_CLASS(CustomColumnHeadersProvider); +}; + +// ---------------------------------------------------------------------------- +// wxWin macros +// ---------------------------------------------------------------------------- + +IMPLEMENT_APP( GridApp ) + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// GridApp +// ---------------------------------------------------------------------------- + +bool GridApp::OnInit() +{ + GridFrame *frame = new GridFrame; + frame->Show(true); + + return true; +} + +// ---------------------------------------------------------------------------- +// GridFrame +// ---------------------------------------------------------------------------- + +BEGIN_EVENT_TABLE( GridFrame, wxFrame ) + EVT_MENU( ID_TOGGLEROWLABELS, GridFrame::ToggleRowLabels ) + EVT_MENU( ID_TOGGLECOLLABELS, GridFrame::ToggleColLabels ) + EVT_MENU( ID_TOGGLEEDIT, GridFrame::ToggleEditing ) + EVT_MENU( ID_TOGGLEROWSIZING, GridFrame::ToggleRowSizing ) + EVT_MENU( ID_TOGGLECOLSIZING, GridFrame::ToggleColSizing ) + EVT_MENU( ID_TOGGLECOLMOVING, GridFrame::ToggleColMoving ) + EVT_MENU( ID_TOGGLEGRIDSIZING, GridFrame::ToggleGridSizing ) + EVT_MENU( ID_TOGGLEGRIDDRAGCELL, GridFrame::ToggleGridDragCell ) + EVT_MENU( ID_COLNATIVEHEADER, GridFrame::SetNativeColHeader ) + EVT_MENU( ID_COLDEFAULTHEADER, GridFrame::SetDefaultColHeader ) + EVT_MENU( ID_COLCUSTOMHEADER, GridFrame::SetCustomColHeader ) + EVT_MENU( ID_TOGGLEGRIDLINES, GridFrame::ToggleGridLines ) + EVT_MENU( ID_AUTOSIZECOLS, GridFrame::AutoSizeCols ) + EVT_MENU( ID_CELLOVERFLOW, GridFrame::CellOverflow ) + EVT_MENU( ID_RESIZECELL, GridFrame::ResizeCell ) + EVT_MENU( ID_SETLABELCOLOUR, GridFrame::SetLabelColour ) + EVT_MENU( ID_SETLABELTEXTCOLOUR, GridFrame::SetLabelTextColour ) + EVT_MENU( ID_SETLABEL_FONT, GridFrame::SetLabelFont ) + EVT_MENU( ID_ROWLABELHORIZALIGN, GridFrame::SetRowLabelHorizAlignment ) + EVT_MENU( ID_ROWLABELVERTALIGN, GridFrame::SetRowLabelVertAlignment ) + EVT_MENU( ID_COLLABELHORIZALIGN, GridFrame::SetColLabelHorizAlignment ) + EVT_MENU( ID_COLLABELVERTALIGN, GridFrame::SetColLabelVertAlignment ) + EVT_MENU( ID_GRIDLINECOLOUR, GridFrame::SetGridLineColour ) + EVT_MENU( ID_INSERTROW, GridFrame::InsertRow ) + EVT_MENU( ID_INSERTCOL, GridFrame::InsertCol ) + EVT_MENU( ID_DELETEROW, GridFrame::DeleteSelectedRows ) + EVT_MENU( ID_DELETECOL, GridFrame::DeleteSelectedCols ) + EVT_MENU( ID_CLEARGRID, GridFrame::ClearGrid ) + EVT_MENU( ID_SELCELLS, GridFrame::SelectCells ) + EVT_MENU( ID_SELROWS, GridFrame::SelectRows ) + EVT_MENU( ID_SELCOLS, GridFrame::SelectCols ) + EVT_MENU( ID_SELROWSORCOLS, GridFrame::SelectRowsOrCols ) + + EVT_MENU( ID_SET_CELL_FG_COLOUR, GridFrame::SetCellFgColour ) + EVT_MENU( ID_SET_CELL_BG_COLOUR, GridFrame::SetCellBgColour ) + + EVT_MENU( wxID_ABOUT, GridFrame::About ) + EVT_MENU( wxID_EXIT, GridFrame::OnQuit ) + EVT_MENU( ID_VTABLE, GridFrame::OnVTable) + EVT_MENU( ID_BUGS_TABLE, GridFrame::OnBugsTable) + EVT_MENU( ID_TABULAR_TABLE, GridFrame::OnTabularTable) + + EVT_MENU( ID_DESELECT_CELL, GridFrame::DeselectCell) + EVT_MENU( ID_DESELECT_COL, GridFrame::DeselectCol) + EVT_MENU( ID_DESELECT_ROW, GridFrame::DeselectRow) + EVT_MENU( ID_DESELECT_ALL, GridFrame::DeselectAll) + EVT_MENU( ID_SELECT_CELL, GridFrame::SelectCell) + EVT_MENU( ID_SELECT_COL, GridFrame::SelectCol) + EVT_MENU( ID_SELECT_ROW, GridFrame::SelectRow) + EVT_MENU( ID_SELECT_ALL, GridFrame::SelectAll) + EVT_MENU( ID_SELECT_UNSELECT, GridFrame::OnAddToSelectToggle) + + EVT_MENU( ID_SIZE_ROW, GridFrame::AutoSizeRow ) + EVT_MENU( ID_SIZE_COL, GridFrame::AutoSizeCol ) + EVT_MENU( ID_SIZE_ROW_LABEL, GridFrame::AutoSizeRowLabel ) + EVT_MENU( ID_SIZE_COL_LABEL, GridFrame::AutoSizeColLabel ) + EVT_MENU( ID_SIZE_LABELS_COL, GridFrame::AutoSizeLabelsCol ) + EVT_MENU( ID_SIZE_LABELS_ROW, GridFrame::AutoSizeLabelsRow ) + EVT_MENU( ID_SIZE_GRID, GridFrame::AutoSizeTable ) + + EVT_MENU( ID_SET_HIGHLIGHT_WIDTH, GridFrame::OnSetHighlightWidth) + EVT_MENU( ID_SET_RO_HIGHLIGHT_WIDTH, GridFrame::OnSetROHighlightWidth) + + EVT_MENU( wxID_PRINT, GridFrame::OnGridRender ) + EVT_MENU( ID_RENDER_COORDS, GridFrame::OnGridRender ) + + EVT_GRID_LABEL_LEFT_CLICK( GridFrame::OnLabelLeftClick ) + EVT_GRID_CELL_LEFT_CLICK( GridFrame::OnCellLeftClick ) + EVT_GRID_ROW_SIZE( GridFrame::OnRowSize ) + EVT_GRID_COL_SIZE( GridFrame::OnColSize ) + EVT_GRID_SELECT_CELL( GridFrame::OnSelectCell ) + EVT_GRID_RANGE_SELECT( GridFrame::OnRangeSelected ) + EVT_GRID_CELL_CHANGING( GridFrame::OnCellValueChanging ) + EVT_GRID_CELL_CHANGED( GridFrame::OnCellValueChanged ) + EVT_GRID_CELL_BEGIN_DRAG( GridFrame::OnCellBeginDrag ) + + EVT_GRID_EDITOR_SHOWN( GridFrame::OnEditorShown ) + EVT_GRID_EDITOR_HIDDEN( GridFrame::OnEditorHidden ) +END_EVENT_TABLE() + + +GridFrame::GridFrame() + : wxFrame( (wxFrame *)NULL, wxID_ANY, wxT("wxWidgets grid class demo"), + wxDefaultPosition, + wxDefaultSize ) +{ + SetIcon(wxICON(sample)); + + wxMenu *fileMenu = new wxMenu; + fileMenu->Append( ID_VTABLE, wxT("&Virtual table test\tCtrl-V")); + fileMenu->Append( ID_BUGS_TABLE, wxT("&Bugs table test\tCtrl-B")); + fileMenu->Append( ID_TABULAR_TABLE, wxT("&Tabular table test\tCtrl-T")); + fileMenu->AppendSeparator(); + + wxMenu* setupMenu = new wxMenu; + wxMenuItem* item; + item = setupMenu->AppendCheckItem( ID_RENDER_ROW_LABEL, + "Render row labels" ); + item->Check(); + item = setupMenu->AppendCheckItem( ID_RENDER_COL_LABEL, + "Render column labels" ); + item->Check(); + item = setupMenu->AppendCheckItem( ID_RENDER_GRID_LINES, + "Render grid cell lines" ); + item->Check(); + item = setupMenu->AppendCheckItem( ID_RENDER_GRID_BORDER, + "Render border" ); + item->Check(); + item = setupMenu->AppendCheckItem( ID_RENDER_SELECT_HLIGHT, + "Render selection highlight" ); + setupMenu->AppendSeparator(); + setupMenu->AppendCheckItem( ID_RENDER_LOMETRIC, + "Use LOMETRIC mapping mode" ); + setupMenu->AppendCheckItem( ID_RENDER_DEFAULT_SIZE, + "Use wxDefaultSize" ); + setupMenu->AppendCheckItem( ID_RENDER_MARGIN, + "Logical 50 unit margin" ); + setupMenu->AppendCheckItem( ID_RENDER_ZOOM, + "Zoom 125%" ); + + fileMenu->AppendSubMenu( setupMenu, "Render setup" ); + fileMenu->Append( wxID_PRINT, "Render" ); + fileMenu->Append( ID_RENDER_COORDS, "Render G5:P30" ); + + fileMenu->AppendSeparator(); + fileMenu->Append( wxID_EXIT, wxT("E&xit\tAlt-X") ); + + wxMenu *viewMenu = new wxMenu; + viewMenu->AppendCheckItem(ID_TOGGLEROWLABELS, "&Row labels"); + viewMenu->AppendCheckItem(ID_TOGGLECOLLABELS, "&Col labels"); + viewMenu->AppendCheckItem(ID_TOGGLEEDIT,"&Editable"); + viewMenu->AppendCheckItem(ID_TOGGLEROWSIZING, "Ro&w drag-resize"); + viewMenu->AppendCheckItem(ID_TOGGLECOLSIZING, "C&ol drag-resize"); + viewMenu->AppendCheckItem(ID_TOGGLECOLMOVING, "Col drag-&move"); + viewMenu->AppendCheckItem(ID_TOGGLEGRIDSIZING, "&Grid drag-resize"); + viewMenu->AppendCheckItem(ID_TOGGLEGRIDDRAGCELL, "&Grid drag-cell"); + viewMenu->AppendCheckItem(ID_TOGGLEGRIDLINES, "&Grid Lines"); + viewMenu->AppendCheckItem(ID_SET_HIGHLIGHT_WIDTH, "&Set Cell Highlight Width..."); + viewMenu->AppendCheckItem(ID_SET_RO_HIGHLIGHT_WIDTH, "&Set Cell RO Highlight Width..."); + viewMenu->AppendCheckItem(ID_AUTOSIZECOLS, "&Auto-size cols"); + viewMenu->AppendCheckItem(ID_CELLOVERFLOW, "&Overflow cells"); + viewMenu->AppendCheckItem(ID_RESIZECELL, "&Resize cell (7,1)"); + + wxMenu *rowLabelMenu = new wxMenu; + + viewMenu->Append( ID_ROWLABELALIGN, wxT("R&ow label alignment"), + rowLabelMenu, + wxT("Change alignment of row labels") ); + + rowLabelMenu->AppendRadioItem( ID_ROWLABELHORIZALIGN, wxT("&Horizontal") ); + rowLabelMenu->AppendRadioItem( ID_ROWLABELVERTALIGN, wxT("&Vertical") ); + + wxMenu *colLabelMenu = new wxMenu; + + viewMenu->Append( ID_COLLABELALIGN, wxT("Col l&abel alignment"), + colLabelMenu, + wxT("Change alignment of col labels") ); + + colLabelMenu->AppendRadioItem( ID_COLLABELHORIZALIGN, wxT("&Horizontal") ); + colLabelMenu->AppendRadioItem( ID_COLLABELVERTALIGN, wxT("&Vertical") ); + + wxMenu *colHeaderMenu = new wxMenu; + + viewMenu->Append( ID_ROWLABELALIGN, wxT("Col header style"), + colHeaderMenu, + wxT("Change style of col header") ); + + colHeaderMenu->AppendRadioItem( ID_COLDEFAULTHEADER, wxT("&Default") ); + colHeaderMenu->AppendRadioItem( ID_COLNATIVEHEADER, wxT("&Native") ); + colHeaderMenu->AppendRadioItem( ID_COLCUSTOMHEADER, wxT("&Custom") ); + + + wxMenu *colMenu = new wxMenu; + colMenu->Append( ID_SETLABELCOLOUR, wxT("Set &label colour...") ); + colMenu->Append( ID_SETLABELTEXTCOLOUR, wxT("Set label &text colour...") ); + colMenu->Append( ID_SETLABEL_FONT, wxT("Set label fo&nt...") ); + colMenu->Append( ID_GRIDLINECOLOUR, wxT("&Grid line colour...") ); + colMenu->Append( ID_SET_CELL_FG_COLOUR, wxT("Set cell &foreground colour...") ); + colMenu->Append( ID_SET_CELL_BG_COLOUR, wxT("Set cell &background colour...") ); + + wxMenu *editMenu = new wxMenu; + editMenu->Append( ID_INSERTROW, wxT("Insert &row") ); + editMenu->Append( ID_INSERTCOL, wxT("Insert &column") ); + editMenu->Append( ID_DELETEROW, wxT("Delete selected ro&ws") ); + editMenu->Append( ID_DELETECOL, wxT("Delete selected co&ls") ); + editMenu->Append( ID_CLEARGRID, wxT("Cl&ear grid cell contents") ); + + wxMenu *selectMenu = new wxMenu; + selectMenu->Append( ID_SELECT_UNSELECT, wxT("Add new cells to the selection"), + wxT("When off, old selection is deselected before ") + wxT("selecting the new cells"), wxITEM_CHECK ); + selectMenu->AppendSeparator(); + selectMenu->Append( ID_SELECT_ALL, wxT("Select all")); + selectMenu->Append( ID_SELECT_ROW, wxT("Select row 2")); + selectMenu->Append( ID_SELECT_COL, wxT("Select col 2")); + selectMenu->Append( ID_SELECT_CELL, wxT("Select cell (3, 1)")); + selectMenu->AppendSeparator(); + selectMenu->Append( ID_DESELECT_ALL, wxT("Deselect all")); + selectMenu->Append( ID_DESELECT_ROW, wxT("Deselect row 2")); + selectMenu->Append( ID_DESELECT_COL, wxT("Deselect col 2")); + selectMenu->Append( ID_DESELECT_CELL, wxT("Deselect cell (3, 1)")); + wxMenu *selectionMenu = new wxMenu; + selectMenu->Append( ID_CHANGESEL, wxT("Change &selection mode"), + selectionMenu, + wxT("Change selection mode") ); + + selectionMenu->Append( ID_SELCELLS, wxT("Select &cells") ); + selectionMenu->Append( ID_SELROWS, wxT("Select &rows") ); + selectionMenu->Append( ID_SELCOLS, wxT("Select col&umns") ); + selectionMenu->Append( ID_SELROWSORCOLS, wxT("Select rows &or columns") ); + + wxMenu *autosizeMenu = new wxMenu; + autosizeMenu->Append( ID_SIZE_ROW, wxT("Selected &row data") ); + autosizeMenu->Append( ID_SIZE_COL, wxT("Selected &column data") ); + autosizeMenu->Append( ID_SIZE_ROW_LABEL, wxT("Selected row la&bel") ); + autosizeMenu->Append( ID_SIZE_COL_LABEL, wxT("Selected column &label") ); + autosizeMenu->Append( ID_SIZE_LABELS_COL, wxT("Column la&bels") ); + autosizeMenu->Append( ID_SIZE_LABELS_ROW, wxT("Row label&s") ); + autosizeMenu->Append( ID_SIZE_GRID, wxT("Entire &grid") ); + + wxMenu *helpMenu = new wxMenu; + helpMenu->Append( wxID_ABOUT, wxT("&About wxGrid demo") ); + + wxMenuBar *menuBar = new wxMenuBar; + menuBar->Append( fileMenu, wxT("&File") ); + menuBar->Append( viewMenu, wxT("&Grid") ); + menuBar->Append( colMenu, wxT("&Colours") ); + menuBar->Append( editMenu, wxT("&Edit") ); + menuBar->Append( selectMenu, wxT("&Select") ); + menuBar->Append( autosizeMenu, wxT("&Autosize") ); + menuBar->Append( helpMenu, wxT("&Help") ); + + SetMenuBar( menuBar ); + + m_addToSel = false; + + grid = new wxGrid( this, + wxID_ANY, + wxPoint( 0, 0 ), + wxSize( 400, 300 ) ); + + +#if wxUSE_LOG + int gridW = 600, gridH = 300; + int logW = gridW, logH = 100; + + logWin = new wxTextCtrl( this, + wxID_ANY, + wxEmptyString, + wxPoint( 0, gridH + 20 ), + wxSize( logW, logH ), + wxTE_MULTILINE ); + + logger = new wxLogTextCtrl( logWin ); + m_logOld = wxLog::SetActiveTarget( logger ); + wxLog::DisableTimestamp(); +#endif // wxUSE_LOG + + // this will create a grid and, by default, an associated grid + // table for strings + grid->CreateGrid( 0, 0 ); + + grid->GetTable()->SetAttrProvider(new CustomColumnHeadersProvider()); + + grid->AppendRows(100); + grid->AppendCols(100); + + int ir = grid->GetNumberRows(); + grid->DeleteRows(0, ir); + grid->AppendRows(ir); + + grid->SetRowSize( 0, 60 ); + grid->SetCellValue( 0, 0, wxT("Ctrl+Home\nwill go to\nthis cell") ); + + grid->SetCellValue( 0, 1, wxT("A long piece of text to demonstrate wrapping.") ); + grid->SetCellRenderer(0 , 1, new wxGridCellAutoWrapStringRenderer); + grid->SetCellEditor( 0, 1 , new wxGridCellAutoWrapStringEditor); + + grid->SetCellValue( 0, 2, wxT("Blah") ); + grid->SetCellValue( 0, 3, wxT("Read only") ); + grid->SetReadOnly( 0, 3 ); + + grid->SetCellValue( 0, 4, wxT("Can veto edit this cell") ); + + grid->SetCellValue( 0, 5, wxT("Press\nCtrl+arrow\nto skip over\ncells") ); + + grid->SetRowSize( 99, 60 ); + grid->SetCellValue( 99, 99, wxT("Ctrl+End\nwill go to\nthis cell") ); + grid->SetCellValue( 1, 0, wxT("This default cell will overflow into neighboring cells, but not if you turn overflow off.")); + + grid->SetCellTextColour(1, 2, *wxRED); + grid->SetCellBackgroundColour(1, 2, *wxGREEN); + + grid->SetCellValue( 1, 4, wxT("I'm in the middle")); + + grid->SetCellValue(2, 2, wxT("red")); + + grid->SetCellTextColour(2, 2, *wxRED); + grid->SetCellValue(3, 3, wxT("green on grey")); + grid->SetCellTextColour(3, 3, *wxGREEN); + grid->SetCellBackgroundColour(3, 3, *wxLIGHT_GREY); + + grid->SetCellValue(4, 4, wxT("a weird looking cell")); + grid->SetCellAlignment(4, 4, wxALIGN_CENTRE, wxALIGN_CENTRE); + grid->SetCellRenderer(4, 4, new MyGridCellRenderer); + + grid->SetCellRenderer(3, 0, new wxGridCellBoolRenderer); + grid->SetCellEditor(3, 0, new wxGridCellBoolEditor); + + wxGridCellAttr *attr; + attr = new wxGridCellAttr; + attr->SetTextColour(*wxBLUE); + grid->SetColAttr(5, attr); + attr = new wxGridCellAttr; + attr->SetBackgroundColour(*wxRED); + grid->SetRowAttr(5, attr); + + grid->SetCellValue(2, 4, wxT("a wider column")); + grid->SetColSize(4, 120); + grid->SetColMinimalWidth(4, 120); + + grid->SetCellTextColour(5, 8, *wxGREEN); + grid->SetCellValue(5, 8, wxT("Bg from row attr\nText col from cell attr")); + grid->SetCellValue(5, 5, wxT("Bg from row attr Text col from col attr and this text is so long that it covers over many many empty cells but is broken by one that isn't")); + + // Some numeric columns with different formatting. + grid->SetColFormatFloat(6); + grid->SetCellValue(0, 6, "Default\nfloat format"); + grid->SetCellValue(1, 6, wxString::Format(wxT("%g"), 3.1415)); + grid->SetCellValue(2, 6, wxString::Format(wxT("%g"), 1415.0)); + grid->SetCellValue(3, 6, wxString::Format(wxT("%g"), 12345.67890)); + + grid->SetColFormatFloat(7, 6, 2); + grid->SetCellValue(0, 7, "Width 6\nprecision 2"); + grid->SetCellValue(1, 7, wxString::Format(wxT("%g"), 3.1415)); + grid->SetCellValue(2, 7, wxString::Format(wxT("%g"), 1415.0)); + grid->SetCellValue(3, 7, wxString::Format(wxT("%g"), 12345.67890)); + + grid->SetColFormatCustom(8, + wxString::Format("%s:%i,%i,%s", wxGRID_VALUE_FLOAT, -1, 4, "g")); + grid->SetCellValue(0, 8, "Compact\nformat"); + grid->SetCellValue(1, 8, wxT("31415e-4")); + grid->SetCellValue(2, 8, wxT("1415")); + grid->SetCellValue(3, 8, wxT("123456789e-4")); + + grid->SetColFormatNumber(9); + grid->SetCellValue(0, 9, "Integer\ncolumn"); + grid->SetCellValue(1, 9, "17"); + grid->SetCellValue(2, 9, "0"); + grid->SetCellValue(3, 9, "-666"); + grid->SetCellAlignment(3, 9, wxALIGN_CENTRE, wxALIGN_TOP); + grid->SetCellValue(3, 10, "<- This numeric cell should be centred"); + + const wxString choices[] = + { + wxT("Please select a choice"), + wxT("This takes two cells"), + wxT("Another choice"), + }; + grid->SetCellEditor(4, 0, new wxGridCellChoiceEditor(WXSIZEOF(choices), choices)); + grid->SetCellSize(4, 0, 1, 2); + grid->SetCellValue(4, 0, choices[0]); + grid->SetCellOverflow(4, 0, false); + + grid->SetCellSize(7, 1, 3, 4); + grid->SetCellAlignment(7, 1, wxALIGN_CENTRE, wxALIGN_CENTRE); + grid->SetCellValue(7, 1, wxT("Big box!")); + + // create a separator-like row: it's grey and it's non-resizable + grid->DisableRowResize(10); + grid->SetRowSize(10, 30); + attr = new wxGridCellAttr; + attr->SetBackgroundColour(*wxLIGHT_GREY); + grid->SetRowAttr(10, attr); + grid->SetCellValue(10, 0, "You can't resize this row interactively -- try it"); + + // this does exactly nothing except testing that SetAttr() handles NULL + // attributes and does reference counting correctly + grid->SetAttr(11, 11, NULL); + grid->SetAttr(11, 11, new wxGridCellAttr); + grid->SetAttr(11, 11, NULL); + + wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL ); + topSizer->Add( grid, + 1, + wxEXPAND ); + +#if wxUSE_LOG + topSizer->Add( logWin, + 0, + wxEXPAND ); +#endif // wxUSE_LOG + + SetSizerAndFit( topSizer ); + + Centre(); + SetDefaults(); +} + + +GridFrame::~GridFrame() +{ +#if wxUSE_LOG + delete wxLog::SetActiveTarget(m_logOld); +#endif // wxUSE_LOG +} + + +void GridFrame::SetDefaults() +{ + GetMenuBar()->Check( ID_TOGGLEROWLABELS, true ); + GetMenuBar()->Check( ID_TOGGLECOLLABELS, true ); + GetMenuBar()->Check( ID_TOGGLEEDIT, true ); + GetMenuBar()->Check( ID_TOGGLEROWSIZING, true ); + GetMenuBar()->Check( ID_TOGGLECOLSIZING, true ); + GetMenuBar()->Check( ID_TOGGLECOLMOVING, false ); + GetMenuBar()->Check( ID_TOGGLEGRIDSIZING, true ); + GetMenuBar()->Check( ID_TOGGLEGRIDDRAGCELL, false ); + GetMenuBar()->Check( ID_TOGGLEGRIDLINES, true ); + GetMenuBar()->Check( ID_CELLOVERFLOW, true ); +} + + +void GridFrame::ToggleRowLabels( wxCommandEvent& WXUNUSED(ev) ) +{ + if ( GetMenuBar()->IsChecked( ID_TOGGLEROWLABELS ) ) + { + grid->SetRowLabelSize( grid->GetDefaultRowLabelSize() ); + } + else + { + grid->SetRowLabelSize( 0 ); + } +} + + +void GridFrame::ToggleColLabels( wxCommandEvent& WXUNUSED(ev) ) +{ + if ( GetMenuBar()->IsChecked( ID_TOGGLECOLLABELS ) ) + { + grid->SetColLabelSize( grid->GetDefaultColLabelSize() ); + } + else + { + grid->SetColLabelSize( 0 ); + } +} + + +void GridFrame::ToggleEditing( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableEditing( + GetMenuBar()->IsChecked( ID_TOGGLEEDIT ) ); +} + + +void GridFrame::ToggleRowSizing( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableDragRowSize( + GetMenuBar()->IsChecked( ID_TOGGLEROWSIZING ) ); +} + + +void GridFrame::ToggleColSizing( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableDragColSize( + GetMenuBar()->IsChecked( ID_TOGGLECOLSIZING ) ); +} + +void GridFrame::ToggleColMoving( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableDragColMove( + GetMenuBar()->IsChecked( ID_TOGGLECOLMOVING ) ); +} + +void GridFrame::ToggleGridSizing( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableDragGridSize( + GetMenuBar()->IsChecked( ID_TOGGLEGRIDSIZING ) ); +} + +void GridFrame::ToggleGridDragCell( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableDragCell( + GetMenuBar()->IsChecked( ID_TOGGLEGRIDDRAGCELL ) ); +} + +void GridFrame::SetNativeColHeader( wxCommandEvent& WXUNUSED(ev) ) +{ + CustomColumnHeadersProvider* provider = + static_cast(grid->GetTable()->GetAttrProvider()); + provider->UseCustomColHeaders(false); + grid->SetUseNativeColLabels(true); +} + +void GridFrame::SetCustomColHeader( wxCommandEvent& WXUNUSED(ev) ) +{ + CustomColumnHeadersProvider* provider = + static_cast(grid->GetTable()->GetAttrProvider()); + provider->UseCustomColHeaders(true); + grid->SetUseNativeColLabels(false); +} + +void GridFrame::SetDefaultColHeader( wxCommandEvent& WXUNUSED(ev) ) +{ + CustomColumnHeadersProvider* provider = + static_cast(grid->GetTable()->GetAttrProvider()); + provider->UseCustomColHeaders(false); + grid->SetUseNativeColLabels(false); +} + + +void GridFrame::ToggleGridLines( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->EnableGridLines( + GetMenuBar()->IsChecked( ID_TOGGLEGRIDLINES ) ); +} + +void GridFrame::OnSetHighlightWidth( wxCommandEvent& WXUNUSED(ev) ) +{ + wxString choices[] = { wxT("0"), wxT("1"), wxT("2"), wxT("3"), wxT("4"), wxT("5"), wxT("6"), wxT("7"), wxT("8"), wxT("9"), wxT("10")}; + + wxSingleChoiceDialog dlg(this, wxT("Choose the thickness of the highlight pen:"), + wxT("Pen Width"), 11, choices); + + int current = grid->GetCellHighlightPenWidth(); + dlg.SetSelection(current); + if (dlg.ShowModal() == wxID_OK) { + grid->SetCellHighlightPenWidth(dlg.GetSelection()); + } +} + +void GridFrame::OnSetROHighlightWidth( wxCommandEvent& WXUNUSED(ev) ) +{ + wxString choices[] = { wxT("0"), wxT("1"), wxT("2"), wxT("3"), wxT("4"), wxT("5"), wxT("6"), wxT("7"), wxT("8"), wxT("9"), wxT("10")}; + + wxSingleChoiceDialog dlg(this, wxT("Choose the thickness of the highlight pen:"), + wxT("Pen Width"), 11, choices); + + int current = grid->GetCellHighlightROPenWidth(); + dlg.SetSelection(current); + if (dlg.ShowModal() == wxID_OK) { + grid->SetCellHighlightROPenWidth(dlg.GetSelection()); + } +} + + + +void GridFrame::AutoSizeCols( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->AutoSizeColumns(); + grid->Refresh(); +} + +void GridFrame::CellOverflow( wxCommandEvent& ev ) +{ + grid->SetDefaultCellOverflow(ev.IsChecked()); + grid->Refresh(); +} + +void GridFrame::ResizeCell( wxCommandEvent& ev ) +{ + if (ev.IsChecked()) + grid->SetCellSize( 7, 1, 5, 5 ); + else + grid->SetCellSize( 7, 1, 1, 5 ); + grid->Refresh(); +} + +void GridFrame::SetLabelColour( wxCommandEvent& WXUNUSED(ev) ) +{ + wxColourDialog dlg( NULL ); + if ( dlg.ShowModal() == wxID_OK ) + { + wxColourData retData; + retData = dlg.GetColourData(); + wxColour colour = retData.GetColour(); + + grid->SetLabelBackgroundColour( colour ); + } +} + + +void GridFrame::SetLabelTextColour( wxCommandEvent& WXUNUSED(ev) ) +{ + wxColourDialog dlg( NULL ); + if ( dlg.ShowModal() == wxID_OK ) + { + wxColourData retData; + retData = dlg.GetColourData(); + wxColour colour = retData.GetColour(); + + grid->SetLabelTextColour( colour ); + } +} + +void GridFrame::SetLabelFont( wxCommandEvent& WXUNUSED(ev) ) +{ + wxFont font = wxGetFontFromUser(this); + if ( font.IsOk() ) + { + grid->SetLabelFont(font); + } +} + +void GridFrame::SetRowLabelHorizAlignment( wxCommandEvent& WXUNUSED(ev) ) +{ + int horiz, vert; + grid->GetRowLabelAlignment( &horiz, &vert ); + + switch ( horiz ) + { + case wxALIGN_LEFT: + horiz = wxALIGN_CENTRE; + break; + + case wxALIGN_CENTRE: + horiz = wxALIGN_RIGHT; + break; + + case wxALIGN_RIGHT: + horiz = wxALIGN_LEFT; + break; + } + + grid->SetRowLabelAlignment( horiz, vert ); +} + +void GridFrame::SetRowLabelVertAlignment( wxCommandEvent& WXUNUSED(ev) ) +{ + int horiz, vert; + grid->GetRowLabelAlignment( &horiz, &vert ); + + switch ( vert ) + { + case wxALIGN_TOP: + vert = wxALIGN_CENTRE; + break; + + case wxALIGN_CENTRE: + vert = wxALIGN_BOTTOM; + break; + + case wxALIGN_BOTTOM: + vert = wxALIGN_TOP; + break; + } + + grid->SetRowLabelAlignment( horiz, vert ); +} + + +void GridFrame::SetColLabelHorizAlignment( wxCommandEvent& WXUNUSED(ev) ) +{ + int horiz, vert; + grid->GetColLabelAlignment( &horiz, &vert ); + + switch ( horiz ) + { + case wxALIGN_LEFT: + horiz = wxALIGN_CENTRE; + break; + + case wxALIGN_CENTRE: + horiz = wxALIGN_RIGHT; + break; + + case wxALIGN_RIGHT: + horiz = wxALIGN_LEFT; + break; + } + + grid->SetColLabelAlignment( horiz, vert ); +} + + +void GridFrame::SetColLabelVertAlignment( wxCommandEvent& WXUNUSED(ev) ) +{ + int horiz, vert; + grid->GetColLabelAlignment( &horiz, &vert ); + + switch ( vert ) + { + case wxALIGN_TOP: + vert = wxALIGN_CENTRE; + break; + + case wxALIGN_CENTRE: + vert = wxALIGN_BOTTOM; + break; + + case wxALIGN_BOTTOM: + vert = wxALIGN_TOP; + break; + } + + grid->SetColLabelAlignment( horiz, vert ); +} + + +void GridFrame::SetGridLineColour( wxCommandEvent& WXUNUSED(ev) ) +{ + wxColourDialog dlg( NULL ); + if ( dlg.ShowModal() == wxID_OK ) + { + wxColourData retData; + retData = dlg.GetColourData(); + wxColour colour = retData.GetColour(); + + grid->SetGridLineColour( colour ); + } +} + + +void GridFrame::InsertRow( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->InsertRows( grid->GetGridCursorRow(), 1 ); +} + + +void GridFrame::InsertCol( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->InsertCols( grid->GetGridCursorCol(), 1 ); +} + + +void GridFrame::DeleteSelectedRows( wxCommandEvent& WXUNUSED(ev) ) +{ + if ( grid->IsSelection() ) + { + wxGridUpdateLocker locker(grid); + for ( int n = 0; n < grid->GetNumberRows(); ) + { + if ( grid->IsInSelection( n , 0 ) ) + grid->DeleteRows( n, 1 ); + else + n++; + } + } +} + + +void GridFrame::AutoSizeRow(wxCommandEvent& WXUNUSED(event)) +{ + wxGridUpdateLocker locker(grid); + const wxArrayInt sels = grid->GetSelectedRows(); + for ( size_t n = 0, count = sels.size(); n < count; n++ ) + { + grid->AutoSizeRow( sels[n], false ); + } +} + +void GridFrame::AutoSizeCol(wxCommandEvent& WXUNUSED(event)) +{ + wxGridUpdateLocker locker(grid); + const wxArrayInt sels = grid->GetSelectedCols(); + for ( size_t n = 0, count = sels.size(); n < count; n++ ) + { + grid->AutoSizeColumn( sels[n], false ); + } +} + +void GridFrame::AutoSizeRowLabel(wxCommandEvent& WXUNUSED(event)) +{ + wxGridUpdateLocker locker(grid); + const wxArrayInt sels = grid->GetSelectedRows(); + for ( size_t n = 0, count = sels.size(); n < count; n++ ) + { + grid->AutoSizeRowLabelSize( sels[n] ); + } +} + +void GridFrame::AutoSizeColLabel(wxCommandEvent& WXUNUSED(event)) +{ + wxGridUpdateLocker locker(grid); + const wxArrayInt sels = grid->GetSelectedCols(); + for ( size_t n = 0, count = sels.size(); n < count; n++ ) + { + grid->AutoSizeColLabelSize( sels[n] ); + } +} + +void GridFrame::AutoSizeLabelsCol(wxCommandEvent& WXUNUSED(event)) +{ + grid->SetColLabelSize( wxGRID_AUTOSIZE ); +} + +void GridFrame::AutoSizeLabelsRow(wxCommandEvent& WXUNUSED(event)) +{ + grid->SetRowLabelSize( wxGRID_AUTOSIZE ); +} + +void GridFrame::AutoSizeTable(wxCommandEvent& WXUNUSED(event)) +{ + grid->AutoSize(); +} + + +void GridFrame::DeleteSelectedCols( wxCommandEvent& WXUNUSED(ev) ) +{ + if ( grid->IsSelection() ) + { + wxGridUpdateLocker locker(grid); + for ( int n = 0; n < grid->GetNumberCols(); ) + { + if ( grid->IsInSelection( 0 , n ) ) + grid->DeleteCols( n, 1 ); + else + n++; + } + } +} + + +void GridFrame::ClearGrid( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->ClearGrid(); +} + +void GridFrame::SelectCells( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->SetSelectionMode( wxGrid::wxGridSelectCells ); +} + +void GridFrame::SelectRows( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->SetSelectionMode( wxGrid::wxGridSelectRows ); +} + +void GridFrame::SelectCols( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->SetSelectionMode( wxGrid::wxGridSelectColumns ); +} + +void GridFrame::SelectRowsOrCols( wxCommandEvent& WXUNUSED(ev) ) +{ + grid->SetSelectionMode( wxGrid::wxGridSelectRowsOrColumns ); +} + +void GridFrame::SetCellFgColour( wxCommandEvent& WXUNUSED(ev) ) +{ + wxColour col = wxGetColourFromUser(this); + if ( col.IsOk() ) + { + grid->SetDefaultCellTextColour(col); + grid->Refresh(); + } +} + +void GridFrame::SetCellBgColour( wxCommandEvent& WXUNUSED(ev) ) +{ + wxColour col = wxGetColourFromUser(this); + if ( col.IsOk() ) + { + // Check the new Refresh function by passing it a rectangle + // which exactly fits the grid. + wxPoint pt(0, 0); + wxRect r(pt, grid->GetSize()); + grid->SetDefaultCellBackgroundColour(col); + grid->Refresh(true, &r); + } +} + +void GridFrame::DeselectCell(wxCommandEvent& WXUNUSED(event)) +{ + grid->DeselectCell(3, 1); +} + +void GridFrame::DeselectCol(wxCommandEvent& WXUNUSED(event)) +{ + grid->DeselectCol(2); +} + +void GridFrame::DeselectRow(wxCommandEvent& WXUNUSED(event)) +{ + grid->DeselectRow(2); +} + +void GridFrame::DeselectAll(wxCommandEvent& WXUNUSED(event)) +{ + grid->ClearSelection(); +} + +void GridFrame::SelectCell(wxCommandEvent& WXUNUSED(event)) +{ + grid->SelectBlock(3, 1, 3, 1, m_addToSel); +} + +void GridFrame::SelectCol(wxCommandEvent& WXUNUSED(event)) +{ + grid->SelectCol(2, m_addToSel); +} + +void GridFrame::SelectRow(wxCommandEvent& WXUNUSED(event)) +{ + grid->SelectRow(2, m_addToSel); +} + +void GridFrame::SelectAll(wxCommandEvent& WXUNUSED(event)) +{ + grid->SelectAll(); +} + +void GridFrame::OnAddToSelectToggle(wxCommandEvent& event) +{ + m_addToSel = event.IsChecked(); +} + +void GridFrame::OnLabelLeftClick( wxGridEvent& ev ) +{ + wxString logBuf; + if ( ev.GetRow() != -1 ) + { + logBuf << wxT("Left click on row label ") << ev.GetRow(); + } + else if ( ev.GetCol() != -1 ) + { + logBuf << wxT("Left click on col label ") << ev.GetCol(); + } + else + { + logBuf << wxT("Left click on corner label"); + } + + if ( ev.ShiftDown() ) + logBuf << wxT(" (shift down)"); + if ( ev.ControlDown() ) + logBuf << wxT(" (control down)"); + wxLogMessage( wxT("%s"), logBuf.c_str() ); + + // you must call event skip if you want default grid processing + // + ev.Skip(); +} + + +void GridFrame::OnCellLeftClick( wxGridEvent& ev ) +{ + wxLogMessage(wxT("Left click at row %d, col %d"), ev.GetRow(), ev.GetCol()); + + // you must call event skip if you want default grid processing + // (cell highlighting etc.) + // + ev.Skip(); +} + + +void GridFrame::OnRowSize( wxGridSizeEvent& ev ) +{ + const int row = ev.GetRowOrCol(); + + wxLogMessage("Resized row %d, new height = %d", + row, grid->GetRowSize(row)); + + ev.Skip(); +} + + +void GridFrame::OnColSize( wxGridSizeEvent& ev ) +{ + const int col = ev.GetRowOrCol(); + + wxLogMessage("Resized column %d, new width = %d", + col, grid->GetColSize(col)); + + ev.Skip(); +} + + +void GridFrame::OnSelectCell( wxGridEvent& ev ) +{ + wxString logBuf; + if ( ev.Selecting() ) + logBuf << wxT("Selected "); + else + logBuf << wxT("Deselected "); + logBuf << wxT("cell at row ") << ev.GetRow() + << wxT(" col ") << ev.GetCol() + << wxT(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F') + << wxT(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F') + << wxT(", AltDown: ")<< (ev.AltDown() ? 'T':'F') + << wxT(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << wxT(" )"); + + //Indicate whether this column was moved + if ( ((wxGrid *)ev.GetEventObject())->GetColPos( ev.GetCol() ) != ev.GetCol() ) + logBuf << wxT(" *** Column moved, current position: ") << ((wxGrid *)ev.GetEventObject())->GetColPos( ev.GetCol() ); + + wxLogMessage( wxT("%s"), logBuf.c_str() ); + + // you must call Skip() if you want the default processing + // to occur in wxGrid + ev.Skip(); +} + +void GridFrame::OnRangeSelected( wxGridRangeSelectEvent& ev ) +{ + wxString logBuf; + if ( ev.Selecting() ) + logBuf << wxT("Selected "); + else + logBuf << wxT("Deselected "); + logBuf << wxT("cells from row ") << ev.GetTopRow() + << wxT(" col ") << ev.GetLeftCol() + << wxT(" to row ") << ev.GetBottomRow() + << wxT(" col ") << ev.GetRightCol() + << wxT(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F') + << wxT(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F') + << wxT(", AltDown: ")<< (ev.AltDown() ? 'T':'F') + << wxT(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << wxT(" )"); + wxLogMessage( wxT("%s"), logBuf.c_str() ); + + ev.Skip(); +} + +void GridFrame::OnCellValueChanging( wxGridEvent& ev ) +{ + int row = ev.GetRow(), + col = ev.GetCol(); + + wxLogMessage("Value of cell at (%d, %d): about to change " + "from \"%s\" to \"%s\"", + row, col, + grid->GetCellValue(row, col), ev.GetString()); + + // test how vetoing works + if ( ev.GetString() == "42" ) + { + wxLogMessage("Vetoing the change."); + ev.Veto(); + return; + } + + ev.Skip(); +} + +void GridFrame::OnCellValueChanged( wxGridEvent& ev ) +{ + int row = ev.GetRow(), + col = ev.GetCol(); + + wxLogMessage("Value of cell at (%d, %d) changed and is now \"%s\" " + "(was \"%s\")", + row, col, + grid->GetCellValue(row, col), ev.GetString()); + + ev.Skip(); +} + +void GridFrame::OnCellBeginDrag( wxGridEvent& ev ) +{ + wxLogMessage(wxT("Got request to drag cell at row %d, col %d"), + ev.GetRow(), ev.GetCol()); + + ev.Skip(); +} + +void GridFrame::OnEditorShown( wxGridEvent& ev ) +{ + + if ( (ev.GetCol() == 4) && + (ev.GetRow() == 0) && + (wxMessageBox(wxT("Are you sure you wish to edit this cell"), + wxT("Checking"),wxYES_NO) == wxNO ) ) { + + ev.Veto(); + return; + } + + wxLogMessage( wxT("Cell editor shown.") ); + + ev.Skip(); +} + +void GridFrame::OnEditorHidden( wxGridEvent& ev ) +{ + + if ( (ev.GetCol() == 4) && + (ev.GetRow() == 0) && + (wxMessageBox(wxT("Are you sure you wish to finish editing this cell"), + wxT("Checking"),wxYES_NO) == wxNO ) ) { + + ev.Veto(); + return; + } + + wxLogMessage( wxT("Cell editor hidden.") ); + + ev.Skip(); +} + +void GridFrame::About( wxCommandEvent& WXUNUSED(ev) ) +{ + wxAboutDialogInfo aboutInfo; + aboutInfo.SetName(wxT("wxGrid demo")); + aboutInfo.SetDescription(_("wxGrid sample program")); + aboutInfo.AddDeveloper(wxT("Michael Bedward")); + aboutInfo.AddDeveloper(wxT("Julian Smart")); + aboutInfo.AddDeveloper(wxT("Vadim Zeitlin")); + + // this is just to force the generic version of the about + // dialog under wxMSW so that it's easy to test if the grid + // repaints correctly when it has lost focus and a dialog + // (different from the Windows standard message box -- it doesn't + // work with it for some reason) is moved over it. + aboutInfo.SetWebSite(wxT("http://www.wxwidgets.org")); + + wxAboutBox(aboutInfo); +} + + +void GridFrame::OnQuit( wxCommandEvent& WXUNUSED(ev) ) +{ + Close( true ); +} + +void GridFrame::OnBugsTable(wxCommandEvent& ) +{ + BugsGridFrame *frame = new BugsGridFrame; + frame->Show(true); +} + +// ---------------------------------------------------------------------------- +// MyGridCellAttrProvider +// ---------------------------------------------------------------------------- + +MyGridCellAttrProvider::MyGridCellAttrProvider() +{ + m_attrForOddRows = new wxGridCellAttr; + m_attrForOddRows->SetBackgroundColour(*wxLIGHT_GREY); +} + +MyGridCellAttrProvider::~MyGridCellAttrProvider() +{ + m_attrForOddRows->DecRef(); +} + +wxGridCellAttr *MyGridCellAttrProvider::GetAttr(int row, int col, + wxGridCellAttr::wxAttrKind kind /* = wxGridCellAttr::Any */) const +{ + wxGridCellAttr *attr = wxGridCellAttrProvider::GetAttr(row, col, kind); + + if ( row % 2 ) + { + if ( !attr ) + { + attr = m_attrForOddRows; + attr->IncRef(); + } + else + { + if ( !attr->HasBackgroundColour() ) + { + wxGridCellAttr *attrNew = attr->Clone(); + attr->DecRef(); + attr = attrNew; + attr->SetBackgroundColour(*wxLIGHT_GREY); + } + } + } + + return attr; +} + +void GridFrame::OnVTable(wxCommandEvent& ) +{ + static long s_sizeGrid = 10000; + + s_sizeGrid = wxGetNumberFromUser(wxT("Size of the table to create"), + wxT("Size: "), + wxT("wxGridDemo question"), + s_sizeGrid, + 0, 32000, this); + + if ( s_sizeGrid != -1 ) + { + BigGridFrame* win = new BigGridFrame(s_sizeGrid); + win->Show(true); + } +} + +// ---------------------------------------------------------------------------- +// MyGridCellRenderer +// ---------------------------------------------------------------------------- + +// do something that the default renderer doesn't here just to show that it is +// possible to alter the appearance of the cell beyond what the attributes +// allow +void MyGridCellRenderer::Draw(wxGrid& grid, + wxGridCellAttr& attr, + wxDC& dc, + const wxRect& rect, + int row, int col, + bool isSelected) +{ + wxGridCellStringRenderer::Draw(grid, attr, dc, rect, row, col, isSelected); + + dc.SetPen(*wxGREEN_PEN); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawEllipse(rect); +} + +// ============================================================================ +// BigGridFrame and BigGridTable: Sample of a non-standard table +// ============================================================================ + +BigGridFrame::BigGridFrame(long sizeGrid) + : wxFrame(NULL, wxID_ANY, wxT("Plugin Virtual Table"), + wxDefaultPosition, wxSize(500, 450)) +{ + m_grid = new wxGrid(this, wxID_ANY, wxDefaultPosition, wxDefaultSize); + m_table = new BigGridTable(sizeGrid); + + // VZ: I don't understand why this slows down the display that much, + // must profile it... + //m_table->SetAttrProvider(new MyGridCellAttrProvider); + + m_grid->SetTable(m_table, true); + +#if defined __WXMOTIF__ + // MB: the grid isn't getting a sensible default size under wxMotif + int cw, ch; + GetClientSize( &cw, &ch ); + m_grid->SetSize( cw, ch ); +#endif +} + +// ============================================================================ +// BugsGridFrame: a "realistic" table +// ============================================================================ + +// ---------------------------------------------------------------------------- +// bugs table data +// ---------------------------------------------------------------------------- + +enum Columns +{ + Col_Id, + Col_Summary, + Col_Severity, + Col_Priority, + Col_Platform, + Col_Opened, + Col_Max +}; + +enum Severity +{ + Sev_Wish, + Sev_Minor, + Sev_Normal, + Sev_Major, + Sev_Critical, + Sev_Max +}; + +static const wxString severities[] = +{ + wxT("wishlist"), + wxT("minor"), + wxT("normal"), + wxT("major"), + wxT("critical"), +}; + +static struct BugsGridData +{ + int id; + wxChar summary[80]; + Severity severity; + int prio; + wxChar platform[12]; + bool opened; +} gs_dataBugsGrid [] = +{ + { 18, wxT("foo doesn't work"), Sev_Major, 1, wxT("wxMSW"), true }, + { 27, wxT("bar crashes"), Sev_Critical, 1, wxT("all"), false }, + { 45, wxT("printing is slow"), Sev_Minor, 3, wxT("wxMSW"), true }, + { 68, wxT("Rectangle() fails"), Sev_Normal, 1, wxT("wxMSW"), false }, +}; + +static const wxChar *headers[Col_Max] = +{ + wxT("Id"), + wxT("Summary"), + wxT("Severity"), + wxT("Priority"), + wxT("Platform"), + wxT("Opened?"), +}; + +// ---------------------------------------------------------------------------- +// BugsGridTable +// ---------------------------------------------------------------------------- + +wxString BugsGridTable::GetTypeName(int WXUNUSED(row), int col) +{ + switch ( col ) + { + case Col_Id: + case Col_Priority: + return wxGRID_VALUE_NUMBER;; + + case Col_Severity: + // fall thorugh (TODO should be a list) + + case Col_Summary: + return wxString::Format(wxT("%s:80"), wxGRID_VALUE_STRING); + + case Col_Platform: + return wxString::Format(wxT("%s:all,MSW,GTK,other"), wxGRID_VALUE_CHOICE); + + case Col_Opened: + return wxGRID_VALUE_BOOL; + } + + wxFAIL_MSG(wxT("unknown column")); + + return wxEmptyString; +} + +int BugsGridTable::GetNumberRows() +{ + return WXSIZEOF(gs_dataBugsGrid); +} + +int BugsGridTable::GetNumberCols() +{ + return Col_Max; +} + +bool BugsGridTable::IsEmptyCell( int WXUNUSED(row), int WXUNUSED(col) ) +{ + return false; +} + +wxString BugsGridTable::GetValue( int row, int col ) +{ + const BugsGridData& gd = gs_dataBugsGrid[row]; + + switch ( col ) + { + case Col_Id: + return wxString::Format(wxT("%d"), gd.id); + + case Col_Priority: + return wxString::Format(wxT("%d"), gd.prio); + + case Col_Opened: + return gd.opened ? wxT("1") : wxT("0"); + + case Col_Severity: + return severities[gd.severity]; + + case Col_Summary: + return gd.summary; + + case Col_Platform: + return gd.platform; + } + + return wxEmptyString; +} + +void BugsGridTable::SetValue( int row, int col, const wxString& value ) +{ + BugsGridData& gd = gs_dataBugsGrid[row]; + + switch ( col ) + { + case Col_Id: + case Col_Priority: + case Col_Opened: + wxFAIL_MSG(wxT("unexpected column")); + break; + + case Col_Severity: + { + size_t n; + for ( n = 0; n < WXSIZEOF(severities); n++ ) + { + if ( severities[n] == value ) + { + gd.severity = (Severity)n; + break; + } + } + + if ( n == WXSIZEOF(severities) ) + { + wxLogWarning(wxT("Invalid severity value '%s'."), + value.c_str()); + gd.severity = Sev_Normal; + } + } + break; + + case Col_Summary: + wxStrncpy(gd.summary, value, WXSIZEOF(gd.summary)); + break; + + case Col_Platform: + wxStrncpy(gd.platform, value, WXSIZEOF(gd.platform)); + break; + } +} + +bool +BugsGridTable::CanGetValueAs(int WXUNUSED(row), + int col, + const wxString& typeName) +{ + if ( typeName == wxGRID_VALUE_STRING ) + { + return true; + } + else if ( typeName == wxGRID_VALUE_BOOL ) + { + return col == Col_Opened; + } + else if ( typeName == wxGRID_VALUE_NUMBER ) + { + return col == Col_Id || col == Col_Priority || col == Col_Severity; + } + else + { + return false; + } +} + +bool BugsGridTable::CanSetValueAs( int row, int col, const wxString& typeName ) +{ + return CanGetValueAs(row, col, typeName); +} + +long BugsGridTable::GetValueAsLong( int row, int col ) +{ + const BugsGridData& gd = gs_dataBugsGrid[row]; + + switch ( col ) + { + case Col_Id: + return gd.id; + + case Col_Priority: + return gd.prio; + + case Col_Severity: + return gd.severity; + + default: + wxFAIL_MSG(wxT("unexpected column")); + return -1; + } +} + +bool BugsGridTable::GetValueAsBool( int row, int col ) +{ + if ( col == Col_Opened ) + { + return gs_dataBugsGrid[row].opened; + } + else + { + wxFAIL_MSG(wxT("unexpected column")); + + return false; + } +} + +void BugsGridTable::SetValueAsLong( int row, int col, long value ) +{ + BugsGridData& gd = gs_dataBugsGrid[row]; + + switch ( col ) + { + case Col_Priority: + gd.prio = value; + break; + + default: + wxFAIL_MSG(wxT("unexpected column")); + } +} + +void BugsGridTable::SetValueAsBool( int row, int col, bool value ) +{ + if ( col == Col_Opened ) + { + gs_dataBugsGrid[row].opened = value; + } + else + { + wxFAIL_MSG(wxT("unexpected column")); + } +} + +wxString BugsGridTable::GetColLabelValue( int col ) +{ + return headers[col]; +} + +// ---------------------------------------------------------------------------- +// BugsGridFrame +// ---------------------------------------------------------------------------- + +BugsGridFrame::BugsGridFrame() + : wxFrame(NULL, wxID_ANY, wxT("Bugs table")) +{ + wxGrid *grid = new wxGrid(this, wxID_ANY); + wxGridTableBase *table = new BugsGridTable(); + table->SetAttrProvider(new MyGridCellAttrProvider); + grid->SetTable(table, true); + + wxGridCellAttr *attrRO = new wxGridCellAttr, + *attrRangeEditor = new wxGridCellAttr, + *attrCombo = new wxGridCellAttr; + + attrRO->SetReadOnly(); + attrRangeEditor->SetEditor(new wxGridCellNumberEditor(1, 5)); + attrCombo->SetEditor(new wxGridCellChoiceEditor(WXSIZEOF(severities), + severities)); + + grid->SetColAttr(Col_Id, attrRO); + grid->SetColAttr(Col_Priority, attrRangeEditor); + grid->SetColAttr(Col_Severity, attrCombo); + + grid->Fit(); + SetClientSize(grid->GetSize()); +} + +// ============================================================================ +// TabularGrid: grid used for display of tabular data +// ============================================================================ + +class TabularGridTable : public wxGridTableBase +{ +public: + enum + { + COL_NAME, + COL_EXT, + COL_SIZE, + COL_DATE, + COL_MAX + }; + + enum + { + ROW_MAX = 3 + }; + + TabularGridTable() { m_sortOrder = NULL; } + + virtual int GetNumberRows() { return ROW_MAX; } + virtual int GetNumberCols() { return COL_MAX; } + + virtual wxString GetValue(int row, int col) + { + if ( m_sortOrder ) + row = m_sortOrder[row]; + + switch ( col ) + { + case COL_NAME: + case COL_EXT: + return GetNameOrExt(row, col); + + case COL_SIZE: + return wxString::Format("%lu", GetSize(row)); + + case COL_DATE: + return GetDate(row).FormatDate(); + + case COL_MAX: + default: + wxFAIL_MSG( "unknown column" ); + } + + return wxString(); + } + + virtual void SetValue(int, int, const wxString&) + { + wxFAIL_MSG( "shouldn't be called" ); + } + + virtual wxString GetColLabelValue(int col) + { + // notice that column parameter here always refers to the internal + // column index, independently of its position on the screen + static const char *labels[] = { "Name", "Extension", "Size", "Date" }; + wxCOMPILE_TIME_ASSERT( WXSIZEOF(labels) == COL_MAX, LabelsMismatch ); + + return labels[col]; + } + + virtual void SetColLabelValue(int, const wxString&) + { + wxFAIL_MSG( "shouldn't be called" ); + } + + void Sort(int col, bool ascending) + { + // we hardcode all sorting orders for simplicity here + static int sortOrders[COL_MAX][2][ROW_MAX] = + { + // descending ascending + { { 2, 1, 0 }, { 0, 1, 2 } }, + { { 2, 1, 0 }, { 0, 1, 2 } }, + { { 2, 1, 0 }, { 0, 1, 2 } }, + { { 1, 0, 2 }, { 2, 0, 1 } }, + }; + + m_sortOrder = col == wxNOT_FOUND ? NULL : sortOrders[col][ascending]; + } + +private: + wxString GetNameOrExt(int row, int col) const + { + static const char * + names[] = { "autoexec.bat", "boot.ini", "io.sys" }; + wxCOMPILE_TIME_ASSERT( WXSIZEOF(names) == ROW_MAX, NamesMismatch ); + + const wxString s(names[row]); + return col == COL_NAME ? s.BeforeFirst('.') : s.AfterLast('.'); + } + + unsigned long GetSize(int row) const + { + static const unsigned long + sizes[] = { 412, 604, 40774 }; + wxCOMPILE_TIME_ASSERT( WXSIZEOF(sizes) == ROW_MAX, SizesMismatch ); + + return sizes[row]; + } + + wxDateTime GetDate(int row) const + { + static const char * + dates[] = { "2004-04-17", "2006-05-27", "1994-05-31" }; + wxCOMPILE_TIME_ASSERT( WXSIZEOF(dates) == ROW_MAX, DatesMismatch ); + + wxDateTime dt; + dt.ParseISODate(dates[row]); + return dt; + } + + int *m_sortOrder; +}; + +// specialized text control for column indexes entry +class ColIndexEntry : public wxTextCtrl +{ +public: + ColIndexEntry(wxWindow *parent) + : wxTextCtrl(parent, wxID_ANY, "") + { + SetValidator(wxTextValidator(wxFILTER_NUMERIC)); + } + + int GetCol() + { + unsigned long col; + if ( !GetValue().ToULong(&col) || col > TabularGridTable::COL_MAX ) + { + SetFocus(); + return -1; + } + + return col; + } + +protected: + virtual wxSize DoGetBestSize() const + { + wxSize size = wxTextCtrl::DoGetBestSize(); + size.x = 3*GetCharWidth(); + return size; + } +}; + +class TabularGridFrame : public wxFrame +{ +public: + TabularGridFrame(); + +private: + enum // control ids + { + Id_Check_UseNativeHeader, + Id_Check_DrawNativeLabels, + Id_Check_ShowRowLabels, + Id_Check_EnableColMove + }; + + // event handlers + + void OnToggleUseNativeHeader(wxCommandEvent&) + { + m_grid->UseNativeColHeader(m_chkUseNative->IsChecked()); + } + + void OnUpdateDrawNativeLabelsUI(wxUpdateUIEvent& event) + { + // we don't draw labels at all, native or otherwise, if we use the + // native header control + event.Enable( !m_chkUseNative->GetValue() ); + } + + void OnToggleDrawNativeLabels(wxCommandEvent&) + { + m_grid->SetUseNativeColLabels(m_chkDrawNative->IsChecked()); + } + + void OnToggleShowRowLabels(wxCommandEvent&) + { + m_grid->SetRowLabelSize(m_chkShowRowLabels->IsChecked() + ? wxGRID_AUTOSIZE + : 0); + } + + void OnToggleColMove(wxCommandEvent&) + { + m_grid->EnableDragColMove(m_chkEnableColMove->IsChecked()); + } + + void OnShowHideColumn(wxCommandEvent& event) + { + int col = m_txtColShowHide->GetCol(); + if ( col != -1 ) + { + m_grid->SetColSize(col, + event.GetId() == wxID_ADD ? wxGRID_AUTOSIZE : 0); + + UpdateOrderAndVisibility(); + } + } + + void OnMoveColumn(wxCommandEvent&) + { + int col = m_txtColIndex->GetCol(); + int pos = m_txtColPos->GetCol(); + if ( col == -1 || pos == -1 ) + return; + + m_grid->SetColPos(col, pos); + + UpdateOrderAndVisibility(); + } + + void OnResetColumnOrder(wxCommandEvent&) + { + m_grid->ResetColPos(); + + UpdateOrderAndVisibility(); + } + + void OnGridColSort(wxGridEvent& event) + { + const int col = event.GetCol(); + m_table->Sort(col, !(m_grid->IsSortingBy(col) && + m_grid->IsSortOrderAscending())); + } + + void OnGridColMove(wxGridEvent& event) + { + // can't update it yet as the order hasn't been changed, so do it a bit + // later + m_shouldUpdateOrder = true; + + event.Skip(); + } + + void OnGridColSize(wxGridSizeEvent& event) + { + // we only catch this event to react to the user showing or hiding this + // column using the header control menu and not because we're + // interested in column resizing + UpdateOrderAndVisibility(); + + event.Skip(); + } + + void OnIdle(wxIdleEvent& event) + { + if ( m_shouldUpdateOrder ) + { + m_shouldUpdateOrder = false; + UpdateOrderAndVisibility(); + } + + event.Skip(); + } + + void UpdateOrderAndVisibility() + { + wxString s; + for ( int pos = 0; pos < TabularGridTable::COL_MAX; pos++ ) + { + const int col = m_grid->GetColAt(pos); + const bool isHidden = m_grid->GetColSize(col) == 0; + + if ( isHidden ) + s << '['; + s << col; + if ( isHidden ) + s << ']'; + + s << ' '; + } + + m_statOrder->SetLabel(s); + } + + // controls + wxGrid *m_grid; + TabularGridTable *m_table; + wxCheckBox *m_chkUseNative, + *m_chkDrawNative, + *m_chkShowRowLabels, + *m_chkEnableColMove; + + ColIndexEntry *m_txtColIndex, + *m_txtColPos, + *m_txtColShowHide; + + wxStaticText *m_statOrder; + + // fla for EVT_IDLE handler + bool m_shouldUpdateOrder; + + wxDECLARE_NO_COPY_CLASS(TabularGridFrame); + DECLARE_EVENT_TABLE() +}; + +BEGIN_EVENT_TABLE(TabularGridFrame, wxFrame) + EVT_CHECKBOX(Id_Check_UseNativeHeader, + TabularGridFrame::OnToggleUseNativeHeader) + EVT_CHECKBOX(Id_Check_DrawNativeLabels, + TabularGridFrame::OnToggleDrawNativeLabels) + EVT_CHECKBOX(Id_Check_ShowRowLabels, + TabularGridFrame::OnToggleShowRowLabels) + EVT_CHECKBOX(Id_Check_EnableColMove, + TabularGridFrame::OnToggleColMove) + + EVT_UPDATE_UI(Id_Check_DrawNativeLabels, + TabularGridFrame::OnUpdateDrawNativeLabelsUI) + + EVT_BUTTON(wxID_APPLY, TabularGridFrame::OnMoveColumn) + EVT_BUTTON(wxID_RESET, TabularGridFrame::OnResetColumnOrder) + EVT_BUTTON(wxID_ADD, TabularGridFrame::OnShowHideColumn) + EVT_BUTTON(wxID_DELETE, TabularGridFrame::OnShowHideColumn) + + EVT_GRID_COL_SORT(TabularGridFrame::OnGridColSort) + EVT_GRID_COL_MOVE(TabularGridFrame::OnGridColMove) + EVT_GRID_COL_SIZE(TabularGridFrame::OnGridColSize) + + EVT_IDLE(TabularGridFrame::OnIdle) +END_EVENT_TABLE() + +TabularGridFrame::TabularGridFrame() + : wxFrame(NULL, wxID_ANY, "Tabular table") +{ + m_shouldUpdateOrder = false; + + wxPanel * const panel = new wxPanel(this); + + // create and initialize the grid with the specified data + m_table = new TabularGridTable; + m_grid = new wxGrid(panel, wxID_ANY, + wxDefaultPosition, wxDefaultSize, + wxBORDER_STATIC | wxWANTS_CHARS); + m_grid->SetTable(m_table, true, wxGrid::wxGridSelectRows); + + m_grid->EnableDragColMove(); + m_grid->UseNativeColHeader(); + m_grid->HideRowLabels(); + + // add it and the other controls to the frame + wxSizer * const sizerTop = new wxBoxSizer(wxVERTICAL); + sizerTop->Add(m_grid, wxSizerFlags(1).Expand().Border()); + + wxSizer * const sizerControls = new wxBoxSizer(wxHORIZONTAL); + + wxSizer * const sizerStyles = new wxBoxSizer(wxVERTICAL); + m_chkUseNative = new wxCheckBox(panel, Id_Check_UseNativeHeader, + "&Use native header"); + m_chkUseNative->SetValue(true); + sizerStyles->Add(m_chkUseNative, wxSizerFlags().Border()); + + m_chkDrawNative = new wxCheckBox(panel, Id_Check_DrawNativeLabels, + "&Draw native column labels"); + sizerStyles->Add(m_chkDrawNative, wxSizerFlags().Border()); + + m_chkShowRowLabels = new wxCheckBox(panel, Id_Check_ShowRowLabels, + "Show &row labels"); + sizerStyles->Add(m_chkShowRowLabels, wxSizerFlags().Border()); + + m_chkEnableColMove = new wxCheckBox(panel, Id_Check_EnableColMove, + "Allow column re&ordering"); + m_chkEnableColMove->SetValue(true); + sizerStyles->Add(m_chkEnableColMove, wxSizerFlags().Border()); + sizerControls->Add(sizerStyles); + + sizerControls->AddSpacer(10); + + wxSizer * const sizerColumns = new wxBoxSizer(wxVERTICAL); + wxSizer * const sizerMoveCols = new wxBoxSizer(wxHORIZONTAL); + const wxSizerFlags + flagsHorz(wxSizerFlags().Border(wxLEFT | wxRIGHT).Centre()); + sizerMoveCols->Add(new wxStaticText(panel, wxID_ANY, "&Move column"), + flagsHorz); + m_txtColIndex = new ColIndexEntry(panel); + sizerMoveCols->Add(m_txtColIndex, flagsHorz); + sizerMoveCols->Add(new wxStaticText(panel, wxID_ANY, "&to"), flagsHorz); + m_txtColPos = new ColIndexEntry(panel); + sizerMoveCols->Add(m_txtColPos, flagsHorz); + sizerMoveCols->Add(new wxButton(panel, wxID_APPLY), flagsHorz); + + sizerColumns->Add(sizerMoveCols, wxSizerFlags().Expand().Border(wxBOTTOM)); + + wxSizer * const sizerShowCols = new wxBoxSizer(wxHORIZONTAL); + sizerShowCols->Add(new wxStaticText(panel, wxID_ANY, "Current order:"), + flagsHorz); + m_statOrder = new wxStaticText(panel, wxID_ANY, "<<< default >>>"); + sizerShowCols->Add(m_statOrder, flagsHorz); + sizerShowCols->Add(new wxButton(panel, wxID_RESET, "&Reset order")); + sizerColumns->Add(sizerShowCols, wxSizerFlags().Expand().Border(wxTOP)); + + wxSizer * const sizerShowHide = new wxBoxSizer(wxHORIZONTAL); + sizerShowHide->Add(new wxStaticText(panel, wxID_ANY, "Show/hide column:"), + flagsHorz); + m_txtColShowHide = new ColIndexEntry(panel); + sizerShowHide->Add(m_txtColShowHide, flagsHorz); + sizerShowHide->Add(new wxButton(panel, wxID_ADD, "&Show"), flagsHorz); + sizerShowHide->Add(new wxButton(panel, wxID_DELETE, "&Hide"), flagsHorz); + sizerColumns->Add(sizerShowHide, wxSizerFlags().Expand().Border(wxTOP)); + + sizerControls->Add(sizerColumns, wxSizerFlags(1).Expand().Border()); + + sizerTop->Add(sizerControls, wxSizerFlags().Expand().Border()); + + panel->SetSizer(sizerTop); + + SetClientSize(panel->GetBestSize()); + SetSizeHints(GetSize()); + + Show(); +} + +void GridFrame::OnTabularTable(wxCommandEvent&) +{ + new TabularGridFrame; +} + +// Example using wxGrid::Render +// Displays a preset selection or, if it exists, a selection block +// Draws the selection to a wxBitmap and displays the bitmap +void GridFrame::OnGridRender( wxCommandEvent& event ) +{ + int styleRender = 0, i; + bool useLometric = false, defSize = false; + double zoom = 1; + wxSize sizeMargin( 0, 0 ); + wxPoint pointOrigin( 0, 0 ); + + wxMenu* menu = GetMenuBar()->GetMenu( 0 ); + wxMenuItem* menuItem = menu->FindItem( ID_RENDER_ROW_LABEL ); + menu = menuItem->GetMenu(); + + if ( menu->FindItem( ID_RENDER_ROW_LABEL )->IsChecked() ) + styleRender |= wxGRID_DRAW_ROWS_HEADER; + if ( menu->FindItem( ID_RENDER_COL_LABEL )->IsChecked() ) + styleRender |= wxGRID_DRAW_COLS_HEADER; + if ( menu->FindItem( ID_RENDER_GRID_LINES )->IsChecked() ) + styleRender |= wxGRID_DRAW_CELL_LINES; + if ( menu->FindItem( ID_RENDER_GRID_BORDER )->IsChecked() ) + styleRender |= wxGRID_DRAW_BOX_RECT; + if ( menu->FindItem( ID_RENDER_SELECT_HLIGHT )->IsChecked() ) + styleRender |= wxGRID_DRAW_SELECTION; + if ( menu->FindItem( ID_RENDER_LOMETRIC )->IsChecked() ) + useLometric = true; + if ( menu->FindItem( ID_RENDER_MARGIN )->IsChecked() ) + { + pointOrigin.x += 50; + pointOrigin.y += 50; + sizeMargin.IncBy( 50 ); + } + if ( menu->FindItem( ID_RENDER_ZOOM )->IsChecked() ) + zoom = 1.25; + if ( menu->FindItem( ID_RENDER_DEFAULT_SIZE )->IsChecked() ) + defSize = true; + + // init render area coords with a default row and col selection + wxGridCellCoords topLeft( 0, 0 ), bottomRight( 8, 6 ); + // check whether we are printing a block selection + // other selection types not catered for here + if ( event.GetId() == ID_RENDER_COORDS ) + { + topLeft.SetCol( 6 ); + topLeft.SetRow( 4 ); + bottomRight.SetCol( 15 ); + bottomRight.SetRow( 29 ); + } + else if ( grid->IsSelection() && grid->GetSelectionBlockTopLeft().Count() ) + { + wxGridCellCoordsArray cells = grid->GetSelectionBlockTopLeft(); + if ( grid->GetSelectionBlockBottomRight().Count() ) + { + cells.Add( grid->GetSelectionBlockBottomRight()[ 0 ] ); + topLeft.Set( cells[ 0 ].GetRow(), + cells[ 0 ].GetCol() ); + bottomRight.Set( cells[ 1 ].GetRow(), + cells[ 1 ].GetCol() ); + } + } + + // sum col widths + wxSize sizeRender( 0, 0 ); + wxGridSizesInfo sizeinfo = grid->GetColSizes(); + for ( i = topLeft.GetCol(); i <= bottomRight.GetCol(); i++ ) + { + sizeRender.x += sizeinfo.GetSize( i ); + } + + // sum row heights + sizeinfo = grid->GetRowSizes(); + for ( i = topLeft.GetRow(); i <= bottomRight.GetRow(); i++ ) + { + sizeRender.y += sizeinfo.GetSize( i ); + } + + if ( styleRender & wxGRID_DRAW_ROWS_HEADER ) + sizeRender.x += grid->GetRowLabelSize(); + if ( styleRender & wxGRID_DRAW_COLS_HEADER ) + sizeRender.y += grid->GetColLabelSize(); + + sizeRender.x *= zoom; + sizeRender.y *= zoom; + + // delete any existing render frame and create new one + wxWindow* win = FindWindow( "frameRender" ); + if ( win ) + win->Destroy(); + + wxFrame* frame = new wxFrame( this, wxID_ANY, "Grid Render" ); + frame->SetClientSize( 780, 400 ); + frame->SetName( "frameRender" ); + + wxPanel* canvas = new wxPanel( frame, wxID_ANY ); + + // make bitmap large enough for margins if any + if ( !defSize ) + sizeRender.IncBy( sizeMargin * 2 ); + else + sizeRender.IncBy( sizeMargin ); + + wxBitmap bmp( sizeRender ); + // don't leave it larger or drawing will be scaled + sizeRender.DecBy( sizeMargin * 2 ); + + wxMemoryDC memDc(bmp); + + // default row labels have no background colour so set background + memDc.SetBackground( wxBrush( canvas->GetBackgroundColour() ) ); + memDc.Clear(); + + // convert sizeRender to mapping mode units if necessary + if ( useLometric ) + { + memDc.SetMapMode( wxMM_LOMETRIC ); + wxSize sizePPI = memDc.GetPPI(); + sizeRender.x = memDc.DeviceToLogicalXRel( sizeRender.x ); + sizeRender.y = memDc.DeviceToLogicalYRel( sizeRender.y ); + } + + // pass wxDefaultSize if menu item is checked + if ( defSize ) + sizeRender = wxDefaultSize; + + grid->Render( memDc, + pointOrigin, + sizeRender, + topLeft, bottomRight, + wxGridRenderStyle( styleRender ) ); + + m_gridBitmap = bmp; + + canvas->Connect( wxEVT_PAINT, + wxPaintEventHandler(GridFrame::OnRenderPaint), + NULL, + this ); + + frame->Show(); +} + +void GridFrame::OnRenderPaint( wxPaintEvent& event ) +{ + wxPanel* canvas = ( wxPanel* )event.GetEventObject(); + wxPaintDC dc( canvas ); + canvas->PrepareDC( dc ); + + if ( !m_gridBitmap.IsOk() ) + return;; + + wxMemoryDC memDc( m_gridBitmap ); + + dc.Blit( 0, 0, + m_gridBitmap.GetWidth(), + m_gridBitmap.GetHeight(), + &memDc, 0, 0 ); +} diff --git a/grid/griddemo.h b/grid/griddemo.h new file mode 100644 index 0000000..401553a --- /dev/null +++ b/grid/griddemo.h @@ -0,0 +1,303 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: griddemo.h +// Purpose: Grid control wxWidgets sample +// Author: Michael Bedward +// Modified by: +// RCS-ID: $Id$ +// Copyright: (c) Michael Bedward, Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + + +#ifndef griddemo_h +#define griddemo_h + +class wxGrid; + +class GridApp : public wxApp +{ +public: + bool OnInit(); +}; + + +class GridFrame : public wxFrame +{ + wxGrid *grid; +#if wxUSE_LOG + wxTextCtrl *logWin; + wxLogTextCtrl *logger; +#endif // wxUSE_LOG + + void SetDefaults(); + + void ToggleRowLabels( wxCommandEvent& ); + void ToggleColLabels( wxCommandEvent& ); + void ToggleEditing( wxCommandEvent& ); + void ToggleRowSizing( wxCommandEvent& ); + void ToggleColSizing( wxCommandEvent& ); + void ToggleColMoving( wxCommandEvent& ); + void ToggleGridSizing( wxCommandEvent& ); + void ToggleGridDragCell ( wxCommandEvent& ); + void SetNativeColHeader ( wxCommandEvent& ); + void SetCustomColHeader( wxCommandEvent& ); + void SetDefaultColHeader( wxCommandEvent& ); + void ToggleGridLines( wxCommandEvent& ); + void AutoSizeCols( wxCommandEvent& ); + void CellOverflow( wxCommandEvent& ); + void ResizeCell( wxCommandEvent& ); + void SetLabelColour( wxCommandEvent& ); + void SetLabelTextColour( wxCommandEvent& ); + void SetLabelFont(wxCommandEvent &); + void SetRowLabelHorizAlignment( wxCommandEvent& ); + void SetRowLabelVertAlignment( wxCommandEvent& ); + void SetColLabelHorizAlignment( wxCommandEvent& ); + void SetColLabelVertAlignment( wxCommandEvent& ); + void SetGridLineColour( wxCommandEvent& ); + + void SetCellFgColour(wxCommandEvent &); + void SetCellBgColour(wxCommandEvent &); + + void InsertRow( wxCommandEvent& ); + void InsertCol( wxCommandEvent& ); + void DeleteSelectedRows( wxCommandEvent& ); + void DeleteSelectedCols( wxCommandEvent& ); + void ClearGrid( wxCommandEvent& ); + void SelectCells( wxCommandEvent& ); + void SelectRows( wxCommandEvent& ); + void SelectCols( wxCommandEvent& ); + void SelectRowsOrCols( wxCommandEvent& ); + + void DeselectCell(wxCommandEvent& event); + void DeselectCol(wxCommandEvent& event); + void DeselectRow(wxCommandEvent& event); + void DeselectAll(wxCommandEvent& event); + void SelectCell(wxCommandEvent& event); + void SelectCol(wxCommandEvent& event); + void SelectRow(wxCommandEvent& event); + void SelectAll(wxCommandEvent& event); + void OnAddToSelectToggle(wxCommandEvent& event); + + void AutoSizeRow(wxCommandEvent& event); + void AutoSizeCol(wxCommandEvent& event); + void AutoSizeRowLabel(wxCommandEvent& event); + void AutoSizeColLabel(wxCommandEvent& event); + void AutoSizeLabelsCol(wxCommandEvent& event); + void AutoSizeLabelsRow(wxCommandEvent& event); + void AutoSizeTable(wxCommandEvent& event); + + void OnLabelLeftClick( wxGridEvent& ); + void OnCellLeftClick( wxGridEvent& ); + void OnRowSize( wxGridSizeEvent& ); + void OnColSize( wxGridSizeEvent& ); + void OnSelectCell( wxGridEvent& ); + void OnRangeSelected( wxGridRangeSelectEvent& ); + void OnCellValueChanging( wxGridEvent& ); + void OnCellValueChanged( wxGridEvent& ); + void OnCellBeginDrag( wxGridEvent& ); + + void OnEditorShown(wxGridEvent&); + void OnEditorHidden(wxGridEvent&); + + void OnSetHighlightWidth(wxCommandEvent&); + void OnSetROHighlightWidth(wxCommandEvent&); + +public: + GridFrame(); + ~GridFrame(); + + void OnQuit( wxCommandEvent& ); + void About( wxCommandEvent& ); + void OnVTable( wxCommandEvent& ); + void OnBugsTable( wxCommandEvent& ); + void OnTabularTable( wxCommandEvent& ); + void OnGridRender( wxCommandEvent& event ); + void OnRenderPaint( wxPaintEvent& event ); + + enum + { + ID_TOGGLEROWLABELS = 100, + ID_TOGGLECOLLABELS, + ID_TOGGLEEDIT, + ID_TOGGLEROWSIZING, + ID_TOGGLECOLSIZING, + ID_TOGGLECOLMOVING, + ID_TOGGLEGRIDSIZING, + ID_TOGGLEGRIDDRAGCELL, + ID_TOGGLEGRIDLINES, + ID_AUTOSIZECOLS, + ID_CELLOVERFLOW, + ID_RESIZECELL, + ID_SETLABELCOLOUR, + ID_SETLABELTEXTCOLOUR, + ID_SETLABEL_FONT, + ID_ROWLABELALIGN, + ID_ROWLABELHORIZALIGN, + ID_ROWLABELVERTALIGN, + ID_COLLABELALIGN, + ID_COLLABELHORIZALIGN, + ID_COLLABELVERTALIGN, + ID_COLDEFAULTHEADER, + ID_COLNATIVEHEADER, + ID_COLCUSTOMHEADER, + ID_GRIDLINECOLOUR, + ID_INSERTROW, + ID_INSERTCOL, + ID_DELETEROW, + ID_DELETECOL, + ID_CLEARGRID, + ID_CHANGESEL, + ID_SELCELLS, + ID_SELROWS, + ID_SELCOLS, + ID_SELROWSORCOLS, + ID_SET_CELL_FG_COLOUR, + ID_SET_CELL_BG_COLOUR, + ID_VTABLE, + ID_BUGS_TABLE, + ID_TABULAR_TABLE, + ID_SELECT_UNSELECT, + ID_SELECT_ALL, + ID_SELECT_ROW, + ID_SELECT_COL, + ID_SELECT_CELL, + ID_DESELECT_ALL, + ID_DESELECT_ROW, + ID_DESELECT_COL, + ID_DESELECT_CELL, + ID_SIZE_ROW, + ID_SIZE_COL, + ID_SIZE_ROW_LABEL, + ID_SIZE_COL_LABEL, + ID_SIZE_LABELS_COL, + ID_SIZE_LABELS_ROW, + ID_SIZE_GRID, + + ID_SET_HIGHLIGHT_WIDTH, + ID_SET_RO_HIGHLIGHT_WIDTH, + + ID_TESTFUNC, + + ID_RENDER_ROW_LABEL, + ID_RENDER_COL_LABEL, + ID_RENDER_GRID_LINES, + ID_RENDER_GRID_BORDER, + ID_RENDER_SELECT_HLIGHT, + ID_RENDER_LOMETRIC, + ID_RENDER_COORDS, + ID_RENDER_ZOOM, + ID_RENDER_MARGIN, + ID_RENDER_DEFAULT_SIZE, + }; + +#if wxUSE_LOG + wxLog *m_logOld; +#endif // wxUSE_LOG + + // add the cells to selection when using commands from select menu? + bool m_addToSel; + + wxBitmap m_gridBitmap; + + DECLARE_EVENT_TABLE() +}; + +class MyGridCellRenderer : public wxGridCellStringRenderer +{ +public: + virtual void Draw(wxGrid& grid, + wxGridCellAttr& attr, + wxDC& dc, + const wxRect& rect, + int row, int col, + bool isSelected); +}; + +// ---------------------------------------------------------------------------- +// demonstration of virtual table which doesn't store all of its data in +// memory +// ---------------------------------------------------------------------------- + +class BigGridTable : public wxGridTableBase +{ +public: + BigGridTable(long sizeGrid) { m_sizeGrid = sizeGrid; } + + int GetNumberRows() { return m_sizeGrid; } + int GetNumberCols() { return m_sizeGrid; } + wxString GetValue( int row, int col ) + { + return wxString::Format(wxT("(%d, %d)"), row, col); + } + + void SetValue( int , int , const wxString& ) { /* ignore */ } + bool IsEmptyCell( int , int ) { return false; } + +private: + long m_sizeGrid; +}; + +class BigGridFrame : public wxFrame +{ +public: + BigGridFrame(long sizeGrid); + +private: + wxGrid* m_grid; + BigGridTable* m_table; +}; + +// ---------------------------------------------------------------------------- +// an example of custom attr provider: this one makes all odd rows appear grey +// ---------------------------------------------------------------------------- + +class MyGridCellAttrProvider : public wxGridCellAttrProvider +{ +public: + MyGridCellAttrProvider(); + virtual ~MyGridCellAttrProvider(); + + virtual wxGridCellAttr *GetAttr(int row, int col, + wxGridCellAttr::wxAttrKind kind) const; + +private: + wxGridCellAttr *m_attrForOddRows; +}; + +// ---------------------------------------------------------------------------- +// another, more realistic, grid example: shows typed columns and more +// ---------------------------------------------------------------------------- + +class BugsGridTable : public wxGridTableBase +{ +public: + BugsGridTable() { } + + virtual int GetNumberRows(); + virtual int GetNumberCols(); + virtual bool IsEmptyCell( int row, int col ); + virtual wxString GetValue( int row, int col ); + virtual void SetValue( int row, int col, const wxString& value ); + + virtual wxString GetColLabelValue( int col ); + + virtual wxString GetTypeName( int row, int col ); + virtual bool CanGetValueAs( int row, int col, const wxString& typeName ); + virtual bool CanSetValueAs( int row, int col, const wxString& typeName ); + + virtual long GetValueAsLong( int row, int col ); + virtual bool GetValueAsBool( int row, int col ); + + virtual void SetValueAsLong( int row, int col, long value ); + virtual void SetValueAsBool( int row, int col, bool value ); +}; + +class BugsGridFrame : public wxFrame +{ +public: + BugsGridFrame(); +}; + + +#endif // griddemo_h + diff --git a/testcurl/main.cpp b/testcurl/main.cpp new file mode 100644 index 0000000..86fc2ab --- /dev/null +++ b/testcurl/main.cpp @@ -0,0 +1,18 @@ +#include "wx/app.h" +#include "testcurl.h" + +class testcurlApp: public wxApp +{ +public : + bool OnInit(); +}; + +IMPLEMENT_APP (testcurlApp) + +bool testcurlApp::OnInit() +{ + curl_global_init (CURL_GLOBAL_DEFAULT); + testcurl * fenetre = new testcurl(NULL); + fenetre -> Show(TRUE); + return TRUE; +} diff --git a/testcurl/testcurl.cpp b/testcurl/testcurl.cpp new file mode 100644 index 0000000..edba0e6 --- /dev/null +++ b/testcurl/testcurl.cpp @@ -0,0 +1,78 @@ +#include "testcurl.h" + +testcurl::testcurl( wxWindow* parent ) +: +testcurlGUI( parent ) +{ + texte_URL->SetFocus (); + texte_URL->SetSelection (-1, -1); + curlhandle = curl_easy_init (); + curl_easy_setopt (curlhandle, CURLOPT_WRITEFUNCTION, WriteDataCallback); + curl_easy_setopt (curlhandle, CURLOPT_WRITEDATA, (void*)&curldata); +} + +testcurl::~testcurl() +{ + curl_easy_cleanup (curlhandle); + curl_global_cleanup (); +} + +void testcurl::OnGo( wxCommandEvent& event ) +{ + if (texte_URL->IsEmpty()) + wxMessageBox("URL vide", "Erreur", wxOK|wxICON_EXCLAMATION); + else + { + texte_Resultat->SetValue(""); + wxString url = texte_URL->GetValue(); + curl_easy_setopt (curlhandle, CURLOPT_URL, _C(url)); + printf ("url = %s\n", _C(url)); + + if (checkbox_Proxy->IsChecked()) + { + wxString proxy = texte_Proxy->GetValue(); + curl_easy_setopt (curlhandle, CURLOPT_PROXY, _C(proxy)); + curl_easy_setopt (curlhandle, CURLOPT_PROXYPORT, spin_Proxy->GetValue()); + printf ("proxy = %s:%i\n", _C(proxy), spin_Proxy->GetValue()); + } + else + curl_easy_setopt (curlhandle, CURLOPT_PROXY, ""); + + curldata.content = (char*) malloc(1); + curldata.size = 0; + + if (curlhandle) + curl_easy_perform(curlhandle); + + printf ("Content = %s", curldata.content); + + wxString content = wxString::FromAscii(curldata.content); + texte_Resultat->SetValue(content); + wxMessageBox("Fini !", "Fini !", wxOK); + + if (curldata.content) + free (curldata.content); + } +} + + + + +static size_t WriteDataCallback(void *contents, size_t size, size_t nmemb, void *userp) +{ + size_t realsize = size * nmemb; + CurlData *mem = (CurlData *)userp; + + mem->content = (char*) realloc(mem->content, mem->size + realsize + 1); + if (mem->content == NULL) { + // out of memory! + printf("not enough memory (realloc returned NULL)\n"); + exit(EXIT_FAILURE); + } + + memcpy(&(mem->content[mem->size]), contents, realsize); + mem->size += realsize; + mem->content[mem->size] = 0; + + return realsize; +} \ No newline at end of file diff --git a/testcurl/testcurl.h b/testcurl/testcurl.h new file mode 100644 index 0000000..b5b8221 --- /dev/null +++ b/testcurl/testcurl.h @@ -0,0 +1,49 @@ +#ifndef __testcurl__ +#define __testcurl__ + +/** +@file +Subclass of testcurlGUI, which is generated by wxFormBuilder. +*/ + +#include "testcurlGUI.h" +#include +#include +#include +#include + +#ifdef __WXGTK__ + #define slash "/" + #define _C(string) string.fn_str() +#elif defined( __WXMSW__ ) + #define slash "\\" + #define _C(string) (const char*) string.c_str() +#endif + +typedef struct _CurlData { + char *content; + size_t size; +} CurlData; + +//// end generated include + +/** Implementing testcurlGUI */ +class testcurl : public testcurlGUI +{ + protected: + // Handlers for testcurlGUI events. + void OnGo( wxCommandEvent& event ); + CURL* curlhandle; + CurlData curldata; + public: + /** Constructor */ + testcurl( wxWindow* parent ); + ~testcurl(); + //// end generated class members + +}; + +static size_t WriteDataCallback(void *contents, size_t size, size_t nmemb, void *userp); + + +#endif // __testcurl__ diff --git a/testcurl/testcurl.project b/testcurl/testcurl.project new file mode 100644 index 0000000..0adbde3 --- /dev/null +++ b/testcurl/testcurl.project @@ -0,0 +1,181 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + diff --git a/testcurl/testcurlGUI.cpp b/testcurl/testcurlGUI.cpp new file mode 100644 index 0000000..dcced8c --- /dev/null +++ b/testcurl/testcurlGUI.cpp @@ -0,0 +1,63 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Sep 8 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#include "testcurlGUI.h" + +/////////////////////////////////////////////////////////////////////////// + +testcurlGUI::testcurlGUI( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style ) +{ + this->SetSizeHints( wxSize( 500,300 ), wxDefaultSize ); + this->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE ) ); + + wxBoxSizer* verticalsizer; + verticalsizer = new wxBoxSizer( wxVERTICAL ); + + texte_URL = new wxTextCtrl( this, wxID_ANY, wxT("Entrez l'url ici"), wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER ); + verticalsizer->Add( texte_URL, 0, wxALIGN_CENTER|wxALL|wxEXPAND, 5 ); + + wxBoxSizer* horizontalsizer_Proxy; + horizontalsizer_Proxy = new wxBoxSizer( wxHORIZONTAL ); + + texte_Blanc = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 ); + texte_Blanc->Wrap( -1 ); + horizontalsizer_Proxy->Add( texte_Blanc, 2, wxALL, 5 ); + + checkbox_Proxy = new wxCheckBox( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 ); + horizontalsizer_Proxy->Add( checkbox_Proxy, 0, wxALL, 5 ); + + texte_Proxy = new wxTextCtrl( this, wxID_ANY, wxT("Entrez l'adresse du proxy ici"), wxDefaultPosition, wxDefaultSize, 0 ); + horizontalsizer_Proxy->Add( texte_Proxy, 1, wxALIGN_CENTER|wxALL|wxEXPAND, 5 ); + + spin_Proxy = new wxSpinCtrl( this, wxID_ANY, wxT("80"), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 65536, 0 ); + horizontalsizer_Proxy->Add( spin_Proxy, 0, wxALIGN_CENTER|wxALL|wxEXPAND, 5 ); + + verticalsizer->Add( horizontalsizer_Proxy, 0, wxALL|wxEXPAND, 5 ); + + boutonGo = new wxButton( this, wxID_ANY, wxT("Go !"), wxDefaultPosition, wxDefaultSize, 0 ); + verticalsizer->Add( boutonGo, 0, wxALIGN_RIGHT|wxALL, 5 ); + + texte_Resultat = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_DONTWRAP|wxTE_READONLY ); + verticalsizer->Add( texte_Resultat, 1, wxALL|wxEXPAND, 5 ); + + this->SetSizer( verticalsizer ); + this->Layout(); + + this->Centre( wxBOTH ); + + // Connect Events + texte_URL->Connect( wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( testcurlGUI::OnGo ), NULL, this ); + boutonGo->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( testcurlGUI::OnGo ), NULL, this ); +} + +testcurlGUI::~testcurlGUI() +{ + // Disconnect Events + texte_URL->Disconnect( wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( testcurlGUI::OnGo ), NULL, this ); + boutonGo->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( testcurlGUI::OnGo ), NULL, this ); + +} diff --git a/testcurl/testcurlGUI.fbp b/testcurl/testcurlGUI.fbp new file mode 100644 index 0000000..79ad426 --- /dev/null +++ b/testcurl/testcurlGUI.fbp @@ -0,0 +1,511 @@ + + + + + + C++ + 1 + source_name + 0 + UTF-8 + connect + testcurlGUI + 1000 + none + 0 + testcurl + + G:\Commun\Etudiants\Maxime W\testcurl + + 1 + 1 + 0 + 0 + + wxSYS_COLOUR_BTNFACE + wxBOTH + + 1 + 1 + impl_virtual + + + + 0 + wxID_ANY + + 500,300 + testcurlGUI + + 800,500 + wxDEFAULT_FRAME_STYLE + + Test libcURL + + + wxFILTER_NONE + wxDefaultValidator + + + + wxTAB_TRAVERSAL + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + verticalsizer + wxVERTICAL + none + + 5 + wxALIGN_CENTER|wxALL|wxEXPAND + 0 + + + + 1 + 1 + + + 0 + wxID_ANY + + 0 + + texte_URL + protected + + + wxTE_PROCESS_ENTER + + + + wxFILTER_NONE + wxDefaultValidator + + Entrez l'url ici + + + + + + + + + + + + + + + + + + + + + + + + + + + OnGo + + + + + + + 5 + wxALL|wxEXPAND + 0 + + + horizontalsizer_Proxy + wxHORIZONTAL + none + + 5 + wxALL + 2 + + + + 1 + 1 + + + 0 + wxID_ANY + + + + texte_Blanc + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + -1 + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL + 0 + + + 0 + + 1 + 1 + + + 0 + wxID_ANY + + + + checkbox_Proxy + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_CENTER|wxALL|wxEXPAND + 1 + + + + 1 + 1 + + + 0 + wxID_ANY + + 0 + + texte_Proxy + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + Entrez l'adresse du proxy ici + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_CENTER|wxALL|wxEXPAND + 0 + + + + 1 + 1 + + + 0 + wxID_ANY + 0 + 65536 + + 0 + + spin_Proxy + protected + + + wxSP_ARROW_KEYS + + + + wxFILTER_NONE + wxDefaultValidator + + 80 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALIGN_RIGHT|wxALL + 0 + + + + 1 + 0 + 1 + + + 0 + wxID_ANY + Go ! + + + boutonGo + protected + + + + + + + wxFILTER_NONE + wxDefaultValidator + + + + + OnGo + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL|wxEXPAND + 1 + + + + 1 + 1 + + + 0 + wxID_ANY + + 0 + + texte_Resultat + protected + + + wxTE_DONTWRAP|wxTE_READONLY + + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testcurl/testcurlGUI.h b/testcurl/testcurlGUI.h new file mode 100644 index 0000000..cc37f94 --- /dev/null +++ b/testcurl/testcurlGUI.h @@ -0,0 +1,54 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Sep 8 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#ifndef __testcurlGUI__ +#define __testcurlGUI__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +/// Class testcurlGUI +/////////////////////////////////////////////////////////////////////////////// +class testcurlGUI : public wxFrame +{ + private: + + protected: + wxTextCtrl* texte_URL; + wxStaticText* texte_Blanc; + wxCheckBox* checkbox_Proxy; + wxTextCtrl* texte_Proxy; + wxSpinCtrl* spin_Proxy; + wxButton* boutonGo; + wxTextCtrl* texte_Resultat; + + // Virtual event handlers, overide them in your derived class + virtual void OnGo( wxCommandEvent& event ) { event.Skip(); } + + + public: + + testcurlGUI( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxT("Test libcURL"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 800,500 ), long style = wxDEFAULT_FRAME_STYLE|wxTAB_TRAVERSAL ); + ~testcurlGUI(); + +}; + +#endif //__testcurlGUI__ diff --git a/testsqlite/main.c b/testsqlite/main.c new file mode 100644 index 0000000..b1690dc --- /dev/null +++ b/testsqlite/main.c @@ -0,0 +1,76 @@ +#include +#include +#include + +static int sqlite_callback(void* notUsed, int nb_col, char **colonne, char **col_name); + +int main(int argc, char **argv) +{ + int rc; + sqlite3* db = NULL; + sqlite3_stmt* stmt = NULL; + + if ((rc = sqlite3_open_v2("test.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL)) == SQLITE_OK) + printf("Ouverture OK\n"); + else + { + printf("Erreur open = %i\n",rc); + exit(0); + } + + if ((rc = sqlite3_prepare_v2(db, "CREATE TABLE Consults (id INTEGER PRIMARY KEY ASC AUTOINCREMENT, n_dossier INT UNIQUE, nom VARCHAR(50), prenom VARCHAR(50), responsable VARCHAR(50), theme TEXT, date_cs DATE, nb_result INT, id_results TEXT, publi BOOLEAN, cs_associe BOOLEAN, publi_CHU BOOLEAN);", -1, &stmt, NULL)) == SQLITE_OK) + printf("Prepare OK\n"); + else + { + printf("Erreur prepare = %i\n",rc); + exit(0); + } + + if ((rc = sqlite3_step(stmt)) == SQLITE_DONE) //SQLITE_ROW si une nouvelle ligne est chopable, traiter la courante avec int/char* sqlite3_column_int/text(stmt, n_col); + //int sqlite_column_count(stmt) retourne nb_col (0 si stmt sans retour de data) + //int sqlite_column_type(stmt, n_col) retourne le type SQLITE_INTEGER/FLOAT/TEXT/BLOB/NULL + printf("Step OK\n"); + else + { + printf("Erreur step = %i\n",rc); + exit(0); + } + + if ((rc = sqlite3_finalize(stmt)) == SQLITE_OK) + printf("Finalize OK\n"); + else + { + printf("Erreur finalize = %i\n",rc); + exit(0); + } + + if ((rc = sqlite3_exec(db, "CREATE TABLE Resultats (id INTEGER PRIMARY KEY, titre TEXT, auteurs TEXT, lien TEXT, abstract TEXT, date_publi DATE);", NULL, NULL, NULL)) == SQLITE_OK) //commande sql sans retour + printf("Exec OK\n"); + else + { + printf("Erreur exec = %i\n",rc); + exit(0); + } + + //rc = sqlite3_exec(db, query, sqlite3_callback, 0, &errMsg) (char* query, errMsg) argument 0 est passé en premier à callback + //if rc!=SQLITE_OK printf("Err %s\n", errMsg); if (errMsg) free (errMesg); + + if ((rc = sqlite3_close(db)) == SQLITE_OK) + printf("Close OK\n"); + else + { + printf("Erreur close = %i\n",rc); + exit(0); + } + return 0; +} + +static int sqlite_callback(void* notUsed, int nb_col, char** colonne, char** col_name) //tout est obtenu avec sqlite3_column_text() +{ + int i; + for (i=0; i + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + +