Optika_ArrayWidget.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//         Optika: A Tool For Developing Parameter Obtaining GUIs
//                Copyright (2009) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, with Sandia Corporation, the 
// U.S. Government retains certain rights in this software.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Kurtis Nusbaum (klnusbaum@gmail.com) 
// 
// ***********************************************************************
// @HEADER
#ifndef OPTIKA_ARRAYWIDGET_HPP_
#define OPTIKA_ARRAYWIDGET_HPP_

#include <QDialog>
#include <QModelIndex>
#include <QPushButton>
#include <QGridLayout>
#include <QDoubleSpinBox>
#include <QComboBox>
#include <QLineEdit>
#include <QGridLayout>
#include <QScrollArea>
#include <QLabel>
#include <vector>
#include "Optika_treemodel.hpp"
#include "Optika_FileNameWidget.hpp"
#include "Optika_ValidatorApplier.hpp"

namespace Optika {

template<class S>
class GenericArrayWidget : public QDialog{

public:


  GenericArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0);

  const QString getType() const {
    return type;
  }

  const QString getName() const{
    return name;
  }

  const RCP<const ParameterEntryValidator> getEntryValidator() const{
    return entryValidator;
  }

  virtual void accept() =0;


protected: 

  //@[

  virtual void setupArrayLayout(){
    if(arrayContainer->layout() == NULL){
      arrayContainer->setLayout(getArrayLayout());
    }
  }

  virtual QLayout* getArrayLayout() =0;  

  virtual void doAcceptWork() =0;




  QWidget *arrayContainer;

  

private:


  QString type;

  QString name;

  RCP<const ParameterEntryValidator> entryValidator;  

};

template<class S>
GenericArrayWidget<S>::GenericArrayWidget(
  QString name, 
  QString type, 
  const RCP<const ParameterEntryValidator> validator,
  QWidget *parent):
  QDialog(parent),
  type(type),
  name(name),
  entryValidator(validator)
{
  setModal(true);
  setSizeGripEnabled(true);
  arrayContainer = new QWidget(this);

  QScrollArea *scrollArea = new QScrollArea(this);
  scrollArea->setWidget(arrayContainer);
  scrollArea->setWidgetResizable(true);

  QPushButton *doneButton = new QPushButton(tr("Done"));
  QPushButton *cancelButton = new QPushButton(tr("Cancel"));
  connect(doneButton, SIGNAL(clicked(bool)), this, SLOT(accept()));
  connect(cancelButton, SIGNAL(clicked(bool)), this, SLOT(reject()));
  QGridLayout *layout = new QGridLayout(this);
  layout->addWidget(scrollArea,0,0,1,3);
  layout->addWidget(doneButton,1,2);
  layout->addWidget(cancelButton,1,1);

  this->setLayout(layout);

  setWindowTitle(name);
}

template <class S>
class Generic2DArrayWidget : public GenericArrayWidget<S>{

public:
  

  Generic2DArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0);



  void initData(TwoDArray<S> array){
    baseArray = array;
    this->setupArrayLayout();
  }

  TwoDArray<S> getArrayFromWidgets(){
    Teuchos::TwoDArray<QWidget*>::size_type numRows = 
      widgetArray.getNumRows()-1;
    Teuchos::TwoDArray<QWidget*>::size_type numCols = 
      widgetArray.getNumCols()-1;
    TwoDArray<S> toReturn(
      numRows, numCols);
    int numColsToIterate =0;
    for(int i=0; i<numRows; ++i){
      numColsToIterate = baseArray.isSymmetrical() ? 
        numCols-numRows+i : numCols;
      for(int j=0; j<numColsToIterate; ++j){
        toReturn(i,j) = getWidgetValue(i+1,j+1);
      }
    }
    toReturn.setSymmetrical(baseArray.isSymmetrical());
    return toReturn;
  }

  virtual S getWidgetValue(int row, int col) = 0;

  inline TwoDArray<S> getData() const{
    return baseArray;
  }


