ViewDisplayDescription.cpp

Go to the documentation of this file.

// Name:        ViewDisplayDescription.cpp
// Purpose:     
// Author:      
// Modified by: 
// Created:     02/08/2010 16:53:38
// RCS-ID:      
// Copyright:   
// Licence:     

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif



#include "ViewDisplayDescription.h"
#include <sstream>
#include "DisplayDescription.h"
#include "wx/generic/gridctrl.h"



/*
 * ViewDisplayDescription type definition
 */

IMPLEMENT_CLASS( ViewDisplayDescription, wxFrame )


/*
 * ViewDisplayDescription event table definition
 */

BEGIN_EVENT_TABLE( ViewDisplayDescription, wxFrame )

    EVT_GRID_CMD_CELL_CHANGE( ID_WIDGET_COMMANDS, ViewDisplayDescription::OnWidgetCommandsCellChange )

    EVT_BUTTON( ID_ADD_RDL, ViewDisplayDescription::OnAddRdlClick )

    EVT_BUTTON( ID_REMOVE_RDL, ViewDisplayDescription::OnRemoveRdlClick )

    EVT_BUTTON( ID_SAVE, ViewDisplayDescription::OnSaveClick )

    EVT_BUTTON( wxID_CANCEL, ViewDisplayDescription::OnCancelClick )

    EVT_TEXT( ID_ROW, ViewDisplayDescription::OnRowTextUpdated )

    EVT_TEXT( ID_COLUMN, ViewDisplayDescription::OnColumnTextUpdated )

    EVT_MENU( ID_MENU_NEW, ViewDisplayDescription::OnMenuNewClick )

    EVT_MENU( ID_MENU_OPEN, ViewDisplayDescription::OnMenuOpenClick )

    EVT_MENU( ID_MENU_SAVE, ViewDisplayDescription::OnMenuSaveClick )

    EVT_MENU( wxID_EXIT, ViewDisplayDescription::OnExitClick )

    EVT_GRID_CMD_CELL_RIGHT_CLICK( ID_WIDGET_COMMANDS, ViewDisplayDescription::OnWidgetCommandsCellRightClick )

END_EVENT_TABLE()


/*
 * ViewDisplayDescription constructors
 */

ViewDisplayDescription::ViewDisplayDescription()
{
    Init();
}

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


/*
 * ViewDisplayDescription creator
 */

bool ViewDisplayDescription::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;
}


/*
 * ViewDisplayDescription destructor
 */

ViewDisplayDescription::~ViewDisplayDescription()
{
}


/*
 * Member initialisation
 */

void ViewDisplayDescription::Init()
{
  m_rdlList = NULL;
  m_variableList = NULL;
  m_evaluatorList = NULL;
  m_displayAttributesList = NULL;
  m_widgetCommands = NULL;
  m_row = NULL;
  m_col = NULL;
}


/*
 * Control creation for ViewDisplayDescription
 */

