NIREPDisplay.cxx

Go to the documentation of this file.

#include "NIREPDisplay.h"

#include "NIREPvtkViewImage2D.h"
#include "NIREPwxVTKRenderWindowInteractor.h"
#include <vtkImageData.h>
#include <vtkRenderer.h>
#include <vtkLookupTableManager.h>
#include "GetPanelFromUser.h"
#include "EditTextPanels.h"
#include "GaugeNotification.h"
#include "NIREPDefinitions.h"
#include "NIREPEditProjectFile.h"
#include "PairwiseComparison.h"

#include "wx/progdlg.h"

IMPLEMENT_CLASS( NIREPDisplay, wxFrame )

BEGIN_EVENT_TABLE( NIREPDisplay, wxFrame )

    EVT_MENU( ID_SAVE, NIREPDisplay::OnSaveClick )
    EVT_MENU( ID_OPEN_NIREPDisplay_DESCRIPTION, NIREPDisplay::OnOpenDisplayDescriptionClick )
    EVT_MENU( ID_NEW_WINDOW, NIREPDisplay::OnNewWindowClick )
    EVT_MENU( ID_CLOSE, NIREPDisplay::OnCloseClick )
    EVT_MENU( ID_ADD_ROW, NIREPDisplay::OnAddRowClick )
    EVT_MENU( ID_ADD_COLUMN, NIREPDisplay::OnAddColumnClick )
    EVT_MENU( ID_TURN_OFF_TITLES, NIREPDisplay::OnTurnOffTitlesClick )
    EVT_MENU( ID_TURN_ON_TITLES, NIREPDisplay::OnTurnOnTitlesClick )

    EVT_MENU( ID_TURN_ON_ALL_CURSORS, NIREPDisplay::OnTurnOnAllCursorsClick )
    EVT_MENU( ID_TURN_OFF_ALL_CURSORS, NIREPDisplay::OnTurnOffAllCursorsClick )

    EVT_MENU( ID_LOCK_ALL, NIREPDisplay::OnLockAllClick )
    EVT_MENU( ID_LOCK_ROWS, NIREPDisplay::OnLockRowsClick )
    EVT_MENU( ID_LOCK_COLS, NIREPDisplay::OnLockColsClick )

    EVT_MENU( ID_UNLOCK_ALL, NIREPDisplay::OnUnLockAllClick )
    EVT_MENU( ID_UNLOCK_ROWS, NIREPDisplay::OnUnLockAllClick )
    EVT_MENU( ID_UNLOCK_COLS, NIREPDisplay::OnUnLockAllClick )

    EVT_MENU( ID_GROUP1, NIREPDisplay::OnGroup1Click )
    EVT_MENU( ID_GROUP2, NIREPDisplay::OnGroup2Click )
    EVT_MENU( ID_GROUP3, NIREPDisplay::OnGroup3Click )
    EVT_MENU( ID_NEXT_GROUP, NIREPDisplay::OnNextGroupClick )
    EVT_MENU( ID_PREVIOUS_GROUP, NIREPDisplay::OnPreviousGroupClick )
    EVT_MENU( ID_ADD_OBJECT_MAPS, NIREPDisplay::OnAddObjectMapsClick )
    EVT_MENU( ID_ADD_LANKDMARKS, NIREPDisplay::OnAddLandmarksClick )

    EVT_MENU( ID_GROUP1, NIREPDisplay::OnGroup1Click )
    EVT_MENU( ID_GROUP2, NIREPDisplay::OnGroup2Click )
    EVT_MENU( ID_GROUP3, NIREPDisplay::OnGroup3Click )
    EVT_MENU( ID_NEXT_GROUP, NIREPDisplay::OnNextGroupClick )
    EVT_MENU( ID_PREVIOUS_GROUP, NIREPDisplay::OnPreviousGroupClick )
    EVT_MENU( ID_ADD_OBJECT_MAPS, NIREPDisplay::OnAddObjectMapsClick )
    EVT_MENU( ID_ADD_LANKDMARKS, NIREPDisplay::OnAddLandmarksClick )

    EVT_MENU( ID_EDIT_PANEL, NIREPDisplay::OnEditPanelClick )

    EVT_MENU( ID_EDIT_DISPLAY_VARS, NIREPDisplay::OnEditDisplayFileClick )

    EVT_MENU( ID_SAC, NIREPDisplay::OnSingleAlgorithmComparisonClick )

END_EVENT_TABLE()


