ScheduleDialog.cpp

Go to the documentation of this file.

/*******************************************************************/
#include <wx/wx.h>
#include <wx/listctrl.h>
#include <wx/statline.h>
 
//void scanSchedule(void);    
 
class AddScheduleDialog : public wxDialog
{
    private:
        wxTextCtrl* SchNameCtrl;
        wxStaticText* SchNameStat;
        wxDatePickerCtrl* SchDatePicker;
        wxStaticText* SchDateStat;
        wxButton* SchSaveButton;
        wxButton* SchCancelButton;
        
        void OnSaveButton(wxCommandEvent& );
        void OnCancelButton(wxCommandEvent& );
    public:
        AddScheduleDialog( wxWindow* parent, wxWindowID id = 500, const wxString& title = wxT("Add Schedule"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCAPTION|wxCLOSE_BOX|wxSYSTEM_MENU );
};
 
AddScheduleDialog::AddScheduleDialog( 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 );
    
    //Colors
    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 );
 
    wxGridSizer* gSizer1;
    gSizer1 = new wxGridSizer( 3, 2, 0, 0 );
    //Filter Invalid Chars
    wxTextValidator textVal(wxFILTER_INCLUDE_CHAR_LIST,NULL);
    textVal.SetCharIncludes(Info.GetValidChars().c_str());
    
    SchNameCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize( 110,-1 ), 0 ,textVal);
    SchNameCtrl->SetToolTip( l("The New Schedule Name") );
 
    gSizer1->Add( SchNameCtrl, 1, wxALL|wxEXPAND, 5 );
 
    SchNameStat = new wxStaticText( this, wxID_ANY, l("Schedule Name"), wxDefaultPosition, wxDefaultSize, 0 );
    SchNameStat->Wrap( -1 );
    gSizer1->Add( SchNameStat, 0, wxALL|wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL, 5 );
 
    SchDatePicker = new wxDatePickerCtrl( this, wxID_ANY, wxDefaultDateTime, wxDefaultPosition, wxSize( 110,-1 ), wxDP_DROPDOWN );
    SchDatePicker->SetToolTip( l("Select A Date For The New Schedule") );
 
    gSizer1->Add( SchDatePicker, 1, wxALL|wxEXPAND, 5 );
 
    SchDateStat = new wxStaticText( this, wxID_ANY, l("Schedule Date"), wxDefaultPosition, wxDefaultSize, 0 );
    SchDateStat->Wrap( -1 );
    gSizer1->Add( SchDateStat, 0, wxALL|wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL, 5 );
 
    SchCancelButton = new wxButton( this, wxID_ANY, l("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    SchCancelButton->SetToolTip( l("Close This Dialog") );
 
    gSizer1->Add( SchCancelButton, 0, wxALL|wxEXPAND, 5 );
    
    SchSaveButton = new wxButton( this, wxID_ANY, l("Save"), wxDefaultPosition, wxDefaultSize, 0 );
    SchSaveButton->SetToolTip( l("Add Schedule") );
 
    gSizer1->Add( SchSaveButton, 0, wxALL|wxEXPAND, 5 );
    
    bSizer1->Add( gSizer1, 0, wxEXPAND, 5 );
    bSizer1->SetSizeHints(this);
    
    SchSaveButton->Bind(wxEVT_BUTTON, &AddScheduleDialog::OnSaveButton, this );
    SchCancelButton->Bind(wxEVT_BUTTON, &AddScheduleDialog::OnCancelButton, this );
 
    this->SetSizer( bSizer1 );
    this->Layout();
}
 
 
void AddScheduleDialog::OnCancelButton(wxCommandEvent& ){EndModal(0);}
 
void AddScheduleDialog::OnSaveButton(wxCommandEvent& )
{
    //Get Name
    string curSchName = SchNameCtrl->GetLineText(0).ToStdString();
    
    if(curSchName == "") {
        wxMessageDialog* dialog = new wxMessageDialog(this,
        l("Please Enter A Name!"));
         dialog->ShowModal();
         dialog->Destroy();
         return;
    }
    
    for(int a = 0; a < Schedules.GetCount(); a++) {
        if(curSchName == Schedules.GetName(a)) {
            wxMessageDialog* dialog = new wxMessageDialog(this,
            l("Please Enter A Different Name!\nThis One Exists Already!"));
            dialog->ShowModal();
            dialog->Destroy();
            return;
        }
    }
    
    //Get Date
    wxDateTime selDate = SchDatePicker->GetValue();
    
    HK_Date hkDate(
        selDate.GetDay(wxDateTime::Local),
        selDate.GetMonth(wxDateTime::Local) + 1,
        selDate.GetYear(wxDateTime::Local)
    );
    
    /* Create SQL statement */
    string SQL = "INSERT INTO Schedules VALUES(" + to_string(Schedules.GetValidID()) + ", '";
    SQL += curSchName + "','" + hkDate.ToSortable("/") + "');";
 
    if(!Database.Execute(SQL)) {
        wxMessageDialog* dialog = new wxMessageDialog(this,
        "Sqlite Error: " + Database.GetErrors());
        dialog->ShowModal();
        dialog->Destroy();
        return;
    }
 
    SchNameCtrl->Clear();
    SchDatePicker->SetValue(wxDateTime::Today());
    EndModal(0);
}
 
class ScheduleDialog : public wxDialog
{
    private:
         //Calendar Vars
        int SchAttr = -1; //The Scheduled Date Shown In Calendar
        vector<int> MarkAttr;  //Other Events Shown In Calendar
        
        //Choice Vars
        bool ShowHatch = true;
        bool ShowStart = true;
        bool ShowCandl = true;
        bool ShowLockd = true;
    
        wxGenericCalendarCtrl* SchCalendar;
        wxListView * SchList;
        wxChoice* SchFilterChoice;
        wxListCtrl* SchOtherEvtList;
        wxStaticLine* m_staticline1;
        wxButton* SchDelButton;
        wxTextCtrl* SchNameCtrl;
        wxStaticText* SchNameStat;
        wxDatePickerCtrl* SchDatePicker;
        wxStaticText* SchDateStat;
        wxStaticLine* m_staticline2;
        wxButton* SchAddButton;
        wxButton* SchCloseButton;
    
        void OnAddButton(wxCommandEvent& );
        void OnRemvButton(wxCommandEvent& );
        void OnClose(wxCommandEvent& );
        void OnSchListSelect(wxListEvent& );
        void OnSchListDESelect(wxListEvent& );
        void SchCalendarChanged(wxCalendarEvent&);
        void FilterChanged(wxCommandEvent&);
        
        void SetSchAttr();
        void SetOtherAttr();
        void RemoveAllAttr();
        void ShowAllEvents();
        void ShowSchedules(bool Scan);
        void AddAttr(int Day);
        
    public:    
        ScheduleDialog( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxT("Schedule A Hatch Date"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize(  500,500  ), long style = wxCAPTION|wxSYSTEM_MENU|wxCLOSE_BOX|wxRESIZE_BORDER  );
};
 
ScheduleDialog::ScheduleDialog( 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 );
    
    //Colors
    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 );
 
    wxGridSizer* gSizer1;
    gSizer1 = new wxGridSizer( 0, 2, 0, 0 );
 
    SchCalendar = new wxGenericCalendarCtrl( this, wxID_ANY, wxDefaultDateTime, wxDefaultPosition, wxDefaultSize, wxCAL_SHOW_SURROUNDING_WEEKS|wxCAL_SEQUENTIAL_MONTH_SELECTION );
    SchCalendar->SetToolTip( l("Calendar To Compare Events: Red = Other Events(List At Right), Purple = Selected Schedule Date(List Below)") );
    wxFont CalFont(11, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL,wxFONTWEIGHT_LIGHT, true);
    SchCalendar->SetOwnFont(CalFont);
    SchCalendar->SetBackgroundColour(wxColor(ColorRed[1],ColorGreen[1],ColorBlue[1],225));
    SchCalendar->SetForegroundColour(wxColor(ColorRed[2],ColorGreen[2],ColorBlue[2],225));
    SchCalendar->SetHeaderColours (wxColor(0,0,0,225), wxColor(211,211,211,225));
 
    gSizer1->Add( SchCalendar, 1, wxALL|wxEXPAND, 5 );
 
    wxBoxSizer* bSizer2;
    bSizer2 = new wxBoxSizer( wxVERTICAL );
 
    wxArrayString SchFilterChoiceChoices;
    SchFilterChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, SchFilterChoiceChoices, 0 );
    SchFilterChoice->SetSelection( 0 );
    SchFilterChoice->SetToolTip( l("Filter Events Shown In List") );
 
    bSizer2->Add( SchFilterChoice, 0, wxALL|wxEXPAND, 5 );
 
    SchOtherEvtList = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT );
    SchOtherEvtList->SetToolTip( l("This List Shows Events For Selected Month") );
 
    bSizer2->Add( SchOtherEvtList, 1, wxALL|wxEXPAND, 5 );
 
 
    gSizer1->Add( bSizer2, 1, wxEXPAND, 5 );
 
 
    bSizer1->Add( gSizer1, 1, wxEXPAND, 5 );
 
    m_staticline1 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    bSizer1->Add( m_staticline1, 0, wxEXPAND | wxALL, 5 );
 
    SchList = new wxListView( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT );
    SchList->SetToolTip( l("Schedules List") );
 
    bSizer1->Add( SchList, 1, wxALL|wxEXPAND, 5 );
 
 
    wxGridSizer* gSizer2;
    gSizer2 = new wxGridSizer( 0, 3, 0, 0 );
 
    SchDelButton = new wxButton( this, wxID_ANY, l("Remove"), wxDefaultPosition, wxDefaultSize, 0 );
    SchDelButton->SetToolTip( l("Delete Schedule") );
 
    gSizer2->Add( SchDelButton, 0, wxEXPAND, 5 );
 
    SchAddButton = new wxButton( this, wxID_ANY, l("Add"), wxDefaultPosition, wxDefaultSize, 0 );
    SchAddButton->SetToolTip( l("Add Schedule") );
 
    gSizer2->Add( SchAddButton, 0, wxEXPAND, 5 );
 
    SchCloseButton = new wxButton( this, wxID_ANY, l("Close"), wxDefaultPosition, wxDefaultSize, 0 );
    SchCloseButton->SetToolTip( l("Close This Dialog") );
 
    gSizer2->Add( SchCloseButton, 0, wxEXPAND, 5 );
 
    bSizer1->Add( gSizer2, 0, wxEXPAND|wxALL, 5 );
 
 
    this->SetSizer( bSizer1 );
    this->Layout();
 
    this->Centre( wxBOTH );
    
    SchList->Bind(wxEVT_COMMAND_LIST_ITEM_SELECTED, &ScheduleDialog::OnSchListSelect, this );
    SchList->Bind(wxEVT_COMMAND_LIST_ITEM_DESELECTED, &ScheduleDialog::OnSchListDESelect, this );
    SchAddButton->Bind(wxEVT_BUTTON, &ScheduleDialog::OnAddButton, this );
    SchDelButton->Bind(wxEVT_BUTTON, &ScheduleDialog::OnRemvButton, this );
    SchCloseButton->Bind(wxEVT_BUTTON, &ScheduleDialog::OnClose, this );
    SchFilterChoice->Bind(wxEVT_CHOICE, &ScheduleDialog::FilterChanged, this );
    SchCalendar->Bind(wxEVT_CALENDAR_PAGE_CHANGED, &ScheduleDialog::SchCalendarChanged, this );
    
    //Set up sort options
    SchFilterChoice->Append(l("Show All Dates"));
    SchFilterChoice->Append(l("Show Only Hatch Dates"));
    SchFilterChoice->Append(l("Show Only Start Dates"));
    SchFilterChoice->Append(l("Show Only Candle Dates"));
    SchFilterChoice->Append(l("Show Only Lockdown Dates"));
    SchFilterChoice->SetSelection(0);
    
    ShowAllEvents(); 
    ShowSchedules(false);
}
 
