void MolecularOrbitals::on_surfaceType_currentIndexChanged(int index)
{
QVariant qvar(m_configurator.surfaceType->itemData(index));
switch (qvar.toUInt()) {
case Orbital:
enableOrbitalSelection(true);
enableSpin(true);
enableNegativeColor(true);
break;
case Density:
enableOrbitalSelection(false);
enableSpin(false);
enableNegativeColor(false);
break;
case SpinDiffDensity:
enableOrbitalSelection(false);
enableSpin(false);
enableNegativeColor(true);
break;
case SpinOnlyDensity:
enableOrbitalSelection(false);
enableNegativeColor(false);
enableSpin(true);
break;
default:
enableOrbitalSelection(false);
break;
}
}
void MolecularOrbitals::on_addToQueueButton_clicked(bool)
{
int quality(m_configurator.quality->value());
double isovalue(m_configurator.isovalue->value());
Data::Spin spin(m_configurator.alphaRadio->isChecked() ? Data::Alpha : Data::Beta);
QColor positive(Preferences::PositiveSurfaceColor());
QColor negative(Preferences::NegativeSurfaceColor());
bool simplifyMesh(m_configurator.simplifyMeshCheckBox->isChecked());
int index(m_configurator.surfaceType->currentIndex());
QVariant qvar(m_configurator.surfaceType->itemData(index));
bool isSigned(true);
int op(m_configurator.opacity->value());
double opacity = op == 100 ? 0.999 : double(op)/100.0;
Data::SurfaceInfo info(Data::SurfaceType::Custom, quality, isovalue,
positive, negative, isSigned, simplifyMesh, opacity);
switch (qvar.toUInt()) {
case Orbital: {
if (spin == Data::Alpha) {
info.type().setKind(Data::SurfaceType::AlphaOrbital);
}else {
info.type().setKind(Data::SurfaceType::BetaOrbital);
}
int orb1(m_configurator.orbitalRangeMin->currentIndex()+1);
int orb2(m_configurator.orbitalRangeMax->currentIndex()+1);
for (int i = std::min(orb1,orb2); i <= std::max(orb1, orb2); ++i) {
info.type().setIndex(i);
queueSurface(info);
}
} break;
case Density: {
info.setIsSigned(false);
info.type().setKind(Data::SurfaceType::TotalDensity);
queueSurface(info);
} break;
case SpinDiffDensity: {
info.type().setKind(Data::SurfaceType::SpinDensity);
queueSurface(info);
} break;
case SpinOnlyDensity: {
info.setIsSigned(false);
if (spin == Data::Alpha) {
info.type().setKind(Data::SurfaceType::AlphaDensity);
}else {
info.type().setKind(Data::SurfaceType::BetaDensity);
}
queueSurface(info);
} break;
}
}
bool doCompileAndLink(const QString &filedata, const QString &flags, int *retcode=0)
{
QDir dir(".");
QString fname = "atest.c";
QString out = "atest";
QFile f(fname);
QCString cs = filedata.latin1();
if(!f.open(IO_WriteOnly | IO_Truncate)) {
debug("unable to open atest.c for writing");
return false;
}
if(f.writeBlock(cs.data(), cs.length()) == -1) {
debug("error writing to atest.c");
return false;
}
f.close();
debug(QString("Wrote atest.c:\n%1").arg(filedata));
QString str = qvar("QMAKE_CXX") + ' ' + fname + " -o " + out;
if(!flags.isEmpty()) {
str += ' ';
str += flags;
}
int r = doCommand(str);
if(r == 0 && retcode)
*retcode = doCommand(QString("./") + out);
dir.remove(fname);
dir.remove(out);
if(r != 0)
return false;
return true;
}
QVariantMap DefaultFilterParameters()
{
QVariantMap map;
QVariant qvar(Get("DefaultFilterParameters"));
if (!qvar.isNull()) map = qvar.toMap();
return map;
}
QMap<QString, T> GetMap(QString const& name)
{
QVariant qvar(Get(name));
QMap<QString,T> map;
if (!qvar.isNull()) {
QMap<QString, QVariant> variantMap(qvar.toMap());
QStringList keys(variantMap.keys());
QStringList::iterator iter;
for (iter = keys.begin(); iter != keys.end(); ++iter) {
qvar = variantMap.value(*iter);
map.insert( (*iter), qvar.value<T>());
}
}
return map;
}
NPVariant NPVariant::fromQVariant(QtNPInstance *This, const QVariant &qvariant)
{
Q_ASSERT(This);
NPVariant npvar;
npvar.type = Null;
QVariant qvar(qvariant);
switch(qvariant.type()) {
case QVariant::Bool:
npvar.value.boolValue = qvar.toBool();
npvar.type = Boolean;
break;
case QVariant::Int:
npvar.value.intValue = qvar.toInt();
npvar.type = Int32;
break;
case QVariant::Double:
npvar.value.doubleValue = qvar.toDouble();
npvar.type = Double;
break;
case QVariant::UserType:
{
QByteArray userType = qvariant.typeName();
if (userType.endsWith('*')) {
QtNPInstance *that = new QtNPInstance;
that->npp = This->npp;
that->qt.object = *(QObject**)qvariant.constData();
NPClass *npclass = new NPClass(that);
npclass->delete_qtnp = true;
npvar.value.objectValue = NPN_CreateObject(This->npp, npclass);
npvar.type = Object;
}
}
break;
default: // including QVariant::String
if (!qvar.convert(QVariant::String))
break;
npvar.type = String;
npvar.value.stringValue = NPString::fromQString(qvar.toString());
break;
}
return npvar;
}
void SurfaceAnimatorDialog::update()
{
QListWidget* fileList(m_dialog.fileList);
fileList->clear();
QList<Layer::CubeData*> cubeFiles(m_molecule->findLayers<Layer::CubeData>(Layer::Children));
QList<Layer::CubeData*>::iterator iter;
for (iter = cubeFiles.begin(); iter != cubeFiles.end(); ++iter) {
QFileInfo info((*iter)->filePath());
QListWidgetItem* item = new QListWidgetItem();
item->setText(info.fileName());
QVariant qvar(QVariantPointer<Layer::CubeData>::toQVariant(*iter));
item->setData(Qt::UserRole, qvar);
fileList->addItem(item);
}
m_dialog.isovalue2->setVisible(fileList->count() == 1);
m_dialog.toLabel->setVisible(fileList->count() == 1);
}
int QtSignalForwarder::qt_metacall(QMetaObject::Call call, int index, void **args)
{
// no support for QObject method/properties etc!
if (!This || !This->npp || call != QMetaObject::InvokeMetaMethod
|| !This->qt.object)
return index;
switch (index) {
case -1:
{
QString msg = *(QString*)args[1];
NPN_Status(This->npp, msg.toLocal8Bit().constData());
}
break;
default:
{
QObject *qobject = This->qt.object;
if (!domNode)
NPN_GetValue(This->npp, NPNVPluginElementNPObject, &domNode);
if (!domNode)
break;
const QMetaObject *metaObject = qobject->metaObject();
if (index < metaOffset(metaObject, MetaMethod))
break;
const QMetaMethod method = metaObject->method(index);
Q_ASSERT(method.methodType() == QMetaMethod::Signal);
QByteArray signalSignature = method.signature();
QByteArray scriptFunction = signalSignature.left(signalSignature.indexOf('('));
NPIdentifier id = NPN_GetStringIdentifier(scriptFunction.constData());
if (NPN_HasMethod(This->npp, domNode, id)) {
QList<QByteArray> parameterTypes = method.parameterTypes();
QVector<NPVariant> parameters;
NPVariant result;
bool error = false;
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid) {
NPN_SetException(domNode, QByteArray("Unsupported parameter type in ") + scriptFunction);
error = true;
break;
}
QVariant qvar(type, args[p + 1]);
NPVariant npvar = NPVariant::fromQVariant(This, qvar);
if (npvar.type == NPVariant::Null || npvar.type == NPVariant::Void) {
NPN_SetException(domNode, QByteArray("Unsupported parameter value in ") + scriptFunction);
error =true;
break;
}
parameters += npvar;
}
if (error)
break;
NPError nperror = NPN_Invoke(This->npp, domNode, id, parameters.constData(), parameters.count(), &result);
if (nperror != NPERR_NO_ERROR && false) { // disabled, as NPN_Invoke seems to always return GENERICERROR
NPN_SetException(domNode, QByteArray("Error invoking event handler ") + scriptFunction);
}
// ### TODO: update return value (args[0]) (out-parameters not supported anyway)
NPN_ReleaseVariantValue(&result);
}
}
break;
}
return index;
}
