/home/millj/Documents/1-Code/HatchKeeper/HatchKeeper.cpp

Go to the documentation of this file.

/**************************H*A*T*C*H*K*E*E*P*E*R************************
* 
*      HatchKeeper v0.90.dev (C) 2017 - 2023 The HatchKeeper Team.
* 
*            Free Open-Source Egg Incubation Software.
* 
*                   ***     ***     ***     ***
*                   ***     ***     ***   ***
*                   ***********     ***  ***
*                   ***********     *** *** 
*                   ***     ***     ***   ***
*                   ***     ***     ***     *** 
* 
*   This program is free software: you can redistribute it and/or modify
*   it under the terms of the GNU General Public License as published
*   by the Free Software Foundation, version 3 of the License.
*
*   This program is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of 
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*   GNU General Public License for more details.
*
*   You should have received a copy of the GNU General Public License
*   along with this program. If not, see <http://www.gnu.org/licenses/>. 
* 
*****************************************************************H*K*T*/ 
#include "HatchKeeper.h"        //HatchFrame Class
 
int HatchCondition = 0;        //Read from condition File at startup
 
static HatchFrame* frame = NULL;       //for running in background
static wxNotificationMessage * TheNotification = NULL;
static wxGenericNotificationMessage  * TheGenNotification = NULL;
bool UsedGen = true;  //Which Notification was actually used
 
static bool ActuallyExit = false;
 
DECLARE_APP(HatchApp)
 
IMPLEMENT_APP(HatchApp)
 
BEGIN_EVENT_TABLE(HatchApp, wxApp)
    EVT_END_SESSION(HatchApp::OnExitSession)
    EVT_QUERY_END_SESSION(HatchApp::OnExitSession)
END_EVENT_TABLE()
 
//Main Frame events
BEGIN_EVENT_TABLE(HatchFrame, wxFrame)
    EVT_TOOL(ON_IMPORT,HatchFrame::OnImport)
    EVT_TOOL(ON_BATCH,HatchFrame::OnNewBatch)
    EVT_TOOL(ON_SCH,HatchFrame::OnSchedule)
    EVT_TOOL(ON_PREF,HatchFrame::OnPreference)
#ifndef __NO_GRAPH__
    EVT_TOOL(ON_GRAPH,HatchFrame::OnGraph)
#endif //__NO_GRAPH__
    EVT_TOOL(ON_REFR,HatchFrame::OnRefresh)
    EVT_TOOL(ON_REMIND,HatchFrame::OnRemind)
    EVT_TOOL(ON_ABOUT,HatchFrame::OnAbout)
    EVT_TOOL(ON_QUIT,HatchFrame::OnQuit)
    EVT_TOOL(ON_SEARCH,HatchFrame::OnSearch)
    EVT_SPINCTRL(ON_EGG, HatchFrame::OnEggSpinner)
    EVT_SPINCTRL(ON_FERTILE, HatchFrame::OnFertileSpin)
    EVT_SPINCTRL(ON_HATCHED, HatchFrame::OnHatchedSpin)
    EVT_BUTTON(ON_UPDATE,HatchFrame::OnUpdate)
    EVT_BUTTON(ON_DELETE,HatchFrame::OnDelete)
    EVT_CHOICE(ON_MORE, HatchFrame::OnMoreActions)
    EVT_BUTTON(ON_CALPRN,HatchFrame::OnCalPrn)
    EVT_CALENDAR_PAGE_CHANGED(CAL_CHANGE, HatchFrame::OnCalChange)
    EVT_CHOICE(ON_SORT, HatchFrame::OnSort)
    EVT_CHECKBOX(HIDE_HATCH, HatchFrame::OnHideChange)
    
    //Advanced
    EVT_TEXT(ADV_EGG_COM, HatchFrame::OnEggCommentChange)
    EVT_CHECKBOX(ADV_FERTILE, HatchFrame::OnAdvFertileChecked)
    EVT_CHECKBOX(ADV_PIP, HatchFrame::OnAdvPippedChecked)
    EVT_SPINCTRLDOUBLE(ADV_WEIGHT, HatchFrame::OnWeightChange)
    EVT_TEXT(ADV_DAY_COM, HatchFrame::OnDayCommentChange)
    EVT_CHOICE(ADV_RES_CH,HatchFrame::OnAdvResultChoice)
    EVT_DATE_CHANGED(ADV_RES_DATE, HatchFrame::OnAdvResultDate)
    EVT_CHOICE(ADV_TAG_CH, HatchFrame::OnTagsChange)
 
    //Groups
    EVT_BUTTON(GR_ADD, HatchFrame::OnAddGroup)
    EVT_BUTTON(GR_DELETE, HatchFrame::OnDelGroup)
    EVT_BUTTON(GR_COMMENT, HatchFrame::OnGrComment)
    EVT_CHOICE(GR_MORE, HatchFrame::OnMoreGroupActions)
    
    EVT_CLOSE(HatchFrame::OnCloseWindow)
    EVT_TIMER(TIMER1,HatchFrame::OnTimer)    
END_EVENT_TABLE()
 
//Taskbar and notifications 
BEGIN_EVENT_TABLE(HatchTaskBarIcon, wxTaskBarIcon)
    EVT_MENU(ON_RESHOW, HatchTaskBarIcon::OnWindowRestore)
    EVT_MENU(ON_EXIT, HatchTaskBarIcon::OnWindowExit)
END_EVENT_TABLE()
 
 
#ifndef __WXMSW__
void HatchTerm(int signum)
{
    //Write a int to tell inform HatchKeeper on start-up
    string FileFolder = HATCHKEEPER_DATA + "Condition";
    FILE *fp;
 
    if ((fp = fopen(FileFolder.c_str(), "w"))== NULL)
        fprintf(stderr,"Error Creating HatchKeeper Condition File!");
    else {
        fprintf(fp,"1");
        fclose(fp);
    }
    
    ActuallyExit = true;
    frame->Close(true);
}
#endif //__WXMSW__
 
bool HatchApp::OnInit()
{
    wxLogNull nolog; //remove stale lockfile warning
    
    //Check For Previous Instance.
    h_checker = new wxSingleInstanceChecker;
    if ( h_checker->IsAnotherRunning()) {
        //Create a client and connect to Previous Instance
        h_client = new HatchClient;
        bool value = h_client->Connect(IPC_HOST, IPC_SERVICE, IPC_TOPIC);
        if (!value)
            wxDELETE(h_client);
        
        wxString s = wxT("HatchKeeper");
        h_client->GetConnection()->Execute(s);
        h_client->Disconnect();
        
        delete h_server;
        h_server = NULL;
        
        delete h_client;
        h_client = NULL;
        
        delete h_checker;
        h_checker = NULL;
        
        //Exit This Instance
        return false;
    }
    
    //else start a server.
    h_server = new HatchServer;
    if (!h_server->Create(IPC_SERVICE)) {
        std::cout<<"Server %s failed to start\n";
        wxDELETE(h_server);
    }
    
//set up for sigterm under Linux
#ifndef __WXMSW__
    struct sigaction action;
    memset(&action, 0, sizeof(struct sigaction));
    action.sa_handler = HatchTerm;
    sigaction(SIGTERM, &action, NULL);
#endif //__WXMSW__
    
    //See what stopped HatchKeeper
    string FileFolder = HATCHKEEPER_DATA + "Condition";
    FILE *fp;
    cout<<FileFolder<<endl;
    if ((fp = fopen(FileFolder.c_str(), "r"))== NULL)
        fprintf(stderr,"Warning, HatchKeeper Condition File Not Found!");
    else {
        fscanf(fp,"%d", &HatchCondition);
        fclose(fp);
    }
    
    frame = new HatchFrame();
    
    if(HatchCondition == 0)
        frame->Show(true); 
    else
        frame->Show(false); //System startup
    
    return true;
}
 
int HatchApp::OnExit()
{
    delete h_checker;
    h_checker = NULL;
    
    delete h_server;
    h_server = NULL;
    
    delete h_client;
    h_client = NULL;
    
    return false;
}
 
void HatchApp::MacReopenApp(){ShowFrame();}
 
void HatchApp::OnExitSession(wxCloseEvent& evt)
{
    string FileFolder = HATCHKEEPER_DATA + "Condition";
    
    //Write a int to tell inform HatchKeeper on start-up
    FILE *fp;
 
    if ((fp = fopen(FileFolder.c_str(), "w"))== NULL) {
        fprintf(stderr,"Error Creating HatchKeeper Condition File!");
        //return;
    }
    else {
        fprintf(fp,"1");
        fclose(fp);
    }
    
    frame->Close(true);
    evt.Skip(); 
}
 
HatchFrame::~HatchFrame(){}
 
void HatchFrame::OnCloseWindow(wxCloseEvent &evt)
{
    if( evt.CanVeto() && ActuallyExit == false) {
        Show(false);
        evt.Veto();
        return;
    }
    else {
        //close
        evt.Skip();
    }
}
 
void HatchFrame::OnQuit(wxCommandEvent& )
{
    int answer = wxMessageBox(
        l("Exit Completely?") + "\n" + l("Yes( No Notifications! )") + "\n" + l("No( Run In Background )"), 
        l("Confirm"),
          wxYES_NO | wxCANCEL, 
          this
    );
    if (answer == wxYES) {
        string FileFolder = HATCHKEEPER_DATA + "Condition";
    
        //Write a int to tell inform HatchKeeper on start-up
        FILE *fp;
 
        if ((fp = fopen(FileFolder.c_str(), "w"))== NULL)
            fprintf(stderr,"Error Creating HatchKeeper Condition File!");
        else {
            fprintf(fp,"0");
            fclose(fp);
        }
        m_taskBarIcon->Destroy();
        ActuallyExit = true; 
        frame->Close(true);
    }
    
    if (answer == wxNO) {
        ActuallyExit = false;
        Show(false);
    }
}
 
void HatchFrame::OnImport(wxCommandEvent&)
{
    wxFileDialog importDialog(
        NULL, 
        l("Import Batch File"),
        wxEmptyString, 
        wxEmptyString, 
        "HatchKeeper Batch Files (*.hkbf)|*.hkbf", 
        wxFD_OPEN|wxFD_FILE_MUST_EXIST, 
        wxDefaultPosition, 
        wxDefaultSize, 
        l("Batches")
    );
 
    if (importDialog.ShowModal() == wxID_CANCEL)
        return;
 
    vector<string> SQL = ExportImport.ImportHKBF(
        importDialog.GetPath().ToStdString(), 
        &Batches, 
        &Groups,
        &Types,
        &Breeds,
        &Schedules
    );
 
    if(SQL.size() < 1) {
        ShowMsg(l("Error! Couldn't Read File!"));
        return;
    }
 
    if(!Database.Execute(SQL))
        ShowMsg("Sqlite Error: " + Database.GetErrors());
 
    Today.Reset();
    ShowBatches(false);
    ShowGroups(true);
}
 
void HatchFrame::OnNewBatch(wxCommandEvent& )
{
    MainList->Select(MainList->GetFirstSelected(),false);//Unselect
    
    BatchDialog* dialog = new BatchDialog(this,200,l("New Batch"));
    dialog->ShowModal();
    bool isCancel = dialog->WasCanceled();
    dialog->Destroy();
 
    if(!isCancel)
       ShowBatches(true);
}
 
