File indexing completed on 2024-12-22 04:17:44

 /***************************************************************************
  *                                                                         *
  *   copyright : (C) 2007 The University of Toronto                        *
  *                   netterfield@astro.utoronto.ca                         *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "scalardialog.h"
 #include "application.h"
 
 #include "datasourceconfiguredialog.h"
 
 #include "enodes.h"
 #include "document.h"
 #include "objectstore.h"
 #include "datascalar.h"
 #include "vscalar.h"
 #include "dialogdefaults.h"
 #include "datasourcepluginmanager.h"
 
 #include <QPushButton>
 #include <QThreadPool>
 
 namespace Kst {
 
 ScalarTab::ScalarTab(ObjectStore *store, QWidget *parent)
   : DataTab(parent),  _mode(DataScalar), _store(store), _requestID(0) {
 
   setupUi(this);
   setTabTitle(tr("Scalar"));
 
   setDataOptions();
 
   connect(_scalarValue, SIGNAL(textChanged(QString)), this, SLOT(entryChanged()));
   connect(_start, SIGNAL(valueChanged(int)), this, SLOT(entryChanged()));
   connect(_countFromEnd, SIGNAL(clicked()), this, SLOT(entryChanged()));
   connect(_field, SIGNAL(editTextChanged(QString)), this, SLOT(entryChanged()));
   connect(_fieldRV, SIGNAL(editTextChanged(QString)), this, SLOT(entryChanged()));
   connect(_readFromSource, SIGNAL(toggled(bool)), this, SLOT(readFromSourceChanged()));
   connect(_readFromRVector, SIGNAL(toggled(bool)), this, SLOT(readFromSourceChanged()));
   connect(_fileName, SIGNAL(changed(QString)), this, SLOT(fileNameChanged(QString)));
   connect(_configure, SIGNAL(clicked()), this, SLOT(showConfigWidget()));
 }
 
 
 ScalarTab::~ScalarTab() {
 }
 
 
 QString ScalarTab::value() const {
   return _scalarValue->text();
 }
 
 
 void ScalarTab::setValue(const QString &value) {
   _scalarValue->setText(value);
 }
 
 
 void ScalarTab::entryChanged() {
   _start->setEnabled(_readFromRVector->isChecked() && !_countFromEnd->isChecked());
   emit valueChanged();
 }
 
 
 void ScalarTab::readFromSourceChanged() {
 
   if (_readFromSource->isChecked()) {
     _mode = DataScalar;
     setDataOptions();
   } else if (_readFromRVector->isChecked()) {
     _mode = RVectorScalar;
     setRVOptions();
   } else {
     _mode = GeneratedScalar;
   }
   _dataScalarGroup->setEnabled((_readFromSource->isChecked())||(_readFromRVector->isChecked()));
 
   bool isRV = _readFromRVector->isChecked();
 
   label_6->setEnabled(isRV);
   label_7->setEnabled(isRV);
   _start->setEnabled(isRV && !_countFromEnd->isChecked());
   _countFromEnd->setEnabled(isRV);
 
  _generatedScalarGroup->setEnabled(_generateX->isChecked());
 
   emit sourceChanged();
 }
 
 
 
 void ScalarTab::hideGeneratedOptions() {
   _readFromSource->setVisible(false);
   _generateX->setVisible(false);
   _readFromRVector->setVisible(false);
   _generatedScalarGroup->setVisible(false);
 }
 
 
 void ScalarTab::hideDataOptions() {
   _readFromSource->setVisible(false);
   _generateX->setVisible(false);
   _readFromRVector->setVisible(false);
   _dataScalarGroup->setVisible(false);
   _generatedScalarGroup->setEnabled(true);
 }
 
 void ScalarTab::setRVOptions() {
  // replace in right order to avoid flicker
  _field->setVisible(false);
  label_5->setVisible(false);
  _fieldRV->setVisible(true);
  label_8->setVisible(true);
  _readFromRVector->setChecked(true);
 }
 
 
 void ScalarTab::setDataOptions() {
   _fieldRV->setVisible(false);
   label_8->setVisible(false);
   _field->setVisible(true);
   label_5->setVisible(true);
   _readFromSource->setChecked(true);
 }
 
 
 DataSourcePtr ScalarTab::dataSource() const {
   return _dataSource;
 }
 
 
 void ScalarTab::setDataSource(DataSourcePtr dataSource) {
   _dataSource = dataSource;
 }
 
 
 QString ScalarTab::file() const {
   return _fileName->file();
 }
 
 
 void ScalarTab::setFile(const QString &file) {
   _fileName->setFile(file);
 }
 
 
 QString ScalarTab::field() const {
   return _field->currentText();
 }
 
 
 void ScalarTab::setField(const QString &field) {
   _current_field = field;
   _field->setCurrentIndex(_field->findText(field));
 }
 
 
 QString ScalarTab::fieldRV() const {
   return _fieldRV->currentText();
 }
 
 
 void ScalarTab::setFieldRV(const QString &field) {
   _current_rvfield = field;
   _fieldRV->setCurrentIndex(_fieldRV->findText(field));
 }
 
 void ScalarTab::setF0(int f0) {
   _start->setValue(f0);
 }
 
 int ScalarTab::F0() const {
   if (_countFromEnd->isChecked() == true) {
     return -1;
   } else {
     return _start->text().toInt();
   }
 }
 
 void ScalarTab::updateDataSource() {
   fileNameChanged(_fileName->file());
 }
 
 
 void ScalarTab::sourceValid(QString filename, int requestID) {
   if (_requestID != requestID) {
     return;
   }
   _dataSource = DataSourcePluginManager::findOrLoadSource(_store, filename);
 
   _field->setEnabled(true);
   _fieldRV->setEnabled(true);
 
   _dataSource->readLock();
 
   _field->addItems(_dataSource->scalar().list());
   setField(_current_field);
   _field->setEditable(!_dataSource->scalar().isListComplete());
   _fieldRV->addItems(_dataSource->vector().list());
   setFieldRV(_current_rvfield);
   _fieldRV->setEditable(!_dataSource->vector().isListComplete());
   _configure->setEnabled(_dataSource->hasConfigWidget());
 
   _dataSource->unlock();
   modified();
 
   _store->cleanUpDataSourceList();
   emit sourceChanged();
 }
 
 
 
 void ScalarTab::fileNameChanged(const QString &file) {
   _field->clear();
   _fieldRV->clear();
   _field->setEnabled(false);
   _fieldRV->setEnabled(false);
   _configure->setEnabled(false);
   emit sourceChanged();
 
   _requestID += 1;
   ValidateDataSourceThread *validateDSThread = new ValidateDataSourceThread(file, _requestID);
   connect(validateDSThread, SIGNAL(dataSourceValid(QString,int)), this, SLOT(sourceValid(QString,int)));
   QThreadPool::globalInstance()->start(validateDSThread);
 }
 
 
 void ScalarTab::showConfigWidget() {
   QPointer<DataSourceConfigureDialog> dialog = new DataSourceConfigureDialog(dataDialog()->editMode(), _dataSource, this);
   if ( dialog->exec() == QDialog::Accepted ) {
     fileNameChanged(_dataSource->fileName());
   }
   delete dialog;
 }
 
 
 ScalarDialog::ScalarDialog(ObjectPtr dataObject, QWidget *parent)
   : DataDialog(dataObject, parent) {
 
   if (editMode() == Edit)
     setWindowTitle(tr("Edit Scalar"));
   else
     setWindowTitle(tr("New Scalar"));
 
   _scalarTab = new ScalarTab(_document->objectStore(), this);
   addDataTab(_scalarTab);
 
   if (editMode() == Edit) {
     configureTab(dataObject);
   } else {
     configureTab(0);
   }
 
   connect(_scalarTab, SIGNAL(valueChanged()), this, SLOT(updateButtons()));
   connect(_scalarTab, SIGNAL(valueChanged()), this, SLOT(modified()));
   connect(_scalarTab, SIGNAL(destroyed()), kstApp->mainWindow(), SLOT(cleanUpDataSourceList()));
   updateButtons();
 }
 
 
 ScalarDialog::~ScalarDialog() {
 }
 
 void ScalarDialog::configureTab(ObjectPtr object) {
   if (DataScalarPtr dataScalar = kst_cast<DataScalar>(object)) {
     _scalarTab->setFile(dataScalar->dataSource()->fileName());
     _scalarTab->setDataSource(dataScalar->dataSource());
     _scalarTab->setField(dataScalar->field());
     _scalarTab->hideGeneratedOptions();
     _scalarTab->setDataOptions();
   } else if (VScalarPtr vScalar = kst_cast<VScalar>(object)) {
     _scalarTab->setFile(vScalar->dataSource()->fileName());
     _scalarTab->setDataSource(vScalar->dataSource());
     _scalarTab->setFieldRV(vScalar->field());
     _scalarTab->setF0(vScalar->F0());
     _scalarTab->hideGeneratedOptions();
     _scalarTab->setRVOptions();
   } else if (ScalarPtr scalar = kst_cast<Scalar>(object)) { // edit value scalar
     _scalarTab->hideDataOptions();
     _scalarTab->setValue(QString::number(scalar->value()));
   } else { // new scalar
     _scalarTab->setFile(dialogDefaults().value("vector/datasource",_scalarTab->file()).toString());
   }
 }
 
 void ScalarDialog::updateButtons() {
   bool valid=false;
 
   switch(_scalarTab->scalarMode()) {
   case ScalarTab::DataScalar:
     valid = !_scalarTab->field().isEmpty();
     break;
   case ScalarTab::RVectorScalar:
     valid = !_scalarTab->fieldRV().isEmpty();
     break;
   case ScalarTab::GeneratedScalar:
     valid = !_scalarTab->value().isEmpty();
     break;
   default:
     valid = false;
   }
 
   _buttonBox->button(QDialogButtonBox::Ok)->setEnabled(valid);
   //_buttonBox->button(QDialogButtonBox::Apply)->setEnabled(valid);
 }
 
 
 ObjectPtr ScalarDialog::createNewDataObject() {
   switch(_scalarTab->scalarMode()) {
   case ScalarTab::DataScalar:
     return createNewDataScalar();
   case ScalarTab::RVectorScalar:
     return createNewVScalar();
   case ScalarTab::GeneratedScalar:
     return createNewGeneratedScalar();
   default:
     return 0;
   }
 }
 
 ObjectPtr ScalarDialog::createNewGeneratedScalar(){
   bool ok = false;
 
   Q_ASSERT(_document && _document->objectStore());
 
   double value = _scalarTab->value().toDouble(&ok);
   if (!ok) {
     value = Equations::interpret(_document->objectStore(), _scalarTab->value().toLatin1(), &ok);
   }
 
   if (!ok) {
     return 0; //invalid
   }
 
   ScalarPtr scalar = _document->objectStore()->createObject<Scalar>();
   scalar->setValue(value);
   scalar->setOrphan(true);
   scalar->setEditable(true);
   if (DataDialog::tagStringAuto()) {
      scalar->setDescriptiveName(QString());
   } else {
      scalar->setDescriptiveName(DataDialog::tagString());
   }
 
   scalar->writeLock();
   scalar->registerChange();
   scalar->unlock();
 
   _dataObjectName = scalar->Name();
 
   //UpdateServer::self()->requestUpdateSignal();
   _scalarTab->setDataSource(0L);
   _document->objectStore()->cleanUpDataSourceList();
 
   return static_cast<ObjectPtr>(scalar);
 }
 
 
 ObjectPtr ScalarDialog::createNewDataScalar() {
   const DataSourcePtr dataSource = _scalarTab->dataSource();
 
   if (!dataSource)
     return 0;
 
   const QString field = _scalarTab->field();
 
   Q_ASSERT(_document && _document->objectStore());
 
   DataScalarPtr scalar = _document->objectStore()->createObject<DataScalar>();
 
   scalar->writeLock();
   scalar->change(dataSource, field);
 
   if (DataDialog::tagStringAuto()) {
      scalar->setDescriptiveName(QString());
   } else {
      scalar->setDescriptiveName(DataDialog::tagString());
   }
 
   scalar->registerChange();
   scalar->unlock();
 
   _dataObjectName = scalar->Name();
 
   //UpdateServer::self()->requestUpdateSignal();
 
   return scalar;
 }
 
 
 ObjectPtr ScalarDialog::createNewVScalar() {
   const DataSourcePtr dataSource = _scalarTab->dataSource();
 
   if (!dataSource)
     return 0;
 
   const QString field = _scalarTab->fieldRV();
   const int f0 = _scalarTab->F0();
 
   Q_ASSERT(_document && _document->objectStore());
 
   VScalarPtr scalar = _document->objectStore()->createObject<VScalar>();
 
   scalar->writeLock();
   scalar->change(dataSource, field, f0);
 
   if (DataDialog::tagStringAuto()) {
      scalar->setDescriptiveName(QString());
   } else {
      scalar->setDescriptiveName(DataDialog::tagString());
   }
 
   scalar->registerChange();
   scalar->unlock();
 
   _dataObjectName = scalar->Name();
 
   kstApp->mainWindow()->updateRecentDataFiles(dataSource->fileName());
   //dialogDefaults().setValue("vector/datasource", dataSource->fileName());
 
   return scalar;
 }
 
 
 ObjectPtr ScalarDialog::editExistingDataObject() const {
   if (DataScalarPtr scalar = kst_cast<DataScalar>(dataObject())) {
     const DataSourcePtr dataSource = _scalarTab->dataSource();
 
     if (dataSource) {
       const QString field = _scalarTab->field();
       scalar->writeLock();
       scalar->change(dataSource, field);
 
       if (DataDialog::tagStringAuto()) {
         scalar->setDescriptiveName(QString());
       } else {
         scalar->setDescriptiveName(DataDialog::tagString());
       }
 
       scalar->registerChange();
       scalar->unlock();
     }
   } else if (VScalarPtr scalar = kst_cast<VScalar>(dataObject())) {
     const DataSourcePtr dataSource = _scalarTab->dataSource();
 
     if (dataSource) {
       const QString field = _scalarTab->fieldRV();
       int f0 = _scalarTab->F0();
       scalar->writeLock();
       scalar->change(dataSource, field, f0);
 
       if (DataDialog::tagStringAuto()) {
         scalar->setDescriptiveName(QString());
       } else {
         scalar->setDescriptiveName(DataDialog::tagString());
       }
 
       scalar->registerChange();
       scalar->unlock();
     }
   } else   if (ScalarPtr scalar = kst_cast<Scalar>(dataObject())) {
     bool ok;
     double value = _scalarTab->value().toDouble(&ok);
     if (!ok) {
       value = Equations::interpret(_document->objectStore(), _scalarTab->value().toLatin1(), &ok);
     }
     if (DataDialog::tagStringAuto()) {
       scalar->setDescriptiveName(QString());
     } else {
       scalar->setDescriptiveName(DataDialog::tagString());
     }
     scalar->writeLock();
     scalar->setValue(value);
     scalar->registerChange();
     scalar->unlock();
   }
 
   return dataObject();
 }
 
 }
 
 // vim: ts=2 sw=2 et