D:/~Research/Code/C++/EvolveTraffic/RoadFeaturesDlg.cpp

Go to the documentation of this file.

// RoadFeaturesDlg.cpp : implementation file
//

#include "stdafx.h"
#include "EvolveTraffic.h"
#include "RoadFeaturesDlg.h"
#include "RoadFeature.h"

#include "GridCtrl_src\GridCellCombo.h"
#include "GridCtrl_src\GridCellNumeric.h"

#include "ConfigData.h"
extern CConfigData g_ConfigData;

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// CRoadFeaturesDlg dialog


CRoadFeaturesDlg::CRoadFeaturesDlg(CWnd* pParent /*=NULL*/)
        : CDialogExt(CRoadFeaturesDlg::IDD, pParent)
{
        //{{AFX_DATA_INIT(CRoadFeaturesDlg)
                // NOTE: the ClassWizard will add member initialization here
        //}}AFX_DATA_INIT

        MAX_SLOPE               = g_ConfigData.Road.RoadFeatures.Gradient.MAX_SLOPE;
        SPEEDLIMIT_MIN  = g_ConfigData.Road.RoadFeatures.SpeedLimit.SPEEDLIMIT_MIN;
        SPEEDLIMIT_MAX  = g_ConfigData.Road.RoadFeatures.SpeedLimit.SPEEDLIMIT_MAX;

        m_sFeatureTypes.Add("Speed Limit");
        m_sFeatureTypes.Add("Gradient");

        m_sDirections.Add("Positive x");
        m_sDirections.Add("Negative x");

        m_sColumnHeaders.Add("Type");
        m_sColumnHeaders.Add("Direction");
        m_sColumnHeaders.Add("Start (m)");
        m_sColumnHeaders.Add("End (m)");
        m_sColumnHeaders.Add("Value");

        m_nFixCols = FIXED_COLUMNS;
        m_nFixRows = FIXED_ROWS;        
        m_nCols = m_sColumnHeaders.GetSize() + m_nFixCols;
}