void ViewDisplayDescription::CreateControls()
{    
    ViewDisplayDescription* 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);

    wxScrolledWindow* itemScrolledWindow2 = new wxScrolledWindow( itemFrame1, ID_SCROLLEDWINDOW2, wxDefaultPosition, wxSize(100, 100), wxSUNKEN_BORDER|wxHSCROLL|wxVSCROLL );
    itemScrolledWindow2->SetScrollbars(1, 1, 0, 0);
    wxFlexGridSizer* itemFlexGridSizer3 = new wxFlexGridSizer(0, 1, 0, 0);
    itemFlexGridSizer3->AddGrowableCol(0);
    itemScrolledWindow2->SetSizer(itemFlexGridSizer3);

    wxStaticText* itemStaticText4 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Resource Description List"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText4, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString itemListBox5Strings;
    m_rdlList = new wxListBox( itemScrolledWindow2, ID_RDL_LIST, wxDefaultPosition, wxDefaultSize, itemListBox5Strings, wxLB_SINGLE );
    itemFlexGridSizer3->Add(m_rdlList, 0, wxGROW|wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer6 = new wxBoxSizer(wxHORIZONTAL);
    itemFlexGridSizer3->Add(itemBoxSizer6, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxButton* itemButton7 = new wxButton( itemScrolledWindow2, ID_ADD_RDL, _("Add Resource Description List"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer6->Add(itemButton7, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton8 = new wxButton( itemScrolledWindow2, ID_REMOVE_RDL, _("Remove Resource Decription List"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer6->Add(itemButton8, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticLine* itemStaticLine9 = new wxStaticLine( itemScrolledWindow2, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    itemFlexGridSizer3->Add(itemStaticLine9, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxStaticText* itemStaticText10 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Variables"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText10, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);


    m_variableList = new IntelliTextCtrl( itemScrolledWindow2, ID_TEXTCTRL9, wxEmptyString, wxDefaultPosition, wxSize(-1, 200), wxTE_MULTILINE );
    itemFlexGridSizer3->Add(m_variableList, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    

    

    wxStaticLine* itemStaticLine13 = new wxStaticLine( itemScrolledWindow2, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    itemFlexGridSizer3->Add(itemStaticLine13, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxStaticText* itemStaticText14 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Evaluator Commands"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText14, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_evaluatorList = new IntelliTextCtrl( itemScrolledWindow2, ID_INTELLITEXTCTRL1, wxEmptyString, wxDefaultPosition, wxSize(-1, 200), wxTE_MULTILINE );
    itemFlexGridSizer3->Add(m_evaluatorList, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);
    std::vector<wxString> rightClickText;
    for(EvaluatorCmdList::iterator i= EvalCmd.begin(); i != EvalCmd.end(); i++) {
      rightClickText.push_back(wxString(i->second.c_str(), wxConvUTF8));
    }
    m_evaluatorList->SetRightClickText(rightClickText);

    wxStaticLine* itemStaticLine17 = new wxStaticLine( itemScrolledWindow2, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    itemFlexGridSizer3->Add(itemStaticLine17, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer18 = new wxBoxSizer(wxHORIZONTAL);
    itemFlexGridSizer3->Add(itemBoxSizer18, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText19 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Number Of Rows"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer18->Add(itemStaticText19, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_row = new wxTextCtrl( itemScrolledWindow2, ID_ROW, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer18->Add(m_row, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer21 = new wxBoxSizer(wxHORIZONTAL);
    itemFlexGridSizer3->Add(itemBoxSizer21, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText22 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Number Of Columns"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer21->Add(itemStaticText22, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_col= new wxTextCtrl( itemScrolledWindow2, ID_COLUMN, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer21->Add(m_col, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText24 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Widget Commands"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText24, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_widgetCommands = new wxGrid( itemScrolledWindow2, ID_WIDGET_COMMANDS, wxDefaultPosition, wxSize(200, 150), wxSUNKEN_BORDER|wxHSCROLL|wxVSCROLL );
    m_widgetCommands->SetDefaultColSize(150);
    m_widgetCommands->SetDefaultRowSize(25);
    m_widgetCommands->SetColLabelSize(25);
    m_widgetCommands->SetRowLabelSize(50);
    m_widgetCommands->CreateGrid(0, 0, wxGrid::wxGridSelectCells);
    itemFlexGridSizer3->Add(m_widgetCommands, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxStaticLine* itemStaticLine26 = new wxStaticLine( itemScrolledWindow2, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    itemFlexGridSizer3->Add(itemStaticLine26, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxStaticText* itemStaticText27 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Widget Attributes"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText27, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_displayAttributesList = new IntelliTextCtrl( itemScrolledWindow2, ID_TEXTCTRL12, wxEmptyString, wxDefaultPosition, wxSize(-1, 100), wxTE_MULTILINE );
    itemFlexGridSizer3->Add(m_displayAttributesList, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);
    wxString text = wxString(DisplayAttributeCmd.find("Rowsize")->second.c_str(), wxConvUTF8);
    text.Append(wxT("("));
    text.Append(m_row->GetValue());
    text.Append(wxT(")\n"));
    m_displayAttributesList->AppendText(text);

    wxString textTwo = wxString(DisplayAttributeCmd.find("Columnsize")->second.c_str(), wxConvUTF8);
    textTwo.Append(wxT("("));
    textTwo.Append(m_row->GetValue());
    textTwo.Append(wxT(")\n"));
    m_displayAttributesList->AppendText(textTwo);

    rightClickText.clear();
    for(DisplayAttributeCmdList::iterator i= DisplayAttributeCmd.begin(); i != DisplayAttributeCmd.end(); i++) {
      rightClickText.push_back(wxString(i->second.c_str(), wxConvUTF8));
    }
    m_displayAttributesList->SetRightClickText(rightClickText);

    wxStaticLine* itemStaticLine29 = new wxStaticLine( itemScrolledWindow2, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    itemFlexGridSizer3->Add(itemStaticLine29, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer30 = new wxBoxSizer(wxHORIZONTAL);
    itemFlexGridSizer3->Add(itemBoxSizer30, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxButton* itemButton31 = new wxButton( itemScrolledWindow2, ID_SAVE, _("Save"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer30->Add(itemButton31, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton32 = new wxButton( itemScrolledWindow2, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer30->Add(itemButton32, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    this->SetDefaults();

    itemScrolledWindow2->FitInside();
}


/*
 * Should we show tooltips?
 */

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

/*
 * Get bitmap resources
 */

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

/*
 * Get icon resources
 */

wxIcon ViewDisplayDescription::GetIconResource( const wxString& name )
{
    wxUnusedVar(name);
    return wxNullIcon;
}


/*
 * wxEVT_GRID_CMD_CELL_CHANGE event handler for ID_WIDGET_COMMANDS
 */

void ViewDisplayDescription::OnWidgetCommandsCellChange( wxGridEvent& event )
{
    event.Skip();

}

/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_ADD_RDL
 */

void ViewDisplayDescription::OnAddRdlClick( wxCommandEvent& event )
{
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a Resource Description List file to add to list"), wxT(""), wxT("untitled.rdl"), wxT("(*.rdl)|*.rdl|(*.*)|*.*"),  0, wxDefaultPosition, wxDefaultSize, wxT("Pick"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}


  m_rdlList->Append(filedialog->GetPath());

  delete filedialog;
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_REMOVE_RDL
 */

void ViewDisplayDescription::OnRemoveRdlClick( wxCommandEvent& event )
{
  if(m_rdlList->GetSelection()  !=wxNOT_FOUND) {
    m_rdlList->Delete(m_rdlList->GetSelection());
  }
  else if(m_rdlList->GetCount() != 0) {
    m_rdlList->Delete(m_rdlList->GetCount()-1);
  }
}

/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_CREATE
 */

void ViewDisplayDescription::OnSaveClick( wxCommandEvent& event )
{
  this->Save();
  this->Close();
}

void ViewDisplayDescription::Save()
{
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a location to save the Display Description"), wxT(""), wxT("untitled.nd3"), wxT("(*.nd3)|*.nd3|(*.*)|*.*"),  wxFD_SAVE|wxFD_OVERWRITE_PROMPT, wxDefaultPosition, wxDefaultSize, wxT("Save"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

  FILE *tempFile = fopen(filedialog->GetPath().mb_str(), "w+");

  fprintf(tempFile,"Begin ResourcedescriptionList\n\n");
  for(int i=0; i< m_rdlList->GetCount(); i++) {
    fprintf(tempFile,"%s\n", m_rdlList->GetString(i));
  }
  fprintf(tempFile,"End ResourceDescriptionList\n\n\n");

  fprintf(tempFile,"begin variablelist\n\n");
  for(int i=0; i< m_variableList->GetNumberOfLines(); i++) {
    fprintf(tempFile,"%s\n", m_variableList->GetLineText(i).c_str() );
  }
  fprintf(tempFile,"end variablelist\n\n\n");

  fprintf(tempFile,"begin evaluatorlist\n\n");
  for(int i=0; i< m_evaluatorList->GetNumberOfLines(); i++) {
    fprintf(tempFile,"%s\n", m_evaluatorList->GetLineText(i).c_str() );
  }
  fprintf(tempFile,"end evaluatorlist\n\n\n");

  fprintf(tempFile,"begin widgetlist\n\n");
  for(int i=0; i< m_widgetCommands->GetNumberRows();i++) {
    for(int j=0; j< m_widgetCommands->GetNumberCols(); j++) {
      wxString temp = wxT("w");
      std::stringstream out;
      out << i;
      temp.Append( wxString(out.str().c_str(), wxConvUTF8));
      out.flush();
      temp.Append(wxT(","));
      std::stringstream outTwo;
      outTwo << j;
      temp.Append(wxString(outTwo.str().c_str(), wxConvUTF8));
      outTwo.flush();
      temp.Append(wxT("="));
      temp.Append(m_widgetCommands->GetCellValue(j,i) );

      fprintf(tempFile,"%s\n", temp.c_str() );
    }
  }
  fprintf(tempFile,"end widgetlist\n\n\n");

  fprintf(tempFile,"begin displayattributes\n");
  for(int i=0; i< m_displayAttributesList->GetNumberOfLines(); i++) {
    fprintf(tempFile,"%s\n", m_displayAttributesList->GetLineText(i).c_str() );
  }
  fprintf(tempFile,"end displayattributes\n");

  
  fclose(tempFile);
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
 */

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

/*
 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_ROW
 */

//When the user updates the input field for the number of rows
//we need to update the size of the widget grid and also update the
//display attribute that contains Rowsize
void ViewDisplayDescription::OnRowTextUpdated( wxCommandEvent& event )
{
  if(m_widgetCommands != NULL) {
    double row = 0;
    m_row->GetValue().ToDouble(&row);
    if(row > m_widgetCommands->GetNumberRows() ) {
      for(int i= m_widgetCommands->GetNumberRows(); i< row; i++) {
        m_widgetCommands->AppendRows();
        for(int j=0; j< m_widgetCommands->GetNumberCols(); j++) {
          m_widgetCommands->SetCellRenderer(i , j, new wxGridCellAutoWrapStringRenderer);
          m_widgetCommands->SetCellEditor( i,  j , new wxGridCellAutoWrapStringEditor);
        }
      }
    }
    else {
      for(int i= m_widgetCommands->GetNumberRows(); i> row; i--) {
        m_widgetCommands->DeleteRows(m_widgetCommands->GetNumberRows() - 1);
      }
    }
  }
  if(m_displayAttributesList != NULL) {
    bool found = false;
    int start = 0;
    for(int i=0; i < m_displayAttributesList->GetNumberOfLines() && found == false; i++) {
      wxString text = m_displayAttributesList->GetLineText(i);
      start += m_displayAttributesList->GetLineLength(i);
      size_t firstP = text.find_first_of(wxT("("));
      if(firstP != wxString::npos) {
        wxString command(text, firstP);
        if(command.compare(wxString(DisplayAttributeCmd.find("Rowsize")->second.c_str(), wxConvUTF8)) == 0) {
          size_t lastP = text.find_first_of(wxT(")"));
          m_displayAttributesList->Replace(start-lastP+firstP,start-1,m_row->GetValue());
        }
      }
      start+=2;
    }
  }
}


/*
 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_COLUMN
 */

//When the user updates the input field for the number of columns
//we need to update the size of the widget grid and also update the
//display attribute that contains Columnsize
void ViewDisplayDescription::OnColumnTextUpdated( wxCommandEvent& event )
{
  if(m_widgetCommands != NULL) {
    double col = 0;
    m_col->GetValue().ToDouble(&col);
    
    //figure out if we need to add columns or delete columns
    if(col > m_widgetCommands->GetNumberCols() ) {
      for(int i= m_widgetCommands->GetNumberCols(); i< col; i++) {
        m_widgetCommands->AppendCols();
        for(int j=0; j< m_widgetCommands->GetNumberRows(); j++) {
          //A nice feature that will wrap the text
          m_widgetCommands->SetCellRenderer(j , i, new wxGridCellAutoWrapStringRenderer);
          m_widgetCommands->SetCellEditor( j,  i , new wxGridCellAutoWrapStringEditor);
        }
      }
    }
    else {
      for(int i= m_widgetCommands->GetNumberCols(); i> col; i--) {
        m_widgetCommands->DeleteCols(m_widgetCommands->GetNumberCols() - 1);
      }
    }
  }

  //Update the display attribute with the new value
  if(m_displayAttributesList != NULL) {
    bool found = false;
    int start = 0;

    //Go through the lines of m_displayAttributesList and find Columnsize and update
    //the value.  If Columnsize is not in m_displayAttributesList then Columnsize will
    //currently not be put in the list.  Also, if the user forgets to put in a ")" then
    //when this replaces it will replace the new line
    for(int i=0; i < m_displayAttributesList->GetNumberOfLines() && found == false; i++) {
      wxString text = m_displayAttributesList->GetLineText(i);
      start += m_displayAttributesList->GetLineLength(i);
      size_t firstP = text.find_first_of(wxT("("));
      if(firstP != wxString::npos) {
        wxString command(text, firstP);
        if(command.compare(wxString(DisplayAttributeCmd.find("Columnsize")->second.c_str(), wxConvUTF8)) == 0) {
          size_t lastP = text.find_first_of(wxT(")"));
          m_displayAttributesList->Replace(start-lastP+firstP,start-1,m_col->GetValue());
        }
      }
      start+=2;
    }
  }
}

/*
 * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENUITEM3
 */

//Clear out the values of the input fields and
//set the defaults
//We could change this to opening a new
//viewDisplayDescription
void ViewDisplayDescription::OnMenuNewClick( wxCommandEvent& event )
{
  this->ClearAll();
  this->SetDefaults();
}


/*
 * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENUITEM1
 */

//Open a display description when the user
//selected open from the file menu
//Once the display description is opened
//then go through and populate the input fields with
//the appropriate values
void ViewDisplayDescription::OnMenuOpenClick( wxCommandEvent& event )
{
  this->ClearAll();
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose the Display Description to open"), wxT(""), wxT("untitled.nd3"), wxT("(*.nd3)|*.nd3|(*.*)|*.*"),  wxFD_OPEN, wxDefaultPosition, wxDefaultSize, wxT("Open"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}
  DisplayDescription *dd = new DisplayDescription();
  dd->Read(std::string(filedialog->GetPath().mb_str()));

  std::string rdlFilename = dd->GetRDL()->GetFilename();
  m_rdlList->Append(wxString(rdlFilename.c_str(), wxConvUTF8));

  std::map<std::string, std::string> *variables = dd->GetVariableList()->GetVariableList();
  for(std::map<std::string, std::string>::iterator i = variables->begin(); i!= variables->end(); i++) {
    m_variableList->AppendText(wxString(i->first.c_str(), wxConvUTF8));
    m_variableList->AppendText(wxT("="));
    m_variableList->AppendText(wxString(i->second.c_str(), wxConvUTF8));
    m_variableList->AppendText(wxT("\n"));
  }

  std::map<std::string, std::string> *evaluatorCommands = dd->GetEvaluatorList()->GetList();
  for(std::map<std::string, std::string>::iterator i = evaluatorCommands->begin(); i!= evaluatorCommands->end(); i++) {
    m_evaluatorList->AppendText(wxString(i->first.c_str(), wxConvUTF8));
    m_evaluatorList->AppendText(wxT("="));
    m_evaluatorList->AppendText(wxString(i->second.c_str(), wxConvUTF8));
    m_evaluatorList->AppendText(wxT("\n"));
  }

  std::map<std::string, std::vector< std::vector<std::string> > > *attributes = dd->GetDisplayAttributes()->GetAttributes();
  for(std::map<std::string, std::vector< std::vector<std::string> > >::iterator i = attributes->begin(); i!= attributes->end(); i++) {
    
    for(int j=0; j< i->second.size(); j++) {
      m_displayAttributesList->AppendText(wxString(i->first.c_str(), wxConvUTF8));
      m_displayAttributesList->AppendText(wxT("("));
      for(int k=0; k< i->second.at(j).size(); k++) {
        m_displayAttributesList->AppendText(wxString(i->second.at(j).at(k).c_str(), wxConvUTF8));
        m_displayAttributesList->AppendText(wxT(","));
      }
      if(i->second.at(j).size() != 0 ) {
        m_displayAttributesList->Remove(m_displayAttributesList->GetInsertionPoint()-1,m_displayAttributesList->GetInsertionPoint());
      }
      m_displayAttributesList->AppendText(wxT(")\n"));
    }
  }

  m_row->SetValue(wxString(attributes->find(DisplayAttributeCmd.find("Rowsize")->second)->second.at(0).at(0).c_str(), wxConvUTF8) );
  m_col->SetValue(wxString(attributes->find(DisplayAttributeCmd.find("Columnsize")->second)->second.at(0).at(0).c_str(), wxConvUTF8) );

  delete dd;
  
  delete filedialog;
}


/*
 * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENUITEM
 */

//Save the display description when the user
//selected save in the File menu
void ViewDisplayDescription::OnMenuSaveClick( wxCommandEvent& event )
{
    this->Save();
}


/*
 * wxEVT_COMMAND_MENU_SELECTED event handler for wxID_EXIT
 */

//Close the display when the user selected exit
//in the File menu
void ViewDisplayDescription::OnExitClick( wxCommandEvent& event )
{
  this->Close();
}

//Clear out the values in all input location
void ViewDisplayDescription::ClearAll()
{
  m_rdlList->Clear();
  m_variableList->Clear();
  m_evaluatorList->Clear();
  m_displayAttributesList->Clear();
  m_widgetCommands->ClearGrid();
  m_row->Clear();
  m_col->Clear();
}

//Have a central location of what the defaults will be for
//this display
void ViewDisplayDescription::SetDefaults()
{
  m_widgetCommands->SetDefaultColSize(50);
  m_widgetCommands->SetDefaultRowSize(25);
  m_widgetCommands->SetColLabelSize(25);
  m_widgetCommands->SetRowLabelSize(50);

  m_col->SetValue(wxT("3"));
  m_row->SetValue(wxT("2"));

  wxString text = wxString(DisplayAttributeCmd.find("Rowsize")->second.c_str(), wxConvUTF8);
  text.Append(wxT("("));
  text.Append(m_row->GetValue());
  text.Append(wxT(")\n"));
  m_displayAttributesList->AppendText(text);

  wxString textTwo = wxString(DisplayAttributeCmd.find("Columnsize")->second.c_str(), wxConvUTF8);
  textTwo.Append(wxT("("));
  textTwo.Append(m_row->GetValue());
  textTwo.Append(wxT(")\n"));
  m_displayAttributesList->AppendText(textTwo);

}


/*
 * wxEVT_GRID_CMD_CELL_RIGHT_CLICK event handler for ID_WIDGET_COMMANDS
 */

//The user right clicked on the grid widgetCommand
//Need to display to the user a popup menu of the 
//widget choices
void ViewDisplayDescription::OnWidgetCommandsCellRightClick( wxGridEvent& event )
{
  wxMenu *temp = new wxMenu();
  for(WidgetCmdList::iterator i=WidgetCmd.begin(); i !=WidgetCmd.end(); i++) {
    temp->Append(wxID_ANY, wxString(i->second.c_str(), wxConvUTF8), wxEmptyString, wxITEM_NORMAL);
    this->Connect(temp->GetMenuItems().back()->GetId(),wxEVT_COMMAND_MENU_SELECTED,
      wxCommandEventHandler(ViewDisplayDescription::OnRightClickSelect),
                     NULL, this);
    LocationAndText lt;
    lt.text = wxString(i->second.c_str(), wxConvUTF8);
    lt.row = event.GetRow();
    lt.col = event.GetCol();
    m_clickToText.insert(std::pair<int,LocationAndText>(temp->GetMenuItems().back()->GetId(), lt));
  }

  this->PopupMenu(temp,ScreenToClient(wxGetMousePosition()));

  delete temp;
}


//The user selected an option from the popup menu
//Need to get the selection and append the results
//to the correct row and column of the widget commands
void ViewDisplayDescription::OnRightClickSelect(wxCommandEvent& event)
{
  int id = event.GetId();
  LocationAndText lt = m_clickToText.find(id)->second;
  wxString text = lt.text;
  text.Append(wxT("()"));
  wxGridCellCoordsArray temp =  m_widgetCommands->GetSelectedCells();
  wxString cv = m_widgetCommands->GetCellValue(lt.row,lt.col);
  cv.Append(text);
  m_widgetCommands->SetCellValue(cv, lt.row, lt.col);
  m_clickToText.clear();
}