protected:
  

  void doAcceptWork(){
    baseArray.clear();
    baseArray = getArrayFromWidgets();
    this->done(QDialog::Accepted);
  }

  virtual QWidget* getEditorWidget(int row, int col) =0;



  TwoDArray<QWidget*> widgetArray;

  TwoDArray<S> baseArray;


private:


  QLayout* getArrayLayout();

};

template<class S>
Generic2DArrayWidget<S>::Generic2DArrayWidget(
  QString name, 
  QString type, 
  const RCP<const ParameterEntryValidator> validator,
  QWidget *parent):
  GenericArrayWidget<S>(name, type, validator, parent)
{}


template<class S>
QLayout* Generic2DArrayWidget<S>::getArrayLayout(){
 widgetArray = TwoDArray<QWidget*>(baseArray.getNumRows()+1, baseArray.getNumCols()+1);
 QGridLayout *widgetLayout = new QGridLayout;
  for(int i =0; i < baseArray.getNumCols(); ++i){
    widgetLayout->addWidget(new QLabel("Column: " +QString::number(i)),0,i+1,Qt::AlignLeft);
  }
  for(int i =0; i < baseArray.getNumRows(); ++i){
    widgetLayout->addWidget(new QLabel("Row: " +QString::number(i)),i+1,0,Qt::AlignLeft);
  }
  int numColsToIterate =0;
  for(int i =0; i < baseArray.getNumRows(); ++i){
    numColsToIterate = baseArray.isSymmetrical() ? 
      baseArray.getNumCols()-baseArray.getNumRows()+i : baseArray.getNumCols();
    for(int j =0; j < numColsToIterate; ++j){
      QWidget* editorWidget = getEditorWidget(i,j);
      widgetLayout->addWidget(editorWidget,i+1,j+1,Qt::AlignLeft);
      widgetArray(i+1,j+1) = editorWidget;
    }
  }
  return widgetLayout;
}

class Int2DArrayWidget : public Generic2DArrayWidget<int>{
Q_OBJECT
public:


  Int2DArrayWidget(
    QString name,
    QString type,
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic2DArrayWidget<int>(name, type, validator, parent)
  {}



  inline int getWidgetValue(int row, int col){
    return ((QSpinBox*)widgetArray(row,col))->value();
  }

protected:

  QWidget* getEditorWidget(int row, int col){
    QSpinBox *newSpin = new QSpinBox(this);
    RCP<const EnhancedNumberValidator<int> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const TwoDArrayValidator<EnhancedNumberValidator<int>, int> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<int>::applyToSpinBox(validator, newSpin);
    newSpin->setValue(baseArray(row, col));
    return newSpin;
  }


public slots:

  void accept(){
    doAcceptWork();
  }


};

class Short2DArrayWidget : public Generic2DArrayWidget<short>{
Q_OBJECT
public:


  Short2DArrayWidget(
    QString name,
    QString type,
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic2DArrayWidget<short>(name, type, validator, parent)
  {}



  inline short getWidgetValue(int row, int col){
    return ((QSpinBox*)widgetArray(row,col))->value();
  }

protected:

  QWidget* getEditorWidget(int row, int col){
    QSpinBox *newSpin = new QSpinBox(this);
    RCP<const EnhancedNumberValidator<short> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const TwoDArrayValidator<EnhancedNumberValidator<short>, short> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<short>::applyToSpinBox(validator, newSpin);
    newSpin->setValue(baseArray(row, col));
    return newSpin;
  }


public slots:


  void accept(){
    doAcceptWork();
  }


};

class Double2DArrayWidget : public Generic2DArrayWidget<double>{
Q_OBJECT
public:


