GenerateRDL.cpp

Go to the documentation of this file.

//
#include "wx/wxprec.h"
//
#ifdef __BORLANDC__
#pragma hdrstop
#endif
//
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
//
//#include "wx/imaglist.h"
//
#include "GenerateRDL.h"
#include "NIREPDefinitions.h"
#include "ViewRDL.h"
//
//
//
//
//
//
// * GenerateRDL type definition
// */
//
IMPLEMENT_CLASS( GenerateRDL, wxFrame )
//
//
// * GenerateRDL event table definition
// */
//
BEGIN_EVENT_TABLE( GenerateRDL, wxFrame )

    EVT_COMBOBOX( ID_DATATYPE, GenerateRDL::OnDatatypeSelected )

    EVT_COMBOBOX( ID_FORMAT, GenerateRDL::OnFormatSelected )

    EVT_BUTTON( ID_BROWSE, GenerateRDL::OnBrowseClick )

    EVT_BUTTON( ID_BROWSE2, GenerateRDL::OnBrowse2Click )

    EVT_BUTTON( ID_BROWSE3, GenerateRDL::OnBrowse3Click )

    EVT_NOTEBOOK_PAGE_CHANGED( ID_NOTEBOOK, GenerateRDL::OnNotebookPageChanged )

    EVT_BUTTON( ID_GENERATE, GenerateRDL::OnGenerateClick )

    EVT_BUTTON( wxID_CANCEL, GenerateRDL::OnCancelClick )

    EVT_BUTTON( ID_ADD_COORDINATE, GenerateRDL::OnAddCoordinateClick )

    EVT_BUTTON( ID_DELETE_COORDINATE, GenerateRDL::OnDeleteCoordinateClick )

    EVT_GRID_CMD_CELL_CHANGE(ID_COORDINATE_GRID,GenerateRDL::OnCoordinateGridChange)

    EVT_TEXT(ID_NAMESPACE, GenerateRDL::OnUpdateDMID)

    EVT_TEXT(ID_LABEL, GenerateRDL::OnUpdateDMID)

    EVT_TEXT(ID_FILENAME_PATTERN, GenerateRDL::OnUpdateVariables)

    EVT_TEXT(ID_FILENAME_PATTERN2, GenerateRDL::OnUpdateVariables)

    EVT_TEXT(ID_FILENAME_PATTERN3, GenerateRDL::OnUpdateVariables)


END_EVENT_TABLE()


//*
// * GenerateRDL constructors
// */

GenerateRDL::GenerateRDL()
{
    Init();
}

GenerateRDL::GenerateRDL( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
    Init();
    Create( parent, id, caption, pos, size, style );
}


/*
 * GenerateRDL creator
 */

bool GenerateRDL::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
    wxFrame::Create( parent, id, caption, pos, size, style );

    CreateControls();
    Centre();
    return true;
}


/*
 * GenerateRDL destructor
 */

GenerateRDL::~GenerateRDL()
{
}


/*
 * Member initialisation
 */

void GenerateRDL::Init()
{
    m_datatype = NULL;
    m_filenamePattern = NULL;
    m_filenamePattern2 = NULL;
    m_filenamePattern3 = NULL;
    m_variableGrid = NULL;
    m_coordinateGrid = NULL;
    m_namespace = NULL;
    m_transformationUnits = NULL;
}


/*
 * Control creation for GenerateRDL
 */

