WidgetList.cxx

Go to the documentation of this file.

#include "WidgetList.h"

#include "NIREPDefinitions.h"
#include <algorithm>

#define WIDGETLIST 1


WidgetList::WidgetList(VariableList* vList, DisplayAttributes *da)
{
  error = false;
  vars = NULL;
  displayAttributes = NULL;
  this->SetVarList(vList);
  this->SetDisplayAttributes(da);
}

WidgetList::WidgetList(const std::string& fileName, VariableList* vList, DisplayAttributes *da)
{
  vars = NULL;
  displayAttributes = NULL;
  this->SetDisplayAttributes(da);
  this->SetVarList(vList);
  error = this->Read(fileName);
}

WidgetList::~WidgetList()
{
  //This class does not own vars or displayAttributes
  //so therefore we do not destroy them but set them
  //to NULL.
  vars = NULL;
  displayAttributes = NULL;
}


void WidgetList::SetDisplayAttributes(DisplayAttributes* da)
{
  if(da == NULL)
    return;
  displayAttributes = da;
}

void WidgetList::SetVarList(VariableList* list)
{
  if(list == NULL)
    return;
  this->vars = list;
}
//read in text description and populate the widget list
bool WidgetList::Read(const std::string& fileName)
{
  this->widget.clear();
  if(displayAttributes->AnyError() )
    return true;
  if(displayAttributes != NULL) {
    this->widget.resize(displayAttributes->GetColDimension()*displayAttributes->GetRowDimension());
  }
  
        std::ifstream file (fileName.c_str());
  int list = 0;
  if (file.is_open())
  {
    std::string line;
    while (! file.eof() )
    {
      getline (file,line);

      // Convert line to all lower case for comparison
      std::transform(line.begin(), line.end(), line.begin(), ::tolower);
      if(line.size() > 0)
      {
          //Run through an if statment.  If we have not hit
          //the begin WidgetList then we are going to be
          //looking for a begin widgetList or columnSize
          //or rowSize.  If we have hit the beginWidgetList
          //then either look for the End WidgetList or
          //insert the items into the vector at the locations
          //specified in the file.  In the file, there should
          //be a line like:
          //  W1,1 = view(_A1, Transverse)
          //  This example will place a view widget at 
          //row 1, column 1.
          if(list == 0)
          {
            if(!line.compare("begin widgetlist"))
            {
              list = WIDGETLIST;
            }
          }
          else if(list == WIDGETLIST) {
            if(!line.compare("end widgetlist")) {
              list =0;
            }
            else if(line.compare("") != 0) {
              
              // Find position of = in widget command 
              size_t index1 = line.find_first_of("=");

              // Load function string with RHS of widget command
              std::string function(line, index1+1,line.length());
              wxString wxFunction(function.c_str(), wxConvUTF8);
              wxFunction.Trim();
              wxFunction.Trim(false);
              function = wxFunction.ToAscii();

              // Set loc to the single index of widget command
              int loc = this->GetLocation(line);
              if(loc >= 0) {
                this->widget[loc] = function;
                std::string widget_type = this->GetWidgetType(loc);
                bool isCommand = false;

                // Loop through list of widget commands to determine if widget_type
                // is a valid widget command.
                WidgetCmdList::iterator iter;
                for(iter = WidgetCmd.begin(); iter != WidgetCmd.end(); iter++){
                  if(!iter->second.compare(widget_type )) {
                     isCommand = true;
                  }
                }

                if(!isCommand) {
                  wxString temp(wxT("Error: Unknown widget command: "));
                  temp.Append(wxString::Format (wxT("%s for %s"), widget_type.c_str(), line.c_str()));
                  wxLogError(temp);
                  return true;
                }
              }
            }
          }
          
      }
    }
    
    file.close();
    return false;
    
  }

  wxString temp(wxT("Error: Could not open file: "));
  temp.Append(wxString::Format (wxT("%s"), fileName.c_str()));
  wxLogError(temp);
  return true;
}