void HatchFrame::OnSort(wxCommandEvent&)
{
    MainList->Select(MainList->GetFirstSelected(),false);//Unselect
    
    Settings.SetValue("BatchSortState", to_string(SortBatchChoice->GetSelection()));
    ShowBatches(true);
    
    string SQL = "UPDATE Settings SET Value = '" + Settings.GetValue("BatchSortState") + "' WHERE Key = 'BatchSortState';";
    if(!Database.Execute(SQL))
        ShowMsg("Sqlite Error: " + Database.GetErrors());
}
 
void HatchFrame::OnSchedule(wxCommandEvent& )
{
    MainList->Select(MainList->GetFirstSelected(),false);//Unselect
    
    ScheduleDialog* dialog = new ScheduleDialog(this,9999,l("Schedule A Hatch Date"));
    dialog->ShowModal();
    dialog->Destroy();
}
 
void HatchFrame::OnRemind(wxCommandEvent& )
{
    MainList->Select(MainList->GetFirstSelected(),false);//Unselect
    
    ReminderDialog *dialog = new ReminderDialog(this,903,l("Reminders"));
    dialog->ShowModal();
    dialog->Destroy();
}
 
void HatchFrame::OnPreference(wxCommandEvent& )
{
    int sel = MainList->GetFirstSelected();
    MainList->Select(sel,false);//unselect
    
    PrefDialog* dialog = new PrefDialog(this,9900,l("Settings"));
    dialog->ShowModal();
    dialog->Destroy();
    
    //update colors
    vector<int> ColorRed = Settings.GetIntArray("ColorRed");
    vector<int> ColorGreen = Settings.GetIntArray("ColorGreen");
    vector<int> ColorBlue = Settings.GetIntArray("ColorBlue");
    //Main Window
    this->SetBackgroundColour(wxColor(ColorRed[0],ColorGreen[0],ColorBlue[0],225) );
 
    //Calendar
    wxFont CalFont(Settings.GetInt("CalTextSize"), wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL,wxFONTWEIGHT_BOLD, true);
    MainCalendar->SetOwnFont(CalFont);
    MainCalendar->SetBackgroundColour(wxColor(ColorRed[1],ColorGreen[1],ColorBlue[1],225));
    MainCalendar->SetForegroundColour(wxColor(ColorRed[2],ColorGreen[2],ColorBlue[2],225));
    
    //Batch List
    MainList->SetBackgroundColour(wxColor(ColorRed[3],ColorGreen[3],ColorBlue[3],225) );
    MainList->SetForegroundColour(wxColor(ColorRed[4],ColorGreen[4],ColorBlue[4],225));
 
    //NoteBook Panels
    BatchPanel->SetBackgroundColour( wxColor(ColorRed[5],ColorGreen[5],ColorBlue[5],225));
    BatchPanel->SetForegroundColour( wxColor(ColorRed[6],ColorGreen[6],ColorBlue[6],225));
       
    GroupPanel->SetBackgroundColour( wxColor(ColorRed[5],ColorGreen[5],ColorBlue[5],225));
    GroupPanel->SetForegroundColour( wxColor(ColorRed[6],ColorGreen[6],ColorBlue[6],225));
    
    NotePanel->SetBackgroundColour( wxColor(ColorRed[5],ColorGreen[5],ColorBlue[5],225));
    NotePanel->SetForegroundColour( wxColor(ColorRed[6],ColorGreen[6],ColorBlue[6],225));
    
    NoteList->SetBackgroundColour(wxColor(ColorRed[9],ColorGreen[9],ColorBlue[9],225) );
    NoteList->SetForegroundColour(wxColor(ColorRed[10],ColorGreen[10],ColorBlue[10],225));
    
    //Refresh it all   
    this->Refresh();
 
    ShowBatches(true);
    ShowGroups(true);
}
#ifndef __NO_GRAPH__
void HatchFrame::OnGraph(wxCommandEvent&)
{
    GraphDialog* dialog = new GraphDialog(this,9569,l("Graphs"));
    dialog->ShowModal();
    dialog->Destroy();
}
#endif //__NO_GRAPH__
 
void HatchFrame::OnRefresh(wxCommandEvent& )
{
    int sel = MainList->GetFirstSelected();
    MainList->Select(sel,false);//Unselect
    
    Today.Reset();
    MainCalendar->SetDate(wxDateTime::Now()); //Refresh MainCalendar.
    
    ShowBatches(true);
}
 
void HatchFrame::OnAbout(wxCommandEvent&)
{
    MainList->Select(MainList->GetFirstSelected(),false);//unselect
    
    HelpDialog* dialog = new HelpDialog(this,9909,l("About"));
    dialog->ShowModal();
    dialog->Destroy();
}
 
void HatchFrame::OnSearch(wxCommandEvent&)
{
    SearchDialog* dialog = new SearchDialog(this,9911,l("Search"));
    dialog->ShowModal();
    dialog->Destroy();
}
 
void HatchFrame::OnColumnClick(wxListEvent& evt) {
    if(evt.GetColumn() == 4) {
        switch(Settings.GetInt("ShowDaysLeft")) {
            case 0: {
                Settings.SetValue("ShowDaysLeft", "1");
                break;
            }
            case 1: {
                Settings.SetValue("ShowDaysLeft", "2");
                break;
            }
            case 2: {
                Settings.SetValue("ShowDaysLeft", "0");
                break;
            }
        }
        ShowBatches(false);
        
        string SQL = "UPDATE Settings SET Value = '" + Settings.GetValue("ShowDaysLeft") + "' WHERE Key = 'ShowDaysLeft';";
        if(!Database.Execute(SQL))
            ShowMsg("Sqlite Error: " + Database.GetErrors());
    }
}
 
void HatchFrame::OnListSelect(wxListEvent&)
{
    BatchPanel->Enable(true);
    
    wxDateTime calTime;
    int calYear, calMonth2;
    string calMonth;    
 
    RemoveAttr();
 
    //unselect GroupList
    int listSel2 = GroupList->GetFirstSelected();
    GroupList->Select(listSel2, false);
 
    //switch view to BatchStatPanel
    if(m_notebook2->GetSelection() == 2 || m_notebook2->GetSelection() == 3)
        m_notebook2->SetSelection(0);
 
    listSel = MainList->GetFirstSelected();
 
    //Setup Stats
    SetupBatchStats(listSel); 
 
    //Setup Graph
    if(Batches.GetEggs(listSel) > 0)
        ShowBatchGraph(listSel);
 
    //Setup Calendar Attrs
    calTime = MainCalendar->GetDate();
    calYear = calTime.GetYear(); 
 
    calMonth = calTime.GetMonthName(calTime.GetMonth());
 
    calMonth2 = Today.MonthToInt(calMonth);
 
    HK_Date Start = Batches.GetStart(listSel);
    HK_Date Candle = Batches.GetCandle(listSel);
    HK_Date Lock = Batches.GetLockdown(listSel);
    HK_Date Hatch = Batches.GetHatch(listSel);
 
    if(calYear !=  Start.GetYear() &&
              calYear !=  Candle.GetYear() &&
                   calYear !=  Lock.GetYear() &&
                        calYear != Hatch.GetYear() )
       return;
 
    if(calMonth2 !=  Start.GetMonth() &&
              calMonth2 !=  Candle.GetMonth() &&
                   calMonth2 !=  Lock.GetMonth() &&
                        calMonth2 !=  Hatch.GetMonth())
       return;
 
     wxCalendarDateAttr* Attr1 = new  wxCalendarDateAttr(wxCAL_BORDER_NONE );
     Attr1->SetBackgroundColour (wxColour(128,0,128));
 
     wxCalendarDateAttr* Attr2 = new  wxCalendarDateAttr(wxCAL_BORDER_NONE  );
     Attr2->SetBackgroundColour (wxColour(0,0,255));
 
     wxCalendarDateAttr* Attr3 = new  wxCalendarDateAttr(wxCAL_BORDER_NONE  );
     Attr3->SetBackgroundColour (wxColour(0,128,0));
 
     wxCalendarDateAttr* Attr4 = new  wxCalendarDateAttr(wxCAL_BORDER_NONE  );
     Attr4->SetBackgroundColour (wxColour(255,0,0));
 
    if(calMonth2 == Start.GetMonth()) {
       MainCalendar->SetAttr( Start.GetDay(), Attr1);
       daysWAttr[dwAttr] = Start.GetDay();
       dwAttr++;    
    }
 
    if(calMonth2 ==   Candle.GetMonth()) {
       MainCalendar->SetAttr( Candle.GetDay(), Attr2);
       daysWAttr[dwAttr] =  Candle.GetDay();
       dwAttr++;    
    } 
 
    if(calMonth2 == Lock.GetMonth()) {
        MainCalendar->SetAttr( Lock.GetDay(), Attr3);
        daysWAttr[dwAttr] = Lock.GetDay();
        dwAttr++;   
    }
 
    if(calMonth2 == Hatch.GetMonth()) {   
        MainCalendar->SetAttr( Hatch.GetDay(), Attr4);   
        daysWAttr[dwAttr] = Hatch.GetDay();
        dwAttr++;    
    }
    MainCalendar->Refresh();
}
 
void HatchFrame::OnListDESelect(wxListEvent& evt)
{ 
    if(Batches.IsDirty(listSel)) 
        ShowMsg(l("Unsaved Batch Changes! Reselect Batch And Click Update To Save Changes"));
 
    UnsetBatchStats();
    RemoveAttr();
    BatchPanel->Disable();
    EggPanel->Disable();
}
 
