示例#1
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InputPathWidget::setupGui()
{
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));

  connect(value, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&)));

  QFileCompleter* com = new QFileCompleter(this, false);
  value->setCompleter(com);
  QObject::connect( com, SIGNAL(activated(const QString&)),
                    this, SLOT(widgetChanged(const QString&)));

  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    QString currentPath = getFilter()->property(PROPERTY_NAME_AS_CHAR).toString();
    value->setText(currentPath);
  }


}
示例#2
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SeparatorWidget::setupGui()
{

  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  label->setStyleSheet(getLabelStyleSheet());

  blockSignals(true);
  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );
  }
  blockSignals(false);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerSelectionWidget::setupGui()
{
  if(getFilter() == NULL)
  {
    return;
  }
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));

  if (getFilterParameter() == NULL)
  {
    return;
  }
  label->setText(getFilterParameter()->getHumanLabel() );

  dataContainerCombo->blockSignals(true);

  dataContainerCombo->clear();

  // Now let the gui send signals like normal
  dataContainerCombo->blockSignals(false);


  populateComboBoxes();

}
示例#4
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StringWidget::setupGui()
{


  blockSignals(true);
  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    QString str = getFilter()->property(PROPERTY_NAME_AS_CHAR).toString();
    value->setText(str);
  }
  blockSignals(false);

  applyChangesBtn->setVisible(false);

  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  connect(value, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&)));

}
示例#5
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CustomWidget::setupGui()
{
  if (getFilterParameter() != NULL)
  {
    CustomWidgetLabel->setText(getFilterParameter()->getHumanLabel() );
  }
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerCreationWidget::setupGui()
{
  blockSignals(true);
  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    QString str = getFilter()->property(PROPERTY_NAME_AS_CHAR).toString();
    dataContainerName->setText(str);
  }
  blockSignals(false);

  applyChangesBtn->setVisible(false);

  // Do not allow the user to put a forward slash into the dataContainerName line edit
  dataContainerName->setValidator(new QRegularExpressionValidator(QRegularExpression("[^/]*"), this));

  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its dataContainerNames updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  connect(dataContainerName, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&)));

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SecondOrderPolynomialWidget::setupGui()
{
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  connect(c20, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(c02, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(c11, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(c10, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(c01, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(c00, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );


  QDoubleValidator* c20Val = new QDoubleValidator(c20);
  c20->setValidator(c20Val);
  QDoubleValidator* c02Val = new QDoubleValidator(c02);
  c02->setValidator(c02Val);
  QDoubleValidator* c11Val = new QDoubleValidator(c11);
  c11->setValidator(c11Val);

  QDoubleValidator* c10Val = new QDoubleValidator(c10);
  c10->setValidator(c10Val);
  QDoubleValidator* c01Val = new QDoubleValidator(c01);
  c01->setValidator(c01Val);
  QDoubleValidator* c00Val = new QDoubleValidator(c00);
  c00->setValidator(c00Val);

  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    Float2ndOrderPoly_t data = getFilter()->property(PROPERTY_NAME_AS_CHAR).value<Float2ndOrderPoly_t>();
    c20->setText( QString::number(data.c20)  );
    c02->setText( QString::number(data.c02)  );
    c11->setText( QString::number(data.c11)  );

    c10->setText( QString::number(data.c10) );
    c01->setText( QString::number(data.c01) );
    c00->setText( QString::number(data.c00) );
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataArraySelectionWidget::setupGui()
{

  // Sanity Check the filter and the filter parameter
  if(getFilter() == NULL)
  {
    return;
  }
  if (getFilterParameter() == NULL)
  {
    return;
  }

  // Generate the text for the QLabel
  label->setText(getFilterParameter()->getHumanLabel() );


  // Get the default path from the Filter instance to cache
  m_DefaultPath = getFilter()->property(PROPERTY_NAME_AS_CHAR).value<DataArrayPath>();
  //  dataContainerCombo->addItem(m_DefaultPath.getDataContainerName());
  //  attributeMatrixCombo->addItem(m_DefaultPath.getAttributeMatrixName() );
  //  attributeArrayCombo->addItem(m_DefaultPath.getDataArrayName() );

  // Block Signals from the ComboBoxes while we clear them
  dataContainerCombo->blockSignals(true);
  attributeMatrixCombo->blockSignals(true);
  attributeArrayCombo->blockSignals(true);

  dataContainerCombo->clear();
  attributeMatrixCombo->clear();
  attributeArrayCombo->clear();

  dataContainerCombo->blockSignals(false);
  attributeMatrixCombo->blockSignals(false);
  attributeArrayCombo->blockSignals(false);

  populateComboBoxes();

  // Lastly, hook up the filter's signals and slots to our own signals and slots
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));

}
示例#9
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FloatVec3Widget::setupGui()
{
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  connect(xData, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(yData, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(zData, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );

  QLocale loc = QLocale::system();

  QDoubleValidator* xVal = new QDoubleValidator(xData);
  xData->setValidator(xVal);
  xVal->setLocale(loc);

  QDoubleValidator* yVal = new QDoubleValidator(yData);
  yData->setValidator(yVal);
  yVal->setLocale(loc);

  QDoubleValidator* zVal = new QDoubleValidator(zData);
  zData->setValidator(zVal);
  zVal->setLocale(loc);
  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    FloatVec3_t data = getFilter()->property(PROPERTY_NAME_AS_CHAR).value<FloatVec3_t>();

    xData->setText(loc.toString(data.x));
    yData->setText(loc.toString(data.y));
    zData->setText(loc.toString(data.z));
  }

  errorLabel->hide();

}
示例#10
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FloatVec3Widget::widgetChanged(const QString& text)
{
  Q_UNUSED(text);

  QLineEdit* le = NULL;
  (sender() == xData) ? le = xData: le = NULL;
  (sender() == yData) ? le = yData: le = NULL;
  (sender() == zData) ? le = zData: le = NULL;

  errorLabel->hide();

  if(le)
  {
    if(le->text().isEmpty())
    {
      QString objName = le->objectName();
      DREAM3DStyles::LineEditErrorStyle(le);
      errorLabel->setStyleSheet(QString::fromLatin1("color: rgb(255, 0, 0);"));
      errorLabel->setText("No value entered. Filter will use default value of " + getFilterParameter()->getDefaultValue().toString());
      errorLabel->show();
    }
  }

  emit parametersChanged();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerArrayProxyWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  // qDebug() << "DataContainerArrayProxyWidget::filterNeedsInputParameters(AbstractFilter* filter)";

  QVariant var;
  var.setValue(m_DcaProxy);
  bool ok = false;
  // Set the value into the Filter
  ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, var);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

//  if(getFilterParameter()->isConditional() )
//  {
//    var.setValue(conditionalCB->isChecked());
//    ok = filter->setProperty(getFilterParameter()->getConditionalProperty().toLatin1().constData(), var);
//    if(false == ok)
//    {
//      FilterParameterWidgetsDialogs::ShowCouldNotSetConditionalFilterParameter(getFilter(), getFilterParameter());
//    }
//  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FourthOrderPolynomialWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  bool ok = false;
  Float4thOrderPoly_t data;
  data.c40 = c40->text().toDouble(&ok);
  data.c04 = c04->text().toDouble(&ok);
  data.c31 = c31->text().toDouble(&ok);
  data.c13 = c13->text().toDouble(&ok);
  data.c22 = c22->text().toDouble(&ok);
  data.c30 = c30->text().toDouble(&ok);
  data.c03 = c03->text().toDouble(&ok);
  data.c21 = c21->text().toDouble(&ok);
  data.c12 = c12->text().toDouble(&ok);
  data.c20 = c20->text().toDouble(&ok);
  data.c02 = c02->text().toDouble(&ok);
  data.c11 = c11->text().toDouble(&ok);
  data.c10 = c10->text().toDouble(&ok);
  data.c01 = c01->text().toDouble(&ok);
  data.c00 = c00->text().toDouble(&ok);

  QVariant v;
  v.setValue(data);
  ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, v);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void PhaseTypeSelectionWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  int count = phaseListWidget->count();
//  {
//    std::cout << "PhaseTypeSelectionWidget::filterNeedsInputParameters Count = " << count << std::endl;
//  }

  PhaseTypeSelectionFilterParameter* p = dynamic_cast<PhaseTypeSelectionFilterParameter*>(getFilterParameter());
  QVariant var;

  // QVector<uint32_t> phaseTypes(count, DREAM3D::PhaseType::UnknownPhaseType);
  QVector<uint32_t> phaseTypes(count + 1, DREAM3D::PhaseType::UnknownPhaseType);
  bool ok = false;
  phaseTypes[0] = DREAM3D::PhaseType::UnknownPhaseType;
  for (int i = 0; i < count; ++i)
  {
    QComboBox* cb = qobject_cast<QComboBox*>(phaseListWidget->itemWidget(phaseListWidget->item(i)));
    unsigned int sType = static_cast<unsigned int>(cb->itemData(cb->currentIndex(), Qt::UserRole).toUInt(&ok));
    //phaseTypes[i+1] = sType;
    phaseTypes[i + 1] = sType;
  }

  UInt32Vector_t data;
  data.d = phaseTypes;
  var.setValue(data);
  ok = false;

  // Set the value into the Filter
  ok = filter->setProperty(p->getPhaseTypeDataProperty().toLatin1().constData(), var);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

  DataArrayPath path(dataContainerCombo->currentText(), attributeMatrixCombo->currentText(), "");

  var.setValue(path);
  ok = false;
  // Set the value into the Filter
  ok = filter->setProperty(p->getAttributeMatrixPathProperty().toLatin1().constData(), var);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }


}
示例#14
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StringWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  bool ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, value->text());
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerCreationWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  bool ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, dataContainerName->text());
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void BooleanWidget::filterNeedsInputParameters(AbstractFilter* filter)
{

    QVariant var(value->isChecked() );
    bool ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, var);
    if(false == ok)
    {
        FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
    }

}
示例#17
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChoiceWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  int index = value->currentIndex();
  QVariant v(index);
  bool ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, v);

  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }
}
示例#18
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void UnknownWidget::setupGui()
{
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));

  if (getFilterParameter() != NULL)
  {
    QString str = QObject::tr("%1: Unknown Filter ParameterWidgetType: %2.").arg(getFilterParameter()->getHumanLabel()).arg(getFilterParameter()->getWidgetType());
    label->setText( str );
  }
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerReaderWidget::setupGui()
{

  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  // Put in a QStandardItemModel
  QAbstractItemModel* oldModel = dcaProxyView->model();
  QStandardItemModel* model = new QStandardItemModel;
  dcaProxyView->setModel(model);
  delete oldModel;

  //  void activated(const QModelIndex& index);
  connect(dcaProxyView, SIGNAL(clicked(const QModelIndex&)),
          this, SLOT(itemActivated(const QModelIndex)));

  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );
  }

  if(getFilter() != NULL)
  {
    QString path = m_Filter->getInputFile();

    filePath->setText(path);
    on_filePath_fileDropped(path);
  }


}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void BooleanWidget::setupGui()
{

    // Catch when the filter is about to execute the preflight
    connect(getFilter(), SIGNAL(preflightAboutToExecute()),
            this, SLOT(beforePreflight()));

    // Catch when the filter is finished running the preflight
    connect(getFilter(), SIGNAL(preflightExecuted()),
            this, SLOT(afterPreflight()));

    // Catch when the filter wants its values updated
    connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
            this, SLOT(filterNeedsInputParameters(AbstractFilter*)));

    connect(value, SIGNAL(stateChanged(int)),
            this, SLOT(widgetChanged(int) ) );

    if (getFilterParameter() != NULL)
    {
        label->setText(getFilterParameter()->getHumanLabel() );

        QVariant objValue = getFilter()->property(PROPERTY_NAME_AS_CHAR);
        if (objValue.isValid() == true)
        {
            value->setChecked(objValue.toBool());
        }
        else
        {
            QString ss = QObject::tr("Error occurred getting Filter Parameter %1 for filter %2").arg(getFilterParameter()->getPropertyName()).arg(getFilter()->getNameOfClass());
            emit errorSettingFilterParameter(ss);
            qDebug() << ss;
        }

    }

}
示例#21
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FloatVec3Widget::filterNeedsInputParameters(AbstractFilter* filter)
{
  bool ok = false;
  FloatVec3_t defValue = m_FilterParameter->getDefaultValue().value<FloatVec3_t>();
  FloatVec3_t data;

  QLocale loc;


  data.x = loc.toFloat(xData->text(), &ok);
  if(!ok)
  {
    errorLabel->setStyleSheet(QString::fromLatin1("color: rgb(255, 0, 0);"));
    errorLabel->setText("X Value entered is beyond the representable range for a double.\nThe filter will use the default value of " + getFilterParameter()->getDefaultValue().toString());
    errorLabel->show();
    DREAM3DStyles::LineEditErrorStyle(xData);
    data.x = defValue.x;
  }

  data.y = loc.toFloat(yData->text(), &ok);
  if(!ok)
  {
    errorLabel->setStyleSheet(QString::fromLatin1("color: rgb(255, 0, 0);"));
    errorLabel->setText("Y Value entered is beyond the representable range for a double.\nThe filter will use the default value of " + getFilterParameter()->getDefaultValue().toString());
    errorLabel->show();
    DREAM3DStyles::LineEditErrorStyle(xData);
    data.y = defValue.y;
  }

  data.z = loc.toFloat(zData->text(), &ok);
  if(!ok)
  {
    errorLabel->setStyleSheet(QString::fromLatin1("color: rgb(255, 0, 0);"));
    errorLabel->setText("Z Value entered is beyond the representable range for a double.\nThe filter will use the default value of " + getFilterParameter()->getDefaultValue().toString());
    errorLabel->show();
    DREAM3DStyles::LineEditErrorStyle(zData);
    data.z = defValue.z;
  }


  QVariant v;
  v.setValue(data);
  ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, v);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AttributeMatrixCreationWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  // Generate the path to the AttributeArray
  DataArrayPath path(dataContainerCombo->currentText(), attributeMatrixName->text(), "");
  QVariant var;
  var.setValue(path);
  bool ok = false;
  // Set the value into the Filter
  ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, var);
  if (false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
示例#23
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChoiceWidget::setupGui()
{

  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));

  connect(value, SIGNAL(currentIndexChanged(int)),
          this, SLOT(widgetChanged(int) ) );

  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    // setup the list of choices for the widget
    ChoiceFilterParameter* choice = dynamic_cast<ChoiceFilterParameter*>(getFilterParameter());
    if(choice)
    {
      QList<QString> choices = choice->getChoices().toList();
      value->blockSignals(true);
      value->addItems(choices);
      value->blockSignals(false);
    }
    // Get the Default value from the filter
    int i = getFilter()->property(PROPERTY_NAME_AS_CHAR).toInt();
    value->setCurrentIndex(i);
  }
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerArrayProxyWidget::setupGui()
{

  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  // Put in a QStandardItemModel
  QAbstractItemModel* oldModel = dcaProxyView->model();
  QStandardItemModel* model = new QStandardItemModel;
  dcaProxyView->setModel(model);
  delete oldModel;

  connect(model, SIGNAL(itemChanged(QStandardItem*)),
          this, SLOT(itemActivated(QStandardItem*)));

  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );


    //If the filter is just being dragged into the pipeline then the filter is going to have an empty
    // Proxy object at which point nothing is going to be put into the lists. But if the Filter was
    // initialized from a pipeline file then it might actually have a proxy so we need to do something
    // with that proxy?
    m_DcaProxy = getFilter()->property(PROPERTY_NAME_AS_CHAR).value<DataContainerArrayProxy>();
    //m_DcaProxy.print("DataContainerArrayProxyWidget::setupGui()");
  }

}
示例#25
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChoiceWidget::widgetChanged(int index, bool emitParametersChanged)
{

  FilterParameter* fp = getFilterParameter();

  // If the parameter type is LinkedChoicesFilterParameter then we need to emit the index that
  // was selected
  LinkedChoicesFilterParameter* lnkedChoices = dynamic_cast<LinkedChoicesFilterParameter*>(fp);
  if(lnkedChoices)
  {
    emit conditionalPropertyChanged(index);
  }


  // We emit no matter what
  if(emitParametersChanged)
  {
    emit parametersChanged();
  }
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataArraySelectionWidget::filterNeedsInputParameters(AbstractFilter* filter)
{
  // Generate the path to the AttributeArray
  QString dc = dataContainerCombo->currentText();
  QString am = attributeMatrixCombo->currentText();
  QString da = attributeArrayCombo->currentText();
 // qDebug() << "++++++++++++++++++++++++++++++++++++++++++++";
 // qDebug() << getFilterParameter()->getHumanLabel() << ":" << dc << "/" << am << "/" << da << "   m_DidCausePreflight:" << (int)(m_DidCausePreflight) << " " << (int)(attributeArrayCombo->signalsBlocked());
 // qDebug() << "++++++++++++++++++++++++++++++++++++++++++++";
  DataArrayPath path(dc, am, da);
  QVariant var;
  var.setValue(path);
  bool ok = false;
  // Set the value into the Filter
  ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, var);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Symmetric6x6Widget::filterNeedsInputParameters(AbstractFilter* filter)
{
  bool ok = false;
  FloatVec21_t data;
  data.v11 = v11->text().toDouble(&ok);
  data.v12 = v12->text().toDouble(&ok);
  data.v13 = v13->text().toDouble(&ok);
  data.v14 = v14->text().toDouble(&ok);
  data.v15 = v15->text().toDouble(&ok);
  data.v16 = v16->text().toDouble(&ok);

  data.v22 = v22->text().toDouble(&ok);
  data.v23 = v23->text().toDouble(&ok);
  data.v24 = v24->text().toDouble(&ok);
  data.v25 = v25->text().toDouble(&ok);
  data.v26 = v26->text().toDouble(&ok);

  data.v33 = v33->text().toDouble(&ok);
  data.v34 = v34->text().toDouble(&ok);
  data.v35 = v35->text().toDouble(&ok);
  data.v36 = v36->text().toDouble(&ok);

  data.v44 = v44->text().toDouble(&ok);
  data.v45 = v45->text().toDouble(&ok);
  data.v46 = v46->text().toDouble(&ok);

  data.v55 = v55->text().toDouble(&ok);
  data.v56 = v56->text().toDouble(&ok);

  data.v66 = v66->text().toDouble(&ok);

  QVariant v;
  v.setValue(data);
  ok = filter->setProperty(PROPERTY_NAME_AS_CHAR, v);
  if(false == ok)
  {
    FilterParameterWidgetsDialogs::ShowCouldNotSetFilterParameter(getFilter(), getFilterParameter());
  }

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerReaderWidget::beforePreflight()
{
#if 0
  if (m_DidCausePreflight == false)
  {
    //  qDebug() << getFilter()->getNameOfClass() << " DataContainerReaderWidget::beforePreflight()";
    // Get the DataContainerArray from the Filter instance. This will have what will become the choices for the user
    // to select from.
    DataContainerArray::Pointer dca = getFilter()->getDataContainerArray();
    DataContainerArrayProxy incomingProxy = DataContainerArrayProxy(dca.get() );
    incomingProxy.setAllFlags(getFilterParameter()->getDefaultFlagValue());
    //incomingProxy.print("BeforePreflight INCOMING");
    //Now the idea becomes to save the selections that the user has made and transfer those changes to the incoming
    // proxy object
    updateProxyFromProxy(m_DcaProxy, incomingProxy);
    //proxy.print("'proxy' beforePreflight AFTER updateProxyFromProxy()");

    m_DcaProxy = incomingProxy;
    // Now that the proxy was updated with our selections, make the updated incoming proxy into our cache
    // Now update the Model
    updateModelFromProxy(m_DcaProxy);
  }
#endif
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Symmetric6x6Widget::setupGui()
{
  // Catch when the filter is about to execute the preflight
  connect(getFilter(), SIGNAL(preflightAboutToExecute()),
          this, SLOT(beforePreflight()));

  // Catch when the filter is finished running the preflight
  connect(getFilter(), SIGNAL(preflightExecuted()),
          this, SLOT(afterPreflight()));

  // Catch when the filter wants its values updated
  connect(getFilter(), SIGNAL(updateFilterParameters(AbstractFilter*)),
          this, SLOT(filterNeedsInputParameters(AbstractFilter*)));


  connect(v11, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v12, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v13, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v14, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v15, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v16, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v22, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v23, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v24, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v25, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v26, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v33, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v34, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v35, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v36, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v44, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v45, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v46, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v55, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v56, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );
  connect(v66, SIGNAL(textChanged(const QString&)),
          this, SLOT(widgetChanged(const QString&) ) );

  QDoubleValidator* v11Val = new QDoubleValidator(v11);
  v11->setValidator(v11Val);
  QDoubleValidator* v12Val = new QDoubleValidator(v12);
  v12->setValidator(v12Val);
  QDoubleValidator* v13Val = new QDoubleValidator(v13);
  v13->setValidator(v13Val);
  QDoubleValidator* v14Val = new QDoubleValidator(v14);
  v14->setValidator(v14Val);
  QDoubleValidator* v15Val = new QDoubleValidator(v15);
  v15->setValidator(v15Val);
  QDoubleValidator* v16Val = new QDoubleValidator(v16);
  v16->setValidator(v16Val);

  QDoubleValidator* v22Val = new QDoubleValidator(v22);
  v22->setValidator(v22Val);
  QDoubleValidator* v23Val = new QDoubleValidator(v23);
  v23->setValidator(v23Val);
  QDoubleValidator* v24Val = new QDoubleValidator(v24);
  v24->setValidator(v24Val);
  QDoubleValidator* v25Val = new QDoubleValidator(v25);
  v25->setValidator(v25Val);
  QDoubleValidator* v26Val = new QDoubleValidator(v26);
  v26->setValidator(v26Val);

  QDoubleValidator* v33Val = new QDoubleValidator(v33);
  v33->setValidator(v33Val);
  QDoubleValidator* v34Val = new QDoubleValidator(v34);
  v34->setValidator(v34Val);
  QDoubleValidator* v35Val = new QDoubleValidator(v35);
  v35->setValidator(v35Val);
  QDoubleValidator* v36Val = new QDoubleValidator(v36);
  v36->setValidator(v36Val);

  QDoubleValidator* v44Val = new QDoubleValidator(v44);
  v44->setValidator(v44Val);
  QDoubleValidator* v45Val = new QDoubleValidator(v45);
  v45->setValidator(v45Val);
  QDoubleValidator* v46Val = new QDoubleValidator(v46);
  v46->setValidator(v46Val);

  QDoubleValidator* v55Val = new QDoubleValidator(v55);
  v55->setValidator(v55Val);
  QDoubleValidator* v56Val = new QDoubleValidator(v56);
  v56->setValidator(v56Val);

  QDoubleValidator* v66Val = new QDoubleValidator(v66);
  v66->setValidator(v66Val);

  if (getFilterParameter() != NULL)
  {
    label->setText(getFilterParameter()->getHumanLabel() );

    FloatVec21_t data = getFilter()->property(PROPERTY_NAME_AS_CHAR).value<FloatVec21_t>();
    v11->setText( QString::number(data.v11)  );
    v12->setText( QString::number(data.v12)  );
    v13->setText( QString::number(data.v13)  );
    v14->setText( QString::number(data.v14)  );
    v15->setText( QString::number(data.v15)  );
    v16->setText( QString::number(data.v16)  );

    v22->setText( QString::number(data.v22) );
    v23->setText( QString::number(data.v23) );
    v24->setText( QString::number(data.v24) );
    v25->setText( QString::number(data.v25) );
    v26->setText( QString::number(data.v26) );

    v33->setText( QString::number(data.v33) );
    v34->setText( QString::number(data.v34) );
    v35->setText( QString::number(data.v35) );
    v36->setText( QString::number(data.v36) );

    v44->setText( QString::number(data.v44) );
    v45->setText( QString::number(data.v45) );
    v46->setText( QString::number(data.v46) );

    v55->setText( QString::number(data.v55) );
    v56->setText( QString::number(data.v56) );

    v66->setText( QString::number(data.v66) );
  }

  //connect combobox to symmetry state
  connect(comboBox, SIGNAL(currentIndexChanged( int )), this, SLOT( changeSym( int ) ) );
  clearSym();
  changeSym(comboBox->currentIndex());

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void PhaseTypeSelectionWidget::updatePhaseComboBoxes()
{
  bool ok = false;
  // setup the list of choices for the widget
  PhaseTypeSelectionFilterParameter* phaseTypes = dynamic_cast<PhaseTypeSelectionFilterParameter*>(getFilterParameter());
  QString countProp = phaseTypes->getPhaseTypeCountProperty();
  int phaseCount = getFilter()->property(countProp.toLatin1().constData()).toInt(&ok);
  QString phaseDataProp = phaseTypes->getPhaseTypeDataProperty();

  UInt32Vector_t vectorWrapper = getFilter()->property(phaseDataProp.toLatin1().constData()).value<UInt32Vector_t>();
  QVector<quint32> dataFromFilter = vectorWrapper.d;
  if(phaseCount < 0 && dataFromFilter.size() < 10)   // there was an issue getting the phase Count from the Filter.
  {
    phaseCount = dataFromFilter.size(); // So lets just use the count from the actual phase data
  }

  // Get our list of predefined enumeration values
  QVector<unsigned int> phaseTypeEnums;
  PhaseType::getPhaseTypeEnums(phaseTypeEnums);

  phaseListWidget->clear();
  // Get our list of Phase Type Strings
  QStringList phaseListChoices = m_FilterParameter->getPhaseListChoices();

  for (int i = 1; i < phaseCount; i++)
  {
    QComboBox* cb = new QComboBox(NULL);
    for (int s = 0; s < phaseListChoices.size(); ++s)
    {
      cb->addItem((phaseListChoices[s]), phaseTypeEnums[s]);
      cb->setItemData(static_cast<int>(s), phaseTypeEnums[s], Qt::UserRole);
    }

    QListWidgetItem* item = new QListWidgetItem(phaseListWidget);
    phaseListWidget->addItem(item);
    phaseListWidget->setItemWidget(item, cb);

    if (i < dataFromFilter.size())
    {
      cb->setCurrentIndex(dataFromFilter[i]);
    }
    connect(cb, SIGNAL(currentIndexChanged(int)),
            this, SLOT(phaseTypeComboBoxChanged(int)) );
  }
}