GraphDialog.cpp

Go to the documentation of this file.

/*******************************************************************/
#ifndef __NO_GRAPH__
 
#include <wx/bars/barplot.h>
 
#include <wx/chartpanel.h>
 
#include <wx/axis/numberaxis.h>
#include <wx/axis/categoryaxis.h>
 
#include <wx/xy/xyhistorenderer.h>
 
#include <wx/category/categorysimpledataset.h>
 
 
class GraphDialog : public wxDialog 
{       
    protected:
        wxChartPanel* GraphChartPanel; 
        wxStaticLine* m_staticline1;
        wxListView* GraphList;
        wxChoice* GraphModeChoice;
        wxStaticText* GraphModeStat;
        wxButton* GraphRefreshButton;
        wxButton* GraphSaveButton;
        wxButton* GraphCloseButton;
        wxCheckBox* BlueCheckBox;
        wxCheckBox* YellowCheckBox;
        wxCheckBox* RedCheckBox;
        wxCheckBox* GreenCheckBox;
    
        void OnModeChoice(wxCommandEvent&);
        void OnListSelect(wxListEvent& evt);
        void OnGraphRefresh(wxCommandEvent&);
        void OnGraphSave(wxCommandEvent&);
        void OnGraphClose(wxCommandEvent&);
        
        void FillGraphList(int a);
        vector<int> GroupAverage(int a);
    public:
        GraphDialog( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 1000,650 ), long style = wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER ); 
    
};
 
