QuickView2.cpp

Go to the documentation of this file.

// Name:        QuickView2.cpp
// Purpose:     
// Author:      Jeffrey Hawley
// Modified by: 
// Created:     12/08/2010 12:03:56
// 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 "QuickView2.h"

#include "EzGrid.h"
#include "GridCellChoiceRenderer.h"
#include "FastComboEditor.h"

#include "NIREPDefinitions.h"

#include <iostream>

#include "Interface.h"



/*
 * QuickView2 type definition
 */

IMPLEMENT_CLASS( QuickView2, wxFrame )


/*
 * QuickView2 event table definition
 */

BEGIN_EVENT_TABLE( QuickView2, wxFrame )

    EVT_TEXT( ID_ROW, QuickView2::OnRowTextUpdated )

    EVT_TEXT( ID_COL, QuickView2::OnColTextUpdated )

    EVT_GRID_CMD_CELL_CHANGE( ID_WIDGET_COMMAND, QuickView2::OnWidgetCommandCellChanged )

    EVT_COMBOBOX( ID_COMBOBOX5, QuickView2::OnCombobox5Selected )

    EVT_COMBOBOX( ID_COMBOBOX6, QuickView2::OnCombobox5Selected )

    EVT_GRID_CMD_CELL_CHANGE( ID_EVALUATOR_COMMAND, QuickView2::OnEvaluatorCommandCellChanged )

    EVT_BUTTON( ID_ADVANCED, QuickView2::OnAdvancedClick )

    EVT_BUTTON( ID_ADD_EVALUATOR_COMMAND, QuickView2::OnAddEvaluatorCommandClick )

    EVT_BUTTON( ID_ADD_WIDGET_COMMAND, QuickView2::OnAddWidgetCommandClick )

    EVT_BUTTON( ID_SHOW, QuickView2::OnShowClick )

    EVT_BUTTON( wxID_CANCEL, QuickView2::OnCancelClick )

    EVT_COMBOBOX( ID_DATATYPE, QuickView2::OnDatatypeSelected )

    EVT_COMBOBOX( ID_FORMAT, QuickView2::OnFormatSelected )

    EVT_BUTTON( ID_BROWSE, QuickView2::OnBrowseClick )

    EVT_BUTTON( ID_BROWSE2, QuickView2::OnBrowse2Click )

    EVT_BUTTON( ID_BROWSE3, QuickView2::OnBrowse3Click )

    EVT_NOTEBOOK_PAGE_CHANGED( ID_NOTEBOOK, QuickView2::OnNotebookPageChanged )

    EVT_BUTTON( ID_ADD_COORDINATE, QuickView2::OnAddCoordinateClick )

    EVT_BUTTON( ID_DELETE_COORDINATE, QuickView2::OnDeleteCoordinateClick )

    EVT_GRID_CMD_CELL_CHANGE(ID_COORDINATE_GRID,QuickView2::OnCoordinateGridChange)

    EVT_TEXT(ID_NAMESPACE, QuickView2::OnUpdateDMID)

    EVT_TEXT(ID_LABEL, QuickView2::OnUpdateDMID)

    EVT_TEXT(ID_FILENAME_PATTERN, QuickView2::OnUpdateVariables)

    EVT_TEXT(ID_FILENAME_PATTERN2, QuickView2::OnUpdateVariables)

    EVT_TEXT(ID_FILENAME_PATTERN3, QuickView2::OnUpdateVariables)

    EVT_LISTBOX( ID_LIST_RDL, QuickView2::OnListRdlSelected )

    EVT_BUTTON( ID_ADD_RDL, QuickView2::OnAddRDL )

    EVT_BUTTON( ID_DELETE_RDL, QuickView2::OnDeleteRDL )


END_EVENT_TABLE()


/*
 * QuickView2 constructors
 */

QuickView2::QuickView2()
{
    Init();
}

QuickView2::QuickView2( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
  
    Init();
    m_parent = dynamic_cast<Interface*>(parent);
    Create( parent, id, caption, pos, size, style );
}


/*
 * QuickView2 creator
 */

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


/*
 * QuickView2 destructor
 */

QuickView2::~QuickView2()
{
  if(deleteDD) {
    delete m_displayDescription;
  }
}


/*
 * Member initialisation
 */

void QuickView2::Init()
{
  deleteDD = true;
  show = true;
  addRDL = false;
  m_parent = NULL;
    m_row = NULL;
    m_col = NULL;
    m_widgetGrid = NULL;
    m_evaluatorCommandGrid = NULL;
    m_format = NULL;
    m_namespace = NULL;
    m_transformationUnits = NULL;
    m_itemFlexGridSizer3 = NULL;
    m_datatype = NULL;
    m_filenamePattern = NULL;
    m_filenamePattern2 = NULL;
    m_filenamePattern3 = NULL;
    m_variableGrid = NULL;
    m_coordinateGrid = NULL;

    m_displayDescription = new DisplayDescription();

    m_widgetList.push_back(wxT("Select Widget Command"));
    m_widgetList.push_back(wxT("---------NEW------------"));
    for(WidgetCmdList::iterator l = WidgetCmd.begin(); l != WidgetCmd.end(); l++) {
      m_widgetList.push_back(wxString(l->second.c_str(), wxConvUTF8));
    }
    m_widgetList.push_back(wxT("--------GENERATED-------"));
    m_appendEvaluatorID = 0;
    m_widgetCommandLocation.x = -1;
    m_widgetCommandLocation.y = -1;
    //for(EvaluatorCmdList::iterator l = EvalCmd.begin(); l != EvalCmd.end(); l++) {
    //  m_evaluatorList.push_back(l->second);
    //}
    //m_evaluatorList.push_back("<Open File>");
}


