PanelForm.cxx

Go to the documentation of this file.

// 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 "PanelForm.h"
#include "Panel.h"
#include "vtkLookupTableManager.h"
#include "NIREPDisplay.h"



IMPLEMENT_DYNAMIC_CLASS( PanelForm, wxDialog )



BEGIN_EVENT_TABLE( PanelForm, wxDialog )

    EVT_BUTTON( ID_OK, PanelForm::OnOkClick )

    EVT_BUTTON( ID_CANCEL, PanelForm::OnCancelClick )

    EVT_BUTTON( ID_HELP, PanelForm::OnHelpClick )

    EVT_BUTTON( ID_DELETE, PanelForm::OnDeleteClick )

    EVT_CHOICE( ID_CHOICE, PanelForm::EnableOrDisableChoiceTwo )

    EVT_CHOICE( ID_CHOICE2, PanelForm::OnChoiceSelected )

    EVT_CHOICE( ID_CHOICE3, PanelForm::OnChoiceTwoSelected )

END_EVENT_TABLE()


PanelForm::PanelForm()
{
    Init();
}

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

    //Set panel equal to the parent which should be a panel.
    panel = (Panel*)parent;
    Create(parent, id, caption, pos, size, style);
}


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

    SetExtraStyle(wxWS_EX_BLOCK_EVENTS);
    wxDialog::Create( parent, id, caption, pos, size, style );

    CreateControls();
    if (GetSizer())
    {
        GetSizer()->SetSizeHints(this);
    }
    Centre();
    return true;
}


PanelForm::~PanelForm()
{
}


void PanelForm::Init()
{
  //viewList.Add("2DImage");
  //viewList.Add("Checkerboard");
  //viewList.Add("Wipe");
  //viewList.Add("Difference");
  //viewList.Add("ObjectMap");
  //viewList.Add("overlayObjectMap");
  //viewList.Add("overlayImage");
  //viewList.Add("relativeOverlap");
  //viewList.Add("RelativeOverlapText");
  //viewList.Add("intensittyVarianceTextWidget");
  //viewList.Add("inverseConsistencyTextWidget");
  //viewList.Add("transitivityErrorTextWidget");

  // Create a vector of widget commands for wxChoice control.
  // This control will allow the user to select the desired widget they want to use.
  WidgetCmdList::iterator iter;
  for(iter = WidgetCmd.begin(); iter != WidgetCmd.end(); iter++){
    viewList.Add(wxString(iter->second.c_str(), wxConvUTF8));
  }
}