void GenerateRDL::CreateControls()
{    
    GenerateRDL* itemFrame1 = this;

    wxMenuBar* menuBar = new wxMenuBar;
    wxMenu* itemMenu34 = new wxMenu;
    itemMenu34->Append(ID_MENU_NEW, _("New"), wxEmptyString, wxITEM_NORMAL);
    itemMenu34->Append(ID_MENU_OPEN, _("Open"), wxEmptyString, wxITEM_NORMAL);
    itemMenu34->Append(ID_MENU_SAVE, _("Save"), wxEmptyString, wxITEM_NORMAL);
    itemMenu34->AppendSeparator();
    itemMenu34->Append(wxID_EXIT, _("Exit"), wxEmptyString, wxITEM_NORMAL);
    menuBar->Append(itemMenu34, _("File"));

    wxMenu* itemMenu35 = new wxMenu;
    itemMenu35->Append(wxID_ANY, _("View Help"), wxEmptyString, wxITEM_NORMAL);
    itemMenu35->Append(wxID_ANY, _("About"), wxEmptyString, wxITEM_NORMAL);
    menuBar->Append(itemMenu35, _("Help"));

    itemFrame1->SetMenuBar(menuBar);

    wxPanel* itemPanel2 = new wxPanel( itemFrame1, ID_PANEL7, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );

    wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxVERTICAL);
    itemPanel2->SetSizer(itemBoxSizer3);

    wxRichTextCtrl* itemRichTextCtrl4 = new wxRichTextCtrl( itemPanel2, ID_TEXT, wxEmptyString, wxDefaultPosition, wxSize(100, 100), wxWANTS_CHARS );
    itemBoxSizer3->Add(itemRichTextCtrl4, 0, wxGROW|wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer3->Add(itemBoxSizer4, 0, wxALIGN_LEFT|wxALL, 5);

    wxStaticText* itemStaticText5 = new wxStaticText( itemPanel2, wxID_STATIC, _("Datatype"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer4->Add(itemStaticText5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString m_datatypeStrings;
    for(DataTypeList::iterator temp = DataType.begin(); temp != DataType.end(); temp++) {
      m_datatypeStrings.Add(temp->second);
    }
    m_datatype = new wxComboBox( itemPanel2, ID_DATATYPE, wxEmptyString, wxDefaultPosition, wxDefaultSize, m_datatypeStrings, wxCB_DROPDOWN );
    itemBoxSizer4->Add(m_datatype, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer7 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer3->Add(itemBoxSizer7, 0, wxALIGN_LEFT|wxALL, 5);

    wxStaticText* itemStaticText8 = new wxStaticText( itemPanel2, ID_STATIC_FORMAT_TEXT, _("Format"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText8->Show(false);
    itemBoxSizer7->Add(itemStaticText8, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString itemComboBox9Strings;
    for(TransformFormatList::iterator temp = TransformFormat.begin(); temp != TransformFormat.end(); temp++) {
      itemComboBox9Strings.Add(temp->second);
    }
    wxComboBox *format = new wxComboBox( itemPanel2, ID_FORMAT, wxEmptyString, wxDefaultPosition, wxDefaultSize, itemComboBox9Strings, wxCB_DROPDOWN );
    format->Show(false);
    itemBoxSizer7->Add(format, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxFlexGridSizer* itemFlexGridSizer10 = new wxFlexGridSizer(0, 3, 0, 0);
    itemFlexGridSizer10->AddGrowableCol(1);
    itemBoxSizer3->Add(itemFlexGridSizer10, 0, wxGROW|wxALL, 5);

    wxStaticText* itemStaticText11 = new wxStaticText( itemPanel2, ID_STATIC_FILEFORMAT1_TEXT, _("Filename pattern 1"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer10->Add(itemStaticText11, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_filenamePattern = new wxTextCtrl( itemPanel2, ID_FILENAME_PATTERN, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer10->Add(m_filenamePattern, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxButton* itemButton13 = new wxButton( itemPanel2, ID_BROWSE, _("Browse"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer10->Add(itemButton13, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText14 = new wxStaticText( itemPanel2, ID_STATIC_FILEFORMAT2_TEXT, _("Filename pattern 2"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText14->Show(false);
    itemFlexGridSizer10->Add(itemStaticText14, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_filenamePattern2 = new wxTextCtrl( itemPanel2, ID_FILENAME_PATTERN2, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    m_filenamePattern2->Show(false);
    itemFlexGridSizer10->Add(m_filenamePattern2, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxButton* itemButton16 = new wxButton( itemPanel2, ID_BROWSE2, _("Browse"), wxDefaultPosition, wxDefaultSize, 0 );
    itemButton16->Show(false);
    itemFlexGridSizer10->Add(itemButton16, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText17 = new wxStaticText( itemPanel2, ID_STATIC_FILEFORMAT3_TEXT, _("Filename pattern 3"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText17->Show(false);
    itemFlexGridSizer10->Add(itemStaticText17, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_filenamePattern3 = new wxTextCtrl( itemPanel2, ID_FILENAME_PATTERN3, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    m_filenamePattern3->Show(false);
    itemFlexGridSizer10->Add(m_filenamePattern3, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxButton* itemButton19 = new wxButton( itemPanel2, ID_BROWSE3, _("Browse"), wxDefaultPosition, wxDefaultSize, 0 );
    itemButton19->Show(false);
    itemFlexGridSizer10->Add(itemButton19, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxFlexGridSizer* itemFlexGridSizer20 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer20->AddGrowableCol(0);
    itemBoxSizer3->Add(itemFlexGridSizer20, 0, wxGROW|wxALL, 5);

    m_variableGrid = new wxGrid( itemPanel2, ID_VARIABLE_GRID, wxDefaultPosition, wxSize(200, 150), wxSUNKEN_BORDER|wxHSCROLL|wxVSCROLL );
    m_variableGrid->SetDefaultColSize(150);
    m_variableGrid->SetDefaultRowSize(25);
    m_variableGrid->SetColLabelSize(25);
    m_variableGrid->SetRowLabelSize(50);
    m_variableGrid->CreateGrid(5, 2, wxGrid::wxGridSelectCells);
    itemFlexGridSizer20->Add(m_variableGrid, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    m_variableGrid->SetColLabelValue(0,"Variable");
    m_variableGrid->SetColLabelValue(1,"Values");

    wxFlexGridSizer* itemFlexGridSizer22 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer22->AddGrowableCol(0);
    itemBoxSizer3->Add(itemFlexGridSizer22, 0, wxGROW|wxALL, 5);

    m_coordinateGrid = new wxGrid( itemPanel2, ID_COORDINATE_GRID, wxDefaultPosition, wxSize(200, 150), wxSUNKEN_BORDER|wxHSCROLL|wxVSCROLL );
    m_coordinateGrid->SetDefaultColSize(150);
    m_coordinateGrid->SetDefaultRowSize(25);
    m_coordinateGrid->SetColLabelSize(25);
    m_coordinateGrid->SetRowLabelSize(150);
    m_coordinateGrid->CreateGrid(1, 2, wxGrid::wxGridSelectCells);
    itemFlexGridSizer22->Add(m_coordinateGrid, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    m_coordinateGrid->SetRowLabelValue(0,"Coordinate System 0");
    m_coordinateGrid->SetColLabelValue(0,"Associated Variable");
    m_coordinateGrid->SetColLabelValue(1,"Namespace (optional)");

    wxBoxSizer* itemBoxSizer24 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer3->Add(itemBoxSizer24, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxButton* itemButton25 = new wxButton( itemPanel2, ID_ADD_COORDINATE, _("Add Coordinate"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer24->Add(itemButton25, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton26 = new wxButton( itemPanel2, ID_DELETE_COORDINATE, _("Delete Coordinate"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer24->Add(itemButton26, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxCheckBox* itemCheckBox27 = new wxCheckBox( itemPanel2, ID_REMOVE_DUPLICATES, _("Remove Identity Maps"), wxDefaultPosition, wxDefaultSize, 0 );
    itemCheckBox27->SetValue(true);
    itemCheckBox27->Show(false);
    itemBoxSizer3->Add(itemCheckBox27, 0, wxALIGN_LEFT|wxALL, 5);

    wxFlexGridSizer* itemFlexGridSizer28 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer28->AddGrowableCol(1);
    itemBoxSizer3->Add(itemFlexGridSizer28, 0, wxGROW|wxALL, 5);

    wxStaticText* itemStaticText29 = new wxStaticText( itemPanel2, ID_STATIC_DEFAULT_NAMESPACE_TEXT, _("Default namespace"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer28->Add(itemStaticText29, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_namespace = new wxTextCtrl( itemPanel2, ID_NAMESPACE, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer28->Add(m_namespace, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer31 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer3->Add(itemBoxSizer31, 0, wxALIGN_LEFT|wxALL, 5);

    wxStaticText* itemStaticText32 = new wxStaticText( itemPanel2, ID_STATIC_TRANSFORMATION_UNITS_TEXT, _("Transformation units"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText32->Show(false);
    itemBoxSizer31->Add(itemStaticText32, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString m_transformationUnitsStrings;
    for(TransformUnitsList::iterator temp = TransformUnits.begin(); temp != TransformUnits.end(); temp++) {
      m_transformationUnitsStrings.Add(temp->second);
    }
    m_transformationUnits = new wxComboBox( itemPanel2, ID_TRANSFORMATION_UNITS, wxEmptyString, wxDefaultPosition, wxDefaultSize, m_transformationUnitsStrings, wxCB_DROPDOWN );
    m_transformationUnits->Show(false);
    itemBoxSizer31->Add(m_transformationUnits, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxFlexGridSizer* itemFlexGridSizer34 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer34->AddGrowableCol(1);
    itemBoxSizer3->Add(itemFlexGridSizer34, 0, wxGROW|wxALL, 5);

    wxFlexGridSizer* itemFlexGridSizer37 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer37->AddGrowableCol(1);
    itemBoxSizer3->Add(itemFlexGridSizer37, 0, wxGROW|wxALL, 5);

    wxStaticText* itemStaticText38 = new wxStaticText( itemPanel2, ID_STATIC_LABEL_TEXT, _("Label"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText38->Show(false);
    itemFlexGridSizer37->Add(itemStaticText38, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl39 = new wxTextCtrl( itemPanel2, ID_LABEL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemTextCtrl39->Show(false);
    itemFlexGridSizer37->Add(itemTextCtrl39, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxNotebook* itemNotebook40 = new wxNotebook( itemPanel2, ID_NOTEBOOK, wxDefaultPosition, wxDefaultSize, wxBK_DEFAULT );

    wxPanel* itemPanel41 = new wxPanel( itemNotebook40, ID_DEFAULT_DMID, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
    wxFlexGridSizer* itemFlexGridSizer42 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer42->AddGrowableCol(1);
    itemPanel41->SetSizer(itemFlexGridSizer42);

    wxStaticText* itemStaticText43 = new wxStaticText( itemPanel41, wxID_STATIC, _("DMID"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer42->Add(itemStaticText43, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl44 = new wxTextCtrl( itemPanel41, ID_DEFAULT_DMID_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemTextCtrl44->Enable(false);
    itemFlexGridSizer42->Add(itemTextCtrl44, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    itemNotebook40->AddPage(itemPanel41, _("Default DMID"));

    wxPanel* itemPanel45 = new wxPanel( itemNotebook40, ID_ADVANCED_DMID, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
    wxFlexGridSizer* itemFlexGridSizer46 = new wxFlexGridSizer(0, 2, 0, 0);
    itemFlexGridSizer46->AddGrowableCol(1);
    itemPanel45->SetSizer(itemFlexGridSizer46);

    wxStaticText* itemStaticText47 = new wxStaticText( itemPanel45, wxID_STATIC, _("DMID"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer46->Add(itemStaticText47, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl48 = new wxTextCtrl( itemPanel45, ID_ADVANCED_DMID_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer46->Add(itemTextCtrl48, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    itemNotebook40->AddPage(itemPanel45, _("Edit DMID"));

    itemBoxSizer3->Add(itemNotebook40, 0, wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer49 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer3->Add(itemBoxSizer49, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxButton* itemButton50 = new wxButton( itemPanel2, ID_GENERATE, _("Generate"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer49->Add(itemButton50, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton51 = new wxButton( itemPanel2, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer49->Add(itemButton51, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
}


/*
 * wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_DATATYPE
 */

void GenerateRDL::OnDatatypeSelected( wxCommandEvent& event )
{
  if(m_datatype->GetValue().compare(DataType.find("Image")->second.c_str() ) == 0 || m_datatype->GetValue().compare(DataType.find("Objectmap")->second.c_str()) == 0) {
    this->FindWindow(ID_LABEL)->Show(true);
    this->FindWindow(ID_STATIC_LABEL_TEXT)->Show(true);

    this->FindWindow(ID_STATIC_FORMAT_TEXT)->Show(false);
    this->FindWindow(ID_FORMAT)->Show(false);
    this->FindWindow(ID_REMOVE_DUPLICATES)->Show(false);
    this->FindWindow(ID_TRANSFORMATION_UNITS)->Show(false);
    this->FindWindow(ID_STATIC_TRANSFORMATION_UNITS_TEXT)->Show(false);
  }
  else if(m_datatype->GetValue().compare(DataType.find("Transformation")->second.c_str() ) == 0) {
    this->FindWindow(ID_STATIC_FORMAT_TEXT)->Show(true);
    this->FindWindow(ID_FORMAT)->Show(true);
    this->FindWindow(ID_REMOVE_DUPLICATES)->Show(true);
    this->FindWindow(ID_TRANSFORMATION_UNITS)->Show(true);
    this->FindWindow(ID_STATIC_TRANSFORMATION_UNITS_TEXT)->Show(true);

    this->FindWindow(ID_LABEL)->Show(false);
    this->FindWindow(ID_STATIC_LABEL_TEXT)->Show(false);
  }
  this->DisplayDMID();

  //Need to get the panel and do the layout of the panel
  //because the panel holds the sizer
  this->FindWindow(ID_PANEL7)->Layout();
  m_variableGrid->Refresh();
  m_coordinateGrid->Refresh();
  this->Refresh();
  this->FindWindow(ID_PANEL7)->Refresh();
}


/*
 * wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_FORMAT
 */

void GenerateRDL::OnFormatSelected( wxCommandEvent& event )
{
  if(event.GetString().compare(TransformFormat.find("Displacement3")->second.c_str()) == 0) {
    this->FindWindow(ID_STATIC_FILEFORMAT2_TEXT)->Show(true);
    this->FindWindow(ID_STATIC_FILEFORMAT3_TEXT)->Show(true);
    this->FindWindow(ID_FILENAME_PATTERN2)->Show(true);
    this->FindWindow(ID_BROWSE2)->Show(true);
    this->FindWindow(ID_FILENAME_PATTERN3)->Show(true);
    this->FindWindow(ID_BROWSE3)->Show(true);
  }
  else {
    this->FindWindow(ID_STATIC_FILEFORMAT2_TEXT)->Show(false);
    this->FindWindow(ID_STATIC_FILEFORMAT3_TEXT)->Show(false);
    this->FindWindow(ID_FILENAME_PATTERN2)->Show(false);
    this->FindWindow(ID_BROWSE2)->Show(false);
    this->FindWindow(ID_FILENAME_PATTERN3)->Show(false);
    this->FindWindow(ID_BROWSE3)->Show(false);
  }
  this->DisplayDMID();

  //Need to get the panel and do the layout of the panel
  //because the panel holds the sizer
  this->FindWindow(ID_PANEL7)->Layout();
  m_variableGrid->Refresh();
  m_coordinateGrid->Refresh();

  this->Refresh();
  this->FindWindow(ID_PANEL7)->Refresh();
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE
 */

void GenerateRDL::OnBrowseClick( wxCommandEvent& event )
{
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file to use for the file pattern"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

  m_filenamePattern->SetValue(filedialog->GetFilename() );

  delete filedialog;
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE2
 */

void GenerateRDL::OnBrowse2Click( wxCommandEvent& event )
{
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file to use for the file pattern"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

  m_filenamePattern2->SetValue(filedialog->GetFilename() );

  delete filedialog;
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE3
 */

void GenerateRDL::OnBrowse3Click( wxCommandEvent& event )
{
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file to use for the file pattern"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

  m_filenamePattern3->SetValue(filedialog->GetFilename() );

  delete filedialog;
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_GENERATE
 */
void GenerateRDL::OnGenerateClick( wxCommandEvent& event )
{
  wxString filenamePattern = m_filenamePattern->GetValue();
  std::queue<ResourceDescription *> queueOfResourceDescription;
  queueOfResourceDescription = ExpandRD(filenamePattern);

  ResourceDescriptionList *rdl = new ResourceDescriptionList();
  rdl->SetNameSpace(m_namespace->GetValue().ToStdString());

  //Go through the queue that was created and move the data
  //over into the rdl
  int queueSize = queueOfResourceDescription.size();
  for(int i=0; i< queueSize; i++) {
    std::string datatype = m_datatype->GetValue().ToStdString();
    if(datatype.compare(DataType.find("Image")->second) == 0 || datatype.compare(DataType.find("Objectmap")->second) == 0) { 
      rdl->AddDataDescrip(queueOfResourceDescription.front()->GetDMID(), queueOfResourceDescription.front());
    }
    else if(datatype.compare(DataType.find("Transformation")->second) == 0) {
      rdl->AddTransformDescrip(queueOfResourceDescription.front()->GetDMID(), queueOfResourceDescription.front());
    }
    else {
      delete queueOfResourceDescription.front();
    }
    queueOfResourceDescription.pop();
  }

  //Display the rdl to the user, who can then
  //make changes to the text and also save
  //the rdl out to file
  ViewRDL *viewRDL = new ViewRDL(this,rdl);
  viewRDL->Show();
  delete rdl;
}


//major re-change, now going to use ResourceDescription
  //The main logic of this is the following:
  //Go through m_variableGrid and get the variable
  //to be used and the values associated.
  //Then run through a while loop that will expand
  //a fifo queue with the subsition of variables
  //for values.
  //Example:
  //  m_variableGrid holds:
  //                        a  01,02,03
  //                        b  01,02,03
  //
  //  file name pattern:
  //                       na{a}_na{b}.warp
  //
  //  Therefore this is what happens:
  //  1.) A blank ResourceDescription is created and put
  //      into the queue along with the filename pattern 
  //      na{a}_na{b}.warp
  //  2.) run through the for loop
  //         a.) first iteration of for loop
  //                i.) Get the variable a and values 01,02,03
  //                ii.) run through the while loop
  //                      A.)  na{a}_na{b}.warp is popped off the queue
  //                      B.)  na01_na{b}.warp
  //                           na02_na{b}.warp
  //                           na03_na{b}.warp
  //                           are all added to the queue
  //                      C.)  na01_na{b}.warp is popped off the queue
  //                      D.)  na01_na{b}.warp
  //                           is added to the queue and the while loop stops
  //         b) next iteration of the for loop
  //                i.) Get the variable b and values 01,02,03
  //                ii.) run through the while loop
  //                      A.)  na02_na{b}.warp is popped off the queue
  //                      B.)  na02_na01.warp
  //                           na02_na02.warp
  //                           na02_na03.warp
  //                           are all added to the queue
  //                      C.)  na03_na{b}.warp is popped off the queue
  //                      D.)  na03_na01.warp
  //                           na03_na02.warp
  //                           na03_na03.warp
  //                           are all added to the queue
  //                      E.)  na01_na{b}.warp is popped off the queue
  //                      F.)  na01_na01.warp
  //                           na01_na02.warp
  //                           na01_na03.warp
  //                           are all added to the queue
  //                      G.)  na02_na01.warp is popped off the queue
  //                      H.)  na02_na01.warp
  //                           is added to the queue and the while loop stops
std::queue<ResourceDescription *> GenerateRDL::ExpandRD(const wxString &pattern)
{
  std::queue<ResourceDescription *> queueOfResourceDescription;
  ResourceDescription *resourceDescription = new ResourceDescription(std::string(m_namespace->GetValue().c_str()));
  //resourceDescription->AddAlgorithm("0", std::string(m_algorithm->GetValue().c_str()));
  if(m_coordinateGrid->GetNumberCols() == 3) {
    for(unsigned int i=1; i<m_coordinateGrid->GetNumberRows(); i++) {
      std::string index;
      std::stringstream out;
      out << i-1;
      index = out.str();
      resourceDescription->AddAlgorithm(index, std::string(m_coordinateGrid->GetCellValue(i,2).c_str()));
    }
  }
  resourceDescription->SetDataType(std::string(m_datatype->GetValue().c_str()));
  resourceDescription->SetDefaultNS(std::string(m_namespace->GetValue().c_str()));
  resourceDescription->SetFormat(std::string(dynamic_cast<wxComboBox*>(this->FindWindow(ID_FORMAT))->GetValue().c_str()));
  resourceDescription->SetTransformUnits(std::string(m_transformationUnits->GetValue().c_str()));
  resourceDescription->SetLabel(std::string(dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_LABEL))->GetValue().c_str()));

  resourceDescription->AddFilename("0",std::string(pattern.c_str()));
  resourceDescription->SetDMID(std::string(dynamic_cast<wxTextCtrl *>(this->FindWindow(ID_ADVANCED_DMID_TEXT))->GetValue().c_str()));

  queueOfResourceDescription.push(resourceDescription);

  for(unsigned int i=0; i< m_variableGrid->GetNumberRows(); i++) {
    if( !m_variableGrid->GetCellValue(i,0).IsEmpty())  {
      //Create a temporary variable associated with the value
      //at m_variableGrid->GetCellValue(i,0), wrap
      //curly braces
      wxString variable = "{";
      variable.Append(m_variableGrid->GetCellValue(i,0));
      variable.Append("}");

      //Create temporary vector called tokens that
      //stores values that are assocated with variable
      wxString commaSeperatedvalues = m_variableGrid->GetCellValue(i,1);
      std::vector<wxString> vectorOfValues;
      this->Tokenize(commaSeperatedvalues,vectorOfValues,",");


      //figure out if m_variableGrid->GetCellValue(i,0) is associated with
      //m_coordinateGrid->GetCellValue(j,0)
      bool isCoordinate = false;
      int index = 0;
      for(unsigned int j=0; j<m_coordinateGrid->GetNumberRows(); j ++) {
        if(m_variableGrid->GetCellValue(i,0).compare(m_coordinateGrid->GetCellValue(j,0) ) == 0) {
          isCoordinate = true;
          index = j;
        }
      } 

      bool availableVariable= true;
      if(vectorOfValues.size()!= 0) {
        while(availableVariable) {
          if(queueOfResourceDescription.size() > 0) {
          ResourceDescription *tempResourceDescription = queueOfResourceDescription.front();
          queueOfResourceDescription.pop();

          for(unsigned int i=0; i< vectorOfValues.size(); i++) {
            //need to make a copy of tempResourceDescription
            ResourceDescription *copyResourceDescription = new ResourceDescription(std::string(m_namespace->GetValue().c_str()));
            copyResourceDescription->SetDataType(tempResourceDescription->GetDataType());
            copyResourceDescription->SetDefaultNS(tempResourceDescription->GetDefaultNS());
            copyResourceDescription->SetFormat(tempResourceDescription->GetFormat());
            copyResourceDescription->SetLabel(tempResourceDescription->GetLabel());
            copyResourceDescription->SetTransformUnits(tempResourceDescription->GetTransformUnits());
            copyResourceDescription->AddAlgorithm("0",tempResourceDescription->GetAlgorithm("0"));
            const ResourceDescription::CSList *cslist = tempResourceDescription->GetCS();
            if(cslist != NULL) {
              for(ResourceDescription::CSList::const_iterator temp = cslist->begin(); temp!= cslist->end(); temp++) {
                copyResourceDescription->AddCS(temp->second.index,temp->second);
              }
            }

            //Get the items that need to be replaced
            wxString tempFile = tempResourceDescription->GetFilename("0", false);
            wxString tempDmidString = tempResourceDescription->GetDMID();
            wxString value = vectorOfValues.at(i);


            unsigned int dmidReplace = tempDmidString.Replace(variable,value);
            unsigned int fileReplace = tempFile.Replace(variable,value);

            //Replace returns the number of items replaced, and so
            //if it is equal to zero, then nothing was replaced
            if(fileReplace  == 0 && dmidReplace == 0  && availableVariable) {
              //Now we just need to push back the items that we popped off
              //the queues and get out of the while loop
              availableVariable = false;

              //Make sure we update the copyResourceDescription with the up to date
              //DMID and filename
              copyResourceDescription->SetDMID(std::string(tempDmidString.c_str()));
              copyResourceDescription->AddFilename("0", std::string(tempFile.c_str()));
              queueOfResourceDescription.push(copyResourceDescription);
            }
            else if(dmidReplace != 0 && availableVariable && fileReplace == 0) {
              //Make sure we update the copyResourceDescription with the up to date
              //DMID and filename
              copyResourceDescription->SetDMID(std::string(tempDmidString.c_str()));
              copyResourceDescription->AddFilename("0", std::string(tempFile.c_str()));
              queueOfResourceDescription.push(copyResourceDescription);
            }
            else if(fileReplace != 0 && availableVariable) {
              copyResourceDescription->AddFilename("0", std::string(tempFile.c_str()));
              bool push = true;
              if(isCoordinate) {

                //Figure out if the current value creates an identity
                if(dynamic_cast<wxCheckBox*>(this->FindWindow(ID_REMOVE_DUPLICATES))->GetValue()) {
                  if(index > 0) {
                    std::string previousIndexString;
                    std::stringstream outTwo;
                    outTwo << index-1;
                    previousIndexString = outTwo.str();
                    if(copyResourceDescription->GetCS(previousIndexString)->id.compare(value.c_str()) == 0) {
                      push = false;
                    }
                    outTwo.flush();
                  }
                }

                //If the values are not an identity then create a new ResourceDescription::CoordinateSystem
                if(push) {
                  ResourceDescription::CoordinateSystem cs;
                  wxString indexString = wxString::Format(_T("%d"), index);
                  cs.index = std::string(indexString.c_str() );
                  cs.id = std::string(value.c_str() );
                  if(!m_coordinateGrid->GetCellValue(index,1).IsEmpty() ) {
                    cs.ns = std::string( m_coordinateGrid->GetCellValue(index,1).c_str() );
                  } else {
                    cs.ns = std::string( m_namespace->GetValue().c_str() );
                  }
                  copyResourceDescription->AddCS(cs.index, cs);
                }
              }

              //If the values are not an identity then push onto the queue
              if(push) {
                copyResourceDescription->SetDMID(std::string(tempDmidString.c_str()));
                queueOfResourceDescription.push(copyResourceDescription);
              } else {
                //make sure that we delete any copies that aren't being used
                //otherwise we will have memory leaks
                delete copyResourceDescription;
              }
            }
            else{
              //make sure that we delete any copies that aren't being used
              //otherwise we will have memory leaks
              delete copyResourceDescription;
            }
            
          }
          delete tempResourceDescription;
          }
        }
      }
    }
  }
  return queueOfResourceDescription;
}


//Found this code from http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
//Had to modify a little bit
void GenerateRDL::Tokenize(const wxString& str,
                      std::vector<wxString>& tokens,
                      const wxString& delimiters)
{
    // Skip delimiters at beginning.
    wxString::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    //JAH added in this if statement
    wxString::size_type pos = wxString::npos;
    if(lastPos != wxString::npos)
      pos = str.find_first_of(delimiters, lastPos);

    while (wxString::npos != pos || wxString::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        //JAH added in this if statement
        if(lastPos != wxString::npos)
          pos = str.find_first_of(delimiters, lastPos);
    }
}



/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
 */

void GenerateRDL::OnCancelClick( wxCommandEvent& event )
{
  this->Close();
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
 */

void GenerateRDL::OnAddCoordinateClick( wxCommandEvent& event )
{
  m_coordinateGrid->AppendRows();
  wxString temp = "Coordinate System ";
  temp.Append(wxString::Format ("%i", m_coordinateGrid->GetNumberRows()-1));
  m_coordinateGrid->SetRowLabelValue(m_coordinateGrid->GetNumberRows()-1,temp);
  if(m_coordinateGrid->GetNumberRows()>1 && m_coordinateGrid->GetNumberCols() != 3) {
    m_coordinateGrid->AppendCols();
    m_coordinateGrid->SetColLabelValue(2,"Algorithm");
    //m_coordinateGrid->SetCellValue("Please do not put an algorithm name here",0,2);
    m_coordinateGrid->SetReadOnly(0,2);
  }
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
 */

void GenerateRDL::OnDeleteCoordinateClick( wxCommandEvent& event )
{
  m_coordinateGrid->DeleteRows(m_coordinateGrid->GetNumberRows()-1);
  if(m_coordinateGrid->GetNumberRows()<2 && m_coordinateGrid->GetNumberCols() == 3) {
    m_coordinateGrid->DeleteCols(2);
  }
}


/*
 * Should we show tooltips?
 */

bool GenerateRDL::ShowToolTips()
{
    return true;
}

/*
 * Get bitmap resources
 */

wxBitmap GenerateRDL::GetBitmapResource( const wxString& name )
{
    // Bitmap retrieval
    wxUnusedVar(name);
    return wxNullBitmap;
}

/*
 * Get icon resources
 */

wxIcon GenerateRDL::GetIconResource( const wxString& name )
{
    // Icon retrieval
    wxUnusedVar(name);
    return wxNullIcon;
}

/*
 * wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED event handler for ID_NOTEBOOK
 */

void GenerateRDL::OnNotebookPageChanged( wxNotebookEvent& event )
{

  int id = event.GetId();
  int selection = event.GetSelection();
  int previous = event.GetOldSelection();
  const wxWindowList temp =  this->GetChildren();
  wxNotebook *tempTwo = dynamic_cast<wxNotebook*>( this->FindWindow(id) );
  wxTextCtrl *tempThree = dynamic_cast<wxTextCtrl*>( tempTwo->GetCurrentPage()->FindWindow(ID_DEFAULT_DMID_TEXT) );
  wxTextCtrl *tempFour = dynamic_cast<wxTextCtrl*>( tempTwo->GetCurrentPage()->FindWindow(ID_ADVANCED_DMID_TEXT) );
  if(previous != -1) {
    wxTextCtrl *defaultText = dynamic_cast<wxTextCtrl*>( tempTwo->GetPage(previous) );

    //make sure that any changes that were made in the advanced get shown in the default
    if(defaultText != NULL && tempFour != NULL) {
      defaultText->Clear();
      defaultText->SetValue(tempFour->GetValue());
    }
  }
}

void GenerateRDL::DisplayDMID()
{
  wxString dmid;

  //Figure out what evaluator command to use
  if(DataType.find("Image")->second.compare(m_datatype->GetValue()) == 0 || DataType.find("Objectmap")->second.compare(m_datatype->GetValue()) == 0) {
    dmid = EvalCmd.find("SpatialData")->second;
  } else if(DataType.find("Transformation")->second.compare(m_datatype->GetValue()) == 0) {
    dmid = EvalCmd.find("Transformation")->second;
  }


  dmid.Append("(");
  //need to check the m_coordinate second column values
  //if there is a value in the second column then we
  //want to use that
  //add the namespace
  if(m_coordinateGrid->GetNumberRows() > 0) {
    if(!m_coordinateGrid->GetCellValue(0,1).IsEmpty() ) {
      dmid.Append(m_coordinateGrid->GetCellValue(0,1));
    } else {
      dmid.Append(m_namespace->GetValue());
    }
  } else {
    dmid.Append(m_namespace->GetValue());
  }
  dmid.Append("|{");
  if(m_coordinateGrid->GetNumberRows() > 0) {
    dmid.Append(m_coordinateGrid->GetCellValue(0,0));
  }
  dmid.Append("},");


  //Figure out which format we should use for DMID
  if(DataType.find("Image")->second.compare(m_datatype->GetValue()) == 0 || DataType.find("Objectmap")->second.compare(m_datatype->GetValue()) == 0) {
    dmid.Append( dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_LABEL))->GetValue() );
  } else if(DataType.find("Transformation")->second.compare(m_datatype->GetValue()) == 0) {
    if(m_coordinateGrid->GetNumberRows() > 0) {
      if(!m_coordinateGrid->GetCellValue(0,1).IsEmpty() ) {
        dmid.Append(m_coordinateGrid->GetCellValue(1,1));
      } else {
        dmid.Append(m_namespace->GetValue());
      }
    } else {
      dmid.Append(m_namespace->GetValue());
    }
    dmid.Append("|{");
    if(m_coordinateGrid->GetNumberRows() > 1) {
      dmid.Append(m_coordinateGrid->GetCellValue(1,0));
    }
    dmid.Append("},");
    if(m_coordinateGrid->GetNumberCols() == 3) {
      dmid.Append(m_coordinateGrid->GetCellValue(1,2));
    }
  }
  dmid.Append(")");

  //Push the newly created DMID out to the text controls
  dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_DEFAULT_DMID_TEXT))->SetValue(dmid);
  dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_ADVANCED_DMID_TEXT))->SetValue(dmid);
}

void GenerateRDL::OnCoordinateGridChange( wxGridEvent& event )
{
  this->DisplayDMID();
}

void GenerateRDL::OnUpdateDMID( wxCommandEvent& event )
{
  this->DisplayDMID();
}

void GenerateRDL::OnUpdateVariables( wxCommandEvent& event )
{
  //Figure out if a user put in a variable in the 
  //filename pattern boxes.  If the user did
  //then add the variable to m_variableGrid
  wxString pattern = event.GetString();
  size_t first = pattern.find_first_of("{");
  size_t second = pattern.find_first_of("}");
  while(first != wxString::npos && second != wxString::npos) {
    wxString temp = pattern.substr(first+1, second - first-1);
    int i=0;
    bool insert = false;
    while(!insert) {
      if(m_variableGrid->GetNumberRows()-1 < i) {
        m_variableGrid->InsertRows(m_variableGrid->GetNumberRows());
      }
      if(m_variableGrid->GetCellValue(i,0).compare(temp) == 0) {
        insert = true;
      }
      else if(m_variableGrid->GetCellValue(i,0).IsEmpty() ) {
        m_variableGrid->SetCellValue(temp, i, 0);
        insert = true;
      }
      i++;
    }
    first = pattern.find("{",first+1);
    second = pattern.find("}",second+1);
  }
}