void HatchFrame::SetupBatchStats(int sel)
{
    //Get Batch
    HK_Batch Batch = Batches.GetBatch(sel);
 
    //Set BatchName
    BPNameCtrl->ChangeValue(Batch.GetName().c_str());
 
    int count1, sel2 = -1;
 
    //Set BirdType
    BPTypeChoice->Clear();
 
    if(Batch.GetAdv() == 0) {
        for(count1 = 0; count1 < Types.GetCount(); count1++) {
            BPTypeChoice->Append(Types.GetName(count1).c_str());
            if(Types.GetName(count1) == Batch.GetType())
                sel2 = count1;
        }
        if(sel2 == -1) {
            BPTypeChoice->Append(Batch.GetType().c_str());
            BPTypeChoice->SetSelection(count1);
        }
        else 
            BPTypeChoice->SetSelection(sel2);
        BPTypeChoice->SetToolTip(l("Edit Type"));
    }
    else {
        BPTypeChoice->Append(Batch.GetType().c_str());
        BPTypeChoice->SetSelection(0);
        BPTypeChoice->SetToolTip(l("Editing Type Is Disabled When Advanced Is Enabled"));
    }
 
    sel2 = -1;
 
    //Set Breed
    BPBreedChoice->Clear();
    int z = 0;
    for(count1 = 0; count1 < Breeds.GetCount(); count1++) {
        if(Batch.GetType() == Breeds.GetText(count1)) {
            BPBreedChoice->Append(Breeds.GetName(count1).c_str());          
            if(Breeds.GetName(count1) == Batch.GetBreed())
                sel2 = z;
            z++;
        }
    }
    if(sel2 == -1) {
        BPBreedChoice->Append(Batch.GetBreed().c_str());
        BPBreedChoice->SetSelection(count1);
    }
    else 
        BPBreedChoice->SetSelection(sel2);
 
    sel2 = -1;
    //Set Group
    BPGroupChoice->Clear();
    for(count1 = 0; count1 < Groups.GetCount(); count1++) {
        BPGroupChoice->Append(Groups.GetName(count1).c_str());
        if(Groups.GetName(count1) == Batch.GetGroup())
            sel2 = count1;
    }
    BPGroupChoice->SetSelection(sel2);
 
    sel2 = -1;
    //Set Incubator
    BPIncubatorChoice->Clear();
    vector<string> Inc = Settings.GetArray("Incubators");
    for(count1 = 0; count1 < Inc.size(); count1++) {
        BPIncubatorChoice->Append(Inc[count1].c_str());
        if(Batch.GetIncubator() == Inc[count1])
            sel2 = count1;
    }
    
    if(sel2 == -1) {
        BPIncubatorChoice->Append(Batch.GetIncubator().c_str());
        BPIncubatorChoice->SetSelection(count1);
    }
    else 
        BPIncubatorChoice->SetSelection(sel2);
 
    //Set Eggs and the Fertile Spinner range
    BPEggSpin->SetValue(Batch.GetEggs());
    
    //Set Fertile Spinner
    BPFertileSpin->SetRange(0 , Batch.GetEggs());
    BPFertileSpin->SetValue(Batch.GetFertile());
    
    //Set HatchedChicks
    BPChicksHatchSpin->SetRange(0 , Batch.GetFertile());
    BPChicksHatchSpin->SetValue(Batch.GetChicks());
    
    //Set number of Fertile unhatched
    BPFerUnStat->SetLabel(wxString::Format(wxT("%d %s"),Batch.FertileUnhatched(),l("Fertile Unhatched")));
    BPPerWerFerStat->Refresh();
    
    //Set Percent Were Fertile
    BPPerWerFerStat->SetLabel(wxString::Format(wxT("%d%% %s"), Batch.PercentFertile(),l("Were Fertile")));
    BPPerWerFerStat->Refresh();
    
    //Set Percent OF Fertile Hatched
    BPPerOfFerStat->SetLabel(wxString::Format(wxT("%d%% %s"),Batch.PercentOfFertile(),l("Of Fertile Hatched"))); 
    BPPerOfFerStat->Refresh();
 
    //Set % Of Total Hatched
    BPPerOfTotalStat->SetLabel(wxString::Format(wxT("%d%% %s"), Batch.PercentOfTotal(),l("Of Total Hatched"))); 
    BPPerOfTotalStat->Refresh();
 
    //Set % Unhatched of total
    BPPerUnhatchStat->SetLabel(wxString::Format(wxT("%d%% %s"), Batch.PercentOfTotalUnhatched(),l("Of Total Unhatched")));
    BPPerUnhatchStat->Refresh();
    
    //Set Comments
    BPCommentCtrl->ChangeValue(Batch.GetComments().c_str());
    BPCommentCtrl->SetInsertionPoint(0);
 
    bool UseGauge = true;
    wxDateTime Date1;
    wxDateTime Date4;
    HK_Date Start = Batch.GetStart();
    //Set StartDate
    if(Start.IsValid()) { 
        wxDateTime startD(Start.GetDay(),
            wxDateTime::Month(wxDateTime::Jan + Start.GetMonth() - 1), 
            Start.GetYear(),
            0,0,0,0); 
            
        BPStartDateCtrl->SetValue(startD);
        Date1 = startD;
    }
    else {
        UseGauge = false;
        cout<<"Log: Invalid Start Date!"<<endl;
    }
 
    //Set CandleDate
    HK_Date Candle = Batch.GetCandle();
    if(Candle.IsValid()) {
        wxDateTime startC(Candle.GetDay(),
            wxDateTime::Month(wxDateTime::Jan + Candle.GetMonth() - 1), 
            Candle.GetYear(),
            0,0,0,0);
            
        BPCandleDateCtrl->SetValue(startC);
    }
    else
        cout<<"Log: Invalid Candle Date"<<endl;
 
    //Set LockdownDate
    HK_Date Lock = Batch.GetLockdown();
    if(Lock.IsValid()) {
        wxDateTime startT(Lock.GetDay(),
            wxDateTime::Month(wxDateTime::Jan + Lock.GetMonth() - 1), 
            Lock.GetYear(),
            0,0,0,0);
        BPLockDateCtrl->SetValue(startT);
    }
    else
        cout<<"Log: Invalid Lockdown Date"<<endl;
 
    //Set HatchDate
    HK_Date Hatch = Batch.GetHatch();
    if(Hatch.IsValid()) {
        wxDateTime startH(Hatch.GetDay(),
            wxDateTime::Month(wxDateTime::Jan + Hatch.GetMonth() - 1),
            Hatch.GetYear(),
            0,0,0,0);
        BPHatchDateCtrl->SetValue(startH);
        Date4 = startH;
    }
    else {
        cout<<"Log: Invalid Hatch Date"<<endl;
        UseGauge = false;
    }
 
    wxDateTime Now1 = wxDateTime::Today();
 
    //Set Progress Gauge
    if(UseGauge) {
        if(Now1.IsBetween(Date1,Date4)) {
            wxTimeSpan timeS = Date4.Subtract(Date1);
            BPProgressGauge->SetRange(timeS.GetDays());
    
            wxTimeSpan timeS2 = Now1.Subtract(Date1);
            BPProgressGauge->SetValue(timeS2.GetDays());    
        }
        else {
            if(Now1.IsEarlierThan(Date1))
                BPProgressGauge->SetValue(0);
 
            if(Now1.IsLaterThan(Date4)) {
                BPProgressGauge->SetRange(10);
                BPProgressGauge->SetValue(10);
            }
        }
    }
 
    //More Actions
    if(Batch.GetAdv() == 0) {
        MoreActionsChoice->Append(l("Enable Advanced"));
        AdvMoreChoice->Append(l("Enable Advanced"));
    }
    else {
        MoreActionsChoice->Append(l("Disable Advanced"));
        AdvMoreChoice->Append(l("Disable Advanced"));
        ShowAdvanced();
    }
}
 
void HatchFrame::UnsetBatchStats()
{
    BPNameCtrl->ChangeValue(" ");
    BPTypeChoice->Clear();
    BPBreedChoice->Clear();
    BPGroupChoice->Clear();
    BPIncubatorChoice->Clear();
    BPEggSpin->SetValue(0);
    BPFertileSpin->SetValue(0);
    BPChicksHatchSpin->SetValue(0);
    
    BPFerUnStat->SetLabel(wxString::Format(wxT("0 %s"),l("Fertile Unhatched")));
    BPFerUnStat->Refresh();
    
    BPPerWerFerStat->SetLabel(wxString::Format(wxT("0%% %s"),l("Where Fertile")));
    BPPerWerFerStat->Refresh();
    
    BPPerOfFerStat->SetLabel(wxString::Format(wxT("0%% %s"),l("Of Fertile Hatched"))); 
    BPPerOfFerStat->Refresh();
 
    BPPerOfTotalStat->SetLabel(wxString::Format(wxT("0%% %s"),l("Of Total Hatched"))); 
    BPPerOfTotalStat->Refresh();
 
    BPPerUnhatchStat->SetLabel(wxString::Format(wxT("0%% %s"),l("Of Total Unhatched")));
    BPPerUnhatchStat->Refresh();
    
    BPProgressGauge->SetValue(0);
 
    //Reset DatePickers
    BPStartDateCtrl->SetValue(wxDateTime::Today());
    BPCandleDateCtrl->SetValue(wxDateTime::Today());
    BPLockDateCtrl->SetValue(wxDateTime::Today());
    BPHatchDateCtrl->SetValue(wxDateTime::Today());
 
    BPCommentCtrl->ChangeValue(l("Comments: "));
 
    //More Actions
    MoreActionsChoice->Delete(MoreActionsChoice->GetCount() - 1);
    AdvMoreChoice->Delete(AdvMoreChoice->GetCount() - 1);
 
    //Clear Avanced Data
    ClearAdvPanel();
}
 