void ScheduleDialog::OnAddButton(wxCommandEvent&)
{
    AddScheduleDialog *dialog = new AddScheduleDialog(this,906,l("Add Schedule"));
    dialog->ShowModal();
    dialog->Destroy();
    ShowSchedules(true);
}
 
void ScheduleDialog::ShowSchedules(bool Scan)
{
    HK_Date Date;
 
    if(Scan)
        Schedules = Database.ReadSchedules();
 
    SchList->ClearAll();//Clear the previous list items
    SchList->InsertColumn(0,l("Schedule Name" ), wxLIST_FORMAT_LEFT, 160);
    SchList->InsertColumn(1,l("Date" ), wxLIST_FORMAT_LEFT, 100);
 
    for(int count1 = 0; count1 < Schedules.GetCount(); count1++) {
        Date = Schedules.GetDate(count1);
        SchList->InsertItem(count1, wxString::Format(wxT("%s"), Schedules.GetName(count1).c_str()));
        SchList->SetItem(count1, 1,wxString::Format(wxT("%s"),Date.ToReadable("/",Settings.GetInt("DateMode"))) );
    }
    SchDelButton->Disable();
}
 
void ScheduleDialog::OnClose(wxCommandEvent&){EndModal(0);}
 
void ScheduleDialog::OnRemvButton(wxCommandEvent& )
{
    int sel = SchList->GetFirstSelected();
    if(sel == -1){
        wxMessageDialog* dialog = new wxMessageDialog(this, l("No Item Is Selected!"));
        dialog->ShowModal();
        dialog->Destroy();
        return;
    }
 
    int really  = wxMessageBox(
        wxString::Format(wxT("Delete %s ?"),
        Schedules.GetName(sel).c_str()), l("Delete?"),
        wxOK| wxCANCEL
    );
 
    if (really == 4) {
        if(!Database.Execute("DELETE FROM Schedules where ID = " + to_string(Schedules.GetID(sel)) + ";")) {
            wxMessageDialog* dialog = new wxMessageDialog(this,
            "Sqlite Error: " + Database.GetErrors());
            dialog->ShowModal();
            dialog->Destroy();
            return;
        }
        ShowSchedules(true);
    }
    else
        return;
}
 