  Double2DArrayWidget(
    QString name,
    QString type,
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic2DArrayWidget<double>(name, type, validator, parent)
  {}



  inline double getWidgetValue(int row, int col){
    return ((QLineEdit*)widgetArray(row,col))->text().toDouble();
  }

protected:

  QWidget* getEditorWidget(int row, int col){
    QLineEdit *newEdit = new QLineEdit(this);
    RCP<const EnhancedNumberValidator<double> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const TwoDArrayValidator<EnhancedNumberValidator<double>, double> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<double>::applyToLineEdit(validator, newEdit);
    newEdit->setText(QString::number(baseArray(row,col)));
    return newEdit;
  }


public slots:


  void accept(){
    doAcceptWork();
  }


};

class Float2DArrayWidget : public Generic2DArrayWidget<float>{
Q_OBJECT
public:


  Float2DArrayWidget(
    QString name,
    QString type,
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic2DArrayWidget<float>(name, type, validator, parent)
  {}



  inline float getWidgetValue(int row, int col){
    return ((QLineEdit*)widgetArray(row,col))->text().toDouble();
  }

protected:

  QWidget* getEditorWidget(int row, int col){
    QLineEdit *newEdit = new QLineEdit(this);
    RCP<const EnhancedNumberValidator<float> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const TwoDArrayValidator<EnhancedNumberValidator<float>, float> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<float>::applyToLineEdit(validator, newEdit);
    newEdit->setText(QString::number(baseArray(row,col)));
    return newEdit;
  }


public slots:


  void accept(){
    doAcceptWork();
  }


};

class String2DArrayWidget : public Generic2DArrayWidget<std::string>{
Q_OBJECT
public:


  String2DArrayWidget(
    QString name,
    QString type,
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic2DArrayWidget<std::string>(name, type, validator, parent)
  {}



  std::string getWidgetValue(int row, int col){
    if(is_null(getEntryValidator())){
       return ((QLineEdit*)widgetArray(row,col))->text().toStdString();
    }
    else if(!is_null(rcp_dynamic_cast<const ArrayValidator<FileNameValidator, std::string> >(getEntryValidator()))){
       return ((FileNameWidget*)widgetArray(row,col))->getCurrentFileName().toStdString();
    }
    else if(getEntryValidator()->validStringValues()->size() !=0){
       return  ((QComboBox*)widgetArray(row,col))->currentText().toStdString();
    }
    else{
       return  ((QLineEdit*)widgetArray(row,col))->text().toStdString();
    }
  }

protected:

  QWidget* getEditorWidget(int row, int col){
    QString currentData = QString::fromStdString(baseArray(row,col));
    if(is_null(getEntryValidator())){
      return new QLineEdit(currentData,this);
    }
    else if(!is_null(rcp_dynamic_cast<const TwoDArrayValidator<FileNameValidator, std::string> >(getEntryValidator()))){
      return new FileNameWidget(
        currentData, 
        rcp_dynamic_cast<const TwoDArrayValidator<FileNameValidator, std::string> >(getEntryValidator())->getPrototype()->fileMustExist(), this);
    }
    else if(getEntryValidator()->validStringValues()->size() != 0){
      RCP<const Array<std::string> > options = getEntryValidator()->validStringValues();
      QComboBox *newCombo = new QComboBox(this);
      for(Array<std::string>::const_iterator itr = options->begin(); itr != options->end(); ++itr){
        newCombo->addItem(QString::fromStdString(*itr));
      }
      int selectedItem = newCombo->findText(currentData);
      newCombo->setCurrentIndex(selectedItem);
      return newCombo;
    }
    else{
      return new QLineEdit(currentData,this);
    }
  }


public slots:

  void accept(){
    doAcceptWork();
  }


};

template <class S>
class Generic1DArrayWidget : public GenericArrayWidget<S>{
public:


  Generic1DArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0);

  



  const Array<S> getData() const{
    return baseArray;
  }




  void initData(Array<S> array){
    baseArray = array;
    this->setupArrayLayout();
  }

  virtual QWidget* getEditorWidget(int index) = 0;