NIREPDisplay::NIREPDisplay (wxWindow* parent,NIREPEvaluator *ev, const std::string& FileName,
                                    int id,                               
                                    const wxString& title,
                                    const wxPoint& pos,
                                    const wxSize& size,
                                    long style,
                                    const wxString& name
                                    )
  : wxFrame(parent, id,title, pos, size, style, name)
{
  
  if(size == wxDefaultSize) {
    this->Maximize();
  }
   m_fileName = wxT("Undefined");
    groupNumber = NOGROUP;
    presetView = 0;
    displayDescription = NULL;
    m_Sizer = NULL;
    //head = NULL;
    wxMenuBar* menuBar = new wxMenuBar;

    //----------------------------------File Menu---------------------------------------
    wxMenu* file_menu = new wxMenu;
    file_menu->Append(ID_OPEN_NIREPDisplay_DESCRIPTION, _("Open NIREPDisplay description"), _T(""), wxITEM_NORMAL);
    file_menu->Append(ID_NEW_WINDOW, _("Open new window"), _T(""), wxITEM_NORMAL);
    file_menu->Append(ID_CLOSE, _("Close"), _T(""), wxITEM_NORMAL);
    //As soon as we get the writing of the different descriptions we will
    //un comment this line and make the function OnSaveClick use the
    //writers of the various desriptions
    //file_menu->Append(ID_SAVE, _("Save"), _T(""), wxITEM_NORMAL);
    menuBar->Append(file_menu, _("File"));
    //----------------------------------End of File Menu---------------------------------------
    

    //----------------------------------Edit Menu---------------------------------------
    wxMenu* edit_menu = new wxMenu;
    edit_menu->Append(ID_EDIT_PANEL, _("Edit Panel..."), _T(""), wxITEM_NORMAL);
    edit_menu->Append(ID_EDIT_DISPLAY_VARS, _("Edit Display Variables..."), _T("Change values of variables that are defined for current display."), wxITEM_NORMAL);
    edit_menu->Append(ID_ADD_ROW, _("Add Row"), _T(""), wxITEM_NORMAL);
    edit_menu->Append(ID_ADD_COLUMN, _("Add Column"), _T(""), wxITEM_NORMAL);
    edit_menu->Append(ID_TURN_OFF_TITLES, _("Turn Off Titles"), _T(""), wxITEM_NORMAL);
    edit_menu->Append(ID_TURN_ON_TITLES, _("Turn On Titles"), _T(""), wxITEM_NORMAL);
    menuBar->Append(edit_menu, _("Edit"));
    //----------------------------------End of Edit Menu---------------------------------------

    //----------------------------------View Menu---------------------------------------
    wxMenu* view_menu = new wxMenu;
    view_menu->Append(ID_TURN_ON_ALL_CURSORS, _("Show Cursors"), _T(""), wxITEM_NORMAL);
    view_menu->Append(ID_TURN_OFF_ALL_CURSORS, _("Hide Cursors"), _T(""), wxITEM_NORMAL);
    menuBar->Append(view_menu, _("View"));
    //----------------------------------End of View Menu---------------------------------------

    //----------------------------------Cursor Lock Menu---------------------------------------
    wxMenu* cursor_lock_menu = new wxMenu;
    cursor_lock_menu->Append(ID_LOCK_ALL, _("Lock All"), _T(""), wxITEM_NORMAL);
    cursor_lock_menu->Append(ID_LOCK_ROWS, _("Lock Rows"), _T(""), wxITEM_NORMAL);
    cursor_lock_menu->Append(ID_LOCK_COLS, _("Lock Columns"), _T(""), wxITEM_NORMAL);

    cursor_lock_menu->Append(ID_UNLOCK_ALL, _("UnLock All"), _T(""), wxITEM_NORMAL);
    cursor_lock_menu->Append(ID_UNLOCK_ROWS, _("UnLock Rows"), _T(""), wxITEM_NORMAL);
    cursor_lock_menu->Append(ID_UNLOCK_COLS, _("UnLock Columns"), _T(""), wxITEM_NORMAL);
    menuBar->Append(cursor_lock_menu, _("Cursor Lock"));
    //----------------------------------End of Cursor Lock Menu---------------------------------------


    //----------------------------------Database view Menu---------------------------------------
    //wxMenu* itemMenu7 = new wxMenu;
    //itemMenu7->Append(ID_GROUP1, _("1-6"), _T(""), wxITEM_NORMAL);
    //itemMenu7->Append(ID_GROUP2, _("7-12"), _T(""), wxITEM_NORMAL);
    //itemMenu7->Append(ID_GROUP3, _("13-16"), _T(""), wxITEM_NORMAL);
    //itemMenu7->Append(ID_NEXT_GROUP, _("Next Group"), _T(""), wxITEM_NORMAL);
    //itemMenu7->Append(ID_PREVIOUS_GROUP, _("Previous Group"), _T(""), wxITEM_NORMAL);
    //itemMenu7->Append(ID_ADD_OBJECT_MAPS, _("Add Object Maps to all"), _T(""), wxITEM_NORMAL);
    //itemMenu7->Append(ID_ADD_LANKDMARKS, _("Add Landmarks to all"), _T(""), wxITEM_NORMAL);
    //menuBar->Append(itemMenu7, _("Database"));
    //----------------------------------End of Database view Menu---------------------------------------

    //----------------------------------Pairwise Comparison Menu---------------------------------------
    wxMenu* itemMenu8 = new wxMenu;
    itemMenu8->Append(ID_SAC, _("Single Algorithm Comparison"), _T(""), wxITEM_NORMAL);
    itemMenu8->Append(wxID_ANY, _("Absoulte Difference"), _T(""), wxITEM_NORMAL);
    itemMenu8->Append(wxID_ANY, _("Window Wipe"), _T(""), wxITEM_NORMAL);
    itemMenu8->Append(wxID_ANY, _("Checkerboard"), _T(""), wxITEM_NORMAL);
    itemMenu8->Append(wxID_ANY, _("R, Y, G fusion"), _T(""), wxITEM_NORMAL);
    itemMenu8->Append(wxID_ANY, _("Relative Overlap"), _T(""), wxITEM_NORMAL);
    menuBar->Append(itemMenu8, _("Pairwise Comparison"));
    //----------------------------------End of Pairwise Comparison Menu---------------------------------------

    //----------------------------------Groupwise Comparison Menu---------------------------------------
    wxMenu* itemMenu9 = new wxMenu;
    menuBar->Append(itemMenu9, _("Groupwise Comparison"));
    //----------------------------------End of Groupwise Comparison Menu---------------------------------------


    this->SetMenuBar(menuBar);
    evaluator = ev; 

    
    m_SizerTwo = new wxFlexGridSizer(1, 1, 0, 0);
    m_SizerTwo->AddGrowableRow(0);
    m_SizerTwo->AddGrowableCol(0);
    this->SetSizer(m_SizerTwo);

    m_scrolledWindow = new wxScrolledWindow( this, ID_SCROLLEDWINDOW, wxDefaultPosition, wxDefaultSize );
    m_SizerTwo->Add(m_scrolledWindow, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5);
    m_scrolledWindow->SetScrollbars(1, 1, 0, 0);

          //have to have a NIREPDisplay description otherwise
          //we will not now what to NIREPDisplay.
    if(!FileName.empty()) {
       CreateNIREPDisplay(FileName);
    }
    //else {
    //  ::wxLogError( "ERROR - NIREP Display Filename is empty!");
    //}

  
}

NIREPDisplay::~NIREPDisplay()
{
  this->RemoveAll();
  int psize = panel.size();
  //Make sure we detach all of the views otherwise we will get errors and
  //memory leaks.
  for(int j=0;j<psize;j++) {
    panel.at(j)->GetWidget()->Detach();
  }
  for(int j=0; j<psize;j++) {
    delete panel.at(j);
    panel.at(j) = NULL;
  }
  if(displayDescription) {
    delete displayDescription;
    displayDescription = NULL;
  }
  if(evaluator) {
    evaluator = NULL;
  }
  if(m_SizerTwo) {
    m_SizerTwo = NULL;
  }
  if(m_scrolledWindow) {
    m_scrolledWindow = NULL;
  }
  if(m_Sizer) {
    m_Sizer = NULL;
  }
}

//Set some class variables.
void NIREPDisplay::SetProperties()
{
  m_InteractionStyle = NIREPvtkViewImage2D::SELECT_INTERACTION;
  m_LinkViews        = true;
  m_ShowCursors      = true;
  m_OrientationFlag = NIREPvtkViewImage::AXIAL_ID;
}

//Update the sizer and the layout of this window.
void NIREPDisplay::DoLayout()
{
  m_Sizer->Layout();
  //set the sizer of this window to the sizer that was created
  this->SetSizer (m_SizerTwo);
  //tell the window to auto layout that way if something changes
  //to the layout, that the layout actually updates
  this->SetAutoLayout (true);
  this->Layout();
}