//This is the main function of this class.  This will create
//the form for the user to change different items of the panel.
//Such as the view, the images used, color map, the label text,
//the label font the label size.
void PanelForm::CreateControls()
{    
    PanelForm* itemDialog1 = this;

    wxFlexGridSizer* itemFlexGridSizer2 = new wxFlexGridSizer(2, 1, 0, 0);
    itemFlexGridSizer2->AddGrowableRow(0);
    itemFlexGridSizer2->AddGrowableRow(1);
    itemFlexGridSizer2->AddGrowableCol(0);
    itemDialog1->SetSizer(itemFlexGridSizer2);

    wxFlexGridSizer* itemFlexGridSizer3 = new wxFlexGridSizer(2, 0, 0);
    itemFlexGridSizer3->AddGrowableCol(0);
    itemFlexGridSizer3->AddGrowableCol(1);
    itemFlexGridSizer2->Add(itemFlexGridSizer3, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText4 = new wxStaticText( itemDialog1, wxID_STATIC, _("Widget"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE );
    itemFlexGridSizer3->Add(itemStaticText4, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText5 = new wxStaticText( itemDialog1, wxID_STATIC, _("Orientation"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE );
    itemFlexGridSizer3->Add(itemStaticText5, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    
    
    view = new wxChoice( itemDialog1, ID_CHOICE, wxDefaultPosition, wxSize(135, -1), viewList, 0 );

    // Get index of the current widget type.
    int widget_index = 0;
    for(int i=0; i<viewList.size(); i++){
      if (panel->GetWidgetType().compare(std::string(viewList[i].mb_str())) == 0){
        widget_index = i;
      }
    }

    //view->SetSelection(panel->GetWidgetType());
    view->SetSelection(widget_index);
    itemFlexGridSizer3->Add(view, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);

    wxArrayString itemChoice7Strings;
    itemChoice7Strings.Add(wxT("Transverse"));
    itemChoice7Strings.Add(wxT("Sagittal"));
    itemChoice7Strings.Add(wxT("Coronal"));
    OrientationChoice = new wxChoice( itemDialog1, ID_ORIENTATION, wxDefaultPosition, wxSize(135, -1), itemChoice7Strings, 0 );
    itemFlexGridSizer3->Add(OrientationChoice, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);

    if(this->panel->GetWidget() != NULL)
      OrientationChoice->SetSelection(this->panel->GetWidget()->GetOrientation());
    wxStaticText* itemStaticText8 = new wxStaticText( itemDialog1, wxID_STATIC, _("Image One"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText8, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText9 = new wxStaticText( itemDialog1, wxID_STATIC, _("Image Two"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText9, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString itemChoice10Strings;

    //This is for the first image.
    //Get the keys and values of the evaluator list.  This way we can display to the user the different
    //images that can be displayed and used.
    panel->GetPanelParent()->GetDisplayDescription()->GetEvaluatorList()->GetTasks(&keys, &values, 1);
    int choiceOne = -1;
    for(int i=0;i<keys.size();i++)
    {
      itemChoice10Strings.Add(wxString(values[i].c_str(), wxConvUTF8));

      if(panel->GetIds().size() > 0) {
        //Figure out which image is being displayed and highlight the choice.
        if(keys[i].compare(panel->GetIds()[0])==0)
        {
          choiceOne = i;
        }
      }
    }
    ImageOneChoice = new wxChoice( itemDialog1, ID_CHOICE2, wxDefaultPosition, wxSize(135, -1), itemChoice10Strings, 0 );
    itemFlexGridSizer3->Add(ImageOneChoice, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);
    if(choiceOne != -1)
      ImageOneChoice->SetSelection(choiceOne);

    wxArrayString itemChoice11Strings;
    
    //This is for the second image.
    //Get the keys and values of the evaluator list.  This way we can display to the user the different
    //images that can be displayed and used.
    for(int i=0;i<keys.size();i++)
    {
      itemChoice11Strings.Add(wxString(values[i].c_str(), wxConvUTF8));

      //See if the panel has more then one image
      if(panel->GetIds().size() >1)
      {
        //Figure out which image is being displayed and highlight the choice.
        if(keys[i].compare(panel->GetIds()[1])==0)
        {
          choiceOne = i;
        }
      }
    }
    ImageTwoChoice = new wxChoice( itemDialog1, ID_CHOICE3, wxDefaultPosition, wxSize(135, -1), itemChoice11Strings, 0 );
    itemFlexGridSizer3->Add(ImageTwoChoice, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);

    //figure out if the panel has more then one image.  If the panel does not have more then
    //one image then set ImageTwoChoice to the first selection of the list.  Else set the
    //selection to what the panel is displaying.
    if(choiceOne != -1)
    {
      if(choiceOne == keys.size())
        ImageTwoChoice->SetSelection(1);
      else
        ImageTwoChoice->SetSelection(choiceOne);
    }

    //if the panel is just a a normal 2D view then disable ImageTwoChoice.  This will need
    //some work because its not just the normal 2D view that will disable ImageTwoChoice.
    if(panel->GetWidgetType().compare(WidgetCmd["view"]) == 0)
    {
       ImageTwoChoice->Disable();
    }

    wxStaticText* itemStaticText12 = new wxStaticText( itemDialog1, wxID_STATIC, _("Overlap Image"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText12, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText13 = new wxStaticText( itemDialog1, wxID_STATIC, _("Link Widgets"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText13, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString itemChoice14Strings;
    wxChoice* itemChoice14 = new wxChoice( itemDialog1, ID_CHOICE4, wxDefaultPosition, wxSize(135, -1), itemChoice14Strings, 0 );
    itemFlexGridSizer3->Add(itemChoice14, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);

    itemChoice14->Disable();

    
    wxArrayString itemCheckListBox15Strings;

    //Get the column dimension and the row dimension
    int colDim = panel->GetPanelParent()->GetDisplayDescription()->GetDisplayAttributes()->GetColDimension();
    int rowDim = panel->GetPanelParent()->GetDisplayDescription()->GetDisplayAttributes()->GetRowDimension();

    //Run through two for loops based on the rows and columns.  What we will
    //be doing is adding the string names of the panels so that we can do linking.
    //To do that, we have to start with W, then append the row number, then append
    //a comma and then append the column
    for(int i=0; i < rowDim; i++)
    {
      for(int j=0; j<colDim; j++)
      {
        if( (i*colDim+j) != panel->GetID() )
        {
          std::string s = "W";
          std::stringstream row;
          row << (i+1);
          std::stringstream col;
          col << (j+1);
          s = s.append(row.str());
          s = s.append(",");
          s = s.append(col.str());
          itemCheckListBox15Strings.Add(wxString(s.c_str(), wxConvUTF8));
        }
        else
        {
          PanelName = "W";
          std::stringstream row;
          row << (i+1);
          std::stringstream col;
          col << (j+1);
          PanelName = PanelName.append(row.str());
          PanelName = PanelName.append(",");
          PanelName = PanelName.append(col.str());
        }
      }
    }
    
    LinkWidgetsCheckList = new wxCheckListBox( itemDialog1, ID_CHECKLISTBOX, wxDefaultPosition, wxDefaultSize, itemCheckListBox15Strings, wxLB_SINGLE );

    //Run through the rows and columns and the size of the vector of linked widgets for the panel.
    //We will be checking those panels that are linked with the panel.  We need to take into
    //account that the panel is part of the vector.
    for(int i=0; i < rowDim; i++)
    {
      for(int j=0; j<colDim; j++)
      {
        for( int k=0; k < panel->GetLinkedWidgets().size(); k++)
        {
          if( (i*colDim+j) == panel->GetLinkedWidgets().at(k))
          {
            //This is taking into account that the panel is part of the vector.
            
            if((i*colDim+j) < panel->GetID() )
            {
              LinkWidgetsCheckList->Check(i*colDim+j);
            }
            else if( (i*colDim+j) != panel->GetID() )
            {
              //Skip over the panel and minus one from the check image because
              //we did the skip.
              LinkWidgetsCheckList->Check(i*colDim+j-1);
            }
          }
        }
      }
    }
    itemFlexGridSizer3->Add(LinkWidgetsCheckList, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);

    wxStaticText* itemStaticText16 = new wxStaticText( itemDialog1, wxID_STATIC, _("Color Map"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText16, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxArrayString itemChoice17Strings;
    //set up the choices of the color maps
    itemChoice17Strings.Add(wxT("B/W"));
    itemChoice17Strings.Add(wxT("B/W Inverse"));
    itemChoice17Strings.Add(wxT("Spectrum"));
    itemChoice17Strings.Add(wxT("HotMetal"));
    itemChoice17Strings.Add(wxT("GEColor"));
    itemChoice17Strings.Add(wxT("Flow"));
    itemChoice17Strings.Add(wxT("LONI"));
    itemChoice17Strings.Add(wxT("LONI2"));
    itemChoice17Strings.Add(wxT("Asymmetry"));
    itemChoice17Strings.Add(wxT("P-Value"));
    itemChoice17Strings.Add(wxT("ROI"));
    itemChoice17Strings.Add(wxT("Other"));
    colorMapChoices = new wxChoice( itemDialog1, ID_CHOICE5, wxDefaultPosition, wxSize(135, -1), itemChoice17Strings, 0 );
    int selection = panel->GetLookupTableSelection();
    colorMapChoices->SetSelection(panel->GetLookupTableSelection());
    itemFlexGridSizer3->Add(colorMapChoices, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_TOP|wxALL, 5);

    wxStaticText* itemStaticText19 = new wxStaticText( itemDialog1, wxID_STATIC, _("Title Text"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText19, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText20 = new wxStaticText( itemDialog1, wxID_STATIC, _("Font, Size, Color"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText20, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText *st = panel->GetPanelParent()->GetPanelTitle(panel->GetID());

    if(st != NULL) {
      wxString labelString = st->GetLabel();
      PanelTitle = new wxTextCtrl( itemDialog1, ID_TEXTCTRL12, labelString, wxDefaultPosition, wxDefaultSize, 0 );
      itemFlexGridSizer3->Add(PanelTitle, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    }
    else {
      PanelTitle = new wxTextCtrl( itemDialog1, ID_TEXTCTRL12, wxT(""), wxDefaultPosition, wxDefaultSize, 0 );
      itemFlexGridSizer3->Add(PanelTitle, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    }
    TitleFontPicker = new wxFontPickerCtrl( itemDialog1, ID_FONTCTRL, wxFont(), wxDefaultPosition, wxDefaultSize, wxFNTP_DEFAULT_STYLE|wxFNTP_FONTDESC_AS_LABEL|wxFNTP_USEFONT_FOR_LABEL );
    itemFlexGridSizer3->Add(TitleFontPicker, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    if(st != NULL)
      TitleFontPicker->SetSelectedFont(st->GetFont());
    wxStaticText* itemStaticText21 = new wxStaticText( itemDialog1, wxID_STATIC, _("Min"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText21, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText22 = new wxStaticText( itemDialog1, wxID_STATIC, _("Max"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(itemStaticText22, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
    

    minSize = new wxTextCtrl( itemDialog1, wxID_ANY, _(""), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(minSize, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    maxSize = new wxTextCtrl( itemDialog1, wxID_ANY, _(""), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer3->Add(maxSize, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);


    //Add another sizer for the four buttons.
    wxFlexGridSizer* itemFlexGridSizer18 = new wxFlexGridSizer(1, 4, 0, 0);
    itemFlexGridSizer18->AddGrowableRow(0);
    itemFlexGridSizer18->AddGrowableCol(0);
    itemFlexGridSizer18->AddGrowableCol(1);
    itemFlexGridSizer18->AddGrowableCol(2);
    itemFlexGridSizer18->AddGrowableCol(3);
    itemFlexGridSizer2->Add(itemFlexGridSizer18, 0, wxGROW|wxGROW|wxALL, 5);

    wxButton* itemButton19 = new wxButton( itemDialog1, ID_OK, _("Ok"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer18->Add(itemButton19, 0, wxGROW|wxGROW|wxALL, 5);

    wxButton* itemButton20 = new wxButton( itemDialog1, ID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer18->Add(itemButton20, 0, wxGROW|wxGROW|wxALL, 5);

    wxButton* itemButton21 = new wxButton( itemDialog1, ID_HELP, _("Help"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer18->Add(itemButton21, 0, wxGROW|wxGROW|wxALL, 5);

    wxButton* itemButton22 = new wxButton( itemDialog1, ID_DELETE, _("Delete Widget"), wxDefaultPosition, wxDefaultSize, 0 );
    itemFlexGridSizer18->Add(itemButton22, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);

    //if( view->GetCurrentSelection() == 4 ||view->GetCurrentSelection() == 5 || view->GetCurrentSelection() == 7)
    std::string widget_type = std::string(viewList[view->GetCurrentSelection()].mb_str());
    if(widget_type.compare(WidgetCmd["overlayObjectMap"]) == 0 ||
       widget_type.compare(WidgetCmd["overlayImage"    ]) == 0 ||
       widget_type.compare(WidgetCmd["relativeOverlap" ]) == 0)
    {
      int count = colorMapChoices->GetCount();
      colorMapChoices->SetSelection(count -1);
      colorMapChoices->Enable(false);
      //colorMapChoices->setSelection();
    }
    else
    {
      colorMapChoices->Enable();
    }
}


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

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

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


//This function takes care of updating the panel when the user
//presses okay.  
void PanelForm::OnOkClick( wxCommandEvent& event )
{
  //Get the label of the panel
  wxStaticText *st = panel->GetPanelParent()->GetPanelTitle(panel->GetID());

  if(st != NULL) {
    //Set the text of the label to what the user put in.
    st->SetLabel(PanelTitle->GetValue());

    //Set the font to what the user choose.
    st->SetFont(TitleFontPicker->GetSelectedFont());
  }

  //Get the image choices
  int oneChoice = ImageOneChoice->GetCurrentSelection();
  int twoChoice = ImageTwoChoice->GetCurrentSelection();

  //Clear the ids of the panel
  panel->ClearIds();

  //Set the ids of the panel.  Might want to check to see if the
  //ids match and if they do, do nothing.
  panel->SetIds(keys[oneChoice]);

  //panel->GetWidget()->Clear();

  //Get the color map choice
  int colorMapChoice = colorMapChoices->GetCurrentSelection();

  //Get the min size
  wxString min = minSize->GetValue();
  double mins;

  //change the min size to a double
  min.ToDouble(&mins);
  double maxs;

  //get the max size
  wxString max = maxSize->GetValue();

  //change the max size to a double
  max.ToDouble(&maxs);

 
  panel->SetOrientation(OrientationChoice->GetSelection());

  //Get the string representation of the widget that is selected
  //std::string temp = view->GetString(view->GetCurrentSelection()).c_str();
  std::string widget_type = std::string(viewList[view->GetCurrentSelection()].mb_str());

  //figure out which view the user wants and have the panel use it.
  //if(viewList[8]==temp)
  //{
  //  panel->SetIds(keys[twoChoice]);
  //  panel->UseRelativeOverlapTextStatistic();
  //  this->Close();
  //  event.Skip();
  //  return;
  //}
  //else if(viewList[0]==temp)
  if(widget_type.compare(WidgetCmd["view"]) == 0)
  {
    panel->UseImage();

    //This is where the min and max size comes into play.  I need
    //to update the other views to accept this.
    //panel->GetWidget()->GetLookupTable()->SetRange(mins,maxs);
  }
  //else if(viewList[1]==temp)
  else if(widget_type.compare(WidgetCmd["checkerboard"]) == 0)
  {
    panel->SetIds(keys[twoChoice]);
    panel->UseCheckerboard();
  }
  //else if(viewList[2]==temp)
  else if(widget_type.compare(WidgetCmd["wipe"]) == 0)
  {
    panel->SetIds(keys[twoChoice]);
    panel->UseWipe();
  }
  //else if(viewList[3]==temp)
  else if(widget_type.compare(WidgetCmd["objectmap"]) == 0)
  {
    panel->SetIds(keys[twoChoice]);
    panel->UseObjectMap();
  }
  //else if(viewList[4]==temp)
  else if(widget_type.compare(WidgetCmd["overlayObjectMap"]) == 0)
  {
    panel->SetIds(keys[twoChoice]);
    panel->UseOverlayObjectMap();
  }
  //else if(viewList[5]==temp)
  else if(widget_type.compare(WidgetCmd["overlayImage"]) == 0)
  {
    panel->SetIds(keys[twoChoice]);
    panel->UseOverlayImage();
  }
  //else if(viewList[6]==temp)
  else if(widget_type.compare(WidgetCmd["relativeOverlap"]) == 0)
  {
    panel->SetIds(keys[twoChoice]);
    panel->UseRelativeOverlap();
  }       
  else if(widget_type.compare(WidgetCmd["relativeOverlapTextWidget"]) == 0) {
    panel->SetIds(keys[twoChoice]);
    panel->UseRelativeOverlapTextStatistic();
    this->Close();
    event.Skip();
    return;
  }
  // GEC: Added the following widgets based on the relativeOverlapTextStatistic above
  // I am not sure if the panel->SetIds(keys[twoChoice]); command is correct
  else if(widget_type.compare(WidgetCmd["intensityVarianceTextWidget"]) == 0) {
    panel->SetIds(keys[twoChoice]);
    panel->UseIntensityVarianceTextStatistic();
    this->Close();
    event.Skip();
    return;
  }
  else if(widget_type.compare(WidgetCmd["inverseConsistencyTextWidget"]) == 0) {
    panel->SetIds(keys[twoChoice]);
    panel->UseInverseConsistencyTextStatistic();
    this->Close();
    event.Skip();
    return;
  }
  else if(widget_type.compare(WidgetCmd["transitivityErrorTextWidget"]) == 0) {
    panel->SetIds(keys[twoChoice]);
    panel->UseTransitivityErrorTextStatistic();
    this->Close();
    event.Skip();
    return;
  }
  else if(widget_type.compare(WidgetCmd["varianceTransformText"]) == 0) {
    panel->SetIds(keys[twoChoice]);
    panel->UseVarianceTransformTextStatistic();
    this->Close();
    event.Skip();
    return;
  }
  else if(widget_type.compare(WidgetCmd["varianceImageText"]) == 0) {
    panel->SetIds(keys[twoChoice]);
    panel->UseVarianceImageTextStatistic();
    this->Close();
    event.Skip();
    return;
  }

  //make sure the color map is not other.  If it is, then it
  //is most likely a colormap, which I don't want to deal
  //with right now.
  //if(colorMapChoice != OTHER )
  //{
  //  vtkLookupTableManager *tempTwo = vtkLookupTableManager::New();
  //  vtkLookupTable *temp = tempTwo->GetLookupTable(colorMapChoice);
  //  // = vtkLookupTableManager::GetLookupTable(colorMapChoice);
  //  panel->SetLookUpTable(temp,colorMapChoice);
  //  temp->Delete();
  //  tempTwo->Delete();
  //}

  //panel->GetWidget()->SetBackgroundColor(0,0,0);

 
  //Figure out which other panels the user wants to be
  //linked to the panel associated with this panel form.
  int numSelects = LinkWidgetsCheckList->GetCount();
  std::vector<int> lw;
  lw.push_back(panel->GetID());
  std::vector<int> unlw;

  //Run through a for loop and convert the strings
  //into numbers so that it is easier to do the
  //linking.
  for(int i=0;i<numSelects;i++)
  {
    double col;
    double row;
    std::string line = std::string(LinkWidgetsCheckList->GetString(i).mb_str());
    size_t found = line.find_first_of(",");

    std::string id(line, 1,found);
    wxString wxID = wxString(id.c_str(), wxConvUTF8);
    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 = wxString(idTwo.c_str(), wxConvUTF8);
    wxIDTwo.Trim();
    wxIDTwo.Trim(false);
    idTwo = wxIDTwo.ToAscii();

    wxIDTwo.ToDouble(&col);
    wxID.ToDouble(&row);
    int tempTwo = ((int)row-1)*panel->GetPanelParent()->GetColumns()+(int)col-1;

    //Figure out if the current panel item is supposed to 
    //be linked or not and place it into the respective
    //vector.
    if(LinkWidgetsCheckList->IsChecked(i))
    {
      
      lw.push_back(tempTwo);

    }
    else
    {
      unlw.push_back(tempTwo);
    }
  }

  //Set the panel with the linked widgets.
  panel->SetLinkedWidgets(lw);

  //Link the panels up.
  panel->GetPanelParent()->LinkViews(lw);

  //Unlink any views that have a panel that should
  //not be linked to the panel associated with this form.
  panel->GetPanelParent()->UnLinkViews(lw, unlw);

  

  //Close this window
  this->Close();
    event.Skip();
}


//Don't do anything but close this window if the user hit close.
void PanelForm::OnCancelClick( wxCommandEvent& event )
{
  this->Close();
    event.Skip();
}


//Have not figured out what we will do when the user
//hits the help button.  Currently it does nothing.
void PanelForm::OnHelpClick( wxCommandEvent& event )
{
    event.Skip();
}


//Currently the way to delete a panel is not correctly
//done so this is doing nothing.  Eventually this will
//allow a user to delete the panel.
void PanelForm::OnDeleteClick( wxCommandEvent& event )
{
  
  this->Close();
  panel->Delete();
}

void PanelForm::EnableOrDisableChoiceTwo( wxCommandEvent& event )
{
  //Figure out if ImageTwoChoice should be enabled or disabled on the fly.
  if(ImageTwoChoice->IsEnabled() && view->GetCurrentSelection() == 0 || view->GetCurrentSelection() == 4)
  {
    ImageTwoChoice->Disable();
  }
  else if(!ImageTwoChoice->IsEnabled() && view->GetCurrentSelection() != 0)
  {
    ImageTwoChoice->Enable();
  }

  

  if(view->GetCurrentSelection() == 4 || view->GetCurrentSelection() == 5 || view->GetCurrentSelection() == 7)
  {
    int count = colorMapChoices->GetCount();
    colorMapChoices->SetSelection(count -1);
    colorMapChoices->Enable(false);
    //colorMapChoices->setSelection();
  }
  else
  {
    colorMapChoices->Enable();
  }
}

void PanelForm::OnChoiceSelected( wxCommandEvent& event )
{
    ImageOneChoice->SetToolTip(ImageOneChoice->GetString(event.GetSelection()));
}

void PanelForm::OnChoiceTwoSelected( wxCommandEvent& event )
{
    ImageTwoChoice->SetToolTip(ImageTwoChoice->GetString(event.GetSelection()));
}