KJS::Value KstBindCurve::yMinusErrorPoint(KJS::ExecState *exec, const KJS::List& args) {
KstVCurvePtr d = makeCurve(_d);
if (!d) {
KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
exec->setException(eobj);
return KJS::Undefined();
}
if (args.size() != 1) {
KJS::Object eobj = KJS::Error::create(exec, KJS::SyntaxError, "Requires exactly one argument.");
exec->setException(eobj);
return KJS::Undefined();
}
unsigned i = 0;
if (args[0].type() != KJS::NumberType || !args[0].toUInt32(i)) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Undefined();
}
KstReadLocker rl(d);
double x, y, e;
d->getEYMinusPoint(i, x, y, e);
return KJS::Number(e);
}
KJS::Value KstBindCurve::hasBars(KJS::ExecState *exec) const {
Q_UNUSED(exec)
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstReadLocker rl(d);
return KJS::Boolean(d->hasBars());
}
return KJS::Boolean(false);
}
KJS::Value KstBindCurve::color(KJS::ExecState *exec) const {
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstReadLocker rl(d);
return KJSEmbed::convertToValue(exec, d->color());
}
return KJSEmbed::convertToValue(exec, QColor());
}
KJS::Value KstBindCurve::barStyle(KJS::ExecState *exec) const {
Q_UNUSED(exec)
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstReadLocker rl(d);
return KJS::Number(d->barStyle());
}
return KJS::Number(0);
}
KJS::Value KstBindCurve::yLabel(KJS::ExecState *exec) const {
Q_UNUSED(exec)
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstReadLocker rl(d);
return KJS::String(d->yLabel());
}
return KJS::String();
}
void KstBindCurve::setYMinusErrorVector(KJS::ExecState *exec, const KJS::Value& value) {
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstVectorPtr vp = extractVector(exec, value);
if (vp) {
KstWriteLocker wl(d);
d->setYMinusError(vp);
}
}
}
KJS::Value KstBindCurve::yMinusErrorVector(KJS::ExecState *exec) const {
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstReadLocker rl(d);
KstVectorPtr vp = d->yMinusErrorVector();
if (vp) {
return KJS::Object(new KstBindVector(exec, vp));
}
}
return KJS::Null();
}
void KstBindCurve::setHasBars(KJS::ExecState *exec, const KJS::Value& value) {
if (value.type() != KJS::BooleanType) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return;
}
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstWriteLocker wl(d);
d->setHasBars(value.toBoolean(exec));
}
}
void KstBindCurve::setBarStyle(KJS::ExecState *exec, const KJS::Value& value) {
unsigned i = 0;
if (value.type() != KJS::NumberType || !value.toUInt32(i)) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return;
}
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstWriteLocker wl(d);
d->setBarStyle(i);
}
}
void KstBindCurve::setColor(KJS::ExecState *exec, const KJS::Value& value) {
QVariant cv = KJSEmbed::convertToVariant(exec, value);
if (!cv.canCast(QVariant::Color)) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return;
}
KstVCurvePtr d = makeCurve(_d);
if (d) {
KstWriteLocker rl(d);
d->setColor(cv.toColor());
}
}
void KstCurveDialogI::edit_I() {
int index;
KstVCurvePtr curve;
KstVCurveList curves = kstObjectSubList<KstDataObject, KstVCurve>(KST::dataObjectList);
index = Select->currentItem();
if (index < 0 || unsigned(index) >= curves.count()) {
new_I();
return;
}
QString tag_name = Select->currentText();
/* verify that the curve name is unique */
if (tag_name != curves[index]->tagName()) {
if (KST::dataTagNameNotUnique(tag_name))
return;
}
curve = curves[index];
curve->setTagName(tag_name);
{ // leave this scope here to destroy the iterator
KstReadLocker ml(&KST::vectorList.lock());
KstVectorList::Iterator i = KST::vectorList.findTag(_xVector->selectedVector());
if (i != KST::vectorList.end())
curve->setXVector(*i);
i = KST::vectorList.findTag(_yVector->selectedVector());
if (i != KST::vectorList.end())
curve->setYVector(*i);
i = KST::vectorList.findTag(_xError->selectedVector());
curve->setXError(*i);
i = KST::vectorList.findTag(_yError->selectedVector());
curve->setYError(*i);
}
curve->setColor(_curveAppearance->color());
curve->setHasPoints(_curveAppearance->showPoints());
curve->setHasLines(_curveAppearance->showLines());
curve->Point.setType(_curveAppearance->pointType());
curve->update(-1);
curve = 0L;
curves.clear();
emit modified();
}
QString KstIfaceImpl::createPowerSpectrum(const QString & name,
const QString& vector,
bool appodize,
bool removeMean,
int fftLength,
const QString& rateUnits,
double sampleRate,
const QString& vectorUnits,
const QColor& color) {
QStringList objList = createPowerSpectrum(name, vector, appodize, removeMean,
fftLength, rateUnits, sampleRate,
vectorUnits);
if (objList.isEmpty())
{
return QString::null;
}
KST::vectorList.lock().readLock();
KstVectorPtr vx = *KST::vectorList.findTag(objList[1]);
KstVectorPtr vy = *KST::vectorList.findTag(objList[2]);
KST::vectorList.lock().unlock();
QString n = objList[0] + "-C";
KST::dataObjectList.lock().readLock();
while (KST::dataObjectList.findTag(n) != KST::dataObjectList.end()) {
n += "'";
}
KST::dataObjectList.lock().unlock();
// create curve as well (but don't plot the curve)
KstVCurvePtr vc = new KstVCurve(n, vx, vy,
0L, 0L, 0L, 0L,
color.isValid() ? color : QColor("darkBlue"));
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(KstDataObjectPtr(vc));
KST::dataObjectList.lock().unlock();
_doc->forceUpdate();
_doc->setModified();
return vc->tagName(); //return the curve name so user can plot it
}
bool KstFilterDialogI::createCurve(KstCPluginPtr plugin) {
KstVectorPtr xVector;
KstVectorPtr yVector;
KST::vectorList.lock().readLock();
KstVectorList::Iterator it = KST::vectorList.findTag(_xvector);
if (it != KST::vectorList.end()) {
xVector = *it;
}
KST::vectorList.lock().unlock();
if (plugin->outputVectors().contains(plugin->plugin()->data()._filterOutputVector)) {
yVector = plugin->outputVectors()[plugin->plugin()->data()._filterOutputVector];
}
if (!xVector || !yVector) {
return false;
}
plugin->setDirty();
QString c_name = KST::suggestCurveName(plugin->tag(), true);
KstVCurvePtr fit = new KstVCurve(c_name, KstVectorPtr(xVector), KstVectorPtr(yVector), KstVectorPtr(0L), KstVectorPtr(0L), KstVectorPtr(0L), KstVectorPtr(0L), _w->_curveAppearance->color());
fit->setHasPoints(_w->_curveAppearance->showPoints());
fit->setHasLines(_w->_curveAppearance->showLines());
fit->setHasBars(_w->_curveAppearance->showBars());
fit->setLineWidth(_w->_curveAppearance->lineWidth());
fit->setLineStyle(_w->_curveAppearance->lineStyle());
fit->pointType = _w->_curveAppearance->pointType();
fit->setBarStyle(_w->_curveAppearance->barStyle());
fit->setPointDensity(_w->_curveAppearance->pointDensity());
KstViewWindow *w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(_window));
if (w && w->view()->findChild(_plotName)) {
Kst2DPlotPtr plot = kst_cast<Kst2DPlot>(w->view()->findChild(_plotName));
if (plot) {
plot->addCurve(fit.data());
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(fit.data());
KST::dataObjectList.lock().unlock();
return true;
}
void KstFilterDialogI::show_setCurve(const QString& curveName,
const QString& plotName,
const QString& window) {
KstBaseCurveList curves = kstObjectSubList<KstDataObject, KstBaseCurve>(KST::dataObjectList);
KstVCurveList vcurves = kstObjectSubList<KstBaseCurve, KstVCurve>(curves);
_window = window;
_plotName = plotName;
_curve = curveName;
// it should be impossible for the curve not to exist so this should
// always be true. If it is false, we do not properly take care of it,
// here and bad things will happen....
KstVCurvePtr curve = *vcurves.findTag(curveName);
if (curve) {
curve->readLock();
_xvector = curve->xVTag().displayString();
_yvector = curve->yVTag().displayString();
curve->unlock();
}
show();
}
const QString& KstIfaceImpl::createCurve(const QString& name, const QString& xVector, const QString& yVector, const QString& xErrorVector, const QString& yErrorVector, const QColor& color) {
QString n = name;
KST::vectorList.lock().readLock();
KstVectorPtr vx = *KST::vectorList.findTag(xVector);
KstVectorPtr vy = *KST::vectorList.findTag(yVector);
KstVectorPtr ex = *KST::vectorList.findTag(xErrorVector);
KstVectorPtr ey = *KST::vectorList.findTag(yErrorVector);
KST::vectorList.lock().unlock();
KST::dataObjectList.lock().writeLock();
while (KST::dataObjectList.findTag(n) != KST::dataObjectList.end()) {
n += "'";
}
KstVCurvePtr c = new KstVCurve(n, vx, vy, ex, ey, ex, ey, color);
KST::dataObjectList.append(KstDataObjectPtr(c));
KST::dataObjectList.lock().unlock();
_doc->forceUpdate();
_doc->setModified();
return c->tagName();
}
QString KstIfaceImpl::createHistogram(const QString& name,
const QString& vector,
double min,
double max,
int numBins,
int normalizationType,
const QColor& color) {
QStringList objList = createHistogram(name, vector, min, max, numBins, normalizationType);
if (objList.isEmpty())
{
return QString::null;
}
// also create the curve for the histogram
QString n = objList[0] + "-C";
KST::vectorList.lock().readLock();
KstVectorPtr vx = *KST::vectorList.findTag(objList[1]);
KstVectorPtr vy = *KST::vectorList.findTag(objList[2]);
KST::vectorList.lock().unlock();
KST::dataObjectList.lock().readLock();
while (KST::dataObjectList.findTag(n) != KST::dataObjectList.end()) {
n += "'";
}
KST::dataObjectList.lock().unlock();
KstVCurvePtr c = new KstVCurve(n, vx, vy, 0L, 0L, 0L, 0L, color);
c->setHasPoints(false);
c->setHasLines(false);
c->setHasBars(true);
c->setBarStyle(1);
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(KstDataObjectPtr(c));
KST::dataObjectList.lock().unlock();
_doc->forceUpdate();
_doc->setModified();
return c->tagName(); //return the curve name so user can plot it
}
bool KstPsdDialog::newObject() {
QString tag_name = _tagName->text();
bool retVal = false;
if (tag_name == defaultTag) {
tag_name = KST::suggestPSDName(KstObjectTag::fromString(_w->_vector->selectedVector()));
}
if (KstData::self()->dataTagNameNotUnique(tag_name)) {
_tagName->setFocus();
return false;
}
if (_w->_vector->selectedVector().isEmpty()) {
QMessageBox::warning(this, QObject::tr("Kst"), QObject::tr("New spectrum not made: define vectors first."));
return false;
}
KST::vectorList.lock().readLock();
KstVectorPtr p = *KST::vectorList.findTag(_w->_vector->selectedVector());
KST::vectorList.lock().unlock();
if (_w->_kstFFTOptions->checkValues()) {
if (p) {
KstVCurvePtr vc;
KstPSDPtr psd;
QColor color;
p->readLock();
psd = new KstPSD(tag_name, p,
_w->_kstFFTOptions->SampRate->text().toDouble(),
_w->_kstFFTOptions->Interleaved->isChecked(),
_w->_kstFFTOptions->FFTLen->text().toInt(),
_w->_kstFFTOptions->Apodize->isChecked(),
_w->_kstFFTOptions->RemoveMean->isChecked(),
_w->_kstFFTOptions->VectorUnits->text(),
_w->_kstFFTOptions->RateUnits->text(),
ApodizeFunction(_w->_kstFFTOptions->ApodizeFxn->currentIndex()),
_w->_kstFFTOptions->Sigma->value(),
PSDType(_w->_kstFFTOptions->Output->currentIndex()));
psd->setInterpolateHoles(_w->_kstFFTOptions->InterpolateHoles->isChecked());
p->unlock();
// xxx color = KstApp::inst()->chooseColorDlg()->getColorForCurve(psd->vX(), psd->vY());
if (!color.isValid()) {
color = _w->_curveAppearance->color();
}
vc = new KstVCurve(KST::suggestCurveName(psd->tag(),true), psd->vX(), psd->vY(), KstVectorPtr(), KstVectorPtr(), KstVectorPtr(), KstVectorPtr(), color);
vc->setHasPoints(_w->_curveAppearance->showPoints());
vc->setHasLines(_w->_curveAppearance->showLines());
vc->setHasBars(_w->_curveAppearance->showBars());
vc->setPointStyle(_w->_curveAppearance->pointType());
vc->setLineWidth(_w->_curveAppearance->lineWidth());
vc->setLineStyle(_w->_curveAppearance->lineStyle());
vc->setBarStyle(_w->_curveAppearance->barStyle());
vc->setPointDensity(_w->_curveAppearance->pointDensity());
QString legend_text = _legendText->text();
if (legend_text == defaultTag) {
vc->setLegendText(QString::null);
} else {
vc->setLegendText(legend_text);
}
Kst2DPlotPtr plot;
KstViewWindow *w;
/* xxx
w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(_w->_curvePlacement->_plotWindow->currentText()));
if (!w) {
QString n = KstApp::inst()->newWindow(KST::suggestWinName());
w = static_cast<KstViewWindow*>(KstApp::inst()->findWindow(n));
}
*/
if (w) {
if (_w->_curvePlacement->existingPlot()) {
plot = kst_cast<Kst2DPlot>(w->view()->findChild(_w->_curvePlacement->plotName()));
if (plot) {
plot->addCurve(vc);
}
}
if (_w->_curvePlacement->newPlot()) {
QString name = w->createPlot(KST::suggestPlotName());
if (_w->_curvePlacement->reGrid()) {
w->view()->cleanup(_w->_curvePlacement->columns());
}
plot = kst_cast<Kst2DPlot>(w->view()->findChild(name));
if (plot) {
plot->setXAxisInterpretation(false, KstAxisInterpretation(), KstAxisDisplay());
plot->setYAxisInterpretation(false, KstAxisInterpretation(), KstAxisDisplay());
_w->_curvePlacement->update();
_w->_curvePlacement->setCurrentPlot(plot->tagName());
plot->addCurve(vc);
plot->generateDefaultLabels();
}
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(psd);
KST::dataObjectList.append(vc);
KST::dataObjectList.lock().unlock();
psd = 0L;
vc = 0L;
emit modified();
retVal = true;
}
}
return retVal;
}
void KstCurveDialogI::new_I() {
KstWriteLocker ml(&KST::vectorList.lock());
KstVectorList::Iterator VX, VY;
KstVectorList::Iterator EX, EY;
KstVCurvePtr curve;
KstPlot *plot;
if (_xVector->selectedVector().isEmpty()) {
KMessageBox::sorry(0L, i18n("New curve not made: define vectors first."));
return;
}
/* find VX and VY */
VX = KST::vectorList.findTag(_xVector->selectedVector());
VY = KST::vectorList.findTag(_yVector->selectedVector());
EX = KST::vectorList.findTag(_xError->selectedVector());
EY = KST::vectorList.findTag(_yError->selectedVector());
if (VX == KST::vectorList.end() || VY == KST::vectorList.end()) {
kdFatal() << "Bug in kst: the XVector field in plotDialog refers to "
<< "a non existant vector...." << endl;
}
KstReadLocker rl1(*VX), rl2(*VY);
QString tag_name = Select->currentText();
tag_name.replace(i18n("<New_Curve>"), (*VY)->tagName());
/* verify that the curve name is unique */
if (KST::dataTagNameNotUnique(tag_name)) {
return;
}
/* create the curve */
curve = new KstVCurve(tag_name, *VX, *VY,
EX != KST::vectorList.end() ? *EX : KstVectorPtr(0L),
EY != KST::vectorList.end() ? *EY : KstVectorPtr(0L),
_curveAppearance->color());
curve->setHasPoints(_curveAppearance->showPoints());
curve->setHasLines(_curveAppearance->showLines());
curve->Point.setType(_curveAppearance->pointType());
if (_curvePlacement->existingPlot()) {
/* assign curve to plot */
plot = KST::plotList.FindKstPlot(_curvePlacement->plotName());
plot->addCurve(curve);
}
if (_curvePlacement->newPlot()) {
/* assign curve to plot */
plot = KST::plotList.addPlot(QString::null, _curvePlacement->columns());
_curvePlacement->appendPlot(plot->tagName(), true);
plot->addCurve(curve);
plot->GenerateDefaultLabels();
}
KST::dataObjectList.lock().readLock();
KST::dataObjectList.append(curve.data());
KST::dataObjectList.lock().writeUnlock();
curve = 0L;
emit modified();
}
KJS::Object KstBindCurve::construct(KJS::ExecState *exec, const KJS::List& args) {
KstVectorPtr x, y, ex, ey, exm, eym;
if (args.size() > 0) {
x = extractVector(exec, args[0]);
if (!x) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Object();
}
}
if (args.size() > 1) {
y = extractVector(exec, args[1]);
if (!y) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Object();
}
}
if (args.size() > 2) {
ex = extractVector(exec, args[2]);
if (!ex) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Object();
}
}
if (args.size() > 3) {
ey = extractVector(exec, args[3]);
if (!ey) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Object();
}
}
if (args.size() > 4) {
exm = extractVector(exec, args[4]);
if (!exm) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Object();
}
}
if (args.size() > 5) {
eym = extractVector(exec, args[5]);
if (!eym) {
KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
exec->setException(eobj);
return KJS::Object();
}
}
if (args.size() > 6) {
KJS::Object eobj = KJS::Error::create(exec, KJS::SyntaxError);
exec->setException(eobj);
return KJS::Object();
}
if (!x || !y) { // force at least X and Y vectors
KJS::Object eobj = KJS::Error::create(exec, KJS::SyntaxError);
exec->setException(eobj);
return KJS::Object();
}
QColor color = KstColorSequence::next();
KstVCurvePtr d = new KstVCurve(QString::null, x, y, ex, ey, exm, eym, color);
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(d.data());
KST::dataObjectList.lock().writeUnlock();
return KJS::Object(new KstBindCurve(exec, d));
}
void KstCurveDialogI::update(int new_index) {
int i_curve;
KstVCurvePtr curve;
int index;
bool isNew = false;
int n_v, n_c;
KstVCurveList curves = kstObjectSubList<KstDataObject, KstVCurve>(KST::dataObjectList);
if (new_index == -1) {
if (curves.findTag(Select->currentText()) != curves.end()) {
QString save = Select->currentText();
Select->blockSignals(true);
Select->clear();
for (KstVCurveList::iterator i = curves.begin(); i != curves.end(); ++i) {
Select->insertItem((*i)->tagName());
}
Select->setCurrentText(save);
Select->blockSignals(false);
return;
}
}
/**********************/
/* initialize indexes */
KST::vectorList.lock().readLock();
n_v = KST::vectorList.count();
KST::vectorList.lock().readUnlock();
n_c = curves.count();
if (new_index == -2) { // initialize for new curve
isNew = true;
index = n_c;
} else if (n_c < 1) {
isNew = true;
index = 0;
} else if (new_index >= 0 && new_index < n_c) { // initialize specific curve
index = new_index;
} else if (Select->count() > 0) { // initialize for old default
index = Select->currentItem();
} else { // initialize for last in list
index = n_c - 1;
}
/*****************************************/
/* fill the Select combo with curve tags */
Select->clear();
for (KstVCurveList::iterator i = curves.begin(); i != curves.end(); ++i) {
Select->insertItem((*i)->tagName());
}
if (isNew) {
QString new_label;
new_label.sprintf("C%d-", curves.count()+1);
new_label += i18n("<New_Curve>");
Select->insertItem(new_label);
}
if ((index>=0) && (index<Select->count())) {
Select->setCurrentItem(index);
}
/*******************************************/
/* fill the Vector lists with vector names */
_xVector->update();
_yVector->update();
_xError->update();
_yError->update();
/***********************************/
/* set the curve placement window */
_curvePlacement->setPlotList(KST::plotList.tagNames(), true);
_curvePlacement->setColumns(KST::plotList.getPlotCols());
if (isNew) {
// guess what placement option is wanted
if (!KST::plotList.isEmpty() && curves.count() > KST::plotList.count()) {
_curvePlacement->setNewPlot(false);
_curvePlacement->setExistingPlot(true);
} else {
_curvePlacement->setNewPlot(true);
_curvePlacement->setExistingPlot(false);
}
}
/****************************************************/
/* set the vector pull downs to the correct vectors */
if (n_c > 0 && !isNew) {
i_curve = Select->currentItem();
curve = curves[i_curve];
_xVector->setSelection(curve->getXVTag());
_yVector->setSelection(curve->getYVTag());
_xError->setSelection(curve->getXETag());
_yError->setSelection(curve->getYETag());
_curveAppearance->setValue(curve->hasLines(), curve->hasPoints(), curve->getColor(), curve->Point.getType());
Delete->setEnabled(curve->getUsage() == 2);
} else { /* no curves defined - initialize what we can to vector 0 */
_curveAppearance->reset();
Delete->setEnabled(false);
}
}
/* returns true if succesful */
bool KstPsdDialogI::newObject() {
QString tag_name = _tagName->text();
if (tag_name == defaultTag) {
tag_name = KST::suggestPSDName(KstObjectTag::fromString(_w->_vector->selectedVector()));
}
// verify that the curve name is unique
if (KstData::self()->dataTagNameNotUnique(tag_name)) {
_tagName->setFocus();
return false;
}
if (_w->_vector->selectedVector().isEmpty()) {
KMessageBox::sorry(this, i18n("New PSD not made: define vectors first."));
return false;
}
KST::vectorList.lock().readLock();
KstVectorPtr p = *KST::vectorList.findTag(_w->_vector->selectedVector());
KST::vectorList.lock().unlock();
if (!p) {
kstdFatal() << "Bug in kst: the vector field (PSD) refers to "
<< "a non existant vector...." << endl;
}
// create the psd curve
if (!_w->_kstFFTOptions->checkValues()) {
return false;
} else {
p->readLock();
KstPSDPtr psd = new KstPSD(tag_name, p,
_w->_kstFFTOptions->SampRate->text().toDouble(),
_w->_kstFFTOptions->Interleaved->isChecked(),
_w->_kstFFTOptions->FFTLen->text().toInt(),
_w->_kstFFTOptions->Apodize->isChecked(),
_w->_kstFFTOptions->RemoveMean->isChecked(),
_w->_kstFFTOptions->VectorUnits->text(),
_w->_kstFFTOptions->RateUnits->text(),
ApodizeFunction(_w->_kstFFTOptions->ApodizeFxn->currentItem()),
_w->_kstFFTOptions->Sigma->value(),
PSDType(_w->_kstFFTOptions->Output->currentItem()));
psd->setInterpolateHoles(_w->_kstFFTOptions->InterpolateHoles->isChecked());
p->unlock();
KstVCurvePtr vc = new KstVCurve(KST::suggestCurveName(psd->tag(),true), psd->vX(), psd->vY(), 0L, 0L, 0L, 0L, _w->_curveAppearance->color());
vc->setHasPoints(_w->_curveAppearance->showPoints());
vc->setHasLines(_w->_curveAppearance->showLines());
vc->setHasBars(_w->_curveAppearance->showBars());
vc->pointType = _w->_curveAppearance->pointType();
vc->setLineWidth(_w->_curveAppearance->lineWidth());
vc->setLineStyle(_w->_curveAppearance->lineStyle());
vc->setBarStyle(_w->_curveAppearance->barStyle());
vc->setPointDensity(_w->_curveAppearance->pointDensity());
QString legend_text = _legendText->text();
if (legend_text == defaultTag) {
vc->setLegendText(QString::null);
} else {
vc->setLegendText(legend_text);
}
Kst2DPlotPtr plot;
KstViewWindow *w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(_w->_curvePlacement->_plotWindow->currentText()));
if (!w) {
QString n = KstApp::inst()->newWindow(KST::suggestWinName());
w = static_cast<KstViewWindow*>(KstApp::inst()->findWindow(n));
}
if (w) {
if (_w->_curvePlacement->existingPlot()) {
// assign curve to plot
plot = kst_cast<Kst2DPlot>(w->view()->findChild(_w->_curvePlacement->plotName()));
if (plot) {
plot->addCurve(vc.data());
}
}
if (_w->_curvePlacement->newPlot()) {
// assign curve to plot
QString name = w->createObject<Kst2DPlot>(KST::suggestPlotName());
if (_w->_curvePlacement->reGrid()) {
w->view()->cleanup(_w->_curvePlacement->columns());
}
plot = kst_cast<Kst2DPlot>(w->view()->findChild(name));
if (plot) {
plot->setXAxisInterpretation(false, KstAxisInterpretation(), KstAxisDisplay());
plot->setYAxisInterpretation(false, KstAxisInterpretation(), KstAxisDisplay());
_w->_curvePlacement->update();
_w->_curvePlacement->setCurrentPlot(plot->tagName());
plot->addCurve(vc.data());
plot->generateDefaultLabels();
}
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(psd.data());
KST::dataObjectList.append(vc.data());
KST::dataObjectList.lock().unlock();
psd = 0L;
vc = 0L;
emit modified();
}
return true;
}
bool KstHsDialog::newObject() {
QString tag_name = _tagName->text();
if (tag_name == defaultTag) {
tag_name = KST::suggestHistogramName(KstObjectTag::fromString(_w->_vector->selectedVector()));
}
//
// verify that the curve name is unique...
//
if (KstData::self()->dataTagNameNotUnique(tag_name)) {
_tagName->setFocus();
return false;
}
if (_w->_vector->selectedVector().isEmpty()) {
QMessageBox::warning(this, QObject::tr("Kst"), QObject::tr("New Histogram not made: define vectors first."));
return false;
}
//
// find max and min...
//
double new_min = _w->Min->text().toDouble();
double new_max = _w->Max->text().toDouble();
if (new_max < new_min) {
double m = new_max;
new_max = new_min;
new_min = m;
}
if (new_max == new_min) {
QMessageBox::warning(this, QObject::tr("kst"), QObject::tr("Max and Min can not be equal."));
return false;
}
int new_n_bins = _w->N->text().toInt();
if (new_n_bins < 1) {
QMessageBox::warning(this, QObject::tr("kst"), QObject::tr("You must have one or more bins in a histogram."));
return false;
}
KstHsNormType new_norm_mode;
if (_w->NormIsPercent->isChecked()) {
new_norm_mode = KST_HS_PERCENT;
} else if (_w->NormIsFraction->isChecked()) {
new_norm_mode = KST_HS_FRACTION;
} else if (_w->PeakIs1->isChecked()) {
new_norm_mode = KST_HS_MAX_ONE;
} else {
new_norm_mode = KST_HS_NUMBER;
}
KstHistogramPtr hs;
KST::vectorList.lock().readLock();
KstVectorPtr vp = *KST::vectorList.findTag(_w->_vector->selectedVector());
KST::vectorList.lock().unlock();
if (vp) {
KstVCurvePtr vc;
KstViewWindow *w;
QColor color;
vp->readLock();
hs = new KstHistogram(tag_name, vp, new_min, new_max,
new_n_bins, new_norm_mode);
vp->unlock();
hs->setRealTimeAutoBin(_w->_realTimeAutoBin->isChecked());
// xxx color = KstApp::inst()->chooseColorDlg()->getColorForCurve(hs->vX(), hs->vY());
if (!color.isValid()) {
color = _w->_curveAppearance->color();
}
vc = new KstVCurve(KST::suggestCurveName(hs->tag(), true), hs->vX(), hs->vY(), KstVectorPtr(), KstVectorPtr(), KstVectorPtr(), KstVectorPtr(), color);
vc->setHasPoints(_w->_curveAppearance->showPoints());
vc->setHasLines(_w->_curveAppearance->showLines());
vc->setHasBars(_w->_curveAppearance->showBars());
vc->setPointStyle(_w->_curveAppearance->pointType());
vc->setLineWidth(_w->_curveAppearance->lineWidth());
vc->setLineStyle(_w->_curveAppearance->lineStyle());
vc->setBarStyle(_w->_curveAppearance->barStyle());
vc->setPointDensity(_w->_curveAppearance->pointDensity());
QString legendText = _legendText->text();
if (legendText == defaultTag) {
vc->setLegendText(QString(""));
} else {
vc->setLegendText(legendText);
}
/* xxx
w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(_w->_curvePlacement->_plotWindow->currentText()));
*/
if (!w) {
QString n = KstApp::inst()->newWindow(KST::suggestWinName());
// xxx w = static_cast<KstViewWindow*>(KstApp::inst()->findWindow(n));
}
if (w) {
Kst2DPlotPtr plot;
if (_w->_curvePlacement->existingPlot()) {
plot = kst_cast<Kst2DPlot>(w->view()->findChild(_w->_curvePlacement->plotName()));
if (plot) {
plot->addCurve(vc);
}
}
if (_w->_curvePlacement->newPlot()) {
QString name = w->createPlot(KST::suggestPlotName());
if (_w->_curvePlacement->reGrid()) {
w->view()->cleanup(_w->_curvePlacement->columns());
}
plot = kst_cast<Kst2DPlot>(w->view()->findChild(name));
if (plot) {
_w->_curvePlacement->update();
_w->_curvePlacement->setCurrentPlot(plot->tagName());
plot->addCurve(vc);
plot->generateDefaultLabels();
}
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(hs);
KST::dataObjectList.append(vc);
KST::dataObjectList.lock().unlock();
hs = 0L;
vc = 0L;
emit modified();
}
return true;
}
KstBindCurve::KstBindCurve(KJS::ExecState *exec, KstVCurvePtr d)
: KstBindDataObject(exec, d.data(), "Curve") {
KJS::Object o(this);
addBindings(exec, o);
}
bool KstEqDialog::newObject() {
QString tag_name = _tagName->text();
QString etext = _w->_equation->text();
etext.remove(QRegExp("[^a-zA-Z0-9\\(\\)\\+\\-\\*/\\%\\^\\|\\&\\!<>=_.]"));
etext.replace(KstObjectTag::tagSeparator, KstObjectTag::tagSeparatorReplacement);
if (etext.length() > 12) {
etext.truncate(12);
etext += "...";
}
if (tag_name == defaultTag) {
tag_name = KST::suggestEQName(etext);
}
if (KstData::self()->dataTagNameNotUnique(tag_name)) {
_tagName->setFocus();
return false;
}
if (!checkEntries()) {
return false;
}
KST::vectorList.lock().readLock();
KstVectorPtr vp = *KST::vectorList.findTag(_w->_xVectors->selectedVector());
if (vp) {
KST::vectorList.lock().unlock();
KstEquationPtr eq;
eq = new KstEquation(tag_name, _w->_equation->text(), vp, _w->_doInterpolation->isChecked());
if (!eq->isValid()) {
QStringList::const_iterator i;
QString strWarning = QObject::tr("There is an error in the equation you entered.\n");
eq = 0L;
for (i = Equation::errorStack.begin(); i != Equation::errorStack.end(); ++i) {
strWarning += *i;
strWarning += "\n";
}
QMessageBox::warning(this, QObject::tr("Kst"), strWarning);
return false;
}
KstVCurvePtr vc;
QColor color;
// xxx color = KstApp::inst()->chooseColorDlg()->getColorForCurve(eq->vX(), eq->vY());
if (!color.isValid()) {
color = _w->_curveAppearance->color();
}
vc = new KstVCurve(KST::suggestCurveName(eq->tag(), true), eq->vX(), eq->vY(), KstVectorPtr(), KstVectorPtr(), KstVectorPtr(), KstVectorPtr(), color);
vc->setHasPoints(_w->_curveAppearance->showPoints());
vc->setHasLines(_w->_curveAppearance->showLines());
vc->setHasBars(_w->_curveAppearance->showBars());
vc->setLineWidth(_w->_curveAppearance->lineWidth());
vc->setLineStyle(_w->_curveAppearance->lineStyle());
vc->setPointStyle(_w->_curveAppearance->pointType());
vc->setPointDensity(_w->_curveAppearance->pointDensity());
vc->setBarStyle(_w->_curveAppearance->barStyle());
QString legend_text = _legendText->text();
if (legend_text == defaultTag) {
vc->setLegendText(QString(""));
} else {
vc->setLegendText(legend_text);
}
KstViewWindow *w;
/* xxx
w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(_w->_curvePlacement->_plotWindow->currentText()));
if (!w) {
QString n = KstApp::inst()->newWindow(KST::suggestWinName());
w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(n));
}
*/
if (w) {
Kst2DPlotPtr plot;
if (_w->_curvePlacement->existingPlot()) {
plot = kst_cast<Kst2DPlot>(w->view()->findChild(_w->_curvePlacement->plotName()));
if (plot) {
plot->addCurve(vc);
}
}
if (_w->_curvePlacement->newPlot()) {
QString name = w->createPlot(KST::suggestPlotName());
if (_w->_curvePlacement->reGrid()) {
w->view()->cleanup(_w->_curvePlacement->columns());
}
plot = kst_cast<Kst2DPlot>(w->view()->findChild(name));
if (plot) {
_w->_curvePlacement->update();
_w->_curvePlacement->setCurrentPlot(plot->tagName());
plot->addCurve(vc);
plot->generateDefaultLabels();
}
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(eq);
KST::dataObjectList.append(vc);
KST::dataObjectList.lock().unlock();
//
// drop the reference before we update...
//
eq = 0L;
vc = 0L;
emit modified();
}
return true;
}
bool KstEqDialogI::newObject() {
QString tag_name = _tagName->text();
QString etext = _w->_equation->text();
etext.remove(QRegExp("[^a-zA-Z0-9\\(\\)\\+\\-\\*/\\%\\^\\|\\&\\!<>=_.]"));
if (etext.length() > 12) {
etext.truncate(12);
etext += "...";
}
if (tag_name == defaultTag) {
tag_name = KST::suggestEQName(etext);
}
/* verify that the curve name is unique */
if (KstData::self()->dataTagNameNotUnique(tag_name)) {
_tagName->setFocus();
return false;
}
if (!checkEntries()) {
return false;
}
KST::vectorList.lock().readLock();
/* find *V */
KstVectorPtr vp = *KST::vectorList.findTag(_w->_xVectors->selectedVector());
if (!vp) {
kstdFatal() << "Bug in kst: the Vector field (Eq) "
<< "refers to a non-existent vector..." << endl;
}
KST::vectorList.lock().unlock();
/** Create the equation here */
vp->readLock();
KstEquationPtr eq = new KstEquation(tag_name, _w->_equation->text(), vp, _w->_doInterpolation->isChecked());
vp->unlock();
if (!eq->isValid()) {
eq = 0L;
QString parseErrors;
for (QStringList::ConstIterator i = Equation::errorStack.begin(); i != Equation::errorStack.end(); ++i) {
parseErrors += *i;
parseErrors += "\n";
}
KMessageBox::detailedSorry(this, i18n("There is an error in the equation you entered."), parseErrors);
return false;
}
KstVCurvePtr vc = new KstVCurve(KST::suggestCurveName(tag_name, true), eq->vX(), eq->vY(), 0L, 0L, 0L, 0L, _w->_curveAppearance->color());
vc->setHasPoints(_w->_curveAppearance->showPoints());
vc->setHasLines(_w->_curveAppearance->showLines());
vc->setHasBars(_w->_curveAppearance->showBars());
vc->setLineWidth(_w->_curveAppearance->lineWidth());
vc->setLineStyle(_w->_curveAppearance->lineStyle());
vc->pointType = _w->_curveAppearance->pointType();
vc->setPointDensity(_w->_curveAppearance->pointDensity());
vc->setBarStyle(_w->_curveAppearance->barStyle());
QString legend_text = _legendText->text();
if (legend_text == defaultTag) {
vc->setLegendText(QString(""));
} else {
vc->setLegendText(legend_text);
}
KstViewWindow *w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(_w->_curvePlacement->_plotWindow->currentText()));
if (!w) {
QString n = KstApp::inst()->newWindow(KST::suggestWinName());
w = dynamic_cast<KstViewWindow*>(KstApp::inst()->findWindow(n));
}
if (w) {
Kst2DPlotPtr plot;
if (_w->_curvePlacement->existingPlot()) {
/* assign curve to plot */
plot = kst_cast<Kst2DPlot>(w->view()->findChild(_w->_curvePlacement->plotName()));
if (plot) {
plot->addCurve(vc.data());
}
}
if (_w->_curvePlacement->newPlot()) {
/* assign curve to plot */
QString name = w->createObject<Kst2DPlot>(KST::suggestPlotName());
if (_w->_curvePlacement->reGrid()) {
w->view()->cleanup(_w->_curvePlacement->columns());
}
plot = kst_cast<Kst2DPlot>(w->view()->findChild(name));
if (plot) {
_w->_curvePlacement->update();
_w->_curvePlacement->setCurrentPlot(plot->tagName());
plot->addCurve(vc.data());
plot->generateDefaultLabels();
}
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(eq.data());
KST::dataObjectList.append(vc.data());
KST::dataObjectList.lock().unlock();
eq = 0L; // drop the reference before we update
vc = 0L;
emit modified();
return true;
}
int main(int argc, char *argv[]) {
int i_file, i_v, i_curve;
int i_plot;
QString fullPath;
KAboutData aboutData("kst", I18N_NOOP("Kst"),
KSTVERSION, description, KAboutData::License_GPL,
I18N_NOOP("(c) 2000-2007 Barth Netterfield"),
0,
"http://kst.kde.org/");
aboutData.addAuthor("Barth Netterfield",
I18N_NOOP("Original author and maintainer."),
"*****@*****.**",
"http://omega.astro.utoronto.ca/");
aboutData.addAuthor("Staikos Computing Services Inc.",
I18N_NOOP("Developed for the University of Toronto."),
"*****@*****.**",
"http://www.staikos.net/");
aboutData.addAuthor("Sumus Technology Limited",
I18N_NOOP("Developed for the University of British Columbia"),
"*****@*****.**",
"http://www.sumusltd.com/");
aboutData.addAuthor("Rick Chern",
I18N_NOOP("University of British Columbia"),
"",
"");
aboutData.addAuthor("Duncan Hanson",
I18N_NOOP("University of British Columbia"),
"",
"");
aboutData.addAuthor("Nicolas Brisset",
"",
"",
"");
aboutData.addAuthor("Matthew Truch",
"",
"http://matt.truch.net/",
"*****@*****.**");
aboutData.addAuthor("Theodore Kisner",
"",
"*****@*****.**",
"");
aboutData.setTranslator(I18N_NOOP("_: NAME OF TRANSLATORS\nYour names"),
I18N_NOOP("_: EMAIL OF TRANSLATORS\nYour emails"));
KCmdLineArgs::init( argc, argv, &aboutData );
KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
KApplication app;
KImageIO::registerFormats();
KstDialogs::replaceSelf(new KstGuiDialogs);
KstData::replaceSelf(new KstGuiData);
KstApp::initialize();
atexit(exitHelper);
if (app.isRestored()) {
RESTORE(KstApp)
} else {
KstApp *kst = new KstApp;
InType in;
QColor color;
QCStringList ycolList;
QCStringList matrixList;
QCStringList yEqList;
QCStringList psdList;
QCStringList hsList;
QCStringList errorList;
unsigned int i_ycol;
QCStringList::Iterator hs_string;
QCStringList::Iterator eq_i;
QCStringList::Iterator mat_i;
bool showQuickStart = false;
bool showDataWizard = false;
bool nOK;
int n_y = 0;
KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
CheckForCMDErrors(args);
QString wizardfile = args->getOption("w");
QString printfile = args->getOption("print");
QString pngfile = args->getOption("png");
bool print_and_exit = false;
if (printfile != "<none>") {
print_and_exit = true;
}
if (pngfile != "<none>") {
print_and_exit = true;
}
if (!print_and_exit) {
app.setMainWidget(kst);
QRect rect = KGlobalSettings::desktopGeometry(kst);
kst->resize(5 * rect.width() / 6, 5 * rect.height() / 6);
kst->show();
}
// get Y axis columns
ycolList = args->getOptionList("y");
matrixList = args->getOptionList("z");
yEqList = args->getOptionList("ye");
psdList = args->getOptionList("p");
hsList = args->getOptionList("h");
errorList = args->getOptionList("e");
// y axis or PSD specified, so the files are data files, not kst files.
n_y = ycolList.count() + psdList.count() + hsList.count() + yEqList.count() + matrixList.count();
if (n_y > 0) {
QString creatingEquations = i18n("Creating equations");
QString creatingCurves = i18n("Creating curves");
QString creatingPlots = i18n("Creating plots");
int count;
int handled;
kst->slotUpdateProgress( 0, 0, QString::null );
SetCMDOptions(args, in, n_y);
KstTopLevelViewPtr tlv = kst->activeView();
if (!tlv) {
// if there was no active view then we create one...
kst->newWindow(false);
tlv = kst->activeView();
}
if (!tlv) {
kstdError() << i18n("Can't create a view.") << endl;
return 0;
}
CreatePlots(in, tlv);
Kst2DPlotList plist = kstObjectSubList<KstViewObject, Kst2DPlot>(tlv->children());
i_plot = 0;
Kst2DPlotPtr plot = *plist.at(i_plot);
KstVCurveList vcurves = kstObjectSubList<KstBaseCurve,KstVCurve>(plot->Curves);
// make stand alone equations if there are no files
if (args->count() < 1) {
if (!yEqList.isEmpty()) {
QString eqS;
double max, min;
int n;
bool xeq;
SetEqXRanges(args->getOption("xe"), &min, &max, &n, &xeq);
if (xeq) {
count = yEqList.size();
handled = 0;
kst->slotUpdateProgress( count, handled, creatingEquations );
for (eq_i = yEqList.begin(); eq_i != yEqList.end(); ++eq_i) {
eqS = *eq_i;
if (NoVectorEq(eqS)) {
KstEquationPtr eq = new KstEquation(KST::suggestEQName(eqS), eqS, min, max, n);
KstVCurvePtr vc = new KstVCurve(KST::suggestCurveName(eq->tag(), true),
eq->vX(), eq->vY(), 0L, 0L, 0L, 0L,
KstColorSequence::next(vcurves,plot->backgroundColor()));
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(eq.data());
KST::dataObjectList.append(vc.data());
KST::dataObjectList.lock().unlock();
plot->addCurve(vc.data());
if (in.sep_plots) {
i_plot++;
if (i_plot < in.n_plots) {
plot = *plist.at(i_plot);
}
}
}
handled++;
kst->slotUpdateProgress( count, handled, creatingEquations );
}
}
}
}
// make the requested curves for each data file
count = args->count();
handled = 0;
kst->slotUpdateProgress( count, handled, creatingCurves );
for (i_curve = i_v = 0, i_file = 0; i_file < args->count(); i_file++) {
// make the file
if (QFile::exists(args->arg(i_file))) {
fullPath = QFileInfo(args->arg(i_file)).absFilePath();
} else {
fullPath = args->arg(i_file);
}
KstDataSourcePtr file = KstDataSource::loadSource(fullPath);
if (file) {
if (!file->isValid() || file->isEmpty()) {
kstdError() << i18n("No data in file %1. Trying to continue...").arg(args->arg(i_file)) << endl;
// The file might get data later!
}
KST::dataObjectList.lock().writeLock();
KST::dataSourceList.append(file);
KST::dataObjectList.lock().unlock();
KstRVectorPtr yvector;
KstRVectorPtr evector;
KstVCurvePtr curve;
KstPSDPtr psd;
KstHistogramPtr hs;
KstRVectorPtr xvector;
if (!ycolList.isEmpty()) { // if there are some xy plots
// make the x axis vector
xvector = GetOrCreateVector(args->getOption("x"), file, in);
if (xvector) {
// make the y axis vectors
for (i_ycol = 0; i_ycol < ycolList.count(); ++i_ycol ) {
yvector = GetOrCreateVector(*(ycolList.at(i_ycol)), file, in);
if (yvector) {
// make the curves
color = KstColorSequence::next(vcurves,plot->backgroundColor());
curve = new KstVCurve(KST::suggestCurveName(yvector->tag(), false),
KstVectorPtr(xvector), KstVectorPtr(yvector),
0L, 0L, 0L, 0L, color);
if (in.has_points) {
curve->setHasPoints(true);
curve->setHasLines(false);
}
if (i_ycol<errorList.count()) {
evector = GetOrCreateVector(*(errorList.at(i_ycol)), file, in);
if (evector) {
curve->setYError(KstVectorPtr(evector));
curve->setYMinusError(KstVectorPtr(evector));
}
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(curve.data());
KST::dataObjectList.lock().unlock();
plot->addCurve(curve.data());
if (in.sep_plots) {
plot->setTagName(curve->tag());
i_plot++;
if (i_plot < in.n_plots) {
plot = *plist.at(i_plot);
}
} // end (if they are separate plots)
}
} // next y col
}
} // end (if there are some xy plots)
if (!yEqList.isEmpty()) {
QString eqS;
double max, min;
int n;
bool xeq, eq_ok;
SetEqXRanges(args->getOption("xe"), &min, &max, &n, &xeq);
for (eq_i = yEqList.begin(); eq_i != yEqList.end(); ++eq_i) {
KstEquationPtr eq;
eqS = *eq_i;
ProcessEq(eqS, file, in, &eq_ok);
if (xeq) {
eq = new KstEquation(KST::suggestEQName(eqS), eqS, min,max,n);
} else {
if (!xvector) {
xvector = GetOrCreateVector(args->getOption("x"), file, in);
}
if (xvector) {
eq = new KstEquation(KST::suggestEQName(eqS), eqS, KstVectorPtr(xvector), true);
}
}
if (eq) {
KstVCurvePtr vc = new KstVCurve(KST::suggestCurveName(eq->tag(), true),
eq->vX(), eq->vY(), 0L, 0L, 0L, 0L,
KstColorSequence::next(vcurves,plot->backgroundColor()));
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(eq.data());
KST::dataObjectList.append(vc.data());
KST::dataObjectList.lock().unlock();
plot->addCurve(vc.data());
if (in.sep_plots) {
plot->setTagName(eq->tag());
i_plot++;
if (i_plot <in.n_plots) {
plot = *plist.at(i_plot);
}
}
}
}
}
if (psdList.count() > 0) { // if there are some psd plots
KstRVectorList rvl = kstObjectSubList<KstVector,KstRVector>(KST::vectorList);
for (QCStringList::ConstIterator it = psdList.begin(); it != psdList.end(); ++it) {
yvector = GetOrCreateVector(*it, file, in);
if (yvector) {
color = KstColorSequence::next(vcurves,plot->backgroundColor());
psd = new KstPSD( KST::suggestPSDName(yvector->tag()), // FIXME: this was yvector->field(), is this right?
KstVectorPtr(yvector), in.rate, true, in.len,
true, true, in.VUnits, in.RUnits, WindowOriginal);
KstVCurvePtr vc = new KstVCurve(KST::suggestCurveName(psd->tag(), true),
psd->vX(), psd->vY(), 0L, 0L, 0L, 0L, color);
if (in.has_points) {
vc->setHasPoints(true);
vc->setHasLines(false);
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(psd.data());
KST::dataObjectList.append(vc.data());
KST::dataObjectList.lock().unlock();
plot->addCurve(vc.data());
if (in.sep_plots) {
plot->setTagName(psd->tag());
i_plot++;
if (i_plot <in.n_plots) {
plot = *plist.at(i_plot);
}
}
}
} // next psd
} // end (if there are some psds)
if (hsList.count() > 0) { // if there are some histograms
double max, min;
int N;
KstRVectorList rvl = kstObjectSubList<KstVector,KstRVector>(KST::vectorList);
for (hs_string = hsList.begin(); hs_string != hsList.end(); ++hs_string) {
yvector = GetOrCreateVector(*hs_string, file, in);
if (yvector) {
color = KstColorSequence::next(vcurves,plot->backgroundColor());
KstHistogram::AutoBin(KstVectorPtr(yvector), &N, &max, &min);
hs = new KstHistogram(KST::suggestHistogramName(yvector->tag()),
KstVectorPtr(yvector), min, max, N, KST_HS_NUMBER);
KstVCurvePtr vc = new KstVCurve(KST::suggestCurveName(hs->tag(), true),
hs->vX(), hs->vY(),
0L, 0L, 0L, 0L, color);
vc->setHasPoints(false);
vc->setHasLines(false);
vc->setHasBars(true);
vc->setBarStyle(1);
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(hs.data());
KST::dataObjectList.append(vc.data());
KST::dataObjectList.lock().unlock();
plot->addCurve(vc.data());
if (in.sep_plots) {
plot->setTagName(hs->tag());
i_plot++;
if (i_plot < in.n_plots) {
plot = *plist.at(i_plot);
}
}
}
} // next histogram
} // end (if there are some histograms)
if (matrixList.count() > 0) { // if there are some matrixes
for (mat_i = matrixList.begin(); mat_i != matrixList.end(); ++mat_i) {
QString tag_name = KST::suggestMatrixName(*mat_i);
if (!file->isValidMatrix(*mat_i)) {
startupErrors.append(i18n("Failed to create matrix '%1' from file '%2'.").arg(*mat_i).arg(file->fileName()));
}
KstRMatrixPtr matrix = new KstRMatrix(file, *mat_i,
KstObjectTag(tag_name, file->tag()),
0,0,-1,-1,false,false,0);
// xStart, yStart, xNumSteps, yNumSteps,
//doAve, doSkip, skip);
// Time to create the image from the matrix
tag_name = KST::suggestImageName(matrix->tag());
QStringList palList = KPalette::getPaletteList();
QString pal;
if (palList.contains("IDL 13 RAINBOW")) {
pal = QString("IDL 13 RAINBOW");
} else {
pal = QString(*palList.at(0));
}
KPalette* newPal = new KPalette(pal);
KstImagePtr image = new KstImage(tag_name, KstMatrixPtr(matrix), 0.0, 1.0,
true, newPal);
plot->addCurve(KstBaseCurvePtr(image));
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(image.data());
KST::dataObjectList.lock().unlock();
image = 0L; // drop the reference
if (in.sep_plots) {
plot->setTagName(matrix->tag());
i_plot++;
if (i_plot < in.n_plots) {
plot = *plist.at(i_plot);
}
}
}
}
} else {
startupErrors.append(i18n("Failed to load file '%1'.").arg(args->arg(i_file)));
}
handled++;
kst->slotUpdateProgress( count, handled, creatingCurves );
} // next data file
count = in.n_plots;
handled = 0;
kst->slotUpdateProgress( count, handled, creatingPlots );
for (i_plot = 0; i_plot < in.n_plots; i_plot++) {
plot = *plist.at(i_plot);
plot->generateDefaultLabels();
// if we have only images in a plot then set the scale mode to AUTO (instead of AUTOBORDER)
KstImageList images = kstObjectSubList<KstBaseCurve,KstImage>(plot->Curves);
if (images.count() == plot->Curves.count()) {
plot->setXScaleMode(AUTO);
plot->setYScaleMode(AUTO);
}
if (plot->Curves.count() > 3 || in.dolegend) {
KstViewLegendPtr vl = plot->getOrCreateLegend();
vl->resizeFromAspect(0.1, 0.1, 0.2, 0.1);
vl->setBorderWidth(2);
}
handled++;
kst->slotUpdateProgress( count, handled, creatingPlots );
}
kst->slotUpdateProgress( 0, 0, QString::null );
} else if (args->count() > 0) { // open a kst file
// some of the options can be overridden
kst->openDocumentFile(args->arg(0),
args->getOption("F"), // override FileName
args->getOption("n").toInt(&nOK), // override number of frames
args->getOption("f").toInt(&nOK), // override starting frame
args->getOption("s").toInt(&nOK), // override skip
args->isSet("a"), // add averaging
!print_and_exit); // delayed
} else {
//kst->openDocumentFile();
showQuickStart = true;
}
if (args->isSet("nq")) {
showQuickStart = false;
}
if (args->isSet("w")) {
showDataWizard = true;
showQuickStart = false;
}
if (printfile != "<none>") {
kst->forceUpdate();
kst->immediatePrintToFile(printfile, false);
}
if (pngfile != "<none>") {
kst->forceUpdate();
kst->immediatePrintToPng(pngfile);
}
kst->document()->setModified(false);
if (print_and_exit) {
delete kst;
return 0;
} else {
kst->updateDialogs();
if (showQuickStart) {
kst->showQuickStartDialog();
}
if (showDataWizard) {
kst->showDataWizardWithFile(wizardfile);
}
for (size_t i = 0; i < startupErrors.size(); ++i) {
KstDebug::self()->log(startupErrors[i], KstDebug::Error);
}
startupErrors.clear();
}
// LEAVE THIS HERE - causes crashes otherwise!
int rc = app.exec();
delete kst;
return rc;
}
return app.exec();
}