//This function is the main function for this class.  This will add in the
//labels and the views based on the NIREPDisplay description.  So this function
//will run through an outer loop of the rows and an inner loop twice. The
//first for loop runs through the columns to place the labels and then run
//another for loop to place the views in.
void NIREPDisplay::CreateGrid ()
{
  int width = 0;
  int num_rows = this->displayDescription->GetDisplayAttributes()->GetRowDimension();
  int num_cols = this->displayDescription->GetDisplayAttributes()->GetColDimension();
  int num_panels = num_rows * num_cols;
  bool cont = true;

  wxProgressDialog * load_status_dialog = new wxProgressDialog(wxT("Creating Display"), wxT("Processing Display Description"),
    num_panels, // number of segments in progress bar
    this, // parent window
    wxPD_CAN_ABORT | wxPD_APP_MODAL | wxPD_AUTO_HIDE |
    wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME | wxPD_REMAINING_TIME);

  //Run through the rows
  for(int i=0;i<num_rows;i++) {
    //Run through the columns for the labels
    for(int j=0;j<num_cols;j++) {
            //Add in the labels that are above the views.  Eventually this 
            //will get moved into the panel so that we just plop a panel
            //in and not worry about the label but there are problems with
            //the size and resizeing things.
      //PanelStorage tempStorage;
      //if(head == NULL)
      //{
      //  head = &tempStorage;
      //}
      //else
      //{
      //  tail->next = &tempStorage;
      //}
      //tail = &tempStorage;

            //first get the parameters from the NIREPDisplay description
      //std::vector<std::string> temp = this->displayDescription->GetWidgetList()->GetWidgetParameters(i,j);

            //create the label
      wxStaticText* itemStaticText67 = new wxStaticText( m_scrolledWindow, wxID_ANY, wxString( this->displayDescription->GetWidgetList()->GetTitle(i,j).c_str(), wxConvUTF8 ), wxDefaultPosition, wxSize(-1,55), wxST_NO_AUTORESIZE|wxALIGN_CENTRE );

            //add the text of the label to a map so that if the user wants to change
            //the text then it is an easy lookup and change.
      panelTitle.insert(std::make_pair(i*this->GetColumns()+j,itemStaticText67));

            //Set the color of the text
      itemStaticText67->SetForegroundColour(wxColour(129, 248, 150));

            //Set the color of the background to black
      itemStaticText67->SetBackgroundColour(wxColour(0, 0, 0));

            //Set the font but if the user wants they can change it from the panelForm
      itemStaticText67->SetFont(wxFont(14, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Tahoma")));

            //add the label to this window
      m_Sizer->Add(itemStaticText67,1, wxALL|wxEXPAND|wxGROW, 0);

      //tempStorage.text = itemStaticText67;
    }

          //run through the columns for the views
    for(int j=0;j<num_cols;j++) {
      //gaugeNotification->AddItem(this->displayDescription->GetWidgetList()->GetWidgetType(i,j));
      wxString msg(wxT("Loading: "));
      msg += wxString(this->displayDescription->GetWidgetList()->GetWidgetType(i,j).c_str(), wxConvUTF8);
      cont = load_status_dialog->Update(i*num_cols + j,msg);

      if (!cont){
        if (wxMessageBox(wxT("Do you really want to cancel?"),
                           wxT("Process dialog question"),
                           wxYES_NO | wxICON_QUESTION) == wxYES){
          // Probably need to do some clean up here if abort, but don't have timme
          // to do it now. GEC
          load_status_dialog->Show(false);
          delete load_status_dialog;
          return;
        }
        load_status_dialog->Resume();
      }

      //Create a panel
      Panel* panelTwo = new Panel (m_scrolledWindow,this->displayDescription,  wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE);

            //set the evaluator that way the panel can get images
      panelTwo->SetEvaluator(this->evaluator);

            //set the id of the panel, this way if we need to figure out which
            //panel this is, we can call getID of the panel and do a quick
            //search in a map.
      panelTwo->SetID(panel.size());

            //the panel needs to know about the NIREPDisplay so that the panel can do
            //some global items, such as linking itself with other panels and deleting
            //itself.
      panelTwo->SetParent(this);

            //add the panel to the sizer
      m_Sizer->Add (panelTwo, 1, wxALL|wxEXPAND|wxGROW, 0);

            //get the parameters for this specific panel
      std::vector<std::string> temp = this->displayDescription->GetWidgetList()->GetWidgetParameters(i,j);

            //set the ids from the NIREPDisplay description.  The ids are the images that the user
            //wants NIREPDisplayed
      //do not grab the last parameter because it is the text that will be NIREPDisplayed
                  //in the label
      for(int k=0;k<temp.size()-1;k++) {
        panelTwo->SetIds(temp[k]);
      }

            //Now run through a big if, else if clause to figure out which
            //view to use.
      std::string widget_type = this->displayDescription->GetWidgetList()->GetWidgetType(i,j);
      
      // Convert widget_type to lower case for comparison
      std::transform(widget_type.begin(), widget_type.end(), widget_type.begin(), ::tolower);

      // The WidgetCmd list is defined in NIREPDefinitions.  If you want to change
      // the string for the widget, change the value of WidgetCmd in NIREPDefinitions and
      // not the key value.  That is the key values below should stay the
      // same no matter what the value associated with the key becomes.
      // Note that all comparison are lower case because the value of WidgetCmd is lower
      // case.  It does not matter the case of the key shown below.
      if(widget_type.compare(WidgetCmd["view"]) == 0) {
        //panelTwo->SetLookUpTable(vtkLookupTableManager::GetLookupTable(3),3);
        panelTwo->UseImage();
      }
      else if(widget_type.compare(WidgetCmd["checkerboard"]) == 0) {
        panelTwo->UseCheckerboard();
      }
      else if(widget_type.compare(WidgetCmd["wipe"]) == 0) {
        panelTwo->UseWipe();
      }
      else if(widget_type.compare(WidgetCmd["objectmap"]) == 0) {
        panelTwo->UseObjectMap();
      }
      else if(widget_type.compare(WidgetCmd["overlayObjectMap"]) == 0) {
        panelTwo->UseOverlayObjectMap();
      }
      else if(widget_type.compare(WidgetCmd["overlayImage"]) == 0) {
        panelTwo->UseOverlayImage();
      }
      else if(widget_type.compare(WidgetCmd["relativeOverlap"]) == 0) {
        panelTwo->UseRelativeOverlap();
      }
      else if(widget_type.compare(WidgetCmd["relativeOverlapTextWidget"]) == 0) {
        panelTwo->UseRelativeOverlapTextStatistic();
      }
      else if(widget_type.compare(WidgetCmd["intensityVarianceTextWidget"]) == 0) {
        panelTwo->UseIntensityVarianceTextStatistic();
      }
      else if(widget_type.compare(WidgetCmd["inverseConsistencyTextWidget"]) == 0) {
        panelTwo->UseInverseConsistencyTextStatistic();
      }
      else if(widget_type.compare(WidgetCmd["transitivityErrorTextWidget"]) == 0) {
        panelTwo->UseTransitivityErrorTextStatistic();
      }
      else if(widget_type.compare(WidgetCmd["varianceTransformText"]) == 0) {
        panelTwo->UseVarianceTransformTextStatistic();
      }
      else if(widget_type.compare(WidgetCmd["varianceImageText"]) == 0) {
        panelTwo->UseVarianceImageTextStatistic();
      }
      else if(widget_type.compare(WidgetCmd["blankWidget"]) == 0) {
        panelTwo->UseBlank();
      }
      else if(widget_type.compare(WidgetCmd["vectorField"]) == 0) {
        panelTwo->UseVectorField();
      }
      else {
        wxString temp = wxT("Unrecognized widget command: ");
        temp.Append(wxString::Format (wxT("%s."), wxString(widget_type.c_str(), wxConvUTF8)));
        wxLogError(temp);
      }

            //push the panel onto a vector so that we can
            //do some global items, such as linking and deleting.
            //Also later on, we can go through this vector and
            //do some saving of information so that the next
            //time the user uses the program they can start
            //from where they left off.
      panel.push_back (panelTwo);
      width += panelTwo->GetMinWidth();
    }
  }

  cont = load_status_dialog->Update(num_panels,wxT("Done."));

  DistributeAttributes();
  
  //wxSize tempSize;
  //tempSize.SetWidth(width);
  //this->SetMinSize(tempSize);

  m_scrolledWindow->FitInside();
  //Call the function DoLayout just to be on the safe side because
  //we did changes to the layout
  this->DoLayout();  

  //gaugeNotification->Show(false);
  //delete gaugeNotification;

  delete load_status_dialog;
}


//Not sure if this actually works.  Might have to change it so that
//we have a viewImage2D with an image of one pixel that is black.
//void NIREPDisplay::RemoveView (const int& i)
//{
//  if( i<0 || i>=(int)(panel.size()) ) {
//    return;
//  }
//  std::vector<Panel*> newWxList;
//  for( int j=0; j<(int)(panel.size()); j++) {
//    if( j==i ) {
//      bool isDetached = m_Sizer->Detach ( panel[j] );
//      if( !isDetached ) {
//        std::cerr << "Warning: child was not found." << std::endl;
//      }
//      panel[j]->GetView()->Detach();
//      panel[j]->GetView()->Delete();
//      m_Sizer->Layout();
//    }
//    else {  
//      if(j<i) {
//      panel[j]->SetID(j);
//      }
//      else {
//        panel[j]->SetID(j-1);
//      }
//      newWxList.push_back ( panel[j] );
//    }
//  }
//  panel = newWxList;
//}

//This function works but needs to be changed.
//This will delete a widget and push all the other
//items behind it in the sizer one space forward.
//So the problem comes in that a widget might go
//into a slot for the label and a label will go
//into a slot for the view.  So this kind of
//works but needs to be changed.
void NIREPDisplay::DeleteWidget(const int &Location)
{
  if( Location<0 || Location>=(int)(panel.size()) ) {
    return;
  }
  std::vector<Panel*> newWxList;
  for( int j=0; j<(int)(panel.size()); j++) {
    if( j==Location ) {
      bool isDetached = m_Sizer->Detach ( panel[j] );
      int debugStop = j%this->GetColumns();
      int debugStopTwo = j/this->GetColumns();
      m_Sizer->InsertStretchSpacer((debugStopTwo+2)*(this->GetColumns())+debugStop);
      if( !isDetached ) {
        std::cerr << "Warning: child was not found." << std::endl;
      }
      delete panel[j];
      m_Sizer->Layout();
    }
    else {  
      if(j<Location) {
        panel[j]->SetID(j);
      }
      else {
        panel[j]->SetID(j-1);
      }
      newWxList.push_back ( panel[j] );
    }
  }
  panel = newWxList;
}

//Remove all the panels from this window.
void NIREPDisplay::RemoveAll()
{
  if(m_Sizer == NULL)
    return;
  int size = m_Sizer->GetChildren().GetCount();
  for( int i=0; i<size;i++) {
    m_Sizer->Detach (0);
  }
  for(int j=0;j<panel.size();j++) {
    if( panel.at(j)->GetView() != NULL)
      panel.at(j)->GetWidget()->Detach();
  }
  for( unsigned int i=0; i<panel.size(); i++) {
    delete panel[i];
  }
  for(std::map<int, wxStaticText*>::iterator temp =  panelTitle.begin(); temp!= panelTitle.end(); temp++) {
    delete temp->second;
  }
  panel.clear();
  panelTitle.clear();
  if(m_Sizer) {
    m_Sizer->Layout();  
  }
}

//Run through all the panels and call render
//on them.
void NIREPDisplay::Render()
{
  for( unsigned int i=0; i<panel.size(); i++) {
    if( !panel[i]->GetRenderWindow()->GetNeverRendered() ) {
      panel[i]->Render();
    }
  }
}



//Set the size of the columns and run through the
//sizer and add growable columns if the sizer had
//less columns then what was passed in.
void NIREPDisplay::SetColumns(int col)
{
  if(m_Sizer->GetCols() <col) {
    for(int i=m_Sizer->GetCols();i<col;i++) {
      m_Sizer->AddGrowableCol(i);
    }
  }
  m_Sizer->SetCols(col);
}

//This will add a panel with the specfic type of view that is passed in type.
//Also need the parameters so that we know what images to use.  This probably
//needs some more work because we have been concentrating in createGrid to
//get things working.
void NIREPDisplay::AddWidget(std::string type, std::vector<std::string> parameters) {
    
  
  
  if(type.compare( WidgetCmd["view"])) {
                  Panel* wxView = new Panel (this,this->displayDescription, wxID_ANY, wxDefaultPosition, wxDefaultSize);
                  wxView->SetID(panel.size());
          wxView->SetParent(this);
          m_Sizer->Add (wxView, 1, wxALL|wxEXPAND|wxGROW, 0);
                  wxView->UseImage();
                  panel.push_back(wxView);
    }
    else if(type.compare( WidgetCmd["objectmap"])) {
                  Panel* wxView = new Panel (this,this->displayDescription, wxID_ANY, wxDefaultPosition, wxDefaultSize);
                  wxView->SetID(panel.size());
                wxView->SetParent(this);
                m_Sizer->Add (wxView, 1, wxALL|wxEXPAND|wxGROW, 0);
                  for(int i=0; i < parameters.size(); i++ ) {
                          //wxView->SetInput(ConvertImage(evaluator->get(wxView,parameters[i])));
                  }
                  wxView->UseObjectMap();
                  panel.push_back(wxView);
    }
    else if(type.compare(WidgetCmd["checkerboard"])) {
                  Panel* wxView = new Panel (this,this->displayDescription, wxID_ANY, wxDefaultPosition, wxDefaultSize);
                  wxView->SetID(panel.size());
                wxView->SetParent(this);
                m_Sizer->Add (wxView, 1, wxALL|wxEXPAND|wxGROW, 0);
                  for(int i=0; i < parameters.size(); i++ ) {
                          //wxView->SetInput(ConvertImage(evaluator->get(wxView,parameters[i])));
                  }
                  wxView->UseCheckerboard ();
                  panel.push_back(wxView);
    }
}

//Link all the views (true) or unlink all the views (false)
void NIREPDisplay::LinkViews (bool val)
{
  m_LinkViews = val;
  if (!m_LinkViews) {
    for( unsigned int i=0; i<panel.size(); i++) {
      panel[i]->GetView()->Detach();
    }
  }
  else {
    NIREPvtkViewImage2D *previousView = NULL;
    NIREPvtkViewImage2D *firstView = NULL;
    for( unsigned int i=0; i<panel.size(); i++) {
      if(panel[i]->GetView() != NULL) {
        panel[i]->GetView()->RemoveAllChildren();
        if(previousView != NULL)
          previousView->AddChild( panel[i]->GetView() );
        else
          firstView = panel[i]->GetView();
        previousView = panel[i]->GetView();
      }
    }
    if(previousView != NULL) 
      previousView->AddChild(firstView);
    previousView = NULL;
    firstView = NULL;

  }
}

//Not using this but might be useful in the future.
//void NIREPDisplay::LinkViews (std::vector<std::string> Panels)
//{
//  if(Panels.empty())
//  {
//    return;
//  }
//  std::string line = Panels[0];
//  //Get the column that the widget is supposed to be in
//  size_t found = line.find_first_of(",");
//
//  std::string id(line, 1,found);
//  wxString wxID = id.c_str();
//  wxID.Trim();
//  wxID.Trim(false);
//  id = wxID.ToAscii();
//
//  //Get the row that the widget is supposed to be in
//  size_t foundTwo = line.find_first_of("=");
//  std::string idTwo(line, found+1,foundTwo);
//  wxString wxIDTwo = idTwo.c_str();
//  wxIDTwo.Trim();
//  wxIDTwo.Trim(false);
//  idTwo = wxIDTwo.ToAscii();
//
//  double col;
//  wxIDTwo.ToDouble(&col);
//  double row;
//  wxID.ToDouble(&row);
//  int tempTwo = ((int)row-1)*this->GetColumns()+(int)col-1;
//  int beginPanel = tempTwo;
//
//  int previousPanel = beginPanel;
//
//  for(int i=1;i<Panels.size();i++)
//  {
//    line = Panels[i];
//    //Get the column that the widget is supposed to be in
//    found = line.find_first_of(",");
//
//    std::string id(line, 1,found);
//    wxID = id.c_str();
//    wxID.Trim();
//    wxID.Trim(false);
//    id = wxID.ToAscii();
//
//    //Get the row that the widget is supposed to be in
//    foundTwo = line.find_first_of("=");
//    std::string idTwo(line, found+1,foundTwo);
//    wxIDTwo = idTwo.c_str();
//    wxIDTwo.Trim();
//    wxIDTwo.Trim(false);
//    idTwo = wxIDTwo.ToAscii();
//
//    wxIDTwo.ToDouble(&col);
//    wxID.ToDouble(&row);
//    tempTwo = ((int)row-1)*this->GetColumns()+(int)col-1;
//
//    panel[previousPanel]->GetView()->Detach();
//
//    
//    previousPanel = tempTwo;
//  }
//
//  panel[previousPanel]->GetView()->Detach();
//
//  previousPanel = beginPanel;
//
//  for(int i=1;i<Panels.size();i++)
//  {
//    line = Panels[i];
//    //Get the column that the widget is supposed to be in
//    found = line.find_first_of(",");
//
//    std::string id(line, 1,found);
//    wxID = id.c_str();
//    wxID.Trim();
//    wxID.Trim(false);
//    id = wxID.ToAscii();
//
//    //Get the row that the widget is supposed to be in
//    foundTwo = line.find_first_of("=");
//    std::string idTwo(line, found+1,foundTwo);
//    wxIDTwo = idTwo.c_str();
//    wxIDTwo.Trim();
//    wxIDTwo.Trim(false);
//    idTwo = wxIDTwo.ToAscii();
//
//    wxIDTwo.ToDouble(&col);
//    wxID.ToDouble(&row);
//    tempTwo = ((int)row-1)*this->GetColumns()+(int)col-1;
//
//    panel[previousPanel]->GetView()->AddChild( panel[tempTwo]->GetView() );
//    previousPanel = tempTwo;
//  }
//
//
//  if(beginPanel != -1)
//  {
//    NIREPvtkViewImage2D *bob = panel[ previousPanel]->GetView();
//    panel[ previousPanel]->GetView()->AddChild(panel[beginPanel]->GetView());
//  }
//
//}

//Link the panels that are passed in.
void NIREPDisplay::LinkViews (std::vector<int> Panels)
{
  if(Panels.empty()) {
    return;
  }

  //First run through the panels and detach from the
  //other panels.  Also set the vector of widgets
  //which the panel is linked to.
  for(int i=0;i<Panels.size();i++) {
    if( panel[Panels.at(i)]->GetView() !=NULL)
      panel[Panels.at(i)]->GetView()->Detach();
    panel[Panels.at(i)]->SetLinkedWidgets(Panels);
  }

  //Link the widgets by adding children to the panels
  for(int i=0;i<(Panels.size()-1);i++) {
    panel[Panels.at(i)]->GetView()->AddChild( panel[Panels.at(i+1)]->GetView() );
  }
  
  //Set the child of the last panel to the first panel, thereby creating
  //a loop of panels.
  if(Panels.size()!=0)
  {
    if( panel[Panels.at(Panels.size()-1)]->GetView() !=NULL && panel[Panels.at(0)]->GetView() != NULL)
      panel[Panels.at(Panels.size()-1)]->GetView()->AddChild(panel[Panels.at(0)]->GetView());
    else if(panel[Panels.at(Panels.size()-1)]->GetView() !=NULL) {
      for(int i=1; i<Panels.size(); i++) {
        panel[Panels.at(Panels.size()-1)]->GetView()->AddChild(panel[Panels.at(i)]->GetView());
      }
    }
    else if(panel[Panels.at(0)]->GetView() != NULL) {
      for(int i=Panels.size()-2; i>0; i--) {
        panel[Panels.at(i)]->GetView()->AddChild(panel[Panels.at(0)]->GetView());
      }
    }
  }

}

//Run through the unlinked panels.  Check the linked vector in each unlinked panel
//and make sure that if there is a panel in the linkedPanels and in the panel that
//is not supposed to be linked that the panel is taken out.
//I.E. if linkedPanels has 1,2 and unlinked panels has 0,3,4 and panel 0 has panel
//1 in the linked panels vector that we take panel 1 out.
void NIREPDisplay::UnLinkViews (std::vector<int> LinkedPanels, std::vector<int> UnLinkedPanels)
{
  if(LinkedPanels.empty()) {
    return;
  }

  for(int i=0;i<UnLinkedPanels.size();i++) {
    std::vector<int>::iterator tempTwo = LinkedPanels.begin();
    std::vector<int> tempThree = panel[UnLinkedPanels.at(i)]->GetLinkedWidgets();
    for(; tempTwo != LinkedPanels.end();tempTwo++) {
      if(panel[UnLinkedPanels.at(i)]->GetLinkedWidgets().size() != 0) {
        std::vector<int>::iterator temp = tempThree.begin();
        std::vector<int>::iterator end = tempThree.end();
        for(; temp != tempThree.end(); temp++) {
          if( *temp == *tempTwo ) {
            temp = tempThree.erase(temp);
            if(temp != tempThree.begin()) {
              temp--;
            }
          }
        }
      }
    }
    panel[UnLinkedPanels.at(i)]->SetLinkedWidgets(tempThree);
  }

}

//Get the label of the panel that is specfied.  This is
//mostly used in the panelForm so that the user can
//change the label.
wxStaticText * NIREPDisplay::GetPanelTitle(int panelID)
{
  return panelTitle[panelID];
}

void NIREPDisplay::OnSaveClick( wxCommandEvent& event )
{
}

void NIREPDisplay::OnOpenDisplayDescriptionClick( wxCommandEvent& event )
{
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose NIREPDisplay file"), wxT(""), wxT("*.*"), wxT("*.*"));
  if( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}
  wxString path = filedialog->GetPath();
  CreateNIREPDisplay(std::string(path.mb_str()));
  delete filedialog;
}

void NIREPDisplay::OnNewWindowClick( wxCommandEvent& event )
{
  NIREPDisplay *newNIREPDisplay = new NIREPDisplay(this->GetParent(),evaluator);
  newNIREPDisplay->Show(true);
}

void NIREPDisplay::OnCloseClick( wxCommandEvent& event )
{
  this->Close();
}

void NIREPDisplay::CreateNIREPDisplay(const std::string& FileName)
{
  this->RemoveAll();
  
  if(!FileName.empty() ) {
    if(displayDescription != NULL)
      delete displayDescription;
    displayDescription = new DisplayDescription(FileName);

    if(displayDescription->GetWidgetList()->AnyError() || displayDescription->GetEvaluatorList()->AnyError() ) {
      m_fileName = wxT("Undefined");
      return;
    }
    m_fileName = wxString(FileName.c_str(), wxConvUTF8);
  }

  // set the evaluator list
  //evaluator->SetTaskList( displayDescription->GetEvaluatorList() );

  //Set the sizer up for 100 rows and the number of columns in the NIREPDisplay
  //description.
  m_Sizer = new wxFlexGridSizer(100,displayDescription->GetDisplayAttributes()->GetColDimension(),0,0);

  

  //Add growable columns, that way when the user resizes the window
  //the views grow or shrink.
  for (unsigned int i=0; i<displayDescription->GetDisplayAttributes()->GetColDimension(); i++) {  
    m_Sizer->AddGrowableCol (i);
  }

  // TO DO : try to put a scrollbar instead of fixing rows to 100
  // TO DO : Get the labels and views together so that I don't
  //         have to to every other row as a view.

  //Make every other row, which will be the views growable,
  //this way when the user resizes the window the views 
  //resize as well.
  for( int i=1; i<displayDescription->GetDisplayAttributes()->GetRowDimension()*2; i=i+2) {
    m_Sizer->AddGrowableRow (i);
  }

  m_scrolledWindow->SetSizer(m_Sizer);

  //This is the function that places the labels and views into
  //this window.
  this->CreateGrid();

  //Set some class variables.
  this->SetProperties();

  //Need to call this so that the sizers can update and everything looks
  //decent when the windows shows up for the first time.
  this->DoLayout();
}

void NIREPDisplay::OnLockAllClick( wxCommandEvent& event )
{
  if(displayDescription == NULL) {
    return;
  }
  this->LinkViews(true);
}

void NIREPDisplay::OnLockRowsClick( wxCommandEvent& event )
{
  if(displayDescription == NULL) {
    return;
  }
  for( unsigned int j=0;j<this->displayDescription->GetDisplayAttributes()->GetRowDimension(); j++) {
    unsigned int i=0;
    for( ; i<this->GetColumns()-1; i++) {
      panel[j*this->GetColumns() + i]->GetView()->RemoveAllChildren();
      panel[j*this->GetColumns() + i]->GetView()->AddChild( panel[j*this->GetColumns() + i+1]->GetView() );
    }
    panel[ j*this->GetColumns() + i]->GetView()->AddChild(panel[j*this->GetColumns()]->GetView());
  }
}

void NIREPDisplay::OnLockColsClick( wxCommandEvent& event )
{
  if(displayDescription == NULL) {
    return;
  }
  for(unsigned int i=0 ; i<this->GetColumns(); i++) {
    unsigned int j=0;
    for(;j<this->displayDescription->GetDisplayAttributes()->GetRowDimension()-1; j++ ) {
      panel[j*this->GetColumns() + i]->GetView()->RemoveAllChildren();
      panel[j*this->GetColumns() + i]->GetView()->AddChild( panel[j*this->GetColumns() + i+this->GetColumns()]->GetView() );
    }
    panel[ j*this->GetColumns() + i]->GetView()->AddChild(panel[i]->GetView());
  }
}

void NIREPDisplay::OnUnLockAllClick( wxCommandEvent& event )
{
  if(displayDescription == NULL) {
    return;
  }
  this->LinkViews(false);
}

void NIREPDisplay::SetPresetView(int pv)
{
  if(pv == NOPRESET || pv == DATABASE_QUERY || pv == PAIRWISE_COMPARISON || pv == GROUP_WISE)
    presetView = pv;
}

int NIREPDisplay::GetPresetView()
{
  return presetView;
}

void NIREPDisplay::OnGroup1Click( wxCommandEvent& event )
{
  groupNumber = GROUP1;
  this->CreateNIREPDisplay("MenuOptions/Group1.txt");
}

void NIREPDisplay::OnGroup2Click( wxCommandEvent& event )
{
  groupNumber = GROUP2;
  this->CreateNIREPDisplay("MenuOptions/Group2.txt");
}

void NIREPDisplay::OnGroup3Click( wxCommandEvent& event )
{
  groupNumber = GROUP3;
  this->CreateNIREPDisplay("MenuOptions/Group3.txt");
}

void NIREPDisplay::OnNextGroupClick( wxCommandEvent& event )
{
  if(groupNumber == NOGROUP) {
    OnGroup1Click(event);
  }
  else if(groupNumber == GROUP1) {
    OnGroup2Click(event);
  }
  else if(groupNumber == GROUP2) {
    OnGroup3Click(event);
  }
  else if(groupNumber == GROUP3) {
    OnGroup1Click(event);
  }
}

void NIREPDisplay::OnPreviousGroupClick( wxCommandEvent& event )
{
  if(groupNumber == NOGROUP) {
    OnGroup3Click(event);
  }
  else if(groupNumber == GROUP1) {
    OnGroup3Click(event);
  }
  else if(groupNumber == GROUP2) {
    OnGroup1Click(event);
  }
  else if(groupNumber == GROUP3) {
    OnGroup2Click(event);
  }
}

void NIREPDisplay::OnAddObjectMapsClick( wxCommandEvent& event )
{
  if(groupNumber == NOGROUP) {
    this->CreateNIREPDisplay("MenuOptions/Group1ObjectMap.txt");
  }
  else if(groupNumber == GROUP1) {
    this->CreateNIREPDisplay("MenuOptions/Group1ObjectMap.txt");
  }
  else if(groupNumber == GROUP2) {
    this->CreateNIREPDisplay("MenuOptions/Group2ObjectMap.txt");
  }
  else if(groupNumber == GROUP3) {
    this->CreateNIREPDisplay("MenuOptions/Group3ObjectMap.txt");
  }
}

void NIREPDisplay::OnAddLandmarksClick( wxCommandEvent& event )
{
  this->CreateNIREPDisplay("MenuOptions/Landmarks.txt");
}

void NIREPDisplay::OnEditPanelClick( wxCommandEvent& event )
{
  if(displayDescription == NULL) {
    return;
  }
  GetPanelFromUser *temp = new GetPanelFromUser(this, this->displayDescription->GetDisplayAttributes()->GetRowDimension(),this->displayDescription->GetDisplayAttributes()->GetColDimension() );
  temp->Show();
}


void NIREPDisplay::OnAddRowClick( wxCommandEvent& event )
{
  //Make sure we update the display description with the new row dimension
  this->displayDescription->GetDisplayAttributes()->SetRowDimension( this->displayDescription->GetDisplayAttributes()->GetRowDimension() + 1 );
  //Because the Titles take up a row by themselves, we have to double the row dimension
  m_Sizer->SetRows(this->displayDescription->GetDisplayAttributes()->GetRowDimension()*2);

  //Because the Titles take up a row by themselves, we have to make both the
  //titles and the widgets growable
  m_Sizer->AddGrowableRow(this->displayDescription->GetDisplayAttributes()->GetRowDimension() - 1);
  m_Sizer->AddGrowableRow(this->displayDescription->GetDisplayAttributes()->GetRowDimension() - 2);

  //Run through a for loop to add in the Titles
  for(unsigned int i=0;i<this->displayDescription->GetDisplayAttributes()->GetColDimension(); i++) {
    //create the label
    wxStaticText* itemStaticText67 = new wxStaticText( m_scrolledWindow, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(-1,55), wxST_NO_AUTORESIZE|wxALIGN_CENTRE );

          //add the text of the label to a map so that if the user wants to change
          //the text then it is an easy lookup and change.
    panelTitle.insert(std::make_pair((this->displayDescription->GetDisplayAttributes()->GetRowDimension()-1)*this->displayDescription->GetDisplayAttributes()->GetColDimension()+i,itemStaticText67));

          //Set the color of the text
    itemStaticText67->SetForegroundColour(wxColour(129, 248, 150));

          //Set the color of the background to black
    itemStaticText67->SetBackgroundColour(wxColour(0, 0, 0));

          //Set the font but if the user wants they can change it from the panelForm
    itemStaticText67->SetFont(wxFont(20, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Tahoma")));

          //add the label to this window
    m_Sizer->Add(itemStaticText67,1, wxALL|wxEXPAND|wxGROW, 0);
  }

  //Run through a for loop to add in the Panels
  //The reason I have two seperate for loops is that items in the sizer is in a linear
  //fashion and not in a grid layout.  So if I were to add a title and then a panel
  //the panel would be where a title should be.
  for(unsigned int i=0;i<this->displayDescription->GetDisplayAttributes()->GetColDimension(); i++) {
    Panel *panelTwo = new Panel(m_scrolledWindow,this->displayDescription,  wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE);

    //set the evaluator that way the panel can get images
    panelTwo->SetEvaluator(this->evaluator);

          //set the id of the panel, this way if we need to figure out which
          //panel this is, we can call getID of the panel and do a quick
          //search in a map.
    panelTwo->SetID(panel.size());

          //the panel needs to know about the NIREPDisplay so that the panel can do
          //some global items, such as linking itself with other panels and deleting
          //itself.
    panelTwo->SetParent(this);

    panelTwo->UseBlank();

          //add the panel to the sizer
    m_Sizer->Add (panelTwo, 1, wxALL|wxEXPAND|wxGROW, 0);
    
    //push the panel onto a vector so that we can
          //do some global items, such as linking and deleting.
          //Also later on, we can go through this vector and
          //do some saving of information so that the next
          //time the user uses the program they can start
          //from where they left off.
    panel.push_back (panelTwo);
  }

  this->DoLayout();
}


void NIREPDisplay::OnAddColumnClick( wxCommandEvent& event )
{
  //Make sure we update the display description with the new column dimension
  this->displayDescription->GetDisplayAttributes()->SetColDimension( this->displayDescription->GetDisplayAttributes()->GetColDimension() + 1 );

  //increase the column size of the sizer
  m_Sizer->SetCols(this->displayDescription->GetDisplayAttributes()->GetColDimension());

  //make the new column growable
  m_Sizer->AddGrowableCol(this->displayDescription->GetDisplayAttributes()->GetColDimension() - 1);

  std::map<int, wxStaticText*> tempPanelTitle;
  int add = 0;
  int PanelTitleLocation = 0;
  this->panel.resize(this->displayDescription->GetDisplayAttributes()->GetRowDimension()*this->displayDescription->GetDisplayAttributes()->GetRowDimension());
  for(int i=0; i < this->displayDescription->GetDisplayAttributes()->GetRowDimension();i++)
  {
    for(int j=0; j < this->displayDescription->GetDisplayAttributes()->GetColDimension()-1;j++)
    {
      if(panelTitle.find(PanelTitleLocation) != panelTitle.end() ) {
        tempPanelTitle.insert(std::make_pair(PanelTitleLocation + add,panelTitle.find(PanelTitleLocation)->second));
        panel.at(PanelTitleLocation)->SetID(PanelTitleLocation + add);
      }
      PanelTitleLocation++;
    }
    add++;
  }
  panelTitle.clear();
  panelTitle = tempPanelTitle;
  //The reason I am using one for loop is that I am inserting a title and panel at the locations that
  //they need to be at.  If I try to use two for loops to first add in the titles and then the panels
  //the location of the titles will be off by one.
  for(unsigned int i=0;i<this->displayDescription->GetDisplayAttributes()->GetRowDimension(); i++) {
    //create the label
    wxStaticText* itemStaticText67 = new wxStaticText( m_scrolledWindow, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(-1,55), wxST_NO_AUTORESIZE|wxALIGN_CENTRE );

          //add the text of the label to a map so that if the user wants to change
          //the text then it is an easy lookup and change.
    int location = this->displayDescription->GetDisplayAttributes()->GetColDimension()*i + this->displayDescription->GetDisplayAttributes()->GetColDimension()-1;
    
    panelTitle.insert(std::make_pair(this->displayDescription->GetDisplayAttributes()->GetColDimension()*i + this->displayDescription->GetDisplayAttributes()->GetColDimension()-1,itemStaticText67));

          //Set the color of the text
    itemStaticText67->SetForegroundColour(wxColour(129, 248, 150));

          //Set the color of the background to black
    itemStaticText67->SetBackgroundColour(wxColour(0, 0, 0));

          //Set the font but if the user wants they can change it from the panelForm
    itemStaticText67->SetFont(wxFont(20, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Tahoma")));

          //add the label to this window
    m_Sizer->Insert(this->displayDescription->GetDisplayAttributes()->GetColDimension()*i*2 + this->displayDescription->GetDisplayAttributes()->GetColDimension()-1, itemStaticText67,1, wxALL|wxEXPAND|wxGROW, 0);

    Panel *panelTwo = new Panel(m_scrolledWindow,this->displayDescription,  wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE);

    //set the evaluator that way the panel can get images
    panelTwo->SetEvaluator(this->evaluator);

          //set the id of the panel, this way if we need to figure out which
          //panel this is, we can call getID of the panel and do a quick
          //search in a map.
    panelTwo->SetID(panel.size());

          //the panel needs to know about the NIREPDisplay so that the panel can do
          //some global items, such as linking itself with other panels and deleting
          //itself.
    panelTwo->SetParent(this);

    panelTwo->UseBlank();


    //int temp = this->displayDescription->GetDisplayAttributes()->GetColDimension()*(i+1)*2 + -1;
          //add the panel to the sizer
    m_Sizer->Insert (this->displayDescription->GetDisplayAttributes()->GetColDimension()*(i+1)*2 + -1,panelTwo, 1, wxALL|wxEXPAND|wxGROW, 0);
    
    //push the panel onto a vector so that we can
          //do some global items, such as linking and deleting.
          //Also later on, we can go through this vector and
          //do some saving of information so that the next
          //time the user uses the program they can start
          //from where they left off.
    panel.push_back (panelTwo);
  }
  this->DoLayout();
}


void NIREPDisplay::OnSingleAlgorithmComparisonClick( wxCommandEvent& event )
{
  PairwiseComparison *temp = new PairwiseComparison(this, this->displayDescription);
  temp->Show(true);
}

void NIREPDisplay::OnEditDisplayFileClick( wxCommandEvent& event )
{
  if(displayDescription == NULL) {
    return;
  }
  NIREPEditProjectFile *temp = new NIREPEditProjectFile(this,displayDescription);
  temp->Show();
}


void NIREPDisplay::OnTurnOffTitlesClick( wxCommandEvent& event )
{
  for(unsigned int i=0;i<this->displayDescription->GetDisplayAttributes()->GetRowDimension(); i++) {
    for(unsigned int j=0; j< this->displayDescription->GetDisplayAttributes()->GetColDimension(); j++) {
      m_Sizer->Show(j + i * this->displayDescription->GetDisplayAttributes()->GetColDimension() * 2, false);
    }
  }
  this->DoLayout();
}

void NIREPDisplay::OnTurnOnTitlesClick( wxCommandEvent& event )
{
  for(unsigned int i=0;i<this->displayDescription->GetDisplayAttributes()->GetRowDimension(); i++) {
    for(unsigned int j=0; j< this->displayDescription->GetDisplayAttributes()->GetColDimension(); j++) {
      m_Sizer->Show(j + i * this->displayDescription->GetDisplayAttributes()->GetColDimension() * 2, true);
    }
  }
  this->DoLayout();
}


void NIREPDisplay::OnTurnOnAllCursorsClick( wxCommandEvent& event )
{
  ShowCursors(true);
  //this->DoLayout();
}

void NIREPDisplay::OnTurnOffAllCursorsClick( wxCommandEvent& event )
{
  ShowCursors(false);
  //this->DoLayout();
}

//Show cursors in all views (true) or turn cursors off in all views (false)
void NIREPDisplay::ShowCursors(bool value)
{
  m_ShowCursors = value;

  for( unsigned int i=0; i<panel.size(); i++) {
    if (m_ShowCursors) {
      panel[i]->GetWidget()->SetShow2DAxis(true);
    } else { 
      panel[i]->GetWidget()->SetShow2DAxis(false);
    }
    panel[i]->GetWidget()->Render();
  }
}


void NIREPDisplay::EditPanel(int row, int col, bool editViewPanel)
{
  if(editViewPanel) {
    panel.at(row*this->GetColumns()+col)->PanelFrame(*(wxCommandEvent*)NULL);
    return;
  }
  std::string widgetType = panel.at(row*this->GetColumns()+col)->GetWidgetType();
  //if(widgetType == RELATIVE_OVERLAP_TEXT ||
  //   widgetType == INTENSITY_VARIANCE_TEXT ||
  //   widgetType == INVERSE_CONSISTENCY_TEXT ||
  //   widgetType ==TRANSITIVITY_ERROR_TEXT)
  if(widgetType.compare(WidgetCmd["relativeOverlapTextWidget"])    == 0 ||
     widgetType.compare(WidgetCmd["intensityVarianceTextWidget"])  == 0 ||
     widgetType.compare(WidgetCmd["inverseConsistencyTextWidget"]) == 0 ||
     widgetType.compare(WidgetCmd["transitivityErrorTextWidget"])  == 0)
  {
    EditTextPanels *editTextPanels = new EditTextPanels(this,row,col);
    editTextPanels->Show(true);
    int debugStop = 0;
  }
  //else if(widgetType == IMAGE_WIDGET ||
  //        widgetType == CHECKERBOARD_WIDGET ||
  //        widgetType == WIPE_WIDGET ||
  //        widgetType == OBJECTMAP_WIDGET ||
  //        widgetType == OVERLAY_OBJECTMAP_WIDGET ||
  //        widgetType == OVERLAY_IMAGE_WIDGET  ||
  //        widgetType == RELATIVE_OVERLAP ||
  //        widgetType == BLANK_WIDGET)
  else if(widgetType.compare(WidgetCmd["view"])             == 0 ||
          widgetType.compare(WidgetCmd["checkerboard"])     == 0 ||
          widgetType.compare(WidgetCmd["wipe"])             == 0 ||
          widgetType.compare(WidgetCmd["objectmap"])        == 0 ||
          widgetType.compare(WidgetCmd["overlayObjectMap"]) == 0 ||
          widgetType.compare(WidgetCmd["overlayImage"])     == 0 ||
          widgetType.compare(WidgetCmd["relativeOverlap"])  == 0 ||
          widgetType.compare(WidgetCmd["blankWidget"])      == 0)
  {
    panel.at(row*this->GetColumns()+col)->PanelFrame(*(wxCommandEvent*)NULL);
    int debugStop=0;
  }
}

void NIREPDisplay::UpdatePanels()
{
  for(int i=0;i<this->displayDescription->GetDisplayAttributes()->GetRowDimension();i++) {
    //Run through the columns for the labels
    for(int j=0;j<this->displayDescription->GetDisplayAttributes()->GetColDimension();j++) {
      wxStaticText *tempText = (wxStaticText*)(this->m_Sizer->GetItem(i*2*this->GetColumns()+j)->GetWindow());
      std::string whatIsThis = this->displayDescription->GetWidgetList()->GetTitle(i,j);
      wxString whatIsThisToo = tempText->GetLabel();
       tempText->SetLabel( wxString( this->displayDescription->GetWidgetList()->GetTitle(i,j).c_str(), wxConvUTF8 ) );
    }
  }
  for(unsigned int i=0;i< panel.size();i++) {
    panel[i]->UpdatePanel();
  }
}

//Since we have DisplayAttributes, need to go through
//the DisplayAttributes and distruibute the items
//that are expressed in the DisplayAttributes
//to the widgets that are identified or
//to other commands for the display of the
//widgets.
void NIREPDisplay::DistributeAttributes()
{
  
  for(DisplayAttributeCmdList::iterator i = DisplayAttributeCmd.begin(); i !=  DisplayAttributeCmd.begin(); i++) {
    std::string displayAttributeCommand = i->second;
    std::vector<std::vector<std::string> > tempTwo = displayDescription->GetDisplayAttributes()->GetAttributes()->find(displayAttributeCommand)->second;
    for(unsigned int j=0; j<tempTwo.size(); j++) {
      std::vector<std::string> tempThree = tempTwo.at(j);
      //Lock
      if(displayAttributeCommand.compare(DisplayAttributeCmd.find("Lock")->second)==0 ) {
          std::vector<int> tempFour;
          for(int k=0; k < tempThree.size(); k++) {
            tempFour.push_back(this->displayDescription->GetWidgetList()->GetLocation(tempThree.at(k) ) );
          }
          this->LinkViews(tempFour);
      }
      //CursorLocation
      else if(displayAttributeCommand.compare(DisplayAttributeCmd.find("Cursorlocation")->second)==0 ) {
        this->panel.at(this->displayDescription->GetWidgetList()->GetLocation(tempThree.at(0) ) ) ->SetCursorLocation(atoi(tempThree.at(1).c_str()),atoi(tempThree.at(2).c_str()) ); 
      }
      //Slice
      else if(displayAttributeCommand.compare(DisplayAttributeCmd.find("Slice")->second)==0 ) {
        this->panel.at(this->displayDescription->GetWidgetList()->GetLocation(tempThree.at(0) ) ) ->SetSlice(atoi(tempThree.at(1).c_str())); 
      }
      else if(displayAttributeCommand.compare(DisplayAttributeCmd.find("Orientation")->second)==0 ) {
          unsigned int ori = 0;
          if(!tempThree.at(1).compare("SAGITTAL")) {
            ori = NIREPvtkViewImage2D::SAGITTAL_ID;
          }
          else if(!tempThree.at(1).compare("CORONAL")) {
            ori = NIREPvtkViewImage2D::CORONAL_ID;
          }
          else if(!tempThree.at(1).compare("TRANSVERSE")) {
            ori = NIREPvtkViewImage2D::AXIAL_ID;
          }
          
          this->panel.at(this->displayDescription->GetWidgetList()->GetLocation(tempThree.at(0) ) ) ->SetOrientation(ori); 
      }
      else if(displayAttributeCommand.compare(DisplayAttributeCmd.find("Lockall")->second)==0 ) {
        this->LinkViews(true);
      }
    }
  }
}

//void NIREPDisplay::InsertIntoLink(int location, PanelStorage* ps)
//{
  //PanelStorage *temp = GetPanelStorage(location);
  //PanelStorage *tempTwo = temp->next;
  //temp->next = ps;
  //ps->next = tempTwo;
//}

//PanelStorage* NIREPDisplay::GetPanelStorage(int location)
//{
//  PanelStorage *temp;
//  for(int i=0;
//  return NULL;
//}