SettingsWithTimePeriodDlg.cpp

Go to the documentation of this file.

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && defined(PKIFRESOURCES_ALLOW_GCC_PRAGMA)
    #pragma implementation "SettingsWithTimePeriodDlg.cpp"
#endif

//Pick up PKIF windows SDK configuration macros instead of WX's 
#include "PKIFdll.h"
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "SettingsWithTimePeriodDlg.h"
#include "TMDDateTimePicker.h"
#include "pkif.h"
#include "PathSettingsNotebook.h"
#include "PkiEnvironmentDefinitionNotebook.h"

//implemented in ScvpResponderEntryDlg.cpp
const char* MakeTimePurty(CPKIFTimePtr& t, std::string& s);

struct SettingsWithTimePeriodDlgImpl
{
    #ifdef __INCLUDE_SCVP_SUPPORT__
    CPKIFExMediatorPtr m_exMed;
    CPKIFExPathSettingsPtr m_exPs;
    #endif
    IPKIFMediatorPtr m_med;
    CPKIFPathSettingsPtr m_ps;
    CPKIFTimePtr m_medNA, m_medNB, m_psNA, m_psNB;
};

// WDR: class implementations

//----------------------------------------------------------------------------
// CSettingsWithTimePeriodDlg
//----------------------------------------------------------------------------

// WDR: event table for CSettingsWithTimePeriodDlg

BEGIN_EVENT_TABLE(CSettingsWithTimePeriodDlg,wxDialog)
    EVT_BUTTON( wxID_OK, CSettingsWithTimePeriodDlg::OnOk )
    EVT_BUTTON( wxID_CANCEL, CSettingsWithTimePeriodDlg::OnCancel )
    EVT_BUTTON( ID_BUTTON_MEDS, CSettingsWithTimePeriodDlg::OnClickMeds )
    EVT_BUTTON( ID_BUTTON_PP, CSettingsWithTimePeriodDlg::OnClickPathSettings )
    EVT_BUTTON( ID_BUTTON_MEDS_NOT_BEFORE, CSettingsWithTimePeriodDlg::OnClickMedsNotBefore )
    EVT_BUTTON( ID_BUTTON_MEDS_NOT_AFTER, CSettingsWithTimePeriodDlg::OnClickMedsNotAfter )
    EVT_BUTTON( ID_BUTTON_PP_NOT_BEFORE, CSettingsWithTimePeriodDlg::OnClickPathNotBefore )
    EVT_BUTTON( ID_BUTTON_PP_NOT_AFTER, CSettingsWithTimePeriodDlg::OnClickPathNotAfter )
END_EVENT_TABLE()
CSettingsWithTimePeriodDlg::CSettingsWithTimePeriodDlg( wxWindow *parent, wxWindowID id, const wxString &title,
    const wxPoint &position, const wxSize& size, long style ) :
    wxDialog( parent, id, title, position, size, style ), m_impl(new SettingsWithTimePeriodDlgImpl)
{
    m_whatToDisplay = DISPLAY_BOTH;

    // WDR: dialog function SettingsWithTimePeriodDlg for CSettingsWithTimePeriodDlg
    SettingsWithTimePeriodDlg( this, TRUE ); 
}
CSettingsWithTimePeriodDlg::~CSettingsWithTimePeriodDlg()
{
}
bool CSettingsWithTimePeriodDlg::Validate()
{
    return TRUE;
}
bool CSettingsWithTimePeriodDlg::TransferDataToWindow()
{
    #ifdef __INCLUDE_SCVP_SUPPORT__
    if(DISPLAY_MEDS == m_whatToDisplay)
    {
        wxSizer* sz = GetSizer();
        sz->Hide(gPathSettingsGroupBox, true);
    }
    if(DISPLAY_PP == m_whatToDisplay)
    {
        wxSizer* sz = GetSizer();
        sz->Hide(gMediatorGroupBox, true);
    }

    if(m_impl->m_exMed)
    {
        m_impl->m_med = m_impl->m_exMed->second;
        m_impl->m_medNA = m_impl->m_exMed->first->notAfter();
        if(m_impl->m_medNA)
        {
            std::string aString;
            GetTextctrlMedsNotAfter()->SetValue(wxString(MakeTimePurty(m_impl->m_medNA, aString),wxConvUTF8));
        }
        m_impl->m_medNB = m_impl->m_exMed->first->notBefore();
        if(m_impl->m_medNB)
        {
            std::string aString;
            GetTextctrlMedsNotBefore()->SetValue(wxString(MakeTimePurty(m_impl->m_medNB, aString),wxConvUTF8));
        }
    }

    if(m_impl->m_exPs)
    {
        m_impl->m_ps = m_impl->m_exPs->second;
        m_impl->m_psNA = m_impl->m_exPs->first->notAfter();
        if(m_impl->m_psNA)
        {
            std::string aString;
            GetTextctrlPpNotAfter()->SetValue(wxString(MakeTimePurty(m_impl->m_psNA, aString),wxConvUTF8));
        }
        m_impl->m_psNB = m_impl->m_exPs->first->notBefore();
        if(m_impl->m_psNB)
        {
            std::string aString;
            GetTextctrlPpNotBefore()->SetValue(wxString(MakeTimePurty(m_impl->m_psNB, aString),wxConvUTF8));
        }
    }
    #endif
    return TRUE;
}
bool CSettingsWithTimePeriodDlg::TransferDataFromWindow()
{
    return TRUE;
}