void ScheduleDialog::OnSchListSelect(wxListEvent&) {
    RemoveAllAttr();
    SchDelButton->Enable(true);
}
 
void ScheduleDialog::OnSchListDESelect(wxListEvent&) {
    RemoveAllAttr();
    SchDelButton->Disable();
}
 
void ScheduleDialog::FilterChanged(wxCommandEvent&)
{   
    switch(SchFilterChoice->GetSelection()) {
        case 0: {
            ShowStart = true;
            ShowCandl = true;
            ShowLockd = true;
            ShowHatch = true;
            break;
        }
        case 1: {
            ShowStart = false;
            ShowCandl = false;
            ShowLockd = false;
            ShowHatch = true;
            break;
        }
        case 2: {
            ShowStart = true;
            ShowCandl = false;
            ShowLockd = false;
            ShowHatch = false;
            break;
        }
        case 3: {
            ShowStart = false;
            ShowCandl = true;
            ShowLockd = false;
            ShowHatch = false;
            break;
        }
        case 4: {
            ShowStart = false;
            ShowCandl = false;
            ShowLockd = true;
            ShowHatch = false;
            break;
        }
    }
    RemoveAllAttr();
}
 
void ScheduleDialog::SchCalendarChanged(wxCalendarEvent&){RemoveAllAttr();}
 