void WidgetList::Write(const std::string& fileName)
{
}


//Need to use this one.
std::string WidgetList::GetWidgetType(int row, int col)
{
  std::string temp = widget.at((row)*this->displayAttributes->GetColDimension()+col);
  size_t tempThree = temp.find_first_of("(");
  std::string type(temp, 0,tempThree);
  return type;
}

//Need to use this one.
std::string WidgetList::GetWidgetType(int location)
{
  std::string temp = widget.at(location);
  size_t tempThree = temp.find_first_of("(");
  std::string type(temp, 0,tempThree);
  return type;
}


void WidgetList::SetWidgetType(std::string widgetName, std::string type)
{
//  widget[widgetName] = type;
}

std::vector<std::string> WidgetList::GetWidgetParameters (int row, int col)
{
  std::vector<std::string> Parameters;
  std::string temp = widget.at((row)*this->displayAttributes->GetColDimension()+col);
  size_t tempTwo = temp.find_first_of("(");
  size_t tempThree = temp.find_last_of(")");
  size_t tempFour = temp.find_first_of(",");
  if(tempThree < tempFour)
  {
    std::string parameter(temp, (tempTwo+1), (tempThree-tempTwo-1));
    Parameters.push_back(parameter);
  }
  else
  {
    std::string parameter(temp, tempTwo+1, tempFour-tempTwo-1);
    Parameters.push_back(parameter);
    while(tempFour != std::string::npos)
    {
      size_t tempFive = tempFour;
      tempFour= temp.find(",",tempFour+1);
      if(tempFour == std::string::npos)
      {
        std::string parameterThree(temp, tempFive+1, tempThree-tempFive-1);
        Parameters.push_back(parameterThree);
      }
      else
      {
        std::string parameterTwo(temp, tempFive+1, tempFour-tempFive-1);
        Parameters.push_back(parameterTwo);
      }
    }
  }
  for(unsigned int i=0; i < Parameters.size(); i++) {
    Parameters[i] = this->vars->UpdateString(Parameters[i]);
  }
  return Parameters;
}

std::string WidgetList::GetTitle(int row, int col)
{
  std::vector<std::string> params = this->GetWidgetParameters(row, col);
  std::string title = params.at(params.size()-1).c_str();
  return this->vars->UpdateString(title);
}

// Note that this function expects widgets to be in the form
// w1,1 where the w can be upper case or lower case
int WidgetList::GetLocation(std::string line)
{
  // Convert line to lower case for comparison
  // Do it in place by providing the same start iterator
  // for both the input and output strings
  std::transform(line.begin(), line.end(), line.begin(), ::tolower);

  //Get the column that the widget is supposed to be in
  size_t index1 = line.find_first_of("w");
  size_t index2 = line.find_first_of(",");
  size_t num = index2 - index1 - 1;
          
  std::string id(line, index1+1,num);
  wxString wxID(id.c_str(), wxConvUTF8);
  wxID.Trim();
  wxID.Trim(false);

  //Get the row that the widget is supposed to be in
  size_t index3 = line.find_first_of("=");
  num = index3 - index2 - 1;

  /*if( foundTwo == std::string::npos ) {
    wxString temp = "Error: Missing equal sign in the line: ";
    temp.Append(wxString::Format ("%s", _(line.c_str())));
    ::wxLogError(temp);
    return true;
  }*/
  std::string idTwo(line, index2+1,num);
  wxString wxIDTwo(idTwo.c_str(), wxConvUTF8);
  wxIDTwo.Trim();
  wxIDTwo.Trim(false);
  idTwo = wxIDTwo.ToAscii();

  long int col;
  wxIDTwo.ToLong(&col);
  long int row;
  //wxString wxID;
  wxID.ToLong(&row);
  return ((int)row-1)*this->displayAttributes->GetColDimension()+(int)col-1;
}