GraphDialog::GraphDialog( 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 );
    //Set Color
    vector<int> ColorRed = Settings.GetIntArray("ColorRed");
    vector<int> ColorGreen = Settings.GetIntArray("ColorGreen");
    vector<int> ColorBlue = Settings.GetIntArray("ColorBlue");
    this->SetForegroundColour( wxColor(ColorRed[8],ColorGreen[8],ColorBlue[8]) );
    this->SetBackgroundColour( wxColor(ColorRed[7],ColorGreen[7],ColorBlue[7]) );
    
    wxBoxSizer* bSizer1;
    bSizer1 = new wxBoxSizer( wxVERTICAL );
 
    GraphChartPanel = new wxChartPanel(this,-1);
    bSizer1->Add(GraphChartPanel, 1,wxALL|wxEXPAND, 5);
    
    m_staticline1 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    bSizer1->Add( m_staticline1, 0, wxEXPAND | wxALL, 5 );
    
    wxGridSizer* gSizer1;
    gSizer1 = new wxGridSizer( 0, 3, 0, 0 );
    
    GraphList = new wxListView( this, wxID_ANY, wxDefaultPosition, wxSize( -1,-1 ),wxLC_REPORT );
    GraphList->Enable(false);
    gSizer1->Add( GraphList, 1, wxALL|wxEXPAND, 5 );
    
    wxBoxSizer* bSizer2;
    bSizer2 = new wxBoxSizer( wxVERTICAL );
    
    wxGridSizer* gSizer2;
    gSizer2 = new wxGridSizer( 0, 2, 0, 0 );
    
    wxArrayString GraphModeChoiceChoices;
    GraphModeChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, GraphModeChoiceChoices, 0 );
    GraphModeChoice->SetSelection( 0 );
    gSizer2->Add( GraphModeChoice, 0, wxALL|wxEXPAND, 5 );
    
    GraphModeStat = new wxStaticText( this, wxID_ANY, l("Step 1 - Graph Mode"), wxDefaultPosition, wxDefaultSize, 0 );
    GraphModeStat->Wrap( -1 );
    gSizer2->Add( GraphModeStat, 0, wxALL|wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL, 5 );
    
    
    bSizer2->Add( gSizer2, 1, wxEXPAND, 5 );
    
    GraphRefreshButton = new wxButton( this, wxID_ANY, l("Step 3 - Refresh Graph"), wxDefaultPosition, wxDefaultSize, 0 );
    GraphRefreshButton->Enable(false);
    bSizer2->Add( GraphRefreshButton, 0, wxALL|wxEXPAND, 5 );
    
    GraphSaveButton = new wxButton( this,wxID_ANY, l("Save Graph As Image"), wxDefaultPosition, wxDefaultSize, 0 );
    GraphSaveButton->Enable(false);
    bSizer2->Add( GraphSaveButton, 0, wxALL|wxEXPAND, 5 );
    
    GraphCloseButton = new wxButton( this, wxID_ANY, l("Close"), wxDefaultPosition, wxDefaultSize, 0 );
    bSizer2->Add( GraphCloseButton, 0, wxALL|wxEXPAND, 5 );
    
    
    gSizer1->Add( bSizer2, 1, wxEXPAND, 5 );
    
    wxBoxSizer* bSizer3;
    bSizer3 = new wxBoxSizer( wxVERTICAL );
    
    BlueCheckBox = new wxCheckBox( this, wxID_ANY, l("Show % Were Fertile(Blue)"), wxDefaultPosition, wxDefaultSize, 0 );
    BlueCheckBox->SetValue(true); 
    bSizer3->Add( BlueCheckBox, 1, wxALL, 5 );
    
    YellowCheckBox = new wxCheckBox( this, wxID_ANY, l("Show % Of Fertile Hatched(Yellow)"), wxDefaultPosition, wxDefaultSize, 0 );
    YellowCheckBox->SetValue(true); 
    bSizer3->Add( YellowCheckBox, 1, wxALL, 5 );
    
    RedCheckBox = new wxCheckBox( this, wxID_ANY, l("Show % Of Total Hatched(Red)"), wxDefaultPosition, wxDefaultSize, 0 );
    RedCheckBox->SetValue(true); 
    bSizer3->Add( RedCheckBox, 1, wxALL, 5 );
    
    GreenCheckBox = new wxCheckBox( this, wxID_ANY, l("Show % Of Total Unhatched(Green)"), wxDefaultPosition, wxDefaultSize, 0 );
    GreenCheckBox->SetValue(true); 
    bSizer3->Add( GreenCheckBox, 1, wxALL, 5 );
    
    
    gSizer1->Add( bSizer3, 1, wxEXPAND, 5 );
    
    
    bSizer1->Add( gSizer1, 0, wxEXPAND, 5 );
    GraphModeChoice->Bind(wxEVT_CHOICE, &GraphDialog::OnModeChoice, this);
    GraphList->Bind(wxEVT_COMMAND_LIST_ITEM_SELECTED, &GraphDialog::OnListSelect, this);
    GraphList->Bind(wxEVT_COMMAND_LIST_ITEM_DESELECTED, &GraphDialog::OnListSelect, this);
    GraphRefreshButton->Bind(wxEVT_BUTTON, &GraphDialog::OnGraphRefresh, this);
    GraphSaveButton->Bind(wxEVT_BUTTON, &GraphDialog::OnGraphSave, this);
    GraphCloseButton->Bind(wxEVT_BUTTON, &GraphDialog::OnGraphClose, this);
    
    this->SetSizer( bSizer1 );
    this->Layout();
    
    this->Centre( wxBOTH );
    
    //Set up Mode options
    GraphModeChoice->Append(l("Select..."));
    GraphModeChoice->Append(l("Multiple Batches"));
    GraphModeChoice->Append(l("Single Group"));
    GraphModeChoice->Append(l("Multiple Groups"));
    GraphModeChoice->SetSelection(0);
    
    wxInitAllImageHandlers();//set up for exporting as png
}
 
 
void GraphDialog::OnModeChoice(wxCommandEvent&)
{  
    int a = GraphModeChoice->GetSelection();
    
    if(a == 0) {
        GraphRefreshButton->Enable(false);
        GraphList->ClearAll();//Clear the previous list items
        return;
    }
    else
        FillGraphList(a);
        
    GraphList->Enable(true);
    GraphRefreshButton->Enable(false);
}
 
void GraphDialog::OnListSelect(wxListEvent& evt) {
    
    int a = GraphModeChoice->GetSelection();
    
    switch(a){
        case 2: {
             if(GraphList->GetSelectedItemCount() > 0)
                GraphRefreshButton->Enable(true);
            else
                GraphRefreshButton->Enable(false);  
            break;
        }
        default: {
            if(GraphList->GetSelectedItemCount() > 1)
                GraphRefreshButton->Enable(true);
            else
                GraphRefreshButton->Enable(false);  
            break;
        }
    }
}
 