void HatchFrame::ShowBatchGraph(int sel)
{
#ifndef __NO_GRAPH__
    wxString title = l("Batch"); //graph title
    
    wxString names[2];
    double values1[2];
    double values2[2];
    double values3[2];
    double values4[2];
    
    names[0] = Batches.GetName(sel);
    values1[0] = Batches.PercentFertile(sel);
    values2[0] = Batches.PercentOfFertile(sel);
    values3[0] = Batches.PercentOfTotal(sel);
    values4[0] = Batches.PercentOfTotalUnhatched(sel);
 
    names[1] = " ";
    values1[1] = 0;
    values2[1] = 0;
    values3[1] = 0;
    values4[1] = 0;
    
    // Create dataset
    CategorySimpleDataset *dataset = new CategorySimpleDataset(names, WXSIZEOF(names));
 
    // add series to it
    dataset->AddSerie(wxT("% Were Fertile"), values1, WXSIZEOF(values1));
    dataset->AddSerie(wxT("% Of Fertile Hatched"), values2, WXSIZEOF(values2));
    dataset->AddSerie(wxT("% Of Total Hatched"), values3, WXSIZEOF(values3));
    dataset->AddSerie(wxT("% 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);
 
    // and finally construct and return chart
    BatchGraphPanel->SetChart(new Chart(plot, title));
#endif
}
 
void HatchFrame::OnCalChange(wxCalendarEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel != -1)
        MainList->Select(sel,false);//unselect
    
    RemoveAttr();
    
    if(sel != -1)
        MainList->Select(sel,true);//Reselect
}
 
void HatchFrame::OnHideChange(wxCommandEvent&)
{
    bool sel = HideCheckBox->GetValue();
    
    if(sel)
        Settings.SetValue("HideHatched","1");
    else
        Settings.SetValue("HideHatched","0");
        
    ShowBatches(false);
 
    //Save 
    string SQL = "UPDATE Settings SET Value = '" + Settings.GetValue("HideHatched");
    SQL += "' WHERE Key = 'HideHatched';";
    if(!Database.Execute(SQL)) {
        ShowMsg("Sqlite Error: " + Database.GetErrors());
        return;
    }
}
 
void HatchFrame::OnCalPrn(wxCommandEvent&)
{
    wxDateTime selDate = MainCalendar->GetDate();
    HK_Date CalDate(
        selDate.GetDay(wxDateTime::Local),
        selDate.GetMonth(wxDateTime::Local) + 1,
        selDate.GetYear(wxDateTime::Local)
    );
    string HTML = ExportImport.HTMLCalendar(CalDate,Batches);
 
    wxHtmlEasyPrinting* htmlPrn = new wxHtmlEasyPrinting(l("Printing"), NULL);
    htmlPrn->SetHeader("<h2 style='text-align:center;'>"+CalDate.MonthName()+"</h2>");
    htmlPrn->SetFooter("<h6 style='text-align:center;'>Automatically Generated By HatchKeeper On @DATE@</h6>");
    
    htmlPrn->PrintText(HTML);
    
    delete htmlPrn;
    htmlPrn = NULL;
}
 
void HatchFrame::RemoveAttr()
{
    for(int counter = 0; counter < dwAttr; counter++)
        MainCalendar->ResetAttr(daysWAttr[counter]); 
    
    dwAttr = 0;
    MainCalendar->Refresh(); 
    listSel = -1;
}
       
void HatchFrame::ShowBatches(bool Scan)
{
    if(Scan)
        Batches = Database.ReadBatches(SortBatchChoice->GetSelection());
    
    MainList->ClearAll();//Clear the previous list items
    MainList->InsertColumn(0,l("Name" ), wxLIST_FORMAT_LEFT, 160);
    MainList->InsertColumn(1,l("# of Eggs" ), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    MainList->InsertColumn(2,l("Type" ), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE );
    MainList->InsertColumn(3,l("Breed" ), wxLIST_FORMAT_LEFT, 120 );
    
    if(Settings.GetValue("ShowDaysLeft") != "Error!") {
        switch(Settings.GetInt("ShowDaysLeft")) {
            case 0: {
                MainList->InsertColumn(4,l("Group" ), wxLIST_FORMAT_LEFT, 150 );
                break;
            }
            case 1: {
                MainList->InsertColumn(4,l("Days Left" ), wxLIST_FORMAT_LEFT, 150 );
                break;
            }
            case 2: {
                MainList->InsertColumn(4,l("On Day" ), wxLIST_FORMAT_LEFT, 150 );
                break;
            }
        }
    }
    else
        MainList->InsertColumn(4,l("Group" ), wxLIST_FORMAT_LEFT, 150 );
        
    //Colors
    vector<int> ColorRed = Settings.GetIntArray("ColorRed");
    vector<int> ColorGreen = Settings.GetIntArray("ColorGreen");
    vector<int> ColorBlue = Settings.GetIntArray("ColorBlue");
 
    Today.Reset();//In case the window is open for several days
    HK_Batch Batch;
    HK_Date Date;
    for (int count1 = 0; count1 < Batches.GetCount(); count1++) {
        Batch = Batches.GetBatch(count1);
        MainList->InsertItem(count1, wxString::Format(wxT("%s"), Batch.GetName().c_str()));
        MainList->SetItem(count1, 1,wxString::Format(wxT("%d"), Batch.GetEggs()) );
        MainList->SetItem(count1, 2,wxString::Format(wxT("%s"), Batch.GetType().c_str()));
        MainList->SetItem(count1, 3,wxString::Format(wxT("%s"), Batch.GetBreed()) );
        
        if(Settings.GetValue("ShowDaysLeft") != "Error!") {
            switch(Settings.GetInt("ShowDaysLeft")) {
                case 0: {
                    MainList->SetItem(count1, 4,wxString::Format(wxT("%s"), Batch.GetGroup().c_str()));
                    break;
                }
                case 1: {
                    MainList->SetItem(count1, 4,wxString::Format(wxT("%d"), Batch.GetDaysLeft()));
                    break;
                }
                case 2: {
                    MainList->SetItem(count1, 4,wxString::Format(wxT("%s"), to_string(Batch.OnDay()) + " "+l("Of")+" " + to_string(Batch.GetStart().Difference(Batch.GetHatch()))) );
                    break;
                }
            }
        }
        else
            MainList->SetItem(count1, 4,wxString::Format(wxT("%s"), Batch.GetGroup().c_str()));
        
        //mark batches that are hatched
        if(Settings.GetInt("HideHatched")) {
            Date = Batch.GetHatch();
            if(Today.GetYear() < Date.GetYear()) {
                ;//Do Nothing
            }
            else if(Date.GetYear() < Today.GetYear()) {
                MainList->SetItemTextColour(count1,wxColor(ColorRed[3],ColorGreen[3],ColorBlue[3],225));
            }
            else {
                //batchHYear == todayYear
                if(Date.GetMonth() > Today.GetMonth()) {
                    ;//Do Nothing
                }
                else if(Date.GetMonth() < Today.GetMonth()) {
                    MainList->SetItemTextColour(count1,wxColor(ColorRed[3],ColorGreen[3],ColorBlue[3],225));
                }
                else {
                    //todayMonth == batchHMonth
                    if(Date.GetDay() < Today.GetDay()) {
                        MainList->SetItemTextColour(count1, wxColor(ColorRed[3],ColorGreen[3],ColorBlue[3],225));
                    }
                }
            }
        }   
    }
    BatchPanel->Enable(false);
}
 
void HatchFrame::OnBatchName(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1)
        return;
    
    HK_Batch Batch = Batches.GetBatch(sel);
    
    Batch.SetName(BPNameCtrl->GetLineText(0).ToStdString());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnBatchType(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1)
        return;
    
    HK_Batch Batch = Batches.GetBatch(sel);
    string Type = BPTypeChoice->GetString(BPTypeChoice->GetSelection()).ToStdString();
    Batch.SetType(Type);
    
    //Set Breed
    BPBreedChoice->Clear();
    BPBreedChoice->Append("Unknown");
    int z = 0, count1;
    for(count1 = 0; count1 < Breeds.GetCount(); count1++) {
        if(Batch.GetType() == Breeds.GetText(count1)) {
            BPBreedChoice->Append(Breeds.GetName(count1).c_str());          
            z++;
        }
    }
    BPBreedChoice->SetSelection(0);
    Batch.SetBreed("Unknown");
    
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnBatchBreed(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1)
        return;
    
    HK_Batch Batch = Batches.GetBatch(sel);
    
    Batch.SetBreed(BPBreedChoice->GetString(BPBreedChoice->GetSelection()).ToStdString());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnBatchGroup(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1)
        return;
    
    HK_Batch Batch = Batches.GetBatch(sel);
    
    Batch.SetGroup(BPGroupChoice->GetString(BPGroupChoice->GetSelection()).ToStdString());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnBatchIncubator(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1)
        return;
    
    HK_Batch Batch = Batches.GetBatch(sel);
    
    Batch.SetIncubator(BPIncubatorChoice->GetString(BPIncubatorChoice->GetSelection()).ToStdString());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnEggSpinner(wxSpinEvent&)
{
    int sel = MainList->GetFirstSelected();
    if(sel == -1)
        return;
    
    if(Batches.GetAdv(sel) == 1) {
        BPEggSpin->SetValue(Batches.GetEggs(sel));
        return;
    }
    BPFertileSpin->SetRange(0, BPEggSpin->GetValue());
    
    HK_Batch Batch = Batches.GetBatch(sel);
    
    Batch.SetEggs(BPEggSpin->GetValue());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnFertileSpin(wxSpinEvent&)
{
    int sel = MainList->GetFirstSelected();
    if(sel == -1)
        return;
        
    if(Batches.GetAdv(sel) == 1){
        BPFertileSpin->SetValue(Batches.GetFertile(sel));
        return;
    }
    BPChicksHatchSpin->SetRange(0, BPFertileSpin->GetValue());
    
    HK_Batch Batch = Batches.GetBatch(sel);
    Batch.SetFertile(BPFertileSpin->GetValue());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnHatchedSpin(wxSpinEvent&)
{
    int sel = MainList->GetFirstSelected();
    if(sel == -1)
        return;
        
    if(Batches.GetAdv(sel) == 1) {
        BPChicksHatchSpin->SetValue(Batches.GetChicks(sel));
        return;
    }
        
    HK_Batch Batch = Batches.GetBatch(sel);
    Batch.SetChicks(BPChicksHatchSpin->GetValue());
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnBatchDates(wxDateEvent&)
{
    int sel = MainList->GetFirstSelected();
    if(sel == -1)
        return;
 
    wxDateTime selDate = BPStartDateCtrl->GetValue();
    HK_Date Start(
        selDate.GetDay(wxDateTime::Local),
        selDate.GetMonth(wxDateTime::Local) + 1,
        selDate.GetYear(wxDateTime::Local)
    );
 
    selDate = BPCandleDateCtrl->GetValue();
    HK_Date Candle(
        selDate.GetDay(wxDateTime::Local),
        selDate.GetMonth(wxDateTime::Local) + 1,
        selDate.GetYear(wxDateTime::Local)
    );
 
    selDate = BPLockDateCtrl->GetValue();
    HK_Date Lock(
        selDate.GetDay(wxDateTime::Local),
        selDate.GetMonth(wxDateTime::Local) + 1,
        selDate.GetYear(wxDateTime::Local)
    );
 
    selDate = BPHatchDateCtrl->GetValue();
    HK_Date Hatch(
        selDate.GetDay(wxDateTime::Local),
        selDate.GetMonth(wxDateTime::Local) + 1,
        selDate.GetYear(wxDateTime::Local)
    );
    
    HK_Batch Batch = Batches.GetBatch(sel);
    Batch.SetStart(Start);
    Batch.SetCandle(Candle);
    Batch.SetLockdown(Lock);
    Batch.SetHatch(Hatch);
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnBatchComments(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    if(sel == -1)
        return;
 
    int lines = BPCommentCtrl->GetNumberOfLines();
    string Comment = ""; 
 
    if(lines == 1)
        Comment =  BPCommentCtrl->GetLineText(0);
    else {
        for (int c = 0;c < lines; c++) {   
            if(c == 0)
                Comment += BPCommentCtrl->GetLineText(c);
            else
                Comment += "\n" + BPCommentCtrl->GetLineText(c);
        }
    }
 
    HK_Batch Batch = Batches.GetBatch(sel);
    Batch.SetComments(Comment);
    Batches.SetBatch(sel, Batch);
}
 
void HatchFrame::OnDelete(wxCommandEvent&)
{
    int really,sel = MainList->GetFirstSelected();
    
    if(sel == -1) {
        ShowMsg(l("No Batch Selected!"));
        return;
    }
 
    really  = wxMessageBox(
        wxString::Format(wxT("Delete %s ?"), 
        Batches.GetName(sel).c_str()), 
        l("Delete?"),
        wxOK| wxCANCEL
    );
    
    MainList->Select(sel,false);
 
    if (really == 4) {
        if(Batches.GetAdv(sel) == 1) {
            if(!Database.Execute("DELETE FROM Advanced where ID = " + to_string(Batches.GetID(sel)) + ";")) {
                ShowMsg("Sqlite Error: " + Database.GetErrors());
                return;
            }
        }
        if(!Database.Execute("DELETE FROM Batches where ID = " + to_string(Batches.GetID(sel)) + ";")) {
            ShowMsg("Sqlite Error: " + Database.GetErrors());
            return;
        }
        ShowBatches(true);
    }
}
 
void HatchFrame::OnUpdate(wxCommandEvent&)
{
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1) {
        ShowMsg(l("No Batch Selected"));
        return;
    }
    vector<string> SQL = Batches.GetBatch(sel).GetUpdate();
    if(!Database.Execute(SQL)) {
        ShowMsg("Sqlite Error: " + Database.GetErrors());
        return;
    }
    Batches.SetClean(sel);
    MainList->Select(sel,false);
    ShowBatches(false);
    MainList->Select(sel,true);
}
 
void HatchFrame::OnMoreActions(wxCommandEvent&)
{
    int MoreSel = -1;
     
    if(MoreActionsChoice->GetSelection() != 0)
        MoreSel = MoreActionsChoice->GetSelection();
    else
        MoreSel = AdvMoreChoice->GetSelection();
    
    
    int sel = MainList->GetFirstSelected();
    
    if(sel == -1) {
        ShowMsg(l("No Batch Selected!"));
        MoreActionsChoice->SetSelection(0);
        AdvMoreChoice->SetSelection(0);
        return;
    }
    MainList->Select(sel,false);
        
    switch(MoreSel) {
        case 1: {
            wxHtmlEasyPrinting* htmlPrn = new wxHtmlEasyPrinting("Printing", NULL);
            htmlPrn->SetHeader("<h2 style='text-align:center;'>"+Batches.GetName(sel)+"</h2>");
            htmlPrn->SetFooter("<h6 style='text-align:center;'>Automatically Generated By HatchKeeper On @DATE@</h6>");
            
            string HTML = ExportImport.BatchHTMLReport(Batches.GetBatch(sel),Settings);
            if(!htmlPrn->PrintText(HTML)) {
                wxMessageDialog dialog(NULL,
                l("Error Printing!"));
                dialog.ShowModal();
            }
            
            delete htmlPrn;
            htmlPrn = NULL;
            
            break;
        }
        case 2: {
            wxFileDialog  exportDialog(NULL, 
                l("Export Report File"), 
                wxEmptyString, 
                Batches.GetName(sel).c_str(), 
                "Text Files (*.txt)|*.txt",
                wxFD_SAVE|wxFD_OVERWRITE_PROMPT, 
                wxDefaultPosition, 
                wxDefaultSize, 
                "Batches"
            );
            
            if (exportDialog.ShowModal() == wxID_CANCEL)
                break;
 
            string path = exportDialog.GetPath().ToStdString();
            wxFileName fname(path.c_str());    
            
            if(fname.GetExt() != "txt")
                path = path + ".txt";
            
            string Report = ExportImport.BatchTextReport(Batches.GetBatch(sel), Settings);
            Report += "\n\n\nAutomatically Generated By HatchKeeper on " + Today.ToReadable("/",Settings.GetInt("DateMode"));
            
            if(!Files.WriteTextFile(path , Report))
                ShowMsg(l("Error Writing File!"));
 
            break;
        }
        case 3: {
            //Get Batch
            HK_Batches batches;
            HK_Storage groups;
            batches.Add(Batches.GetBatch(sel));
            
            for(int a = 0; a < Groups.GetCount(); a++)
                if(Batches.GetGroup(sel) == Groups.GetName(a))
                    groups.Add(Groups.GetName(a),Groups.GetID(a),Groups.GetText(a));
 
            wxFileDialog  exDialog(NULL, 
                    l("Export Batch File"), 
                    wxEmptyString, 
                    Batches.GetName(sel).c_str(), 
                    "HatchKeeper Batch Files (*.hkbf)|*.hkbf", 
                    wxFD_SAVE|wxFD_OVERWRITE_PROMPT, 
                    wxDefaultPosition,
                    wxDefaultSize, 
                    "Batches"
            );
            
            if (exDialog.ShowModal() == wxID_CANCEL)
                return;
            
            string path = exDialog.GetPath().ToStdString();
            
            wxFileName fname(path.c_str());
            if(fname.GetExt() != "hkbf") 
                path += ".hkbf";
            
            ExportImport.ExportHKBF(path, batches, groups);
            
            break;
        }
        case 4: {
            wxFileDialog  exportDialog(NULL,
                l("Export Calendar File"), 
                wxEmptyString, 
                Batches.GetName(sel).c_str(), 
                "iCal Files (*.ics)|*.ics", 
                wxFD_SAVE|wxFD_OVERWRITE_PROMPT, 
                wxDefaultPosition,
                wxDefaultSize, 
                "Batches"
            );
        
            if (exportDialog.ShowModal() == wxID_CANCEL)
                break;
 
            string path = exportDialog.GetPath().ToStdString();
            wxFileName fname(path.c_str());
            
            if(fname.GetExt() != "ics")
                path += ".ics";
            
            if(!Files.WriteTextFile(path,ExportImport.BatchICal(Batches.GetBatch(sel),false)))
                ShowMsg("Error Writing File!");
                
            break;
        }
        case 5: {
            string Report = ExportImport.BatchTextReport(Batches.GetBatch(sel),Settings);
            // Write Report To Clipboard
            if (wxTheClipboard->Open()) {
                wxTheClipboard->SetData( new wxTextDataObject(Report) );
                wxTheClipboard->Close();
            }
            break;
        }
        case 6: {
            int really;
            if(Batches.GetAdv(sel) == 0) {
                really  = wxMessageBox(
                    wxString::Format(wxT("%s %s ?"), l("Enable Advanced For"),
                    Batches.GetName(sel).c_str()), 
                    "Enable?",
                    wxOK| wxCANCEL
                );
        
                if(really == 4) {
                    if(!SetBatchAsAdvanced(sel)) {
                        ShowMsg(l("Sqlite Error: ") + Database.GetErrors());
                        return;
                    }
                    
                    if(!Database.Execute("UPDATE Batches set AdvEnabled = 1 where ID = " + to_string(Batches.GetID(sel)) + ";"))
                        ShowMsg(l("Sqlite Error: ") + Database.GetErrors());
                }
            }
            else {
                really  = wxMessageBox(
                    wxString::Format(wxT("Disable Advanced For %s ?\nThis Will Delete All Advanced Data For This Batch!"), 
                    Batches.GetName(sel).c_str()), 
                    l("Disable?"),
                    wxOK| wxCANCEL
                );
            
                if(really == 4) {
                    if(!Database.Execute("UPDATE Batches set AdvEnabled = 0 where ID = " + to_string(Batches.GetID(sel)) + ";")) {
                        ShowMsg(l("Sqlite Error: ") + Database.GetErrors());
                        return;
                    }
                    
                    DeleteAdvanced(sel);
                }
            }
            ShowBatches(true);
            MainList->Select(sel, true);
            break;
        }
    }
    MoreActionsChoice->SetSelection(0);
    AdvMoreChoice->SetSelection(0);
}
 
void HatchFrame::ShowGroups(bool Scan)
{
    if(Scan)
        Groups = Database.ReadGroups();
        
    GroupList->ClearAll();//Clear the previous list items
    GroupList->InsertColumn(0,l("Name"), wxLIST_FORMAT_LEFT, 200);
    
    for (int G = 0; G < Groups.GetCount(); G++)
        GroupList->InsertItem(G, wxString::Format(wxT("%s"), Groups.GetName(G).c_str()));
    
    //Disable Buttons
    GrUpateButton->Enable(false);
    GrMoreChoice->Enable(false);
    GrDeleteButton->Enable(false);
}
 
void HatchFrame::AddGroup(string Name, string Comments)
{
    string SQL = "INSERT INTO Groups VALUES(" + to_string(Groups.GetValidID());
    SQL += ",'" + Name + "','" + Comments + " ');";
    
    if(!Database.Execute(SQL))
        ShowMsg("Sqlite Error: " + Database.GetErrors());
}
 
void HatchFrame::OnAddGroup(wxCommandEvent&)
{
    string GName;   
    wxTextValidator textVal(wxFILTER_INCLUDE_CHAR_LIST);
    textVal.SetCharIncludes(Info.GetValidChars().c_str());
    
    wxTextEntryDialog dlg(this, l("Enter Group Name"),l("Enter Name"),wxEmptyString,wxOK|wxCANCEL,wxDefaultPosition);
    dlg.SetTextValidator(textVal);
    
    if ( dlg.ShowModal() == wxID_OK )
        GName = dlg.GetValue();
    else 
        return;
    
    if(GName == "")
        return;
        
    if(!Groups.IsValidName(GName)) {    
        ShowMsg(l("Name Exists! Please Enter A New Name!"));
        return;
    }
 
    AddGroup(GName," ");
    ShowGroups(true); 
}
 
void HatchFrame::OnDelGroup(wxCommandEvent&)
{
    int listSel3 = GroupList->GetFirstSelected();
    
    GroupList->Select(listSel3, false);
    
    if(listSel3 == -1) {
        ShowMsg(l("No Group Is Selected"));
        return;
    }
    
    if(Groups.GetName(listSel3) == "None") {
        ShowMsg(l("This Group Can't Be Deleted"));
        return;
    }
 
    //Get Batches 
    HK_Batches GrBatches;
    for(int C = 0; C < Batches.GetCount(); C++)
        if(Batches.GetGroup(C) == Groups.GetName(listSel3))
            GrBatches.Add(Batches.GetBatch(C));
 
    if(GrBatches.GetCount() < 1) {
        wxMessageDialog dialog(this,l("There Are No Batches In This Group!\nAre You Sure You Want To Delete"),l("Delete?"),wxCANCEL|wxOK);
        if ( dialog.ShowModal() == wxID_OK ) {
           if(!Database.Execute("DELETE FROM Groups where ID = " + to_string(Groups.GetID(listSel3)) + ";"))
                ShowMsg("Sqlite Error: " + Database.GetErrors());
           ShowGroups(true);
        }
        return;
    }
    else {
        string GDWarning = "Deleting This Group Will Delete " + to_string(GrBatches.GetCount());
        GDWarning +=" Batches\nAre You Sure You Want To Delete?";
        
        wxMessageDialog dialog(this,l(GDWarning).c_str(),l("Delete?"),wxCANCEL|wxOK);
       
        if(dialog.ShowModal() == wxID_OK){
            for(int C = 0; C < GrBatches.GetCount(); C++) {
                if(!Database.Execute("DELETE FROM Batches WHERE ID = " + to_string(GrBatches.GetID(C)) + ";"))
                    ShowMsg("Sqlite Error: " + Database.GetErrors());
            }
            
            //And Remove The Group
            if(!Database.Execute("DELETE FROM Groups WHERE ID = " + to_string(Groups.GetID(listSel3)) + ";"))
                ShowMsg("Sqlite Error: " + Database.GetErrors());
            
            //Rescan
            ShowGroups(true);
            ShowBatches(true);
        }
    }
}
 
void HatchFrame::OnGroupSelect(wxListEvent&)
{
    //Enable Buttons
    GrUpateButton->Enable(true);
    GrMoreChoice->Enable(true);
    GrDeleteButton->Enable(true);
    
    int sel = MainList->GetFirstSelected();
    int GrSel = GroupList->GetFirstSelected();
    
    MainList->Select(sel,false);//Unselect
 
    HK_Batches GrBatches;
    
    //Copy All Needed Batches into One HK_Batches Instance
    for(int A = 0; A < Batches.GetCount(); A++) {
        if(Batches.GetGroup(A) == Groups.GetName(GrSel))
            GrBatches.Add(Batches.GetBatch(A));
    }
    
    //Set Group Comments
    GrCommentCtrl->Clear();
    GrCommentCtrl->AppendText(Groups.GetText(GrSel).c_str());
    
    //Return If There Aren't Any Batches
    if(GrBatches.GetCount() == 0) 
        return;
 
    //and fill in GrBatchList
    GrBatchList->ClearAll();//Clear the previous list items
    GrBatchList->InsertColumn(0,l(("Batch Name") ), wxLIST_FORMAT_LEFT, 170);
    GrBatchList->InsertColumn(1,l(("# Of Eggs" )), wxLIST_FORMAT_LEFT, -1);
    
    for(int A = 0; A < GrBatches.GetCount(); A++) {
        GrBatchList->InsertItem(A, wxString::Format(wxT("%s"),  GrBatches.GetName(A).c_str()));
        GrBatchList->SetItem(A, 1,wxString::Format(wxT("%d"), GrBatches.GetEggs(A)) );
    }
    
    //Add Totals
    GrTEggCtrl->AppendText(wxString::Format(wxT("%d"),GrBatches.TotalEggs()));
    GrTChickCtrl->AppendText(wxString::Format(wxT("%d"),GrBatches.TotalChicks()));
    
    //And Averages
    GrAWFerStat->SetLabel(wxString::Format(wxT("%d%% %s"),GrBatches.AvgFertile(), l("Avg % Fertile")));
    GrAWFerStat->Wrap( 250 );
    GrAWFerStat->Refresh();
    GrAOTHatchStat->SetLabel(wxString::Format(wxT("%d%% %s"),GrBatches.AvgTotalHatch(), l("Avg % Of Fertile Hatched")));
    GrAOTHatchStat->Wrap( 250 );
    GrAOTHatchStat->Refresh();
    GrAOFHatchStat->SetLabel(wxString::Format(wxT("%d%% %s"),GrBatches.AvgFertileHatch(), l("Avg % of Total Hatched")));
    GrAOTHatchStat->Wrap( 250 );
    GrAOFHatchStat->Refresh();
    GrAOTUnHatchStat->SetLabel(wxString::Format(wxT("%d%% %s"),GrBatches.AvgTotalUnHatch(), l("Avg % of Total Unhatched")));
    GrAOTUnHatchStat->Wrap( 250 );
    GrAOTUnHatchStat->Refresh();
}
 
void HatchFrame::OnGroupUnSelect(wxListEvent&)
{
    GrBatchList->ClearAll();
    GrTEggCtrl->Clear();
    GrTChickCtrl->Clear();
    GrAWFerStat->SetLabel(wxString::Format(wxT("0%% %s"), l("Avg % Fertile")));
    GrAWFerStat->Wrap( 250 );
    GrAWFerStat->Refresh();
    GrAOTHatchStat->SetLabel(wxString::Format(wxT("0%% %s"), l("Avg % Of Fertile Hatched")));
    GrAOTHatchStat->Wrap( 250 );
    GrAOTHatchStat->Refresh();
    GrAOFHatchStat->SetLabel(wxString::Format(wxT("0%% %s"), l("Avg % of Total Hatched")));
    GrAOFHatchStat->Wrap( 250 );
    GrAOFHatchStat->Refresh();
    GrAOTUnHatchStat->SetLabel(wxString::Format(wxT("0%% %s"), l("Avg % of Total Unhatched")));
    GrAOTUnHatchStat->Wrap( 250 );
    GrAOTUnHatchStat->Refresh();
    GrCommentCtrl->Clear();
    GrCommentCtrl->AppendText(l("Comments:"));
    
    //Disable Buttons
    GrUpateButton->Enable(false);
    GrMoreChoice->Enable(false);
    GrDeleteButton->Enable(false);
}
 
void HatchFrame::OnGrComment(wxCommandEvent&)
{
    int lines = GrCommentCtrl->GetNumberOfLines();
    int sel = GroupList->GetFirstSelected();
    string forComment = "", sql;
    
    if(sel == -1)
        return;
 
    if(lines == 1) {
        forComment =  GrCommentCtrl->GetLineText(0);
    }else {
        for (int count1 = 0;count1 < lines; count1++) {
            if(count1 == 0)
                forComment = forComment + GrCommentCtrl->GetLineText(count1);
            else
                forComment = forComment + "\n" + GrCommentCtrl->GetLineText(count1);
        }
    }
    
    if(forComment != Groups.GetText(sel)) {
        Groups.SetText(sel, forComment);
        sql = "UPDATE Groups set GroupComments = '" + forComment;
        sql += "' where ID = " + to_string(Groups.GetID(sel)) + ";";
       
        if(!Database.Execute(sql))
            ShowMsg("Sqlite Error: " + Database.GetErrors());
        
        GroupList->Select(sel, false);
        
        ShowGroups(true);
        
        GroupList->Select(sel, true); 
    }
}
 
void HatchFrame::OnMoreGroupActions(wxCommandEvent&)
{
    int sel = GroupList->GetFirstSelected();
    int MoreSel = GrMoreChoice->GetSelection();
    string path;
    
    if(sel == -1) {
        ShowMsg(l("No Group Selected!"));
        GrMoreChoice->SetSelection(0);
        return;
    }
 
    //Get Batches
    HK_Batches GrBatches;
    for(int A = 0; A < Batches.GetCount(); A++)
        if(Groups.GetName(sel) == Batches.GetGroup(A))
            GrBatches.Add(Batches.GetBatch(A));
            
    //check for batches
    if(GrBatches.GetCount() < 1) {
        ShowMsg(l("Sorry This Group Contains No Batches!"));
        GrMoreChoice->SetSelection(0);
        return;
    }
    
    //Unselect
    GroupList->Select(sel,false);
    
    switch(MoreSel) {
        case 1: {
            wxFileDialog  exportDialog(NULL, 
                l("Export Report File"), 
                wxEmptyString, Groups.GetName(sel).c_str(), 
                "Text Files (*.txt)|*.txt", 
                wxFD_SAVE|wxFD_OVERWRITE_PROMPT, 
                wxDefaultPosition, wxDefaultSize, 
                "Batches"
            );
    
            if (exportDialog.ShowModal() == wxID_CANCEL)
                return;
    
            path = exportDialog.GetPath().ToStdString();
            wxFileName fname(path.c_str());
    
            if(fname.GetExt().ToStdString() != "txt")
                path += ".txt";
 
            //Generate And Write Text File
            if(!Files.WriteTextFile(path,ExportImport.GroupTextReport(GrBatches,Groups.GetName(sel),Groups.GetText(sel),Settings)))
                ShowMsg(l("Error Writing File!"));
            break;
        }
        case 2: {
            wxHtmlEasyPrinting* htmlPrn = new wxHtmlEasyPrinting(l("Printing"), NULL);
            string HTML = ExportImport.GroupHTMLReport(GrBatches,Groups.GetName(sel),Groups.GetText(sel),Settings);
            
            htmlPrn->PrintText(HTML);
            
            delete htmlPrn;
            htmlPrn = NULL;
            
            break;
        }
        case 3: {
            //get path
            wxFileDialog  exportDialog(NULL, l("Export Group File"), wxEmptyString, 
                Groups.GetName(sel).c_str(), "HatchKeeper Batch Files (*.hkbf)|*.hkbf", 
                wxFD_SAVE|wxFD_OVERWRITE_PROMPT, wxDefaultPosition, wxDefaultSize, 
                l("Groups"));
        
            if (exportDialog.ShowModal() == wxID_CANCEL)
                return;
 
            path = exportDialog.GetPath();
            wxFileName fname(path.c_str());
            
            if(fname.GetExt().ToStdString() != "hkbf")
                path += ".hkbf";
            HK_Storage groups;
            groups.Add(Groups.GetName(sel),Groups.GetID(sel),Groups.GetText(sel));
            
            if(!ExportImport.ExportHKBF(path, GrBatches, groups))
                ShowMsg(l("Error Writing File!"));
 
            break;
        }
        case 4: {
            wxFileDialog  exportDialog(NULL, 
                l("Export Calendar File"), 
                wxEmptyString, Groups.GetName(sel).c_str(), 
                "iCal Files (*.ics)|*.ics", 
                wxFD_SAVE|wxFD_OVERWRITE_PROMPT, 
                wxDefaultPosition, 
                wxDefaultSize, 
                "Batches"
            );
                
            if (exportDialog.ShowModal() == wxID_CANCEL)
                return;
 
            path = exportDialog.GetPath();
            wxFileName fname(path.c_str());
            
            if(fname.GetExt().ToStdString() != "ics")
                path = path + ".ics";
    
            if(!Files.WriteTextFile(path,ExportImport.GroupICal(GrBatches, Groups.GetName(sel))))
                ShowMsg(l("Error Saving iCal File!"));
            break;
        }
    }
    
    GrMoreChoice->SetSelection(0);
}
 
/*Advanced Panel*/ 
 
void HatchFrame::ShowAdvanced()
{
    EggPanel->Enable(true);
    AdvEggList->ClearAll();//Clear the previous list items
    AdvEggList->InsertColumn(0,l("Egg"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    AdvEggList->InsertColumn(1,l("Weight Loss"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    
    HK_Advanced AdvEggs = Batches.GetAdvanced(MainList->GetFirstSelected());
        
    for(int a = 0;a < AdvEggs.GetEggCount();a++) {
        AdvEggList->InsertItem(a, wxString::Format(wxT("%s %d"),l("Egg") ,a + 1));
        AdvEggList->SetItem(a, 1, wxString::Format(wxT("%d%%"),AdvEggs.GetEgg(a).CalcTotalLoss()));
    }
}
 
 
 
bool HatchFrame::SetBatchAsAdvanced(int sel)
{
    int a,b,c;
    
    vector<HK_Egg> Eggs;
    HK_Batch Batch = Batches.GetBatch(sel);
    HK_Date TempDate = Batch.GetStart();
    int Days = Batch.GetStart().Difference(Batch.GetHatch());
    
    vector<HK_Weight> DayWeight;
    vector< string > DayComments;
    
    //Day Weight
    for(b = 0; b < Days; b++) {
        HK_Weight Weight;
        DayWeight.push_back(Weight);
    }
    
    //Day Comments
    for(b = 0; b < Days; b++) {
        TempDate.AddDays(1);
        DayComments.push_back("Day " + to_string(b+1) + ": " + TempDate.ToReadable("/",Settings.GetInt("DateMode")) + ": ");
    }
    
    for(a = 0; a < Batch.GetEggs(); a++) {
        HK_Egg Egg;
        Egg.Set("None","None","None",0,0,-1,Batch.GetHatch(),"Comments: ",DayWeight,DayComments);
        Eggs.push_back(Egg);
    }
    
    HK_Advanced Advanced;
    Advanced.Set(Batch.GetID(), Settings.GetInt("WeightUnit"),Days,Eggs);
    Batch.SetAdvanced(Advanced);
    Batches.SetBatch(sel,Batch);
            
    return Database.Execute(Advanced.GetSQL());
}
 
void HatchFrame::DeleteAdvanced(int sel)
{
    if(!Database.Execute("DELETE FROM Advanced where ID = " + to_string(Batches.GetID(sel)) + ";"))
        ShowMsg("Sqlite Error: " + Database.GetErrors());
}
 
void HatchFrame::OnSelectEgg(wxListEvent&)
{
    //Get Batch Advanced Data
    int sel = MainList->GetFirstSelected();
    HK_Advanced Adv = Batches.GetAdvanced(sel);
    
    HK_Egg Egg = Adv.GetEgg(AdvEggList->GetFirstSelected());
    unsigned int a, found = -1;
    
    vector<string> AdvTag1Data = Settings.GetArray("Tag1");
 
    AdvTag1Choice->Clear();
    for(a = 0; a < AdvTag1Data.size(); a++) {
        AdvTag1Choice->Append(AdvTag1Data[a]);
        if(AdvTag1Data[a] == Egg.GetTag1())
            found = a;
    }
    
    if(found == -1) {   
        if(Egg.GetTag1() == "None")
            AdvTag1Choice->SetSelection(0);
        else {
            AdvTag1Choice->Append(Egg.GetTag1());
            AdvTag1Choice->SetSelection(a);
        }
    }
    else
        AdvTag1Choice->SetSelection(found);
    
    //Set Tag2
    found = -1;
 
    vector<string> AdvTag2Data = Settings.GetArray("Tag2");
 
    AdvTag2Choice->Clear();
    for(a = 0; a < AdvTag2Data.size(); a++) {
        AdvTag2Choice->Append(AdvTag2Data[a]);
        if(AdvTag2Data[a] == Egg.GetTag2())
            found = a;
    }
    
    if(found == -1) {
        if(Egg.GetTag2() == "None")
            AdvTag2Choice->SetSelection(0);
        else {
            AdvTag2Choice->Append(Egg.GetTag2());
            AdvTag2Choice->SetSelection(a);
        }
    }
    else
        AdvTag2Choice->SetSelection(found);
    
    //Set Tag3
    found = -1;
    
    vector<string> AdvTag3Data = Settings.GetArray("Tag3");
 
    AdvTag3Choice->Clear();
    for(a = 0; a < AdvTag3Data.size(); a++) {
        AdvTag3Choice->Append(AdvTag3Data[a]);
        if(AdvTag3Data[a] == Egg.GetTag3())
            found = a;
    }
    
    if(found == -1) {   
        if(Egg.GetTag3() == "None")
            AdvTag3Choice->SetSelection(0);
        else {
            AdvTag3Choice->Append(Egg.GetTag3());
            AdvTag3Choice->SetSelection(a);
        }
    }
    else
        AdvTag3Choice->SetSelection(found);
    
    //Set Fertile
    if(Egg.GetFertile() == 0)
        AdvFertileCheckbox->SetValue(false);
    else
        AdvFertileCheckbox->SetValue(true);
    
    //Set Pipped
    if(Egg.GetPipped() == 0)
        AdvPipCheckbox->SetValue(false);
    else
        AdvPipCheckbox->SetValue(true);
        
    //Set Result
    if(Egg.GetResult() == -1)
        AdvResultChoice->SetSelection(0);
    else if(Egg.GetResult() == 0)
        AdvResultChoice->SetSelection(1);
    else 
        AdvResultChoice->SetSelection(2);
 
    //Set Result Date
    HK_Date D = Egg.GetDate();
    wxDateTime resultD(D.GetDay(),wxDateTime::Month(wxDateTime::Jan + D.GetMonth() - 1), D.GetYear(),0,0,0,0);
    if(D.IsValid())
        AdvResultDate->SetValue(resultD);
    else
        cout<<"Log: Invalid Result Date!"<<endl;
    
    
    //Set Comment
    AdvCommentCtrl->ChangeValue(Egg.GetComments().c_str());
    
    //Weight
    ShowAdvWeight(Egg, -1);
    
    //Loss Fix
    AdvTotalLossStat->SetLabel( wxString::Format(wxT("%d%% %s"), Egg.CalcTotalLoss(),l("Total Weight Loss")));
    AdvTotalLossStat->Refresh();
    
    AdvAvgBatchLossStat->SetLabel( wxString::Format(wxT("%d%% %s"), Adv.CalcAvgLoss(),l("Avg Weight Loss For All Eggs In Batch")));
    AdvAvgBatchLossStat->Wrap( 150 );
    AdvAvgBatchLossStat->Refresh();
    
    //Select Day
    HK_Date Date;
    int Diff = Batches.GetStart(sel).Difference(Date);
 
    if( Diff > Adv.GetDays()) {
        AdvWeightList->Select(Adv.GetDays() - 1,true);
        AdvWeightList->EnsureVisible(Adv.GetDays() - 1);
    }
    else if (Diff < 1) {
        AdvWeightList->Select(0,true);
        AdvWeightList->EnsureVisible(0);
    }
    else {
        AdvWeightList->Select(Diff - 1,true);
        AdvWeightList->EnsureVisible(Diff - 1);
    }
}
 
void HatchFrame::OnUnSelectEgg(wxListEvent&)
{
    AdvWeightList->ClearAll();//Clear the previous list items
    AdvCommentCtrl->ChangeValue(" ");
    AdvDayCommentCtrl->ChangeValue(" ");
    
    //Tags
    AdvTag1Choice->SetSelection(0);
    AdvTag2Choice->SetSelection(0);
    AdvTag3Choice->SetSelection(0);
    
    AdvFertileCheckbox->SetValue(false);
    AdvPipCheckbox->SetValue(false);
    
    AdvResultChoice->SetSelection(0);
    
    AdvWeightCtrl->SetValue(0.000);
    AdvTotalLossStat->SetLabel("0%" + l("Total Weight Loss"));
    AdvTotalLossStat->Refresh();
}
 
void HatchFrame::ClearAdvPanel()
{
    //Clear Lists
    AdvEggList->ClearAll();
    AdvWeightList->ClearAll();
    
    AdvFertileCheckbox->SetValue(false);
    AdvPipCheckbox->SetValue(false);
    
    AdvResultDate->SetValue(wxDateTime::Today());
    AdvCommentCtrl->ChangeValue(" ");
    
    AdvWeightCtrl->SetValue(0.000);
    AdvTotalLossStat->SetLabel("0%" + l("Total Weight Loss"));
    AdvTotalLossStat->Refresh();
    AdvDayCommentCtrl->ChangeValue(" ");
}
 
void HatchFrame::OnAdvDaySelect(wxListEvent&)
{   
    //Weight
    HK_Advanced Adv = Batches.GetAdvanced(MainList->GetFirstSelected());
    HK_Egg Egg = Adv.GetEgg(AdvEggList->GetFirstSelected());
    int sel2 = AdvWeightList->GetFirstSelected(); 
    
    AdvWeightCtrl->SetValue(Egg.GetDayWeight()[sel2].GetFloat());
    
    //Loss
    AdvTotalLossStat->SetLabel(wxString::Format(wxT("%d%% %s"), Egg.CalcTotalLoss(),l("Total Weight Loss")));
    AdvTotalLossStat->Refresh();
    
    AdvDayLossStat->SetLabel(wxString::Format(wxT("%d%% %s %d"), Egg.CalcDayLoss(sel2),l("Loss On Day"),(sel2+1)));
    AdvDayLossStat->Refresh();
    //Day Comment
    AdvDayCommentCtrl->ChangeValue(Egg.GetDayComments()[sel2].c_str());
}
 
void HatchFrame::OnAdvDayUnSelect(wxListEvent&)
{
    AdvWeightCtrl->SetValue(0.000);
    AdvDayCommentCtrl->ChangeValue(" ");
}
 
void HatchFrame::OnEggCommentChange(wxCommandEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1)
        return;
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
    
     //Comments
    int lines = AdvCommentCtrl->GetNumberOfLines();
    string forComment = ""; 
 
    if(lines == 1) {
        forComment = AdvCommentCtrl->GetLineText(0);
    }
    else {
        for (int a = 0;a < lines; a++) {   
            if(a == 0)
                forComment += AdvCommentCtrl->GetLineText(a);
            else
                forComment += "\n" + AdvCommentCtrl->GetLineText(a);
        }
    }
    Egg.SetComments(forComment);
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
void HatchFrame::OnTagsChange(wxCommandEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1)
        return;
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
    
    Egg.SetTag1(AdvTag1Choice->GetString(AdvTag1Choice->GetSelection()).ToStdString());
    Egg.SetTag2(AdvTag2Choice->GetString(AdvTag2Choice->GetSelection()).ToStdString());
    Egg.SetTag3(AdvTag3Choice->GetString(AdvTag3Choice->GetSelection()).ToStdString());
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
void HatchFrame::OnAdvFertileChecked(wxCommandEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1) {
        AdvFertileCheckbox->SetValue(false);
        return;
    }
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
    
    
    if(AdvFertileCheckbox->GetValue())
        Egg.SetFertile(1);
    else {
        //Has To Be Fertile If Pipped
        if(AdvPipCheckbox->GetValue())
            AdvFertileCheckbox->SetValue(true);
        else
            Egg.SetFertile(0);
    }
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
void HatchFrame::OnAdvPippedChecked(wxCommandEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1) {
        AdvPipCheckbox->SetValue(false);
        return;
    }
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
    
    if(AdvPipCheckbox->GetValue()) {
        Egg.SetPipped(1);
        if(!AdvFertileCheckbox->GetValue()) {
            AdvFertileCheckbox->SetValue(true);
            Egg.SetFertile(1); 
        }
    }
    else {
        //Has To Be Pipped If Hatched
        if(AdvResultChoice->GetSelection() == 1)
            AdvPipCheckbox->SetValue(true);
        else
            Egg.SetPipped(0);
    }
        
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
void HatchFrame::OnAdvResultChoice(wxCommandEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1)
        return;
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
        
    if(AdvResultChoice->GetSelection() == 0)
        Egg.SetResult(-1);
    else if(AdvResultChoice->GetSelection() == 1) {
        Egg.SetResult(0);
        
        //Set Fertile And Pipped As Well
        if(!AdvPipCheckbox->GetValue()) {
            Egg.SetPipped(1);
            AdvPipCheckbox->SetValue(true);
        }
        
        if(!AdvFertileCheckbox->GetValue()) {
            Egg.SetFertile(1);
            AdvFertileCheckbox->SetValue(true);
        }
    }
    else
        Egg.SetResult(2);
    
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
void HatchFrame::OnAdvResultDate(wxDateEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1) {
        AdvPipCheckbox->SetValue(false);
        return;
    }
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
    
    wxDateTime NewD = AdvResultDate->GetValue(); 
    HK_Date Date(
        NewD.GetDay(wxDateTime::Local),
        NewD.GetMonth(wxDateTime::Local) + 1,
        NewD.GetYear(wxDateTime::Local)
    );
    Egg.SetDate(Date);
    
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
void HatchFrame::ShowAdvWeight(HK_Egg Egg, int Select)
{
    //Set Day Weight
    AdvWeightList->ClearAll();//Clear the previous list items
    AdvWeightList->InsertColumn(0,l("Day"), wxLIST_FORMAT_LEFT, 50);
    AdvWeightList->InsertColumn(1,l("Weight"), wxLIST_FORMAT_LEFT, 60);
 
    for(int b = 0;b < Egg.GetDays();b++) {
        AdvWeightList->InsertItem(b, wxString::Format(wxT("%s %d"),l("Day"), b + 1));
        if(Batches.GetAdvanced(MainList->GetFirstSelected()).GetUnit() == 0)
            AdvWeightList->SetItem(b, 1, wxString::Format(wxT("%.3foz"), Egg.GetDayWeight()[b].GetFloat()));
        else
            AdvWeightList->SetItem(b, 1, wxString::Format(wxT("%.3fg"), Egg.GetDayWeight()[b].GetFloat()));
    }
    
    if(Select != -1)
        AdvWeightList->Select(Select, true);
}
 
void HatchFrame::OnWeightChange(wxSpinDoubleEvent&)
{
    int sel = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1)
        return; 
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
 
    int sel2 = AdvWeightList->GetFirstSelected();
    
    if(sel2 == -1) 
        return;
    vector<HK_Weight> W = Egg.GetDayWeight();
    
    W[sel2].Set(AdvWeightCtrl->GetValue());
    
    Egg.SetDayWeight(W);
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
    
    //Update Controls
    if(Batches.GetAdvanced(MainList->GetFirstSelected()).GetUnit() == 0)
        AdvWeightList->SetItem(sel2, 1, wxString::Format(wxT("%.3foz"), AdvWeightCtrl->GetValue()));
    else
        AdvWeightList->SetItem(sel2, 1, wxString::Format(wxT("%.3fg"), AdvWeightCtrl->GetValue()));
    AdvEggList->SetItem(sel, 1, wxString::Format(wxT("%d%%"),Egg.CalcTotalLoss()));
    
    AdvTotalLossStat->SetLabel(wxString::Format(wxT("%d%% %s"), Egg.CalcTotalLoss(), l("Total Weight Loss")));
    AdvTotalLossStat->Refresh();
    
    AdvDayLossStat->SetLabel(wxString::Format(wxT("%d%% %s %d"), Egg.CalcDayLoss(sel2),l("Loss On Day"),(sel2+1)));
    AdvDayLossStat->Refresh();
    
    AdvAvgBatchLossStat->SetLabel( wxString::Format(wxT("%d%% %s"), Batches.GetAdvanced(MainList->GetFirstSelected()).CalcAvgLoss(), l("Avg Weight Loss For All Eggs In Batch")));
    AdvAvgBatchLossStat->Wrap( 150 );
    AdvAvgBatchLossStat->Refresh();
}
 
void HatchFrame::OnDayCommentChange(wxCommandEvent&)
{
    int sel  = AdvEggList->GetFirstSelected();
    
    if(sel == -1 || MainList->GetFirstSelected() == -1)
        return; 
    
    HK_Egg Egg = Batches.GetAdvanced(MainList->GetFirstSelected()).GetEgg(sel);
    
    int sel2 = AdvWeightList->GetFirstSelected();
     //Comments
    int lines = AdvDayCommentCtrl->GetNumberOfLines();
    string forComment = ""; 
 
    if(lines == 1)
        forComment = AdvDayCommentCtrl->GetLineText(0);
 
    else {
        for (int a = 0;a < lines; a++) {   
            if(a == 0)
                forComment += AdvDayCommentCtrl->GetLineText(a);
            else 
                forComment += "\n" + AdvDayCommentCtrl->GetLineText(a);
            
        }
    }
    vector<string> C = Egg.GetDayComments();
    C[sel2] = forComment;
    
    Egg.SetDayComments(C);
    Batches.SetAdvEgg(MainList->GetFirstSelected(),Egg,sel);
    Batches.SetAdvUpdate(MainList->GetFirstSelected(),true);
}
 
/*Notification*/
void HatchFrame::ShowMsg(string Msg)
{
    wxMessageDialog dialog(this,Msg.c_str());
    dialog.ShowModal();
}
 
void HatchTaskBarIcon::OnWindowRestore(wxCommandEvent&){ShowFrame();}
 
void HatchTaskBarIcon::OnWindowExit(wxCommandEvent& )
{
    string FileFolder = HATCHKEEPER_DATA + "Condition";
    
    //Write a int to tell inform HatchKeeper on start-up
    FILE *fp;
 
    if ((fp = fopen(FileFolder.c_str(), "w"))== NULL)
        fprintf(stderr,"Error Creating HatchKeeper Condition File!");
    else {
        fprintf(fp,"0");
        fclose(fp);
    }
    
    ActuallyExit = true;
    
    //Clean up some stuff to prevent segfault
    this->Destroy(); //HatchTaskBarIcon 
    frame->Close(true);
}
 
void HatchFrame::OnTimer(wxTimerEvent&){ShowNotifications();} 
 
void HatchFrame::ShowNotifications()
{
    unsigned int A = 0;
    vector<string> Updates = Notify.CheckDates(Batches, Remind);
    
    for(A = 0; A < Updates.size(); A++) {
        if(!Database.Execute(Updates[A]))
            ShowMsg("Sqlite Error: " + Database.GetErrors());
            
    }
    Notify = Database.ReadNotify();
    
    bool rescan = false;
    string notifyNote,sql;
    
    //And show them
    HK_Date hkDate;
    
    NoteList->ClearAll();//Clear the previous list items
    NoteList->InsertColumn(0,l("Name" ), wxLIST_FORMAT_LEFT, 125);
    NoteList->InsertColumn(1,l("Description" ), wxLIST_FORMAT_LEFT, 260);
    NoteList->InsertColumn(2,l("Date Issued" ), wxLIST_FORMAT_LEFT, 90);
    NoteList->InsertColumn(3,l("Days Old" ), wxLIST_FORMAT_LEFT, 70);
    
    for (A = 0; A < Notify.GetCount(); A++) {
        
        hkDate = Notify.GetDate(A);
        wxDateTime date(
            hkDate.GetDay(),
            wxDateTime::Month(wxDateTime::Jan + hkDate.GetMonth() - 1), 
            hkDate.GetYear(),
            0,0,0,0
        );
        
        wxDateTime now = wxDateTime::Now();
        wxTimeSpan timeS = now.Subtract(date);
        
        NoteList->InsertItem(A, wxString::Format(wxT("%s"),  Notify.GetName(A).c_str()));
        NoteList->SetItem(A, 1,wxString::Format(wxT("%s"), Notify.GetText(A).c_str()) );
        NoteList->SetItem(A, 2,wxString::Format(wxT("%s"), hkDate.ToReadable("/",Settings.GetInt("DateMode")).c_str()) );
        NoteList->SetItem(A, 3,wxString::Format(wxT("%d"), timeS.GetDays()) );
 
        if(Notify.GetNumber(A) == 0) {
            notifyNote = Notify.GetText(A);
 
            if(Settings.GetInt("UseGenNotify") == 0){
                TheGenNotification = new wxGenericNotificationMessage(
                "HatchKeeper_Reminder   ",
                notifyNote.c_str(),
                NULL);
                
                TheGenNotification->SetIcon(TaskBar_xpm);
 
                TheGenNotification->Show(wxNotificationMessage::Timeout_Never);
                TheGenNotification->Bind(wxEVT_NOTIFICATION_MESSAGE_CLICK, &HatchFrame::OnNotificationClicked, this);
                TheGenNotification->Bind(wxEVT_NOTIFICATION_MESSAGE_DISMISSED, &HatchFrame::OnNotificationDismissed, this);
                UsedGen = true;
            }
            else {
                TheNotification = new wxNotificationMessage(
                "HatchKeeper_Reminder   ",
                notifyNote.c_str(),
                NULL);
 
                TheNotification->SetIcon(TaskBar_xpm);
 
//Under Windows we Bind the notification to the taskbaricon         
#if defined(__WXMSW__) && wxUSE_TASKBARICON
                wxNotificationMessage::UseTaskBarIcon(m_taskBarIcon);
#endif      
                TheNotification->Show(wxNotificationMessage::Timeout_Never);
                TheNotification->Bind(wxEVT_NOTIFICATION_MESSAGE_CLICK, &HatchFrame::OnNotificationClicked, this);
                TheNotification->Bind(wxEVT_NOTIFICATION_MESSAGE_DISMISSED, &HatchFrame::OnNotificationDismissed, this);
                
                UsedGen = false;
            }
            
            //Update LocalStorage
            Notify.SetNumber(A, 1);
            //Update Database
            if(!Database.Execute("UPDATE Notifications SET IsNotified = 1 WHERE ID = " + to_string(Notify.GetID(A)) + ";"))
                ShowMsg("Sqlite Error: " + Database.GetErrors());
        }
        
        if(timeS.GetDays()  >  3)
            if(!Database.Execute("DELETE FROM Notifications where ID = " + to_string(Notify.GetID(A)) + ";"))
                ShowMsg("Sqlite Error: " + Database.GetErrors());
    }
}
 
void HatchFrame::OnNotificationClicked(wxCommandEvent&)
{
    if(Settings.GetInt("OpenOnClick") == 0) {
        int hold;
        //turn off splash 
        hold = Settings.GetInt("ShowSplash");
        Settings.SetValue("ShowSplash", "1");
    
        ShowFrame();
    
        m_notebook2->SetSelection(3);
    
        Settings.SetValue("ShowSplash", to_string(hold));
    }
    
    //Clean Up
    if(UsedGen) {
        delete TheGenNotification;
        TheGenNotification = NULL;
    }
//Under OSX it crashes if we delete native notifications
#ifndef __WXOSX__ 
    else {
        delete TheNotification;
        TheNotification = NULL;
    }
#endif //__WXOSX__
}
 
void HatchFrame::OnNotificationDismissed(wxCommandEvent&)
{
    if(Settings.GetInt("OpenOnDismiss") == 0) {
        //turn off splash 
        int hold = Settings.GetInt("ShowSplash");
        Settings.SetValue("ShowSplash", "1");
    
        ShowFrame();
    
        m_notebook2->SetSelection(3);
    
        Settings.SetValue("ShowSplash", to_string(hold));
    }
    //Clean Up
    if(UsedGen) {
        delete TheGenNotification;
        TheGenNotification = NULL;
    }
//Under OSX it crashes if we delete native notifications
#ifndef __WXOSX__ 
    else {
        delete TheNotification;
        TheNotification = NULL;
    }
#endif //__WXOSX__
}
 
void ShowFrame()
{
    if (Settings.GetInt("ShowSplash") == 0) {
        wxBitmap bitmap;
 
        string FileFolder = HATCHKEEPER_DATA + "Images/Splash.png";
        if (bitmap.LoadFile(FileFolder.c_str(), wxBITMAP_TYPE_PNG)) {
            wxSplashScreen* splash = new wxSplashScreen(bitmap,
            wxSPLASH_CENTRE_ON_PARENT|wxSPLASH_TIMEOUT,
            3000, NULL, -1, wxDefaultPosition, wxDefaultSize,
            wxBORDER_SIMPLE|wxSTAY_ON_TOP|wxHORIZONTAL|wxCENTER_ON_SCREEN);
        }
    }
    frame->Show(true);
    frame->Raise();
}