void CRoadFeaturesDlg::DoDataExchange(CDataExchange* pDX)
{
        CDialogExt::DoDataExchange(pDX);
        //{{AFX_DATA_MAP(CRoadFeaturesDlg)
        DDX_Control(pDX, IDC_GRID, m_Grid);             // associate the grid window with a C++ object
        //}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CRoadFeaturesDlg, CDialogExt)
        //{{AFX_MSG_MAP(CRoadFeaturesDlg)
        ON_NOTIFY(GVN_ENDLABELEDIT, IDC_GRID, OnGridEndEdit)
        ON_BN_CLICKED(IDC_BTN_ADDFEAT, OnBtnAddfeat)
        ON_BN_CLICKED(IDC_BTN_DELFEAT, OnBtnDelfeat)
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

// CRoadFeaturesDlg message handlers

BOOL CRoadFeaturesDlg::OnInitDialog()
{
        CDialogExt::OnInitDialog();

        // init rows
        m_NoFeatures = m_vRoadFeatures.GetSize();
        m_nRows = m_nFixRows + m_NoFeatures;

        TRY {
                m_Grid.SetRowCount(m_nRows);
                m_Grid.SetColumnCount(m_nCols);
                m_Grid.SetFixedRowCount(m_nFixRows);
                m_Grid.SetFixedColumnCount(m_nFixCols);
        }
        CATCH (CMemoryException, e)
        {
                e->ReportError();
                return FALSE;
        }
        END_CATCH
        
        SetGridHeadings();
        SetCells(false);        // false because not addition or detletion
        m_Grid.ExpandColumnsToFit();    
        
        LoadFeaturesIntoGrid();

        return TRUE;  // return TRUE  unless you set the focus to a control
}

void CRoadFeaturesDlg::OnValidate(UINT &nID, CString &strMessage)
{
        int nFeats = m_vRoadFeatures.GetSize();
        
        for(int i = 0; i < nFeats;  i++)
        {
                CRoadFeature *pFeat = reinterpret_cast<CRoadFeature*>(m_vRoadFeatures.GetAt(i));
                
                // In case the start specified is after the end, swap them
                int FeatStart = pFeat->getStart();
                int FeatEnd = pFeat->getEnd();
                if(FeatStart > FeatEnd)
                {
                        pFeat->setStart(FeatEnd);
                        pFeat->setEnd(FeatStart);
                        int temp = FeatStart; FeatStart = FeatEnd; FeatEnd = temp;      // for use below
                }

                // check on bounds
                if(FeatStart > m_RoadLength || FeatEnd > m_RoadLength)
                {
                        strMessage.Format("Feature %d: Starts or ends outside the road length.", i+1);
                        nID = IDC_GRID;
                        return;
                }

                int FeatType = pFeat->getType();        // for further use
                // check on values
                if(FeatType == FEAT_GRADIENT && pFeat->getValue() > MAX_SLOPE)
                {
                        strMessage.Format("Feature %d: Gradient specified is greater \nthan the maximum of %d%%.", i+1, MAX_SLOPE);
                        nID = IDC_GRID;
                        return;
                }

                double speed_limit = pFeat->getValue()*M_PER_S_TO_KM_PER_H;
                if(FeatType == FEAT_SPEEDLIMIT && speed_limit < SPEEDLIMIT_MIN)
                {
                        strMessage.Format("Feature %d: Speed limit specified is smaller \nthan the minimum of %d km/h.", i+1, SPEEDLIMIT_MIN);
                        nID = IDC_GRID;
                        return;
                }

                if(FeatType == FEAT_SPEEDLIMIT && speed_limit > SPEEDLIMIT_MAX)
                {
                        strMessage.Format("Feature %d: Speed limit specified is greater \nthan the maximum of %d km/h.", i+1, SPEEDLIMIT_MAX);
                        nID = IDC_GRID;
                        return;
                }
                
                bool FeatDirPos = pFeat->getDirPos();
                // check on overlaps
                for(int j = 0; j < nFeats; j++) // because they are not sorted
                {
                        if( j != i)     // better than j++ which causes bounds problem
                        {
                                CRoadFeature *pFeatJ = reinterpret_cast<CRoadFeature*>(m_vRoadFeatures.GetAt(j));
                                
                                // if the same type and same direction
                                if(FeatType == pFeatJ->getType() && FeatDirPos == pFeatJ->getDirPos())  
                                {
                                        int FeatJStart = pFeatJ->getStart();
                                        int FeatJEnd = pFeatJ->getEnd();
                                        if( (FeatStart > FeatJStart && FeatEnd < FeatJEnd) ||   // complete overlap or iFeat starts before jFeat ends
                                                (FeatJStart > FeatStart && FeatJStart < FeatEnd) )      // iFeat ends after jFeat starts
                                        {
                                                strMessage.Format("Feature %d overlaps with Feature %d \n- change start and end points.", i+1, j+1);
                                                nID = IDC_GRID;
                                                return;
                                        }
                                }
                        } // end of if j != i
                }
        } // end of main for loop

}

void CRoadFeaturesDlg::SetGridHeadings()
{
        int row = 0;
        int col = 0;

        // Set fixed column text
        for (col = 1; col < m_nCols; col++)
                m_Grid.SetItemText(row,col,m_sColumnHeaders.GetAt(col-1));

        // Set fixed row text
        col = 0;
        for(row = m_nFixRows; row < m_nRows; row++)
        {
                CString str;
                str.Format("Feature %d", row);
                m_Grid.SetItemText(row,col,str);
        }
}

void CRoadFeaturesDlg::SetCells(bool bAddDelete)
{
        // these lines are for the resizing of the rows due to addtions/deletions
        if(bAddDelete)
        {
                m_NoFeatures = m_vRoadFeatures.GetSize();
                m_nRows = m_nFixRows + m_NoFeatures;
                m_Grid.SetRowCount(m_nRows);
                // update row headings
                for(int row = m_nFixRows; row < m_nRows; row++)
                {
                        CString str;
                        str.Format("Feature %d", row);
                        m_Grid.SetItemText(row,0,str);
                }
        }

        for (int row = m_nFixRows; row < m_nRows; row++)
        {
                int col = 1;    // Do Feature-type drop down
                m_Grid.SetCellType(row,col, RUNTIME_CLASS(CGridCellCombo));     
            CGridCellCombo *pCell = (CGridCellCombo*) m_Grid.GetCell(row,col);
                pCell->SetOptions(m_sFeatureTypes);
                pCell->SetStyle(CBS_DROPDOWNLIST);

                col = 2;                // Do directions drop down
                m_Grid.SetCellType(row,col, RUNTIME_CLASS(CGridCellCombo));     
            pCell = (CGridCellCombo*) m_Grid.GetCell(row,col);
                pCell->SetOptions(m_sDirections);
                pCell->SetStyle(CBS_DROPDOWNLIST);
        }

        for (row = m_nFixRows; row < m_nRows; row++)
        {
                for (int col = m_nFixCols+2; col < m_nCols; col++)
                {
                        m_Grid.SetCellType(row,col, RUNTIME_CLASS(CGridCellNumeric));
                        m_Grid.GetCell(row,col)->SetFormat(DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX|DT_END_ELLIPSIS);
                        CGridCellNumeric *pCell = (CGridCellNumeric*)m_Grid.GetCell(row,col);
                        if(col == m_nCols - 1)
                                pCell->SetFlags(CGridCellNumeric::Real | CGridCellNumeric::Negative);   // last column is double or neg
                        else
                                pCell->SetFlags(CGridCellNumeric::Integer);     // all others are positive int
                }
        }
}

void CRoadFeaturesDlg::LoadFeaturesIntoGrid()
{
        for(int i = 0; i < m_NoFeatures; i++)
        {
                int col = m_nFixCols;
                int row = m_nFixRows + i;
                CRoadFeature* pFeat = reinterpret_cast<CRoadFeature*>(m_vRoadFeatures[i]);

                CString txt = MapTypeToString( pFeat->getType() );
                m_Grid.SetItemText(row,col,txt);

                // get direction text
                txt = pFeat->getDirPos() == true ? m_sDirections.GetAt(0) : m_sDirections.GetAt(1);
                m_Grid.SetItemText(row,col+1,txt);

                CGridCellNumeric* pCell1 = (CGridCellNumeric *)(m_Grid.GetCell(row,col+2));
                CGridCellNumeric* pCell2 = (CGridCellNumeric *)(m_Grid.GetCell(row,col+3));
                CGridCellNumeric* pCell3 = (CGridCellNumeric *)(m_Grid.GetCell(row,col+4));
                pCell1->SetNumber( pFeat->getStart() );
                pCell2->SetNumber( pFeat->getEnd() );
                
                double val = pFeat->getValue();
                if(pFeat->getType() == FEAT_SPEEDLIMIT)
                        val = val * M_PER_S_TO_KM_PER_H;        // note the unit conversion done close to GUI
                
                pCell3->SetNumber( val );
        }
        m_Grid.AutoSizeRows();
        m_Grid.Invalidate();
}

void CRoadFeaturesDlg::OnBtnAddfeat() 
{
        // Add the feature to the vector
        m_NoFeatures++;
        CRoadFeature* pFeat = new CRoadFeature; // create one to use
        m_vRoadFeatures.Add(pFeat);

        // add a row to the table
        SetCells(true);
        LoadFeaturesIntoGrid(); 
}

void CRoadFeaturesDlg::OnBtnDelfeat() 
{
        if(m_NoFeatures != 0)
        {
                // Get the ptr and remove from the vector
                CRoadFeature* pFeat = reinterpret_cast<CRoadFeature*>(m_vRoadFeatures.GetAt(m_NoFeatures-1));
                m_vRoadFeatures.RemoveAt( m_NoFeatures-1 );

                delete pFeat;   // remove feature from heap
                m_NoFeatures--; // decrement only now

                // update the table
                SetCells(true);
                LoadFeaturesIntoGrid();
        }
        else
                MessageBox("No road feature to delete.", "EvolveTraffic", MB_OK|MB_ICONWARNING);
}

// This function handles the GVN_ENDLABELEDIT messages
void CRoadFeaturesDlg::OnGridEndEdit(NMHDR *pNotifyStruct, LRESULT* pResult)
{
        // if change is ok, then *pResult 0, else *pResult -1
        
        // pItem is the cell that has just been edited
    NM_GRIDVIEW* pItem = (NM_GRIDVIEW*) pNotifyStruct;
    
    int row = pItem->iRow;      int col = pItem->iColumn;

        if(col < 2 + m_nFixRows )       // is the type or direction column
        {
                CString strCell = m_Grid.GetCell(row,col)->GetText();
                if(strCell != "")
                {
                        // data is ok
                        SetParamData(row,col,strCell);
                        *pResult = 0;
                }       
                else
                        *pResult = -1;
        }
        else
        {
                // no need to verify CNumericCells since will always be a number
                // even deleting a cell's data results in a zero
                double val = ((CGridCellNumeric *)(m_Grid.GetCell(row,col)))->GetNumber();
                SetParamData(row,col,val);
                *pResult = 0;
        }

}

void CRoadFeaturesDlg::SetParamData(int row, int col, CString str)
{
        // if it's a string it's either col 1 or 2
        CRoadFeature* pFeat = reinterpret_cast<CRoadFeature*>(m_vRoadFeatures[row-m_nFixRows]);
        
        col = col - m_nFixCols;

        if(col == 0)            // feature type
                pFeat->setType( MapStringToType(str) );
        
        else if(col == 1)       // direction
        {
                bool DirPos = str == m_sDirections.GetAt(0) ? true : false;
                pFeat->setDirPos(DirPos);
        }
}

void CRoadFeaturesDlg::SetParamData(int row, int col, double val)
{
        CRoadFeature* pFeat = reinterpret_cast<CRoadFeature*>(m_vRoadFeatures[row-m_nFixRows]);

        switch(col)
        {
                case 3:
                        pFeat->setStart( (int)val );
                        break;
                case 4:
                        pFeat->setEnd( (int)val );
                        break;
                case 5:
                        {
                                if(pFeat->getType() == FEAT_SPEEDLIMIT)
                                        val = val * KM_PER_H_TO_M_PER_S;        // note the unit conversion done close to GUI
                                pFeat->setValue( val );
                                break;
                        }
                default:
                        pFeat->setValue( val );
        }
}

CString CRoadFeaturesDlg::MapTypeToString(WORD type)
{
        switch(type)
        {
                case FEAT_SPEEDLIMIT:   return m_sFeatureTypes.GetAt(0);
                case FEAT_GRADIENT:             return m_sFeatureTypes.GetAt(1);
                default:                                return m_sFeatureTypes.GetAt(0);        // speed limit
        }
}

WORD CRoadFeaturesDlg::MapStringToType(CString str)
{
        // Note this function reqires the order of the types 
        // to not change
        int i = 0;
        while(str != m_sFeatureTypes.GetAt(i))
                i++;

        switch(i)
        {
                case 0:         return FEAT_SPEEDLIMIT;
                case 1:         return FEAT_GRADIENT;
                default:        return FEAT_SPEEDLIMIT;
        }
}

---