/*
 * Control creation for QuickView2
 */

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

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

    wxStaticText* itemStaticText4 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Widgets"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText4->SetFont(wxFont(16, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Tahoma")));
    m_itemFlexGridSizer3->Add(itemStaticText4, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxBoxSizer* itemBoxSizer5 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer5, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText6 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Row"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer5->Add(itemStaticText6, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

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

    wxBoxSizer* itemBoxSizer8 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer8, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText9 = new wxStaticText( itemScrolledWindow2, wxID_STATIC, _("Column"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer8->Add(itemStaticText9, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

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

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

    wxStaticText* itemStaticText12 = new wxStaticText( itemScrolledWindow2, ID_STATIC_WIDGET_INPUTS, _("Widget Inputs"), wxDefaultPosition, wxDefaultSize, 0 );
    m_itemFlexGridSizer3->Add(itemStaticText12, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemStaticText12->Show(false);

    wxBoxSizer* itemBoxSizer13 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer13, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxArrayString itemComboBox14Strings;
    wxComboBox* itemComboBox14 = new wxComboBox( itemScrolledWindow2, ID_COMBOBOX5, _("Select Evaluator Command"), wxDefaultPosition, wxDefaultSize, itemComboBox14Strings, wxCB_DROPDOWN );
    itemComboBox14->SetStringSelection(_("Select Evaluator Command"));
    itemBoxSizer13->Add(itemComboBox14, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemComboBox14->Show(false);

    wxBoxSizer* itemBoxSizer16 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer16, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxArrayString itemComboBox17Strings;
    wxComboBox* itemComboBox17 = new wxComboBox( itemScrolledWindow2, ID_COMBOBOX6, _("Select Evaluator Command"), wxDefaultPosition, wxDefaultSize, itemComboBox17Strings, wxCB_DROPDOWN );
    itemComboBox17->SetStringSelection(_("Select Evaluator Command"));
    itemBoxSizer16->Add(itemComboBox17, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemComboBox17->Show(false);

    wxBoxSizer* itemBoxSizer19 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer19, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText20 = new wxStaticText( itemScrolledWindow2, ID_TITLE, _("Title"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer19->Add(itemStaticText20, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemStaticText20->Show(false);

    wxTextCtrl* itemTextCtrl21 = new wxTextCtrl( itemScrolledWindow2, ID_TEXTCTRL23, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer19->Add(itemTextCtrl21, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemTextCtrl21->Show(false);

    wxStaticText* itemStaticText16 = new wxStaticText( itemScrolledWindow2, ID_STATIC_INPUTS_EC, _("Inputs for Evaluator Command"), wxDefaultPosition, wxDefaultSize, 0 );
    m_itemFlexGridSizer3->Add(itemStaticText16, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemStaticText16->Show(false);

    m_evaluatorCommandGrid = new EzGrid( itemScrolledWindow2, ID_EVALUATOR_COMMAND, wxDefaultPosition, wxSize(200, 150), wxSUNKEN_BORDER|wxHSCROLL|wxVSCROLL );
    m_evaluatorCommandGrid->SetDefaultColSize(150);
    m_evaluatorCommandGrid->SetDefaultRowSize(25);
    m_evaluatorCommandGrid->SetColLabelSize(25);
    m_evaluatorCommandGrid->SetRowLabelSize(50);
    m_evaluatorCommandGrid->CreateGrid(1, 3, wxGrid::wxGridSelectCells);

    m_evaluatorCommandGrid->SetColLabelValue(0,wxT("Evaluator ID"));
    m_evaluatorCommandGrid->SetColLabelValue(1,wxT(""));
    m_evaluatorCommandGrid->SetColLabelValue(2,wxT("Evaluator Command"));
    m_evaluatorCommandGrid->SetColSize(1,25);

    m_evaluatorCommandGrid->SetCellValue(wxT("="),0,1);
    m_evaluatorCommandGrid->SetReadOnly(0,1);
    m_evaluatorCommandGrid->SetReadOnly(0,2);
    m_itemFlexGridSizer3->Add(m_evaluatorCommandGrid, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);
    m_evaluatorCommandGrid->Show(false);

    wxButton* itemButton24 = new wxButton( itemScrolledWindow2, ID_ADD_EVALUATOR_COMMAND, _("Add Evaluator Command"), wxDefaultPosition, wxDefaultSize, 0 );
    m_itemFlexGridSizer3->Add(itemButton24, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemButton24->Show(false);

    wxButton* itemButton25 = new wxButton( itemScrolledWindow2, ID_ADD_WIDGET_COMMAND, _("Add Widget Command"), wxDefaultPosition, wxDefaultSize, 0 );
    m_itemFlexGridSizer3->Add(itemButton25, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemButton25->Show(false);

    wxButton* itemButton18 = new wxButton( itemScrolledWindow2, ID_ADVANCED, _("Advanced >>"), wxDefaultPosition, wxDefaultSize, 0 );
    m_itemFlexGridSizer3->Add(itemButton18, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxFlexGridSizer* itemBoxSizer64 = new wxFlexGridSizer(0, 2, 0, 0);
    itemBoxSizer64->AddGrowableCol(0);
    itemBoxSizer64->AddGrowableCol(1);
    itemBoxSizer64->AddGrowableRow(0);
    m_itemFlexGridSizer3->Add(itemBoxSizer64, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL|wxGROW, 5);

    wxArrayString itemListBox29Strings;
    wxListBox* itemListBox29 = new wxListBox( itemScrolledWindow2, ID_LIST_RDL, wxDefaultPosition, wxDefaultSize, itemListBox29Strings, wxLB_SINGLE|wxLB_NEEDED_SB );
    itemBoxSizer64->Add(itemListBox29, 0, wxGROW|wxALL, 5);
    itemListBox29->Show(false);

    wxRichTextCtrl* itemRichTextCtrl4 = new wxRichTextCtrl( itemScrolledWindow2, ID_TEXT, wxEmptyString, wxDefaultPosition, wxSize(100, 100), wxWANTS_CHARS );
    itemBoxSizer64->Add(itemRichTextCtrl4, 0, wxGROW|wxGROW|wxALL, 5);
    itemRichTextCtrl4->Show(false);
    itemRichTextCtrl4->SetEditable(false);

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

    wxStaticText* itemStaticText5 = new wxStaticText( itemScrolledWindow2, ID_STATIC_DATATYPE, _("Datatype"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer4->Add(itemStaticText5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemStaticText5->Show(false);

    wxArrayString m_datatypeStrings;
    m_datatypeStrings.Add("Select Datatype");
    for(DataTypeList::iterator temp = DataType.begin(); temp != DataType.end(); temp++) {
      m_datatypeStrings.Add(wxString(temp->second.c_str(), wxConvUTF8));
    }
    m_datatype = new wxComboBox( itemScrolledWindow2, ID_DATATYPE, wxEmptyString, wxDefaultPosition, wxDefaultSize, m_datatypeStrings, wxCB_DROPDOWN );
    itemBoxSizer4->Add(m_datatype, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    m_datatype->Show(false);
    m_datatype->SetSelection(0,0);

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

    wxStaticText* itemStaticText8 = new wxStaticText( itemScrolledWindow2, 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(wxString(temp->second.c_str(), wxConvUTF8));
    }
    wxComboBox *format = new wxComboBox( itemScrolledWindow2, 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);
    m_itemFlexGridSizer3->Add(itemFlexGridSizer10, 0, wxGROW|wxALL, 5);

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

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

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

    wxStaticText* itemStaticText14 = new wxStaticText( itemScrolledWindow2, 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( itemScrolledWindow2, 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( itemScrolledWindow2, 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( itemScrolledWindow2, 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( itemScrolledWindow2, 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( itemScrolledWindow2, 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);
    m_itemFlexGridSizer3->Add(itemFlexGridSizer20, 0, wxGROW|wxALL, 5);

    m_variableGrid = new wxGrid( itemScrolledWindow2, 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,wxT("Variable"));
    m_variableGrid->SetColLabelValue(1,wxT("Values"));
    m_variableGrid->Show(false);

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

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

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

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

    m_coordinateGrid = new wxGrid( itemScrolledWindow2, 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,wxT("Coordinate System 0"));
    m_coordinateGrid->SetColLabelValue(0,wxT( "Associated Variable" ));
    m_coordinateGrid->SetColLabelValue(1,wxT("Namespace (optional)"));
    m_coordinateGrid->Show(false);

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

    wxButton* itemButton252 = new wxButton( itemScrolledWindow2, ID_ADD_COORDINATE, _("Add Coordinate"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer24->Add(itemButton252, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemButton252->Show(false);

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

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





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

    wxStaticText* itemStaticText32 = new wxStaticText( itemScrolledWindow2, 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(wxString(temp->second.c_str(), wxConvUTF8));
    }
    m_transformationUnits = new wxComboBox( itemScrolledWindow2, 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);
    m_itemFlexGridSizer3->Add(itemFlexGridSizer34, 0, wxGROW|wxALL, 5);

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

    wxStaticText* itemStaticText38 = new wxStaticText( itemScrolledWindow2, 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( itemScrolledWindow2, ID_LABEL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemTextCtrl39->Show(false);
    itemFlexGridSizer37->Add(itemTextCtrl39, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxALL, 5);

    wxNotebook* itemNotebook40 = new wxNotebook( itemScrolledWindow2, ID_NOTEBOOK, wxDefaultPosition, wxDefaultSize, wxBK_DEFAULT );
    itemNotebook40->Show(false);

    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"));

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

    wxBoxSizer* itemBoxSizer63 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer63, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxButton* itemButton64 = new wxButton( itemScrolledWindow2, ID_ADD_RDL, _("Add RDL Information"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer63->Add(itemButton64, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemButton64->Show(false);

    wxButton* itemButton65 = new wxButton( itemScrolledWindow2, ID_DELETE_RDL, _("Delete RDL Information"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer63->Add(itemButton65, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    itemButton65->Show(false);

    wxScrolledWindow* itemScrolledWindow33 = new wxScrolledWindow( itemScrolledWindow2, ID_SCROLLEDWINDOW32, wxDefaultPosition, wxSize(100, 150), wxSUNKEN_BORDER|wxHSCROLL|wxVSCROLL );
    itemScrolledWindow33->Show(false);
    m_itemFlexGridSizer3->Add(itemScrolledWindow33, 0, wxGROW|wxGROW|wxALL|wxFIXED_MINSIZE, 5);
    itemScrolledWindow33->SetScrollbars(1, 1, 0, 0);
    wxBoxSizer* itemBoxSizer34 = new wxBoxSizer(wxHORIZONTAL);
    itemScrolledWindow33->SetSizer(itemBoxSizer34);

    wxBoxSizer* itemBoxSizer35 = new wxBoxSizer(wxVERTICAL);
    itemBoxSizer34->Add(itemBoxSizer35, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText36 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("coordinate 0 (source)"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer35->Add(itemStaticText36, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl37 = new wxTextCtrl( itemScrolledWindow33, ID_TEXTCTRL162, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer35->Add(itemTextCtrl37, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxStaticText* itemStaticText382 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("namespace"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer35->Add(itemStaticText382, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl392 = new wxTextCtrl( itemScrolledWindow33, ID_TEXTCTRL172, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer35->Add(itemTextCtrl392, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxStaticText* itemStaticText40 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("->"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText40->SetForegroundColour(wxColour(255, 0, 0));
    itemStaticText40->SetFont(wxFont(16, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Tahoma")));
    itemBoxSizer34->Add(itemStaticText40, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer41 = new wxBoxSizer(wxVERTICAL);
    itemBoxSizer34->Add(itemBoxSizer41, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText42 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("Algorithm Name"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer41->Add(itemStaticText42, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl43 = new wxTextCtrl( itemScrolledWindow33, ID_TEXTCTRL182, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer41->Add(itemTextCtrl43, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxStaticText* itemStaticText44 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("->"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText44->SetForegroundColour(wxColour(255, 0, 0));
    itemStaticText44->SetFont(wxFont(16, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Tahoma")));
    itemBoxSizer34->Add(itemStaticText44, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer45 = new wxBoxSizer(wxVERTICAL);
    itemBoxSizer34->Add(itemBoxSizer45, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxStaticText* itemStaticText46 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("coordinate 1 (target)"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer45->Add(itemStaticText46, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl47 = new wxTextCtrl( itemScrolledWindow33, ID_TEXTCTRL2, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer45->Add(itemTextCtrl47, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxStaticText* itemStaticText48 = new wxStaticText( itemScrolledWindow33, wxID_STATIC, _("namespace"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer45->Add(itemStaticText48, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxTextCtrl* itemTextCtrl49 = new wxTextCtrl( itemScrolledWindow33, ID_TEXTCTRL12, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer45->Add(itemTextCtrl49, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    itemScrolledWindow33->FitInside();
    wxBoxSizer* itemBoxSizer50 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer50, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxButton* itemButton51 = new wxButton( itemScrolledWindow2, ID_ADD_COORDINATE, _("Add Coordinate System"), wxDefaultPosition, wxDefaultSize, 0 );
    itemButton51->Show(false);
    itemBoxSizer50->Add(itemButton51, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton52 = new wxButton( itemScrolledWindow2, ID_DELETE_COORDINATE, _("Delete Coordinate System"), wxDefaultPosition, wxDefaultSize, 0 );
    itemButton52->Show(false);
    itemBoxSizer50->Add(itemButton52, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer61 = new wxBoxSizer(wxHORIZONTAL);
    m_itemFlexGridSizer3->Add(itemBoxSizer61, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    wxButton* itemButton62 = new wxButton( itemScrolledWindow2, ID_SHOW, _("Show"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer61->Add(itemButton62, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

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

    itemScrolledWindow2->FitInside();

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

}


/*
 * Should we show tooltips?
 */

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

/*
 * Get bitmap resources
 */

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

/*
 * Get icon resources
 */

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


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BUTTON13
 */

void QuickView2::OnAdvancedClick( wxCommandEvent& event )
{
  this->FindWindow(ID_TEXT)->Show(show);
  this->FindWindow(ID_STATIC_DATATYPE)->Show(show);
  this->FindWindow(ID_DATATYPE)->Show(show);
  this->FindWindow(ID_STATIC_FILEFORMAT1_TEXT)->Show(show);
  this->FindWindow(ID_FILENAME_PATTERN)->Show(show);
  this->FindWindow(ID_BROWSE)->Show(show);

  m_variableGrid->Show(show);
  m_coordinateGrid->Show(show);
  this->FindWindow(ID_ADD_COORDINATE)->Show(show);
  this->FindWindow(ID_DELETE_COORDINATE)->Show(show);
  this->FindWindow(ID_REMOVE_DUPLICATES)->Show(show);
  this->FindWindow(ID_STATIC_DEFAULT_NAMESPACE_TEXT)->Show(show);
  this->FindWindow(ID_NAMESPACE)->Show(show);
  this->FindWindow(ID_NOTEBOOK)->Show(show);
  this->FindWindow(ID_LIST_RDL)->Show(show);
  this->FindWindow(ID_ADD_RDL)->Show(show);
  this->FindWindow(ID_DELETE_RDL)->Show(show);


  show = !show;

  if(show) {
    dynamic_cast<wxButton*>(this->FindWindow(ID_ADVANCED) )->SetLabel(wxT("Advanced >>"));

    //just to make sure that everything is hidden
    this->FindWindow(ID_FORMAT)->Show(false);
    this->FindWindow(ID_STATIC_FORMAT_TEXT)->Show(false);
    this->FindWindow(ID_TRANSFORMATION_UNITS)->Show(false);
    this->FindWindow(ID_STATIC_TRANSFORMATION_UNITS_TEXT)->Show(false);

    this->FindWindow(ID_STATIC_FILEFORMAT2_TEXT)->Show(false);
    this->FindWindow(ID_FILENAME_PATTERN2)->Show(false);
    this->FindWindow(ID_BROWSE2)->Show(false);

    this->FindWindow(ID_STATIC_FILEFORMAT3_TEXT)->Show(false);
    this->FindWindow(ID_FILENAME_PATTERN3)->Show(false);
    this->FindWindow(ID_BROWSE3)->Show(false);

    this->FindWindow(ID_STATIC_LABEL_TEXT)->Show(false);
    this->FindWindow(ID_LABEL)->Show(false);
  } else {
    dynamic_cast<wxButton*>(this->FindWindow(ID_ADVANCED) )->SetLabel("<< Advanced");

    dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->Clear();
    FILE * tempfile = fopen("tempfile.txt", "w+");
    m_displayDescription->GetRDL()->Save(tempfile);
    rewind(tempfile);
    int character;
    while( (character = fgetc(tempfile) ) != EOF ) {
      wxString temp;
      temp.Append(static_cast<char>(character) );
      dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->AppendText(temp);
    }
    fclose(tempfile);
  }
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}






/*
 * wxEVT_GRID_CMD_CELL_CHANGED event handler for ID_GRID6
 */

void QuickView2::OnWidgetCommandCellChanged( wxGridEvent& event )
{
  this->FindWindow(ID_STATIC_WIDGET_INPUTS)->Show();
  this->FindWindow(ID_TITLE)->Show();
  this->FindWindow(ID_TEXTCTRL23)->Show();
  this->FindWindow(ID_ADD_WIDGET_COMMAND)->Show();

  this->FindWindow(ID_STATIC_INPUTS_EC)->Show(false);
  m_evaluatorCommandGrid->Show(false);
  this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show(false);

  //this->FindWindow(ID_ADVANCED)->Show();

  wxString widgetCommand = event.GetString();
  m_widgetCommandLocation.x = event.GetRow();
  m_widgetCommandLocation.y = event.GetCol();
  std::pair<WidgetInputList::iterator, WidgetInputList::iterator> inputs = WidgetInput.equal_range(std::string(widgetCommand.mb_str()));
  int k=0;
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Clear();
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Clear();
  
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(wxT("Select Evaluator Command"));
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(wxT("Select Evaluator Command"));
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->SetStringSelection(_("Select Evaluator Command"));
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->SetStringSelection(_("Select Evaluator Command"));

  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(wxT("---------NEW------------"));
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(wxT("---------NEW------------"));
  WidgetInputList::iterator i;
  for(i = inputs.first; i!= inputs.second; ++i, k++) {
    EvalOutputList::iterator output;
    for(output = EvalOutput.begin(); output != EvalOutput.end(); ++output) {
      if(i->second.compare(output->second) ==0 && output->first.compare(EvalCmd.find("SpatialData")->second) == 0 ) {
        if(k == 0) {
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(wxT("<Open Spatial Data File>"));
        }
        else {
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(wxT("<Open Spatial Data File>"));
        }
      }
      else if(i->second.compare(output->second) ==0 && output->first.compare(EvalCmd.find("Transformation")->second) == 0) {
        if(k == 0) {
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(wxT("<Open Transformation File>"));
        }
        else {
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(wxT("<Open Transformation File>"));
        }
      }
      else if(i->second.compare(output->second) ==0) {
        if(k == 0) {
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(wxString(output->first.c_str(), wxConvUTF8));
        }
        else {
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(wxString(output->first.c_str(), wxConvUTF8));
        }
      }
    }

  }

  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append("--------RDL DMID-------");
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append("--------RDL DMID-------");

    k = 0;
    for(i = inputs.first; i!= inputs.second; ++i, k++) {
      for(int j = 0; j < m_rdl.size(); j++) {
        EvalOutputList::iterator output;
        for(output = EvalOutput.begin(); output != EvalOutput.end(); ++output) {
          if(i->second.compare(output->second) ==0 ) {
            //need to first get the evaluator command
            wxString eC = m_rdl.at(j);
            eC = eC.BeforeFirst('(');

            //then need to see if the command produces the right output
            if(eC.compare(output->first.c_str()) ==0 ) {
              if(k == 0) {
                dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(m_rdl.at(j));
              } else {
                dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(m_rdl.at(j));
              }
            }
          }
        }

      }
    }

  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append("--------GENERATED-------");
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append("--------GENERATED-------");


  k = 0;
  for(i = inputs.first; i!= inputs.second; ++i, k++) {
    for(int j = 0; j < m_evaluatorList.size(); j++) {
      EvalOutputList::iterator output;
      for(output = EvalOutput.begin(); output != EvalOutput.end(); ++output) {
        if(i->second.compare(output->second) ==0 ) {
          //need to first get the evaluator command
          wxString eC = m_evaluatorList.at(j);
          eC = eC.Remove(0,eC.find_first_of(wxT("="))+1);
          eC = eC.Remove(eC.find_first_of(wxT("(")),eC.size() - eC.find_first_of(wxT("(")));

          //then need to see if the command produces the right output
          if(eC.compare(wxString(output->first.c_str(), wxConvUTF8)) ==0 ) {
            if(k == 0) {
              dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(m_evaluatorList.at(j));
            } else {
              dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(m_evaluatorList.at(j));
            }
          }
        }
      }

    }
  }
  
  if( k == 0) {
    this->FindWindow(ID_COMBOBOX6)->Show(false);
    this->FindWindow(ID_COMBOBOX5)->Show(false);

    this->FindWindow(ID_STATIC_WIDGET_INPUTS)->Show(false);
    this->FindWindow(ID_TITLE)->Show(false);
    this->FindWindow(ID_TEXTCTRL23)->Show(false);
    this->FindWindow(ID_ADD_WIDGET_COMMAND)->Show(false);
    //this->FindWindow(ID_ADVANCED)->Show(false);
  }
  else if(k >2) {
    this->FindWindow(ID_COMBOBOX6)->Show(true);

    this->FindWindow(ID_COMBOBOX5)->Show(true);
  }
  else {
    this->FindWindow(ID_COMBOBOX6)->Show(false);

    this->FindWindow(ID_COMBOBOX5)->Show(true);
  }
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_GRID_CMD_CELL_CHANGED event handler for ID_GRID7
 */

void QuickView2::OnEvaluatorCommandCellChanged( wxGridEvent& event )
{
  if(event.GetString().compare("<Open File>") == 0) {
      wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file to use for data."), wxT(""), wxT("*"), "*",  wxFD_OPEN|wxFD_FILE_MUST_EXIST, wxDefaultPosition, wxDefaultSize, wxT("Open"));
      if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

      
      wxArrayString tempTwo;
      filedialog->GetPaths(tempTwo);
      wxString tempThree;
      int count = 0;
      for(wxArrayString::iterator i = tempTwo.begin(); i != tempTwo.end(); i++) {
        tempThree.Append(i->c_str());
        tempThree.Append(wxT(";"));
        count++;
      }
      wxString::iterator semiColonErase = tempThree.end();
      semiColonErase--;
      tempThree.erase(semiColonErase,tempThree.end());
      //m_browseText->SetValue(tempThree );

  
      size_t dot = filedialog->GetFilename().find_last_of(wxT("."));
      std::string extension(std::string(filedialog->GetFilename().mb_str()),dot);

      if(count == 3) {
        //we have a disp transformation
      }
      else if(FileExtension.find(extension) != FileExtension.end() ) {
        std::pair<FileExtensionList::iterator, FileExtensionList::iterator> typesAndTransforms = FileExtension.equal_range(extension);
        if(FileExtension.find(extension)->second.compare(DataType["Transformation"])) {
        }
        else {
        }
      }
      else{
        //not the right data type
      }

      delete filedialog;
  }
  else if(event.GetString().compare("<Open Transformation File>") == 0) {
    wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file(s) to use for data.  If multiple files then please choose 3 that correspond to one data."), wxT(""), wxT("*"), wxT("*"),  wxFD_OPEN|wxFD_FILE_MUST_EXIST|wxFD_MULTIPLE, wxDefaultPosition, wxDefaultSize, wxT("Open"));
    if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

    addRDL = true;
    wxArrayString tempTwo;
    filedialog->GetPaths(tempTwo);
    wxString tempThree;
    int count = 0;
    for(wxArrayString::iterator i = tempTwo.begin(); i != tempTwo.end(); i++) {
      tempThree.Append(i->c_str());
      tempThree.Append(";");
      count++;
    }
    tempThree = tempThree.RemoveLast();

  
    size_t dot = filedialog->GetFilename().find_last_of(".");
    std::string extension = filedialog->GetFilename().After(wxT('.')).ToStdString();
    if(count == 3) {
      //we have a disp transformation
    }
    else if(FileExtension.find(extension) != FileExtension.end() ) {
      std::pair<FileExtensionList::iterator, FileExtensionList::iterator> typesAndTransforms = FileExtension.equal_range(extension);
      wxString evalCommand;
      wxString nameSpace = filedialog->GetDirectory();
      nameSpace.Remove(0,nameSpace.find_last_of('\\')+1);
      wxString csID;
      if(FileExtension.find(extension)->second.compare(DataType["Transformation"]) == 0) {
        evalCommand = EvalCmd["Transformation"];
      }
      this->ChangeEvaluatorGrid(evalCommand,wxString(),filedialog->GetFilename().BeforeFirst('.'), csID, extension);
    }
    else{
      //not the right data type
    }

    delete filedialog;
  }
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_COMBOBOX5
 */

void QuickView2::OnCombobox5Selected( wxCommandEvent& event )
{
  m_appendEvaluatorID = event.GetId();
  if(event.GetString().compare("<Open Spatial Data File>")==0) {
    wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file to use for data."), wxT(""), wxT("*"), wxT("*"),  wxFD_OPEN|wxFD_FILE_MUST_EXIST, wxDefaultPosition, wxDefaultSize, wxT("Open"));
    if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

    addRDL = true;
    wxArrayString tempTwo;
    filedialog->GetPaths(tempTwo);
    wxString tempThree;
    int count = 0;
    for(wxArrayString::iterator i = tempTwo.begin(); i != tempTwo.end(); i++) {
      tempThree.Append(i->c_str());
      tempThree.Append(";");
      count++;
    }
    tempThree = tempThree.RemoveLast();

  
    size_t dot = filedialog->GetFilename().find_last_of(".");
    std::string extension = filedialog->GetFilename().After(wxT('.')).ToStdString();

    if(extension.compare("obj") == 0) {
      int sel = m_datatype->FindString(DataType["Objectmap"]);
      m_datatype->SetSelection(sel);
      dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_LABEL))->SetValue("Objectmap");
    } else {
      int sel = m_datatype->FindString(DataType["Image"]);
      m_datatype->SetSelection(sel);
      dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_LABEL))->SetValue("Image");
    }
    m_filenamePattern->SetValue(filedialog->GetPath());
    m_coordinateGrid->SetCellValue(filedialog->GetFilename().BeforeFirst('.'),0,0);
    m_namespace->SetValue(filedialog->GetDirectory().AfterLast('\\'));
      

    if(FileExtension.find(extension) != FileExtension.end() ) {
      wxString evalCommand;
      wxString nameSpace = filedialog->GetDirectory();
      nameSpace.Remove(0,nameSpace.find_last_of('\\')+1);
      wxString csID;
      evalCommand = EvalCmd["SpatialData"];
      csID = nameSpace;
      csID.Append("|");
      csID.Append(filedialog->GetFilename().BeforeFirst('.'));
      this->ChangeEvaluatorGrid(evalCommand,wxString(),filedialog->GetFilename().BeforeFirst('.'), csID, extension);

    }
    else{
      //not the right data type
    }


    delete filedialog;

    this->FindWindow(ID_STATIC_INPUTS_EC)->Show();
    m_evaluatorCommandGrid->Show();
    this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show();
  } else if(event.GetString().compare("<Open Transformation File>")==0) {
    wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file(s) to use for data.  If multiple files then please choose 3 that correspond to one data."), wxT(""), wxT("*"), wxT("*"),  wxFD_OPEN|wxFD_FILE_MUST_EXIST|wxFD_MULTIPLE, wxDefaultPosition, wxDefaultSize, wxT("Open"));
    if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

    addRDL = true;
    wxArrayString tempTwo;
    filedialog->GetPaths(tempTwo);
    wxString tempThree;
    int count = 0;
    for(wxArrayString::iterator i = tempTwo.begin(); i != tempTwo.end(); i++) {
      tempThree.Append(i->c_str());
      tempThree.Append(";");
      count++;
    }
    tempThree = tempThree.RemoveLast();

  
    size_t dot = filedialog->GetFilename().find_last_of(".");
    std::string extension = filedialog->GetFilename().After(wxT('.')).ToStdString();
    if(count == 3) {
      //we have a disp transformation
    }
    else if(FileExtension.find(extension) != FileExtension.end() ) {
      std::pair<FileExtensionList::iterator, FileExtensionList::iterator> typesAndTransforms = FileExtension.equal_range(extension);
      wxString evalCommand;
      wxString nameSpace = filedialog->GetDirectory();
      nameSpace.Remove(0,nameSpace.find_last_of('\\')+1);
      wxString csID;
      if(FileExtension.find(extension)->second.compare(DataType["Transformation"]) == 0) {
        evalCommand = EvalCmd["Transformation"];
      }
      else {
        evalCommand = EvalCmd["SpatialData"];
        csID = nameSpace;
        csID.Append("|");
        csID.Append(filedialog->GetFilename().BeforeFirst('.'));
      }
      this->ChangeEvaluatorGrid(evalCommand,wxString(),filedialog->GetFilename().BeforeFirst('.'), csID, extension);
    }
    else{
      //not the right data type
    }

    delete filedialog;
    this->FindWindow(ID_STATIC_INPUTS_EC)->Show();
    m_evaluatorCommandGrid->Show();
    this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show();
  } else if(event.GetString().compare("Select Evaluator Command")!=0 && event.GetString().compare("--------GENERATED-------")!=0 && event.GetString().compare("---------NEW------------")!=0 && event.GetString().compare("--------RDL DMID-------") !=0 ){
    addRDL = false;
    //not the cleanist just yet.  Now that i'm appending generated evaluator commands
    //I need to see if its a generated evaluator command or one they want to create.
    wxString evaluatorCommand = event.GetString();
    wxString ecID = evaluatorCommand.BeforeFirst('=');
    wxString commaSeperatedInput;
    if(ecID.compare(evaluatorCommand) != 0 ) {
      m_evaluatorCommandGrid->SetCellValue(ecID,0,0);
      evaluatorCommand = evaluatorCommand.AfterFirst('=');
      commaSeperatedInput = evaluatorCommand.AfterFirst('(');
      commaSeperatedInput = commaSeperatedInput.BeforeLast(')');
      evaluatorCommand = evaluatorCommand.BeforeFirst('(');
    }
    else if(evaluatorCommand.BeforeFirst('(').compare(evaluatorCommand) != 0) {
      m_evaluatorCommandGrid->SetCellValue("",0,0);
      commaSeperatedInput = evaluatorCommand.AfterFirst('(');
      commaSeperatedInput = commaSeperatedInput.BeforeLast(')');
      evaluatorCommand = evaluatorCommand.BeforeFirst('(');
    }
    else {
      m_evaluatorCommandGrid->SetCellValue(wxT(""),0,0);
    }
    m_evaluatorCommandGrid->SetCellValue(evaluatorCommand,0,2);

    this->ChangeEvaluatorGrid(evaluatorCommand, commaSeperatedInput);

    this->FindWindow(ID_STATIC_INPUTS_EC)->Show();
    m_evaluatorCommandGrid->Show();
    this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show();
  }
  else {
    this->FindWindow(ID_STATIC_INPUTS_EC)->Show(false);
    m_evaluatorCommandGrid->Show(false);
    this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show(false);
  }


  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}

void QuickView2::ChangeEvaluatorGrid(const wxString& evalCommand, const wxString& commaSeperatedInput, const wxString& evalID, const wxString& csID, const wxString& extension)
{
    std::pair<EvaluatorInputList::iterator,EvaluatorInputList::iterator> ret = EvalInput.equal_range( std::string(evalCommand.mb_str()) );
    int col = 3;
    wxStringTokenizer tk;
    if(!commaSeperatedInput.empty()) {
      tk.SetString(commaSeperatedInput,wxT(","));
    }

    for(EvaluatorInputList::iterator i = ret.first; i != ret.second; i++,col++) {
    if(col > m_evaluatorCommandGrid->GetNumberCols()-1 ) {
      m_evaluatorCommandGrid->AppendCols();
      m_evaluatorCommandGrid->SetCellRenderer(0, col, new wxGridCellChoiceRenderer);
      m_evaluatorCommandGrid->SetCellEditor(0, col, new wxFastComboEditor());
    }

    m_evaluatorCommandGrid->SetCellValue(wxT(""),0,col);
    m_evaluatorCommandGrid->SetColLabelValue(col,wxString(i->second.c_str(), wxConvUTF8));
    wxArrayString strChoices;

    m_evaluatorCommandGrid->SetCellValue(wxT("Select Evaluator Input"),0,col);
    strChoices.Add(wxT("Select Evaluator Input"));
    wxString selection = wxT("Select Evaluator Input");

    if(!commaSeperatedInput.empty()) {
      wxString token = tk.GetNextToken();
      strChoices.Add(token);
      m_evaluatorCommandGrid->SetCellValue(token,0,col);
      selection = token;
    }

    for(int j = 0; j < m_evaluatorList.size(); j++) {
      EvalOutputList::iterator output;
      for(output = EvalOutput.begin(); output != EvalOutput.end(); ++output) {
        if(i->second.compare(output->second) ==0 && i->second.compare(EvalCmd.find("SpatialData")->second) != 0 && i->second.compare(EvalCmd.find("Transformation")->second) != 0) {
          //need to first get the evaluator command
          wxString eC = m_evaluatorList.at(j);
          eC = eC.Remove(0,eC.find_first_of(wxT("="))+1);
          eC = eC.Remove(eC.find_first_of(wxT("(")),eC.size() - eC.find_first_of(wxT("(")));

          //then need to see if the command produces the right output
          if(eC.compare(wxString(output->first.c_str(), wxConvUTF8)) ==0 ) {
            strChoices.Add(m_evaluatorList.at(j));
          }
        }
      }

    }
    if(!evalID.IsEmpty()) {
      m_evaluatorCommandGrid->SetCellValue(0,0,evalID);
    }
    m_evaluatorCommandGrid->SetCellValue(0,2,evalCommand);

    //Yeah, i'm hard coding but i'm trying to make the users life a little easier
    //by pre-populating some information so that user does not have to figure out
    //what to do.
    if(!csID.IsEmpty()){
      if(col == 3) {
        strChoices.Add(csID);
        m_evaluatorCommandGrid->SetCellValue(csID,0,col);
        selection = csID;
      }
    }
    
    if(!extension.IsEmpty()) {
      if(col == 4 && FileExtension.find(std::string(extension.mb_str()))->second.compare(DataType["Transformation"]) == 0) {
      }
      else if(col ==4 && FileExtension.find(std::string(extension.mb_str()))->second.compare(DataType["Objectmap"]) == 0) {
        strChoices.Add(wxT("Objectmap"));
        m_evaluatorCommandGrid->SetCellValue(wxT("Objectmap"),0,col);
        selection = wxT("Objectmap");
      }
      else if(col == 4){
        strChoices.Add(wxT("Image"));
        m_evaluatorCommandGrid->SetCellValue(wxT("Image"),0,col);
        selection = wxT("Image");
      }
    }


    if(i->second.compare(InputType["Image"]) == 0 ) {
      strChoices.Add(wxT("<Open Spatial Data File>"));
    } else if(i->second.compare(InputType["Transformation"]) == 0) {
      strChoices.Add(wxT("<Open Transformation File>"));
    }
    //wxString *strChoicesPointer = new wxString[strChoices.size()];
    wxFastComboEditor * fce = dynamic_cast<wxFastComboEditor *>(m_evaluatorCommandGrid->GetCellEditor(0, col));
    fce->SetParameters(strChoices);
    fce->SetChoice(selection);
    //Need this decrement reference otherwise you will have memory leaks
    fce->DecRef();
    }

    if(m_evaluatorCommandGrid->GetNumberCols() > (col) ) {
      for(int i = m_evaluatorCommandGrid->GetNumberCols(); i > (col); i--) {
        m_evaluatorCommandGrid->DeleteCols(i-1);
      }
    }
}


/*
 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_ROW
 */

void QuickView2::OnRowTextUpdated( wxCommandEvent& event )
{
  if(m_widgetGrid != NULL) {
    double row;
    m_row->GetValue().ToDouble(&row);

    m_displayDescription->GetDisplayAttributes()->SetRowDimension(row);
    m_displayDescription->GetWidgetList()->Resize();
    if(row > m_widgetGrid->GetNumberRows() ) {
      for(int i= m_widgetGrid->GetNumberRows(); i< row; i++) {
        m_widgetGrid->AppendRows();
        for(int j=0; j< m_widgetGrid->GetNumberCols(); j++) {
          //m_widgetCommands->SetCellRenderer(i , j, new wxGridCellAutoWrapStringRenderer);
          //m_widgetCommands->SetCellEditor( i,  j , new wxGridCellAutoWrapStringEditor);
          m_widgetGrid->SetCellRenderer(i, j, new wxGridCellChoiceRenderer);
          wxString *strChoices = new wxString[m_widgetList.size()];
          for(unsigned int l = 0; l < m_widgetList.size(); l++) {
            strChoices[l] = m_widgetList.at(l);
          }
          m_widgetGrid->SetCellEditor(i, j, new wxFastComboEditor(m_widgetList.size(), strChoices, true));
          m_widgetGrid->SetCellValue(m_widgetList.at(0),i, j);
          delete [] strChoices;
        }
      }
    }
    else {
      for(int i= m_widgetGrid->GetNumberRows(); i> row; i--) {
        m_widgetGrid->DeleteRows(m_widgetGrid->GetNumberRows() - 1);
      }
    }
  }
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_COL
 */

void QuickView2::OnColTextUpdated( wxCommandEvent& event )
{
  if(m_widgetGrid != NULL) {
    double col = 0;
    m_col->GetValue().ToDouble(&col);
    m_displayDescription->GetDisplayAttributes()->SetColDimension(col);
    m_displayDescription->GetWidgetList()->Resize();

    //figure out if we need to add columns or delete columns
    if(col > m_widgetGrid->GetNumberCols() ) {
      for(int i= m_widgetGrid->GetNumberCols(); i< col; i++) {
        m_widgetGrid->AppendCols();
        for(int j=0; j< m_widgetGrid->GetNumberRows(); j++) {
          //A nice feature that will wrap the text
          //m_widgetCommands->SetCellRenderer(j , i, new wxGridCellAutoWrapStringRenderer);
          //m_widgetCommands->SetCellEditor( j,  i , new wxGridCellAutoWrapStringEditor);
          m_widgetGrid->SetCellRenderer(j, i, new wxGridCellChoiceRenderer);
          wxString *strChoices = new wxString[m_widgetList.size()];
          for(unsigned int l = 0; l < m_widgetList.size(); l++) {
            strChoices[l] = m_widgetList.at(l);
          }
          m_widgetGrid->SetCellEditor(j, i, new wxFastComboEditor(m_widgetList.size(), strChoices, true));
          m_widgetGrid->SetCellValue(m_widgetList.at(0),j, i);
          delete [] strChoices;
        }
      }
    }
    else {
      for(int i= m_widgetGrid->GetNumberCols(); i> col; i--) {
        m_widgetGrid->DeleteCols(m_widgetGrid->GetNumberCols() - 1);
      }
    }
  }
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}

/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BUTTON13
 */

void QuickView2::OnAddEvaluatorCommandClick( wxCommandEvent& event )
{

  if(addRDL) {
    wxString filenamePattern = m_filenamePattern->GetValue();
    std::queue<ResourceDescription *> queueOfResourceDescription;
    queueOfResourceDescription = ExpandRD(filenamePattern);

    //ResourceDescriptionList *rdl = new ResourceDescriptionList();
    m_displayDescription->GetRDL()->SetNameSpace(std::string(m_namespace->GetValue().mb_str()));

    //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 = std::string(m_datatype->GetValue().mb_str());
      if(datatype.compare(DataType.find("Image")->second) == 0 || datatype.compare(DataType.find("Objectmap")->second) == 0) { 
        m_displayDescription->GetRDL()->AddDataDescrip(queueOfResourceDescription.front()->GetDMID(), queueOfResourceDescription.front());
        dynamic_cast<wxListBox*>(this->FindWindow(ID_LIST_RDL) )->Append(queueOfResourceDescription.front()->GetDMID());
      }
      else if(datatype.compare(DataType.find("Transformation")->second) == 0) {
        m_displayDescription->GetRDL()->AddTransformDescrip(queueOfResourceDescription.front()->GetDMID(), queueOfResourceDescription.front());
        dynamic_cast<wxListBox*>(this->FindWindow(ID_LIST_RDL) )->Append(queueOfResourceDescription.front()->GetDMID());
      }
      else {
        delete queueOfResourceDescription.front();
      }
      queueOfResourceDescription.pop();
    }
  }

  this->FindWindow(ID_STATIC_INPUTS_EC)->Show(false);
  m_evaluatorCommandGrid->Show(false);
  this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show(false);
  //this->FindWindow(ID_ADVANCED)->Show(false);

  wxString command;
  command.Append(m_evaluatorCommandGrid->GetCellValue(0,0));
  command.Append(m_evaluatorCommandGrid->GetCellValue(0,1));
  command.Append(m_evaluatorCommandGrid->GetCellValue(0,2));
  command.Append(wxT("("));
  for(int i=3; i < m_evaluatorCommandGrid->GetNumberCols(); i++) {
    command.Append(m_evaluatorCommandGrid->GetCellValue(0,i));
    command.Append(wxT(","));
  }
  command.RemoveLast();
  command.Append(wxT(")"));
  m_evaluatorList.push_back(command);
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Append(command);
  dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Append(command);

  
  wxComboBox *comboBox= dynamic_cast<wxComboBox*>(this->FindWindow(m_appendEvaluatorID));
  if(comboBox != NULL) {
    int location = comboBox->FindString(command);
    comboBox->SetSelection(location);
  }

  //need to create an rdl entry
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_ADD_WIDGET_COMMAND
 */

void QuickView2::OnAddWidgetCommandClick( wxCommandEvent& event )
{
  this->FindWindow(ID_STATIC_INPUTS_EC)->Show(false);
  m_evaluatorCommandGrid->Show(false);
  this->FindWindow(ID_ADD_EVALUATOR_COMMAND)->Show(false);
  this->FindWindow(ID_COMBOBOX5)->Show(false);
  this->FindWindow(ID_COMBOBOX6)->Show(false);
  this->FindWindow(ID_TITLE)->Show(false);
  this->FindWindow(ID_STATIC_WIDGET_INPUTS)->Show(false);
  this->FindWindow(ID_ADD_WIDGET_COMMAND)->Show(false);
  this->FindWindow(ID_TEXTCTRL23)->Show(false);
  //this->FindWindow(ID_ADVANCED)->Show(false);

  if(m_widgetCommandLocation.x != -1) {
    wxString command;
    wxString commandWithEvaluatorID;
    command = m_widgetGrid->GetCellValue(m_widgetCommandLocation.x,m_widgetCommandLocation.y);
    commandWithEvaluatorID = m_widgetGrid->GetCellValue(m_widgetCommandLocation.x,m_widgetCommandLocation.y);
    command.Append(wxT("("));
    commandWithEvaluatorID.Append(wxT("("));

    command.Append(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->GetValue().AfterFirst('='));
    commandWithEvaluatorID.Append(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->GetValue().BeforeFirst('='));
    m_displayDescription->GetEvaluatorList()->SetEvaluatorTask(std::string(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->GetValue().BeforeFirst('=').mb_str()), std::string(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->GetValue().AfterFirst('=').mb_str()));
    if(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->GetValue().compare(wxT("Select Evaluator Command")) != 0) {
      command.Append(wxT(","));
      commandWithEvaluatorID.Append(wxT(","));
      command.Append(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->GetValue().AfterFirst('='));
      commandWithEvaluatorID.Append(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->GetValue().BeforeFirst('='));
      m_displayDescription->GetEvaluatorList()->SetEvaluatorTask(std::string(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->GetValue().BeforeFirst('=').mb_str()), std::string(dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->GetValue().AfterFirst('=').mb_str()));
    }
    command.Append(wxT(","));
    command.Append(dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_TEXTCTRL23))->GetValue());
    command.Append(wxT(")"));

    commandWithEvaluatorID.Append(wxT(","));
    commandWithEvaluatorID.Append(dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_TEXTCTRL23))->GetValue());
    commandWithEvaluatorID.Append(wxT(")"));

    this->m_widgetList.push_back(command);
    m_widgetCommand.insert(std::pair<wxString,wxString>(command,commandWithEvaluatorID));

    //m_displayDescription->GetWidgetList()->SetWidget(m_widgetCommandLocation.x,m_widgetCommandLocation.y,command.c_str());
    wxFastComboEditor * fce = dynamic_cast<wxFastComboEditor *>(m_widgetGrid->GetCellEditor(m_widgetCommandLocation.x, m_widgetCommandLocation.y));
    fce->AppendToCombo(command);
    fce->SetChoice(command);
    m_widgetGrid->SetCellValue(command,m_widgetCommandLocation.x, m_widgetCommandLocation.y);
    //Need this decrement reference otherwise you will have memory leaks
    fce->DecRef();

    for(int i=0; i< m_widgetGrid->GetNumberCols(); i++) {
      for(int j=0; j< m_widgetGrid->GetNumberRows();j++) {
        if(i!=  m_widgetCommandLocation.y || j != m_widgetCommandLocation.x) {
          wxFastComboEditor * fceTwo = dynamic_cast<wxFastComboEditor *>(m_widgetGrid->GetCellEditor(j, i));
          fceTwo->AppendToCombo(command);
          //Need this decrement reference otherwise you will have memory leaks
          fceTwo->DecRef();
        }
      }
    }
    
  }
  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_SHOW
 */

void QuickView2::OnShowClick( wxCommandEvent& event )
{
  deleteDD = false;
  for(int i=0; i< m_widgetGrid->GetNumberCols(); i++) {
    for(int j=0; j< m_widgetGrid->GetNumberRows(); j++) {
      wxString tempTeo = m_widgetGrid->GetCellValue(j,i);
      if(m_widgetGrid->GetCellValue(j,i).compare("Select Widget Command") != 0 ) {
        if(m_widgetCommand.find(m_widgetGrid->GetCellValue(j,i)) != m_widgetCommand.end())  {
          m_displayDescription->GetWidgetList()->SetWidget(j,i,m_widgetCommand.find(m_widgetGrid->GetCellValue(j,i))->second.ToStdString());
        }
        else {
          std::string blank = WidgetCmd.find("blankWidget")->second;
          blank.append("(blankWidget)");
          m_displayDescription->GetWidgetList()->SetWidget(j,i,blank);
        }
      }
      else{
        std::string blank = WidgetCmd.find("blankWidget")->second;
        blank.append("(blankWidget)");
        m_displayDescription->GetWidgetList()->SetWidget(j,i,blank);
      }
    }
  }
  NIREPDisplay *temp = new NIREPDisplay(this->GetParent(),m_parent->GetEvaluator());
  temp->SetDisplayDescription(m_displayDescription);
  temp->CreateNIREPDisplay("");
  temp->Show();
  this->Close();
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
 */

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


/*
 * wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_DATATYPE
 */

void QuickView2::OnDatatypeSelected( wxCommandEvent& event )
{
  if(m_datatype->GetValue().compare(wxString(DataType.find("Image")->second.c_str(), wxConvUTF8) ) == 0 || m_datatype->GetValue().compare(wxString(DataType.find("Objectmap")->second.c_str(), wxConvUTF8)) == 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(wxString(DataType.find("Transformation")->second.c_str(), wxConvUTF8) ) == 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);
  }
  else {
    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);

    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_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_FORMAT
 */

void QuickView2::OnFormatSelected( wxCommandEvent& event )
{
  if(event.GetString().compare(wxString(TransformFormat.find("Displacement3")->second.c_str(), wxConvUTF8)) == 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_SCROLLEDWINDOW7)->FitInside();
  m_variableGrid->Refresh();
  m_coordinateGrid->Refresh();

  this->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();
}


/*
 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE
 */

void QuickView2::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 QuickView2::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 QuickView2::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 QuickView2::OnGenerateClick( wxCommandEvent& event )
//{
//  wxString filenamePattern = m_filenamePattern->GetValue();
//  std::queue<ResourceDescription *> queueOfResourceDescription;
//  queueOfResourceDescription = ExpandRD(filenamePattern);
//
//  ResourceDescriptionList *rdl = new ResourceDescriptionList();
//  rdl->SetNameSpace(m_namespace->GetValue().c_str());
//
//  //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().c_str();
//    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();
//  }
//
//
//  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 *> QuickView2::ExpandRD(const wxString &pattern)
{
  std::queue<ResourceDescription *> queueOfResourceDescription;
  ResourceDescription *resourceDescription = new ResourceDescription(std::string(m_namespace->GetValue().mb_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).mb_str()));
    }
  }
  resourceDescription->SetDataType(std::string(m_datatype->GetValue().mb_str()));
  resourceDescription->SetDefaultNS(std::string(m_namespace->GetValue().mb_str()));
  resourceDescription->SetFormat(std::string(dynamic_cast<wxComboBox*>(this->FindWindow(ID_FORMAT))->GetValue().mb_str()));
  resourceDescription->SetTransformUnits(std::string(m_transformationUnits->GetValue().mb_str()));
  resourceDescription->SetLabel(std::string(dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_LABEL))->GetValue().mb_str()));

  resourceDescription->AddFilename("0",std::string(pattern.mb_str()));
  resourceDescription->SetDMID(std::string(dynamic_cast<wxTextCtrl *>(this->FindWindow(ID_ADVANCED_DMID_TEXT))->GetValue().mb_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 = wxT("{");
      variable.Append(m_variableGrid->GetCellValue(i,0));
      variable.Append(wxT("}"));

      //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,wxT(","));


      //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().mb_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 = wxString(tempResourceDescription->GetFilename("0", false).c_str(), wxConvUTF8);
            wxString tempDmidString = wxString(tempResourceDescription->GetDMID().c_str(), wxConvUTF8);
            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.mb_str()));
              copyResourceDescription->AddFilename("0", std::string(tempFile.mb_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.mb_str()));
              copyResourceDescription->AddFilename("0", std::string(tempFile.mb_str()));
              queueOfResourceDescription.push(copyResourceDescription);
            }
            else if(fileReplace != 0 && availableVariable) {
              copyResourceDescription->AddFilename("0", std::string(tempFile.mb_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(std::string(value.mb_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.mb_str() );
                  cs.id = std::string(value.mb_str() );
                  if(!m_coordinateGrid->GetCellValue(index,1).IsEmpty() ) {
                    cs.ns = std::string( m_coordinateGrid->GetCellValue(index,1).mb_str() );
                  } else {
                    cs.ns = std::string( m_namespace->GetValue().mb_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.mb_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 QuickView2::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 QuickView2::OnAddCoordinateClick( wxCommandEvent& event )
{
  m_coordinateGrid->AppendRows();
  wxString temp = wxT("Coordinate System ");
  temp.Append(wxString::Format (wxT("%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,wxT("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 QuickView2::OnDeleteCoordinateClick( wxCommandEvent& event )
{
  m_coordinateGrid->DeleteRows(m_coordinateGrid->GetNumberRows()-1);
  if(m_coordinateGrid->GetNumberRows()<2 && m_coordinateGrid->GetNumberCols() == 3) {
    m_coordinateGrid->DeleteCols(2);
  }
}

/*
 * wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED event handler for ID_NOTEBOOK
 */

void QuickView2::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 QuickView2::DisplayDMID()
{
  wxString dmid;

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


  dmid.Append(wxT("("));
  //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(wxT("|"));
  if(m_coordinateGrid->GetNumberRows() > 0) {
    dmid.Append(m_coordinateGrid->GetCellValue(0,0));
  }
  dmid.Append(wxT(","));


  //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() > 1) {
      if(!m_coordinateGrid->GetCellValue(1,1).IsEmpty() ) {
        dmid.Append(m_coordinateGrid->GetCellValue(1,1));
      } else {
        dmid.Append(m_namespace->GetValue());
      }
    } else {
      dmid.Append(m_namespace->GetValue());
    }
    dmid.Append("|");
    //dmid.Append("|{");
    if(m_coordinateGrid->GetNumberRows() > 1) {
      dmid.Append(m_coordinateGrid->GetCellValue(1,0));
    }
    //dmid.Append("},");
    dmid.Append(",");
    if(m_coordinateGrid->GetNumberCols() == 3) {
      dmid.Append(m_coordinateGrid->GetCellValue(1,2));
    }
  }
  dmid.Append(wxT(")"));

  //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 QuickView2::OnCoordinateGridChange( wxGridEvent& event )
{
  this->DisplayDMID();
}

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

void QuickView2::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(wxT("{"));
  size_t second = pattern.find_first_of(wxT("}"));
  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(wxT("{"),first+1);
    second = pattern.find(wxT("}"),second+1);
  }
}

/*
 * wxEVT_COMMAND_LISTBOX_SELECTED event handler for ID_LIST_RDL
 */

void QuickView2::OnListRdlSelected( wxCommandEvent& event )
{
  int length = 0;
  for(int i=0; i< dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->GetNumberOfLines(); i++) {
    int sel = dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->GetLineText(i).Find(event.GetString());
    if(sel != -1) {
      dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->SetSelection(length+sel, length+sel+event.GetString().size());
      dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->ShowPosition(length+sel);
      return;
    }
    length += dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->GetLineLength(i);
    length ++;
  }
  
}

void QuickView2::OnAddRDL( wxCommandEvent& event )
{
    wxString filenamePattern = m_filenamePattern->GetValue();
    std::queue<ResourceDescription *> queueOfResourceDescription;
    queueOfResourceDescription = ExpandRD(filenamePattern);

    //ResourceDescriptionList *rdl = new ResourceDescriptionList();
    m_displayDescription->GetRDL()->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) { 
        if(m_displayDescription->GetRDL()->AddDataDescrip(queueOfResourceDescription.front()->GetDMID(), queueOfResourceDescription.front())) {
          dynamic_cast<wxListBox*>(this->FindWindow(ID_LIST_RDL) )->Append(queueOfResourceDescription.front()->GetDMID());
        
          m_rdl.push_back(queueOfResourceDescription.front()->GetDMID());

          int loc = dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->FindString("--------RDL DMID-------");
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Insert(queueOfResourceDescription.front()->GetDMID(), loc+1);

          loc = dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->FindString("--------RDL DMID-------");
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Insert(queueOfResourceDescription.front()->GetDMID(), loc+1);
        }
      }
      else if(datatype.compare(DataType.find("Transformation")->second) == 0) {
        if(m_displayDescription->GetRDL()->AddTransformDescrip(queueOfResourceDescription.front()->GetDMID(), queueOfResourceDescription.front())) {
          dynamic_cast<wxListBox*>(this->FindWindow(ID_LIST_RDL) )->Append(queueOfResourceDescription.front()->GetDMID());

          m_rdl.push_back(queueOfResourceDescription.front()->GetDMID());

          int loc = dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->FindString("--------RDL DMID-------");
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX5))->Insert(queueOfResourceDescription.front()->GetDMID(), loc+1);

          loc = dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->FindString("--------RDL DMID-------");
          dynamic_cast<wxComboBox*>(this->FindWindow(ID_COMBOBOX6))->Insert(queueOfResourceDescription.front()->GetDMID(), loc+1);
        }
      }
      else {
        delete queueOfResourceDescription.front();
      }
      queueOfResourceDescription.pop();
    }

    
    m_filenamePattern->Clear();
    m_namespace->Clear();
    m_filenamePattern2->Clear();
    m_filenamePattern3->Clear();
    m_transformationUnits->Clear();
    dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_LABEL))->Clear();
    

    for(int i=0; i< m_variableGrid->GetNumberCols(); i++) {
      for(int j=0; j<m_variableGrid->GetNumberRows(); j++) {
        m_variableGrid->SetCellValue("",j,i);
      }
    }
    for(int i=0; i< m_coordinateGrid->GetNumberCols(); i++) {
      for(int j=0; j<m_coordinateGrid->GetNumberRows(); j++) {
        m_coordinateGrid->SetCellValue("",j,i);
      }
    }
    dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_DEFAULT_DMID_TEXT))->Clear();
    dynamic_cast<wxTextCtrl*>(this->FindWindow(ID_ADVANCED_DMID_TEXT))->Clear();
    m_datatype->SetSelection(0);

    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);

    this->FindWindow(ID_LABEL)->Show(false);
    this->FindWindow(ID_STATIC_LABEL_TEXT)->Show(false);
    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->FindWindow(ID_SCROLLEDWINDOW7)->FitInside();

    dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->Clear();
    FILE * tempfile = fopen("tempfile.txt", "w+");
    m_displayDescription->GetRDL()->Save(tempfile);
    rewind(tempfile);
    int character;
    while( (character = fgetc(tempfile) ) != EOF ) {
      wxString temp;
      temp.Append(static_cast<char>(character) );
      dynamic_cast<wxRichTextCtrl*>(this->FindWindow(ID_TEXT))->AppendText(temp);
    }
    fclose(tempfile);
}

void QuickView2::OnDeleteRDL( wxCommandEvent& event )
{
}