// WDR: handler implementations for CSettingsWithTimePeriodDlg
void CSettingsWithTimePeriodDlg::OnClickPathNotAfter( wxCommandEvent &event )
{
    TMDDateTimePicker dlg(0,wxID_ANY,wxT("Select a date"));
    dlg.SetMorningOrNight(false);
    if(m_impl->m_psNA)
    {
        CPKIFTimePtr notAfter = m_impl->m_psNA;
        dlg.SetDate(notAfter);
    }
    dlg.CentreOnParent();
    if(wxID_OK == dlg.ShowModal()) 
    {
        GetTextctrlPpNotAfter()->SetValue(dlg.GetDate());
        m_impl->m_psNA = dlg.GetDateAsPKIFTime();
    }
}
void CSettingsWithTimePeriodDlg::OnClickPathNotBefore( wxCommandEvent &event )
{
    TMDDateTimePicker dlg(0,wxID_ANY,wxT("Select a date"));
    dlg.SetMorningOrNight(true);
    if(m_impl->m_psNB)
    {
        CPKIFTimePtr notBefore = m_impl->m_psNB;
        dlg.SetDate(notBefore);
    }
    dlg.CentreOnParent();
    if(wxID_OK == dlg.ShowModal()) 
    {
        GetTextctrlPpNotBefore()->SetValue(dlg.GetDate());
        m_impl->m_psNB = dlg.GetDateAsPKIFTime();
    }
}
void CSettingsWithTimePeriodDlg::OnClickPathSettings( wxCommandEvent &event )
{
    CPKIFPathSettingsNotebook psn(NULL,-1,wxT("Path Validation Settings"),wxDefaultPosition,wxDefaultSize,
        wxDEFAULT_DIALOG_STYLE);
    psn.SetInitialPathSettings(m_impl->m_ps);
    psn.Center();
    wxButton * okButton = (wxButton *)psn.FindWindow(wxID_OK);
    if(okButton) okButton->SetLabel(wxT("Save"));
    if(wxID_OK == psn.ShowModal())
    {
        m_impl->m_ps = psn.GetPathSettings();
    }
}
void CSettingsWithTimePeriodDlg::OnClickMedsNotAfter( wxCommandEvent &event )
{
    TMDDateTimePicker dlg(0,wxID_ANY,wxT("Select a date"));
    dlg.SetMorningOrNight(false);
    if(m_impl->m_medNA)
    {
        CPKIFTimePtr notAfter = m_impl->m_medNA;
        dlg.SetDate(notAfter);
    }
    dlg.CentreOnParent();
    if(wxID_OK == dlg.ShowModal()) 
    {
        GetTextctrlMedsNotAfter()->SetValue(dlg.GetDate());
        m_impl->m_medNA = dlg.GetDateAsPKIFTime();
    }
}
void CSettingsWithTimePeriodDlg::OnClickMedsNotBefore( wxCommandEvent &event )
{
    TMDDateTimePicker dlg(0,wxID_ANY,wxT("Select a date"));
    dlg.SetMorningOrNight(true);
    if(m_impl->m_medNB)
    {
        CPKIFTimePtr notBefore = m_impl->m_medNB;
        dlg.SetDate(notBefore);
    }
    dlg.CentreOnParent();
    if(wxID_OK == dlg.ShowModal()) 
    {
        GetTextctrlMedsNotBefore()->SetValue(dlg.GetDate());
        m_impl->m_medNB = dlg.GetDateAsPKIFTime();
    }
}
void CSettingsWithTimePeriodDlg::OnClickMeds( wxCommandEvent &event )
{
    CPKIFPkiEnvironmentDefinitionNotebook pedn(NULL,-1,wxT("PKI Environment Definition for SCVP Response Processing"),
        wxDefaultPosition,wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
    pedn.SetInitialMediator(m_impl->m_med);
    pedn.Center();
    wxButton * okButton = (wxButton *)pedn.FindWindow(wxID_OK);
    if(okButton) okButton->SetLabel(wxT("Save"));
    if(wxID_OK == pedn.ShowModal())
    {
        m_impl->m_med = pedn.GetMediator();
    }
}
void CSettingsWithTimePeriodDlg::OnOk(wxCommandEvent &event)
{
    #ifdef __INCLUDE_SCVP_SUPPORT__
    if(DISPLAY_MEDS == m_whatToDisplay || DISPLAY_BOTH == m_whatToDisplay)
    {
        if(m_impl->m_medNB == (CPKIFTime*)NULL)
        {
            wxString msg =  wxT("\"Do not use before\" time is not specified");
            wxMessageBox(msg);
            return;
        }
        if(m_impl->m_medNA == (CPKIFTime*)NULL)
        {
            wxString msg =  wxT("\"Do not use after\" time is not specified");
            wxMessageBox(msg);
            return;
        }
        if(m_impl->m_med == (IPKIFMediator*)NULL)
        {
            wxString msg =  wxT("PKI Environment Settings are is not specified");
            wxMessageBox(msg);
            return;
        }
        if(*m_impl->m_medNB > *m_impl->m_medNA)
        {
            wxString msg =  wxT("\"Do not use before\" time is after \"Do not use after\" time");
            wxMessageBox(msg);
            return;
        }

        CPKIFExMediatorPtr newEx(new CPKIFExMediator);

        CPKIFValidityPtr newV(new CPKIFValidity(m_impl->m_medNB, m_impl->m_medNA));
        newEx->first = newV;

        newEx->second = m_impl->m_med;
        m_impl->m_exMed = newEx;

    }
    else
    {
        CPKIFExMediatorPtr empty;
        m_impl->m_exMed = empty;
    }

    if(DISPLAY_PP == m_whatToDisplay || DISPLAY_BOTH == m_whatToDisplay)
    {
        if(m_impl->m_psNB == (CPKIFTime*)NULL)
        {
            wxString msg =  wxT("\"Do not use before\" time is not specified");
            wxMessageBox(msg);
            return;
        }
        
        if(m_impl->m_psNA == (CPKIFTime*)NULL)
        {
            wxString msg =  wxT("\"Do not use after\" time is not specified");
            wxMessageBox(msg);
            return;
        }
        if(m_impl->m_ps == (CPKIFPathSettings*)NULL)
        {
            wxString msg =  wxT("PKI Environment Settings are not specified");
            wxMessageBox(msg);
            return;
        }
        
        if(*m_impl->m_psNB > *m_impl->m_psNA)
        {
            wxString msg =  wxT("\"Do not use before\" time is after \"Do not use after\" time");
            wxMessageBox(msg);
            return;
        }

        CPKIFExPathSettingsPtr newEx(new CPKIFExPathSettings);

        CPKIFValidityPtr newV(new CPKIFValidity(m_impl->m_psNB, m_impl->m_psNA));
        newEx->first = newV;

        newEx->second = m_impl->m_ps;
        m_impl->m_exPs = newEx;
    }
    else
    {
        CPKIFExPathSettingsPtr empty;
        m_impl->m_exPs = empty;
    }

    #endif
    event.Skip();
}
void CSettingsWithTimePeriodDlg::OnCancel(wxCommandEvent &event)
{
    event.Skip();
}
#ifdef __INCLUDE_SCVP_SUPPORT__

CPKIFExMediatorPtr CSettingsWithTimePeriodDlg::GetMediator()
{
    return m_impl->m_exMed;
}
CPKIFExPathSettingsPtr CSettingsWithTimePeriodDlg::GetPathSettings()
{
    return m_impl->m_exPs;
}
void CSettingsWithTimePeriodDlg::SetMediator(CPKIFExMediatorPtr& med)
{
    m_impl->m_exMed = med;
}
void CSettingsWithTimePeriodDlg::SetPathSettings(CPKIFExPathSettingsPtr& ps)
{
    m_impl->m_exPs = ps;
}
#endif