void ScheduleDialog::ShowAllEvents()
{
    //Get Selected Month/Year 
    wxDateTime calTime;
    calTime = SchCalendar->GetDate();
    HK_Date Date;
    Date.SetMonth(calTime.GetMonth(wxDateTime::Local) + 1);
    Date.SetYear(calTime.GetYear(wxDateTime::Local));
     
    int a,b,c = 0;
    vector<int> MarkArray;
    vector<string> MarkNotes;
    
    //Loop through all batches
    for(b = 0; b < Batches.GetCount(); b++) {
        if(Date.IsEqualMonth(Batches.GetStart(b)) && ShowStart == true) {
            MarkArray.push_back(Batches.GetStart(b).GetDay());
            MarkNotes.push_back(Batches.GetName(b) + l(" Start Date"));
        }
        
        if(Date.IsEqualMonth(Batches.GetCandle(b)) && ShowCandl == true) {
            MarkArray.push_back(Batches.GetCandle(b).GetDay());
            MarkNotes.push_back(Batches.GetName(b) + l(" Candle Date"));
        }
        
        if(Date.IsEqualMonth(Batches.GetLockdown(b)) && ShowLockd == true) {
            MarkArray.push_back(Batches.GetLockdown(b).GetDay());
            MarkNotes.push_back(Batches.GetName(b) + l(" Lockdown Date"));
            c++;
        }
        
        if(Date.IsEqualMonth(Batches.GetHatch(b)) && ShowHatch == true) {
            MarkArray.push_back(Batches.GetHatch(b).GetDay());
            MarkNotes.push_back(Batches.GetName(b) + l(" Hatch Date"));
        }
    }
        
    //Add To List View
    SchOtherEvtList->ClearAll();//Clear the previous list items
    SchOtherEvtList->InsertColumn(0,l("Event Name" ), wxLIST_FORMAT_LEFT, 160);
    SchOtherEvtList->InsertColumn(1,l("Day" ), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
 
    for(unsigned int count1 = 0; count1 < MarkArray.size(); count1++) {
        SchOtherEvtList->InsertItem(count1, wxString::Format(wxT("%s"), MarkNotes[count1].c_str()));
        SchOtherEvtList->SetItem(count1, 1,wxString::Format(wxT("%d"),MarkArray[count1]) );
        
        //Check Against SchAttr
        if(MarkArray[count1] == SchAttr)
            continue;
            
        //Check Against MarkAttr[]
        for(a = 0; a < MarkAttr.size(); a++) {
            if(MarkArray[count1] == MarkAttr[a])
                continue;
        }
        
        //Finally Add It To MarkAttr[] and mark it in SchCalendar
        MarkAttr.push_back(MarkArray[count1]);
        
        AddAttr(MarkArray[count1]);
    }
 
    SchCalendar->Refresh();
}
 
void ScheduleDialog::AddAttr(int Day)
{
    wxCalendarDateAttr* Attr1 = new  wxCalendarDateAttr(wxCAL_BORDER_NONE );
    Attr1->SetBackgroundColour (wxColour(225,0,0));
    
    SchCalendar->SetAttr( Day, Attr1);
}
 
void ScheduleDialog::SetSchAttr()
{
    int listSel = SchList->GetFirstSelected();
 
    if(listSel == -1){
        SchAttr = -1;
        return;
    }
    
    HK_Date Date = Schedules.GetDate(listSel);
    
    wxDateTime calTime = SchCalendar->GetDate();
    HK_Date CalDate(
        calTime.GetDay(wxDateTime::Local),
        calTime.GetMonth(wxDateTime::Local) + 1,
        calTime.GetYear(wxDateTime::Local)
    );
 
    if(!Date.IsEqualMonth(CalDate)) {
        SchAttr = -1;
        return;
    }
    
    wxCalendarDateAttr* Attr1 = new  wxCalendarDateAttr(wxCAL_BORDER_NONE );
    Attr1->SetBackgroundColour (wxColour(128,0,128));   
    
    SchCalendar->SetAttr( Date.GetDay(), Attr1);
    SchAttr = Date.GetDay();
    SchCalendar->Refresh();
}
 
void ScheduleDialog::RemoveAllAttr()
{
    //Reset Sch List Selection
    if(SchAttr != -1) {
        SchCalendar->ResetAttr(SchAttr);
        SchAttr = -1;
    }
    
    //Reset Other Events
    for(unsigned int a = 0; a < MarkAttr.size(); a++)
        SchCalendar->ResetAttr(MarkAttr[a]);
    
    MarkAttr.clear();
    
    SchCalendar->Refresh();
    
    SetSchAttr();
    ShowAllEvents();
}