  virtual Array<S> getArrayFromWidgets() = 0;



protected:


  typedef std::vector<QWidget*> WVector;



  WVector widgetVector;

  Array<S> baseArray;
  


  void doAcceptWork();


private:


  QLayout* getArrayLayout();

};

template<class S>
Generic1DArrayWidget<S>::Generic1DArrayWidget(
  QString name, 
  QString type, 
  const RCP<const ParameterEntryValidator> validator,
  QWidget *parent):
  GenericArrayWidget<S>(name, type, validator, parent)
{}


template<class S>
QLayout* Generic1DArrayWidget<S>::getArrayLayout(){
  QGridLayout *widgetLayout = new QGridLayout;
  for(int i=0; i<baseArray.size(); ++i){
    widgetLayout->addWidget(new QLabel("Item: " +QString::number(i)),0,i,Qt::AlignLeft);
    QWidget* editorWidget = getEditorWidget(i);
    widgetLayout->addWidget(editorWidget,1,i,Qt::AlignLeft);
    widgetVector.push_back(editorWidget);
  }
  return widgetLayout;
}

template<class S>
void Generic1DArrayWidget<S>::doAcceptWork(){
  baseArray.clear();
  baseArray = getArrayFromWidgets();
  this->done(QDialog::Accepted);
}

class IntArrayWidget: public Generic1DArrayWidget<int>{
  Q_OBJECT
public:


  IntArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic1DArrayWidget<int>(name, type, validator,parent){}


  
  Array<int> getArrayFromWidgets(){
    Array<int> toReturn(widgetVector.size(), 0);
    for(size_t i=0; i < widgetVector.size(); ++i){
      toReturn[i]= ((QSpinBox*)widgetVector[i])->value();
    }
    return toReturn;
  }

private:

  QWidget* getEditorWidget(int index){
    QSpinBox *newSpin = new QSpinBox(this);
    RCP<const EnhancedNumberValidator<int> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const ArrayValidator<EnhancedNumberValidator<int>, int> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<int>::applyToSpinBox(validator, newSpin);
    newSpin->setValue(baseArray[index]);
    return newSpin;
  }



public slots:


  void accept(){
    doAcceptWork();
  }


};

class ShortArrayWidget: public Generic1DArrayWidget<short>
{
  Q_OBJECT
public:


  ShortArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic1DArrayWidget<short>(name, type, validator,parent){}



  Array<short> getArrayFromWidgets(){
    Array<short> toReturn(widgetVector.size(), 0);
    for(size_t i=0; i < widgetVector.size(); ++i){
      toReturn[i]= ((QSpinBox*)widgetVector[i])->value();
    }
    return toReturn;
  }


private:

  QWidget* getEditorWidget(int index){
    QSpinBox *newSpin = new QSpinBox(this);
    RCP<const EnhancedNumberValidator<short> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const ArrayValidator<EnhancedNumberValidator<short>, short> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<short>::applyToSpinBox(validator, newSpin);
    newSpin->setValue(baseArray[index]);
    return newSpin;
  }


public slots:

  void accept(){
    doAcceptWork();
  }

};

class DoubleArrayWidget: public Generic1DArrayWidget<double>
{
  Q_OBJECT
public:


  DoubleArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic1DArrayWidget<double>(name, type, validator,parent){}



  Array<double> getArrayFromWidgets(){
    Array<double> toReturn(widgetVector.size(), 0.0);
    for(size_t i=0; i < widgetVector.size(); ++i){
      toReturn[i]= ((QLineEdit*)widgetVector[i])->text().toDouble();
    }
    return toReturn;
  }

private:

  QWidget* getEditorWidget(int index){
    QLineEdit *newEdit = new QLineEdit(this);
    RCP<const EnhancedNumberValidator<double> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const ArrayValidator<EnhancedNumberValidator<double>, double> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<double>::applyToLineEdit(validator, newEdit);
    newEdit->setText(QString::number(baseArray[index], 'g', ((QDoubleValidator*)newEdit->validator())->decimals()));
    return newEdit;
  }

  
public slots:

  void accept(){
    doAcceptWork();
  }


};

class FloatArrayWidget: public Generic1DArrayWidget<float>
{
  Q_OBJECT
public:

  FloatArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic1DArrayWidget<float>(name, type, validator,parent){}

  

  Array<float> getArrayFromWidgets(){
    Array<float> toReturn(widgetVector.size(), 0.0);
    for(size_t i=0; i < widgetVector.size(); ++i){
      toReturn[i]= ((QLineEdit*)widgetVector[i])->text().toDouble();
    }
    return toReturn;
  }

private:

  QWidget* getEditorWidget(int index){
    QLineEdit *newEdit = new QLineEdit(this);
    RCP<const EnhancedNumberValidator<float> > validator = null;
    if(!is_null(getEntryValidator())){
      validator = rcp_dynamic_cast<const ArrayValidator<EnhancedNumberValidator<float>, float> >(getEntryValidator(),true)->getPrototype();
    }
    ValidatorApplier<float>::applyToLineEdit(validator, newEdit);
    newEdit->setText(QString::number(baseArray[index], 'g', ((QDoubleValidator*)newEdit->validator())->decimals()));
    return newEdit;
  }



public slots:


  void accept(){
    doAcceptWork();
  }


};

class StringArrayWidget : public Generic1DArrayWidget<std::string>{
  Q_OBJECT
public:


  StringArrayWidget(
    QString name, 
    QString type, 
    const RCP<const ParameterEntryValidator> validator,
    QWidget *parent=0):
    Generic1DArrayWidget<std::string>(name, type, validator,parent)
  {}



  Array<std::string> getArrayFromWidgets(){
    Array<std::string> toReturn(widgetVector.size(), "");
    for(size_t i=0; i < widgetVector.size(); ++i){
      if(is_null(getEntryValidator())){
        toReturn[i] = ((QLineEdit*)widgetVector[i])->text().toStdString();
      }
      else if(!is_null(rcp_dynamic_cast<const ArrayValidator<FileNameValidator, std::string> >(getEntryValidator()))){
        toReturn[i] = ((FileNameWidget*)widgetVector[i])->getCurrentFileName().toStdString();
      }
      else if(getEntryValidator()->validStringValues()->size() !=0){
        toReturn[i] = ((QComboBox*)widgetVector[i])->currentText().toStdString();
      }
      else{
        toReturn[i] = ((QLineEdit*)widgetVector[i])->text().toStdString();
      }
    }
    return toReturn;
  }

private:

  QWidget* getEditorWidget(int index){
    QString currentData = QString::fromStdString(baseArray[index]);
    if(is_null(getEntryValidator())){
      return new QLineEdit(currentData,this);
    }
    else if(!is_null(rcp_dynamic_cast<const ArrayValidator<FileNameValidator, std::string> >(getEntryValidator()))){
      return new FileNameWidget(
        currentData, 
        rcp_dynamic_cast<const ArrayValidator<FileNameValidator, std::string> >(getEntryValidator())->getPrototype()->fileMustExist(), this);
    }
    else if(getEntryValidator()->validStringValues()->size() != 0){
      RCP<const Array<std::string> > options = getEntryValidator()->validStringValues();
      QComboBox *newCombo = new QComboBox(this);
      for(Array<std::string>::const_iterator itr = options->begin(); itr != options->end(); ++itr){
        newCombo->addItem(QString::fromStdString(*itr));
      }
      int selectedItem = newCombo->findText(currentData);
      newCombo->setCurrentIndex(selectedItem);
      return newCombo;
    }
    else{
      return new QLineEdit(currentData,this);
    }
  }


public slots:


  void accept(){
    doAcceptWork();
  }



};


} //end namespace
#endif //OPTIKA_ARRAYWIDGET_HPP_