void GraphDialog::OnGraphRefresh(wxCommandEvent&)
{
    wxString GrTitle; //graph title
    vector<string> TempNames;
    vector<double> TempValues1,TempValues2,TempValues3,TempValues4;
    
    int b, sel; //misc numbers
    vector<int> z; //holds all averages for one group
    int a = GraphModeChoice->GetSelection();
    bool checker; //for checking if certain bars should be displayed
    
    //get selected items and data
    switch(a) {
        case 0: {
            wxMessageDialog dialog(this,
            l("Hey Change The Mode And Select\nSomthing From The List!"));
            dialog.ShowModal();
            return;
        }
        case 1: {
            for(b = 0; b < Batches.GetCount(); b++) {
                if(!GraphList->IsSelected(b))
                    continue;
                else {
                    TempNames.push_back(Batches.GetName(b));
                    TempValues1.push_back(Batches.PercentFertile(b));
                    TempValues2.push_back(Batches.PercentOfFertile(b));
                    TempValues3.push_back(Batches.PercentOfTotal(b));
                    TempValues4.push_back(Batches.PercentOfTotalUnhatched(b));
                }
            }
            if(TempNames.size() < 2) {
                wxMessageDialog dialog(this,
                l("You'll Need To Select More Than 1\n Batch For This To Work.\n\nHold CTRL or Cmd + Click\n To Select Multiple Items."));
                dialog.ShowModal();
                return;
            }
            GrTitle = l("Batches");
            
            break;
        }
        case 2: {   
            sel = GraphList->GetFirstSelected();
            for(b = 0; b < Batches.GetCount(); b++) {
                if(Groups.GetName(sel) == Batches.GetGroup(b)) {
                    TempNames.push_back(Batches.GetName(b));
                    TempValues1.push_back(Batches.PercentFertile(b));
                    TempValues2.push_back(Batches.PercentOfFertile(b));
                    TempValues3.push_back(Batches.PercentOfTotal(b));
                    TempValues4.push_back(Batches.PercentOfTotalUnhatched(b));
                }
            }
            if(TempNames.size() < 2) {
                wxMessageDialog dialog(this,
                l("This Group Only Has One Batch!\nAdd Some More To Compare."));
                dialog.ShowModal();
                return;
            }
            GrTitle = l("Batches For Group: ") + Groups.GetName(sel);
            break;
            
        }
        case 3: {
            for(b = 0; b < Groups.GetCount(); b++) {
                if(!GraphList->IsSelected(b))
                    continue;
                else {
                    TempNames.push_back(Groups.GetName(b));
                    
                    z = GroupAverage(b);
                    TempValues1.push_back(z[0]);
                    TempValues2.push_back(z[1]);
                    TempValues3.push_back(z[2]);
                    TempValues4.push_back(z[3]);
                }
            }
            if(TempNames.size() < 2) {
                wxMessageDialog dialog(this,
                l("You'll Need To Select More Than 1 Group\nFor This To Work.\n\nHold CTRL or Cmd + Click\n To Select Multiple Items"));
                dialog.ShowModal();
                return;
            }
            GrTitle = l("Group Averages");
            break;
        }
    }
    int DataCount = TempNames.size();
    
    wxString names[DataCount];
    double values1[DataCount];
    double values2[DataCount];
    double values3[DataCount];
    double values4[DataCount];
    
    bool oneFound = false;
    
    for(b = 0; b < DataCount; b++) {
        names[b] = TempNames[b];
        
        if(BlueCheckBox->IsChecked()) {
            values1[b] = TempValues1[b];
            oneFound = true;
        }
        else
            values1[b] = 0;
            
        if(YellowCheckBox->IsChecked()) {
            values2[b] = TempValues2[b];
            oneFound = true;
        }
        else
            values2[b] = 0;
            
        if(RedCheckBox->IsChecked()) {  
            values3[b] = TempValues3[b];
            oneFound = true;
        }
        else
            values3[b] = 0;
            
        if(GreenCheckBox->IsChecked()) {    
            values4[b] = TempValues4[b];
            oneFound = true;
        }
        else
            values4[b] = 0;
    }
    
    //make sure there is a checkbox toggled
    if(oneFound == false) {
        wxMessageDialog dialog(this,
        l("You'll Need At Least One Check Box Checked!"));
        dialog.ShowModal();
        return;
    }
    
    // Create dataset
    CategorySimpleDataset *dataset = new CategorySimpleDataset(names, WXSIZEOF(names));
 
    // add two series to it
    
    dataset->AddSerie(l("% Were Fertile"), values1, WXSIZEOF(values1));
    dataset->AddSerie(l("% Of Fertile Hatched"), values2, WXSIZEOF(values2));
    dataset->AddSerie(l("% Of Total Hatched"), values3, WXSIZEOF(values3));
    dataset->AddSerie(l("% Of Total UnHatched"), values4, WXSIZEOF(values4));
    // create layered bar type with width=40 and base=0
    BarType *barType = new LayeredBarType(40, 0);
 
    // Set bar renderer for it, with layered bar type
    BarRenderer *renderer = new BarRenderer(barType);
 
    // Some eye-candy: gradient bars
    renderer->SetBarDraw(0, new GradientAreaDraw(*wxBLUE, wxColor(0,171,255), 
                                                    wxColor(0,171,255).ChangeLightness(150), wxNORTH));
    renderer->SetBarDraw(1, new GradientAreaDraw(*wxYELLOW, wxColor(215,215,35), 
                                                    wxColor(215,215,35).ChangeLightness(150), wxNORTH));
                                                        
    renderer->SetBarDraw(2, new GradientAreaDraw(*wxRED, wxColor(255,0,0), 
                                                    wxColor(255,0,0).ChangeLightness(150), wxNORTH));
                                                        
    renderer->SetBarDraw(3, new GradientAreaDraw(*wxGREEN, wxColor(0,128,0), 
                                                    wxColor(0,128,0).ChangeLightness(150), wxNORTH));
 
    // assign renderer to dataset
    dataset->SetRenderer(renderer);
 
    // Create bar plot
    BarPlot *plot = new BarPlot();
 
    // Add left category axis
    NumberAxis *leftAxis = new NumberAxis(AXIS_LEFT);
    leftAxis->SetMargins(0, 0);
    plot->AddAxis(leftAxis);
 
    // Add bottom number axis
    CategoryAxis *bottomAxis = new CategoryAxis(AXIS_BOTTOM);
    bottomAxis->SetMargins(20, 20);
    plot->AddAxis(bottomAxis);
 
    // Add dataset to plot
    plot->AddDataset(dataset);
 
    // Link first dataset with first horizontal axis
    plot->LinkDataHorizontalAxis(0, 0);
 
    // Link first dataset with first vertical axis
    plot->LinkDataVerticalAxis(0, 0);
    
    //test
    Legend* legend = new Legend(wxCENTER, wxRIGHT, new FillAreaDraw(*wxTRANSPARENT_PEN, *wxTRANSPARENT_BRUSH));
    plot->SetLegend(legend);
 
    // and finally construct and return chart
    GraphChartPanel->SetChart(new Chart(plot, GrTitle));
    
    GraphSaveButton->Enable(true);
}
 
