void KstPluginDialogI::new_I() {
KstPluginPtr plugin;
QString tagName = Select->currentText();
if (KST::dataTagNameNotUnique(tagName, true, this)) {
Select->setFocus();
return;
}
int pitem = PluginCombo->currentItem();
if (pitem >= 0 && PluginCombo->count() > 0) {
KstSharedPtr<Plugin> pPtr = PluginCollection::self()->plugin(_pluginList[pitem]);
if (pPtr != 0L) {
plugin = new KstPlugin;
if (!saveInputs(plugin, pPtr)) {
return;
}
plugin->setPlugin(pPtr);
if (tagName.endsWith(newPluginString)) {
QString tmpTagName;
int i = 0;
do {
tmpTagName = i18n("P%1-%2").arg(++i).arg(_pluginList[pitem]);
} while (KST::dataTagNameNotUnique(tmpTagName, false));
tagName = tmpTagName;
}
plugin->setTagName(tagName);
if (!saveOutputs(plugin, pPtr)) {
return;
}
}
}
if (!plugin || !plugin->isValid()) {
KMessageBox::sorry(this, i18n("There is an error in the plugin you entered. Please fix it."));
return;
}
KST::dataObjectList.lock().writeLock();
KST::dataObjectList.append(plugin.data());
KST::dataObjectList.lock().writeUnlock();
plugin = 0L;
emit modified();
}
bool KstPluginDialogI::saveInputs(KstPluginPtr plugin, KstSharedPtr<Plugin> p) {
KST::vectorList.lock().readLock();
KST::scalarList.lock().readLock();
const QValueList<Plugin::Data::IOValue>& itable = p->data()._inputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = itable.begin(); it != itable.end(); ++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
QObject *field = _frameWidget->child((*it)._name.latin1(), "VectorSelector");
assert(field);
VectorSelector *vs = static_cast<VectorSelector*>(field);
KstVectorPtr v = *KST::vectorList.findTag(vs->selectedVector());
plugin->inputVectors().insert((*it)._name, v);
} else {
QObject *field = _frameWidget->child((*it)._name.latin1(), "ScalarSelector");
assert(field);
ScalarSelector *ss = static_cast<ScalarSelector*>(field);
KstScalarPtr s = *KST::scalarList.findTag(ss->selectedScalar());
plugin->inputScalars().insert((*it)._name, s);
}
}
KST::scalarList.lock().readUnlock();
KST::vectorList.lock().readUnlock();
return true;
}
bool KstPluginDialogI::saveOutputs(KstPluginPtr plugin, KstSharedPtr<Plugin> p) {
const QValueList<Plugin::Data::IOValue>& otable = p->data()._outputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin(); it != otable.end(); ++it) {
QObject *field = _frameWidget->child((*it)._name.latin1(), "QLineEdit");
assert(field);
QLineEdit *li = static_cast<QLineEdit*>(field);
if (li->text().isEmpty()) {
QString tagName = Select->currentText();
if (tagName.endsWith(newPluginString)) {
tagName = plugin->tagName();
}
li->setText(tagName+"-"+(*it)._name);
}
QString nt = li->text();
if ((*it)._type == Plugin::Data::IOValue::TableType) {
if (!KST::vectorTagNameNotUnique(nt, false)) {
plugin->outputVectors()[(*it)._name]->setTagName(nt);
} else if (plugin->outputVectors()[(*it)._name]->tagName() != nt) {
while (KST::vectorTagNameNotUnique(nt, false)) {
nt += "'";
}
plugin->outputVectors()[(*it)._name]->setTagName(nt);
}
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
if (!KST::vectorTagNameNotUnique(nt, false)) {
plugin->outputScalars()[(*it)._name]->setTagName(nt);
} else if (plugin->outputScalars()[(*it)._name]->tagName() != nt) {
while (KST::vectorTagNameNotUnique(nt, false)) {
nt += "'";
}
plugin->outputScalars()[(*it)._name]->setTagName(nt);
}
}
}
return true;
}
void renderLabel(RenderContext& rc, Label::Chunk *fi) {
// FIXME: RTL support
int oldSize = rc.size;
int oldY = rc.y;
int oldX = rc.x;
while (fi) {
if (fi->vOffset != Label::Chunk::None) {
if (fi->vOffset == Label::Chunk::Up) {
rc.y -= int(0.4 * rc.fontHeight());
} else { // Down
rc.y += int(0.4 * rc.fontHeight());
}
if (rc.size > 5) {
rc.size = (rc.size*2)/3;
}
}
QFont f = rc.font();
if (rc.fontSize() != rc.size) {
f.setPointSize(rc.size);
}
f.setBold(fi->attributes.bold);
f.setItalic(fi->attributes.italic);
f.setUnderline(fi->attributes.underline);
if (rc.p && fi->attributes.color.isValid()) {
rc.p->setPen(fi->attributes.color);
} else if (rc.p) {
rc.p->setPen(rc.pen);
}
rc.setFont(f);
if (fi->linebreak) {
rc.x = oldX;
rc.y += rc.fontAscent() + rc.fontDescent() + 1;
fi = fi->next;
continue;
}
if (!rc.substitute && (fi->scalar || fi->vector)) {
QString txt = QString("[") + fi->text + "]";
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
}
rc.x += rc.fontWidth(txt);
} else if (fi->scalar) {
// do scalar/string/fit substitution
QString txt;
if (!fi->text.isEmpty() && fi->text[0] == '=') {
// Parse and evaluate as an equation
bool ok = false;
const double eqResult(Equation::interpret(fi->text.mid(1).latin1(), &ok));
txt = QString::number(eqResult, 'g', rc.precision);
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRExpression, fi->text, QString::null, 0.0, QVariant(eqResult)));
}
} else {
KST::scalarList.lock().readLock();
KstScalarPtr scp = *KST::scalarList.findTag(fi->text);
KST::scalarList.lock().unlock();
if (scp) {
scp->readLock();
txt = QString::number(scp->value(), 'g', rc.precision);
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRScalar, fi->text, QString::null, 0.0, QVariant(scp->value())));
}
scp->unlock();
} else {
KST::stringList.lock().readLock();
KstStringPtr stp = *KST::stringList.findTag(fi->text);
KST::stringList.lock().unlock();
if (stp) {
stp->readLock();
txt = stp->value();
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRString, fi->text, QString::null, 0.0, QVariant(stp->value())));
}
stp->unlock();
} else {
KST::dataObjectList.lock().readLock();
KstDataObjectList::Iterator oi = KST::dataObjectList.findTag(fi->text);
KST::dataObjectList.lock().unlock();
if (oi != KST::dataObjectList.end()) {
KstPluginPtr fit = kst_cast<KstPlugin>(*oi);
if (fit) {
fit->readLock();
const QString txtAll = fit->label(rc.precision);
fit->unlock();
const QValueList<QString> strList = QStringList::split('\n', txtAll);
QValueListConstIterator<QString> last = --(strList.end());
for (QValueListConstIterator<QString> iter = strList.begin(); iter != strList.end(); ++iter) {
txt = (*iter);
if (iter != last) {
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
} else {
rc.ascent = kMax(rc.ascent, -rc.y + rc.fontAscent());
if (-rc.y - rc.fontDescent() < 0) {
rc.descent = kMax(rc.descent, rc.fontDescent() + rc.y);
}
}
rc.x += rc.fontWidth(txt);
rc.xMax = kMax(rc.xMax, rc.x);
rc.x = oldX;
rc.y += rc.fontAscent() + rc.fontDescent() + 1;
}
}
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRFit, fi->text, txtAll, rc.precision, QVariant(0.0)));
}
}
}
}
}
}
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
}
rc.x += rc.fontWidth(txt);
} else if (fi->vector) {
QString txt;
KST::vectorList.lock().readLock();
KstVectorPtr vp = *KST::vectorList.findTag(fi->text);
KST::vectorList.lock().unlock();
if (vp) {
if (!fi->expression.isEmpty()) {
// Parse and evaluate as an equation
bool ok = false;
// FIXME: make more efficient: cache the parsed equation
const double idx = Equation::interpret(fi->expression.latin1(), &ok);
if (ok) {
vp->readLock();
const double vVal(vp->value()[int(idx)]);
txt = QString::number(vVal, 'g', rc.precision);
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRVector, fi->text, fi->expression, idx, QVariant(vVal)));
}
vp->unlock();
} else {
txt = "NAN";
}
}
}
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
}
rc.x += rc.fontWidth(txt);
} else if (fi->tab) {
const int tabWidth = rc.fontWidth("MMMMMMMM");
const int toSkip = tabWidth - (rc.x - rc.xStart) % tabWidth;
if (rc.p && fi->attributes.underline) {
const int spaceWidth = rc.fontWidth(" ");
const int spacesToSkip = tabWidth / spaceWidth + (tabWidth % spaceWidth > 0 ? 1 : 0);
rc.p->drawText(rc.x, rc.y, QString().fill(' ', spacesToSkip));
}
rc.x += toSkip;
} else {
if (rc.p) {
#ifdef BENCHMARK
QTime t;
t.start();
#endif
rc.p->drawText(rc.x, rc.y, fi->text);
#ifdef BENCHMARK
kstdDebug() << "Renderer did draw, time: " << t.elapsed() << endl;
#endif
}
rc.x += rc.fontWidth(fi->text);
}
if (!rc.p) {
// No need to compute ascent and descent when really painting
rc.ascent = kMax(rc.ascent, -rc.y + rc.fontAscent());
if (-rc.y - rc.fontDescent() < 0) {
rc.descent = kMax(rc.descent, rc.fontDescent() + rc.y);
}
}
int xNext = rc.x;
if (fi->group) {
renderLabel(rc, fi->group);
xNext = rc.x;
}
if (fi->up) {
int xPrev = rc.x;
renderLabel(rc, fi->up);
xNext = kMax(xNext, rc.x);
rc.x = xPrev;
}
if (fi->down) {
renderLabel(rc, fi->down);
xNext = kMax(xNext, rc.x);
}
rc.x = xNext;
rc.xMax = kMax(rc.xMax, rc.x);
fi = fi->next;
}
rc.size = oldSize;
rc.y = oldY;
}
bool KstCPlugin::setPlugin(KstPluginPtr plugin) {
// Assumes that this is called with a write lock in place on this object
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (plugin == _plugin) {
return true;
}
freeParameters();
if (_localData) {
if (!_plugin || !_plugin->freeLocalData(&_localData)) {
free(_localData);
}
_localData = 0L;
}
if (!plugin) {
_inputVectors.clear();
_inputScalars.clear();
_inputStrings.clear();
_outputVectors.clear();
_outputScalars.clear();
_outputStrings.clear();
_plugin = 0L;
return true;
}
Plugin::countScalarsVectorsAndStrings(plugin->data()._inputs, _inScalarCnt, _inArrayCnt, _inStringCnt, _inPid);
if (_inputVectors.count() != _inArrayCnt ||
_inputScalars.count() != _inScalarCnt - _inPid ||
_inputStrings.count() != _inStringCnt) {
_plugin = 0L;
return false;
}
_outScalarCnt = 0;
_outArrayCnt = 0;
_outStringCnt = 0;
_outputVectors.clear();
_outputScalars.clear();
_outputStrings.clear();
const QValueList<Plugin::Data::IOValue>& otable = plugin->data()._outputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin(); it != otable.end(); ++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
KstWriteLocker blockVectorUpdates(&KST::vectorList.lock());
KstVectorPtr v;
if ((*it)._subType == Plugin::Data::IOValue::FloatNonVectorSubType) {
v = new KstVector(KstObjectTag((*it)._name, tag()), 0, this, true);
} else {
v = new KstVector(KstObjectTag((*it)._name, tag()), 0, this, false);
}
_outputVectors.insert((*it)._name, v);
++_outArrayCnt;
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
KstWriteLocker blockScalarUpdates(&KST::scalarList.lock());
KstScalarPtr s = new KstScalar(KstObjectTag((*it)._name, tag()), this);
_outputScalars.insert((*it)._name, s);
++_outScalarCnt;
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
KstWriteLocker blockStringUpdates(&KST::stringList.lock());
KstStringPtr s = new KstString(KstObjectTag((*it)._name, tag()), this);
_outputStrings.insert((*it)._name, s);
++_outStringCnt;
}
}
allocateParameters();
_plugin = plugin;
return true;
}
KstDataObjectPtr KstPlugin::makeDuplicate(KstDataObjectDataObjectMap& duplicatedMap) {
KstPluginPtr plugin = new KstPlugin;
// use same inputs
for (KstVectorMap::ConstIterator iter = _inputVectors.begin(); iter != _inputVectors.end(); ++iter) {
plugin->inputVectors().insert(iter.key(), iter.data());
}
for (KstScalarMap::ConstIterator iter = _inputScalars.begin(); iter != _inputScalars.end(); ++iter) {
plugin->inputScalars().insert(iter.key(), iter.data());
}
for (KstStringMap::ConstIterator iter = _inputStrings.begin(); iter != _inputStrings.end(); ++iter) {
plugin->inputStrings().insert(iter.key(), iter.data());
}
// create new outputs
for (KstVectorMap::ConstIterator iter = outputVectors().begin(); iter != outputVectors().end(); ++iter) {
KstVectorPtr v = new KstVector(iter.data()->tagName() + "'", 0, plugin.data());
plugin->outputVectors().insert(iter.key(), v);
KST::addVectorToList(v);
}
for (KstScalarMap::ConstIterator iter = outputScalars().begin(); iter != outputScalars().end(); ++iter) {
KstScalarPtr s = new KstScalar(iter.data()->tagName() + "'", plugin.data());
plugin->outputScalars().insert(iter.key(), s);
}
for (KstStringMap::ConstIterator iter = outputStrings().begin(); iter != outputStrings().end(); ++iter) {
KstStringPtr s = new KstString(iter.data()->tagName() + "'", plugin.data());
plugin->outputStrings().insert(iter.key(), s);
}
// set the same plugin
plugin->setPlugin(_plugin);
plugin->setTagName(tagName() + "'");
duplicatedMap.insert(this, KstDataObjectPtr(plugin));
return KstDataObjectPtr(plugin);
}
void KstPluginDialogI::edit_I() {
int index = Select->currentItem();
if (Select->count() == 0 || index < 0) {
new_I();
return;
}
QString tagName = Select->currentText();
KstPluginList pl = kstObjectSubList<KstDataObject, KstPlugin>(KST::dataObjectList);
KstPluginPtr plugin = pl[index];
if (!plugin.data()) {
new_I();
return;
}
int pitem = PluginCombo->currentItem();
if (tagName.endsWith(newPluginString)) {
QString tmpTagName;
int i = 0;
do {
tmpTagName = i18n("P%1-%2").arg(++i).arg(_pluginList[pitem]);
} while (KST::dataTagNameNotUnique(tmpTagName, false));
tagName = tmpTagName;
}
//kdDebug() << "Apply as edit [" << tagName << "]" << endl;
if (tagName != plugin->tagName()) {
if (KST::dataTagNameNotUnique(tagName, true, this)) {
Select->setFocus();
return;
}
}
plugin->setTagName(tagName);
plugin->inputVectors().clear();
plugin->inputScalars().clear();
KstSharedPtr<Plugin> pPtr = PluginCollection::self()->plugin(_pluginList[pitem]);
// Save the vectors and scalars
if (!saveInputs(plugin, pPtr)) {
return;
}
if (pitem >= 0 && PluginCombo->count() > 0) {
plugin->setPlugin(pPtr);
}
if (!saveOutputs(plugin, pPtr)) {
return;
}
if (!plugin->isValid()) {
KMessageBox::sorry(this, i18n("There is an error in the plugin you entered. Please fix it."));
return;
}
plugin = 0L; // release
pl.clear(); // release
emit modified();
}
void KstPluginDialogI::updatePlugin(int new_index) {
QString selectedVector;
QString selectedScalar;
int oldSelect = Select->currentItem();
int oldCount = Select->count();
KstPluginList pl = kstObjectSubList<KstDataObject, KstPlugin>(KST::dataObjectList);
Select->clear();
for (KstPluginList::iterator it = pl.begin(); it != pl.end(); ++it) {
Select->insertItem((*it)->tagName());
}
if (new_index == -2 || Select->count() == 0) {
Select->insertItem(i18n("P%1-%2").arg(Select->count()+1).arg(newPluginString));
Select->setCurrentItem(Select->count()-1);
} else if (new_index >= 0 && new_index < Select->count()) {
Select->setCurrentItem(new_index);
} else if (oldCount != Select->count()) {
Select->setCurrentItem(Select->count()-1);
} else {
Select->setCurrentItem(oldSelect < Select->count() ? oldSelect : Select->count()-1);
}
if (_pluginList.isEmpty()) {
updatePluginList();
}
KstPluginPtr plugin = pl[Select->currentItem()];
if (!plugin) {
kdWarning() << "Couldn't find plugin in list: " << Select->currentItem() << endl;
return;
}
int oldPluginIndex = PluginCombo->currentItem();
int newPluginIndex = _pluginList.findIndex(plugin->plugin()->data()._name);
bool updateCombos = (newPluginIndex != oldPluginIndex);
if (updateCombos) {
PluginCombo->setCurrentItem(newPluginIndex);
pluginChanged(PluginCombo->currentItem());
}
KstSharedPtr<Plugin> pPtr = PluginCollection::self()->plugin(_pluginList[PluginCombo->currentItem()]);
if( pPtr != 0 ) {
// Update input vector and scalar combos
const QValueList<Plugin::Data::IOValue>& itable = pPtr->data()._inputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = itable.begin(); it != itable.end(); ++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) { // vector
QObject *field = _frameWidget->child((*it)._name.latin1(), "VectorSelector");
assert(field);
if (field) {
VectorSelector *vs = static_cast<VectorSelector*>(field);
selectedVector = vs->selectedVector();
if (!updateCombos) {
vs->update();
}
if (plugin.data() && plugin->isValid()) {
vs->setSelection(plugin->inputVectors()[(*it)._name]->tagName());
} else {
vs->setSelection(selectedVector);
}
}
} else {
QObject *field = _frameWidget->child((*it)._name.latin1(), "ScalarSelector");
assert(field);
if (field) {
ScalarSelector *ss = static_cast<ScalarSelector*>(field);
selectedScalar = ss->selectedScalar( );
if (!updateCombos) {
ss->update();
}
if (plugin.data() && plugin->isValid()) {
ss->setSelection(plugin->inputScalars()[(*it)._name]->tagName());
} else {
ss->setSelection(selectedScalar);
}
}
}
}
// Update output vector and scalar lineedits
// const QValueList<Plugin::Data::IOValue>& otable = plugin->plugin()->data()._outputs;
if (plugin.data() && plugin->isValid()) {
const QValueList<Plugin::Data::IOValue>& otable = pPtr->data()._outputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin(); it != otable.end(); ++it) {
QObject *field = _frameWidget->child((*it)._name.latin1(), "QLineEdit");
assert(field);
if (field) {
QLineEdit *li = static_cast<QLineEdit*>(field);
QString ts;
if ((*it)._type == Plugin::Data::IOValue::TableType) { // vector
ts = plugin->outputVectors()[(*it)._name]->tagName();
} else { // scalar
ts = plugin->outputScalars()[(*it)._name]->tagName();
}
li->setText(ts);
}
}
}
} else { // invalid plugin
PluginCollection *pc = PluginCollection::self();
QString cur = _pluginList[PluginCombo->currentItem()];
Plugin::Data pdata = pc->pluginList()[pc->pluginNameList()[cur]];
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = pdata._outputs.begin(); it != pdata._outputs.end(); ++it) {
QObject *field = _frameWidget->child((*it)._name.latin1(), "QLineEdit");
if (field) {
static_cast<QLineEdit*>(field)->setText(QString::null);
}
}
}
QTimer::singleShot(0, this, SLOT(fixupLayout()));
}