void GraphDialog::OnGraphSave(wxCommandEvent&)
{
    string path;
    string ext1, ext2 = "png";
    Chart *chart = GraphChartPanel->GetChart();
    
    if (chart != NULL) {
        wxFileDialog dlg(this, l("Choose file..."), wxEmptyString, wxEmptyString,
                wxString(wxT("PNG files (*.png)|*.png")), wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
        if (dlg.ShowModal() != wxID_OK)
            return ;
 
        path = dlg.GetPath();
        
        wxFileName fname(path.c_str());
        ext1 = fname.GetExt();
    
        if( ext1 != ext2)
            path = path + ".png";
 
 
        wxBitmap bitmap =GraphChartPanel->CopyBackbuffer();
        bitmap.ConvertToImage().SaveFile(path.c_str(), wxBITMAP_TYPE_PNG);
    }
    else {
        wxMessageDialog dialog(this,
        l("Error! No Graph is Being Shown!"));
        dialog.ShowModal();
        return;
    }
}
 
void GraphDialog::OnGraphClose(wxCommandEvent&){EndModal(0);}
 
void GraphDialog::FillGraphList(int a)
{
    int b;
    
    GraphList->ClearAll();//Clear the previous list items
    GraphList->InsertColumn(0,l("Step 2 - Select Item(s)" ), wxLIST_FORMAT_LEFT, 400);
    
    switch(a) {
        case 1: {
            for(b = 0; b < Batches.GetCount(); b++)
                GraphList->InsertItem(b, wxString::Format(wxT("%s"),  Batches.GetName(b).c_str()));
            break;
        }
        case 2: {
            for(b = 0; b < Groups.GetCount(); b++)
                GraphList->InsertItem(b, wxString::Format(wxT("%s"),  Groups.GetName(b).c_str()));
            break;
        }
        case 3: {
            for(b = 0; b < Groups.GetCount(); b++)
                GraphList->InsertItem(b, wxString::Format(wxT("%s"),  Groups.GetName(b).c_str()));
            break;
        }
    }
}
 
vector<int> GraphDialog::GroupAverage(int a)
{
    vector<int> Out;
    int c, d = 0;
    
    int fertileTotal = 0;
    int hatchOfTotal = 0;
    int hatchOfFer = 0; 
    int unHatchOfT = 0;
    
    for(c = 0; c < Batches.GetCount(); c++) {
        if(Groups.GetName(a) == Batches.GetGroup(c)) {  
            fertileTotal += Batches.GetFertile(c);
            hatchOfTotal += Batches.PercentOfTotal(c);
            hatchOfFer += Batches.PercentOfFertile(c); 
            unHatchOfT += Batches.PercentOfTotalUnhatched(c);
            d++;
        }
    }
    
    Out.push_back(fertileTotal / d);
    Out.push_back(hatchOfTotal / d);
    Out.push_back(hatchOfFer / d);  
    Out.push_back(unHatchOfT / d);
    
    return Out;
}
#endif //__NO_GRAPH__