void Ut_CReporterNotifyDialogPlugin::testUpdateNotification()
{
// Test notification update.
QSignalSpy requestCompletedSpy(m_Subject, SIGNAL(requestCompleted()));
m_Subject->initialize(m_Server);
QVariantList args;
args << QString("/media/mmc1/core-dumps/test-1234-11-4321.rcore.lzo");
// Request plugin and show notification.
bool retVal = m_Subject->requestDialog(args);
QVERIFY(retVal == true);
QVERIFY(notificationCreated = true);
QVERIFY(notificationTimeoutSet = true);
notificationTimeoutSet = false;
args.clear();
args << QString("/media/mmc1/core-dumps/application-1234-9-4321.rcore.lzo");
// Request plugin and show notification.
retVal = m_Subject->requestDialog(args);
QVERIFY(retVal == true);
// Notifications are no longer updated but removed and replaced with a new one
//QVERIFY(notificationUpdated == true);
QVERIFY(notificationTimeoutSet == true);
m_Subject->notificationTimeout();
QVERIFY(m_Subject->isActive() == false);
// Now request is not completed until the dialog has disappeared so this cannot be tested here.
//QVERIFY(requestCompletedSpy.count() == 1);
}
void QxtWebJsonRPCService::Private::handle(QxtWebRequestEvent *event, QVariant rid, QString action, QVariant argsE)
{
QVariantMap argsM;
QVariantList args;
if (argsE.type() == QVariant::Map) {
argsM = argsE.toMap();
args = argsM.values();
} else {
args = argsE.toList();
}
if (!invokable)
initTables(p);
if (!methods.contains(action.toUtf8() + QByteArray::number(args.count()))) {
QVariantMap res;
res.insert("result", QVariant());
res.insert("error", "no such method or incorrect number of arguments");
res.insert("id", rid);
QxtWebPageEvent *err = new QxtWebPageEvent(event->sessionID, event->requestID,
QxtJSON::stringify(res).toUtf8() + "\r\n");
p->postEvent(err);
return;
}
Method method = methods.value(action.toUtf8() + QByteArray::number(args.count()));
if (argsE.type() == QVariant::Map) {
args.clear();
foreach (const QString &pname, method.meta.parameterNames ()) {
args.append(argsM.value(pname));
}
}
QList<NutshMetaData> NutshSqlSaver::getMetaDatas(const QString& listName) {
//retourne la liste de métadonnée selon une requete
QList<NutshMetaData> metaList;
QVariantList cache;
QSqlQuery requete;
if(listName != QString()){
if(!requete.exec(QString("SELECT * FROM bibliotheque INNER JOIN relationships ON relationships.music_id = bibliotheque.id WHERE (relationships.playlist_id = %1)").arg(crypt(listName)))) {
qDebug() << requete.lastError() << requete.lastQuery();
}
} else {
if(!requete.exec(QString("SELECT * FROM bibliotheque"))) {
qDebug() << requete.lastError() << requete.lastQuery();
}
}
while(requete.next()) {
for(int i = 0;i<NB_CHAMPS_DATABASE;i++) {
cache.append(requete.value(i));
}
metaList.append(NutshMetaData(cache));
cache.clear();
}
return metaList;
}
QString ScenarioChangeMapper::updateStatement(DomainObject* _subject, QVariantList& _updateValues) const
{
QString updateStatement =
QString("UPDATE " + TABLE_NAME +
" SET uuid = ?, "
" datetime = ?, "
" username = ?, "
" undo_patch = ?, "
" redo_patch = ?, "
" is_draft = ? "
" WHERE id = ? "
);
ScenarioChange* change = dynamic_cast<ScenarioChange*>(_subject);
_updateValues.clear();
_updateValues.append(change->uuid().toString());
_updateValues.append(change->datetime().toString("yyyy-MM-dd hh:mm:ss"));
_updateValues.append(change->user());
_updateValues.append(change->undoPatch());
_updateValues.append(change->redoPatch());
_updateValues.append(change->isDraft() ? "1" : "0");
_updateValues.append(change->id().value());
return updateStatement;
}
QString CharacterPhotoMapper::deleteStatement(DomainObject* _subject, QVariantList& _deleteValues) const
{
QString deleteStatement = "DELETE FROM " + TABLE_NAME + " WHERE id = ?";
_deleteValues.clear();
_deleteValues.append(_subject->id().value());
return deleteStatement;
}
void CRtTable::getRecByID(int keyid,QVariantList& vecValues)
{
vecValues.clear();
QString strSQL = getAllField();
strSQL += " where id = ";
strSQL += QString::number(keyid);
QVector<QVariantList> vecList;
getRecsBySQL(strSQL,vecList);
if (vecList.count() > 0)
{
vecValues = vecList[0];
}
}
QString CharacterPhotoMapper::insertStatement(DomainObject* _subject, QVariantList& _insertValues) const
{
QString insertStatement =
QString("INSERT INTO " + TABLE_NAME +
" (id, fk_character_id, photo, sort_order) "
" VALUES(?, ?, ?, ?) "
);
CharacterPhoto* photo = dynamic_cast<CharacterPhoto*>(_subject);
_insertValues.clear();
_insertValues.append(photo->id().value());
_insertValues.append(photo->character()->id().value());
_insertValues.append(ImageHelper::bytesFromImage(photo->photo()));
_insertValues.append(photo->sortOrder());
return insertStatement;
}
QVariant QCollectionJsonItem::toVariant() const
{
QVariantMap result;
result[HREF] = href();
QVariantList list;
foreach(const QCollectionJsonData data, d->data) {
list.append(data.toVariant());
}
if(!list.isEmpty()) result[DATA] = list;
list.clear();
foreach(const QCollectionJsonLink link, d->links) {
list.append(link.toVariant());
}
if(!list.isEmpty()) result[LINKS] = list;
return result;
}
QString CharacterPhotoMapper::updateStatement(DomainObject* _subject, QVariantList& _updateValues) const
{
QString updateStatement =
QString("UPDATE " + TABLE_NAME +
" SET fk_character_id = ?, "
" photo = ?, "
" sort_order = ? "
" WHERE id = ? "
);
CharacterPhoto* photo = dynamic_cast<CharacterPhoto*>(_subject);
_updateValues.clear();
_updateValues.append(photo->character()->id().value());
_updateValues.append(ImageHelper::bytesFromImage(photo->photo()));
_updateValues.append(photo->sortOrder());
_updateValues.append(photo->id().value());
return updateStatement;
}
QList<NutshMetaData> NutshSqlSaver::getLastReaden(int display) {
QSqlQuery requete;
QList<NutshMetaData> liste;
QVariantList cache;
if(!requete.exec(QString("SELECT * FROM bibliotheque ORDER BY derniereLecture DESC LIMIT 0, %1").arg(display))) {
qDebug() << requete.lastError()<< requete.lastQuery();
}
while(requete.next()) {
for(int i = 0;i<NB_CHAMPS_DATABASE;i++) {
cache.append(requete.value(i));
}
liste.append(NutshMetaData(cache));
cache.clear();
}
return liste;
}
QString ScenarioChangeMapper::insertStatement(DomainObject* _subject, QVariantList& _insertValues) const
{
QString insertStatement =
QString("INSERT INTO " + TABLE_NAME +
" (" + COLUMNS + ") "
" VALUES(?, ?, ?, ?, ?, ?, ?) "
);
ScenarioChange* change = dynamic_cast<ScenarioChange*>(_subject );
_insertValues.clear();
_insertValues.append(change->id().value());
_insertValues.append(change->uuid().toString());
_insertValues.append(change->datetime().toString("yyyy-MM-dd hh:mm:ss"));
_insertValues.append(change->user());
_insertValues.append(change->undoPatch());
_insertValues.append(change->redoPatch());
_insertValues.append(change->isDraft() ? "1" : "0");
return insertStatement;
}
QList<NutshMetaData> NutshSqlSaver::getMostReaden(int display) {
QList<NutshMetaData> metaList;
QVariantList cache;
REQUETE(QString("SELECT * FROM bibliotheque ORDER BY compteur DESC LIMIT 0, %1").arg(display));
while(requete.next()) {
for(int i = 0;i<NB_CHAMPS_DATABASE;i++) {
cache.append(requete.value(i));
}
metaList.append(NutshMetaData(cache));
cache.clear();
}
return metaList;
}
void
PreferencesWidget::showHelp()
{
PropertyEditor propertyEditor;
QMap<QString, QVariantList> plist;
QVariantList vlist;
vlist.clear();
QFile helpFile(":/preferences.help");
if (helpFile.open(QFile::ReadOnly))
{
QTextStream in(&helpFile);
QString line = in.readLine();
while (!line.isNull())
{
if (line == "#begin")
{
QString keyword = in.readLine();
QString helptext;
line = in.readLine();
while (!line.isNull())
{
helptext += line;
helptext += "\n";
line = in.readLine();
if (line == "#end") break;
}
vlist << keyword << helptext;
}
line = in.readLine();
}
}
plist["commandhelp"] = vlist;
QStringList keys;
keys << "commandhelp";
propertyEditor.set("Preferences Help", plist, keys);
propertyEditor.exec();
}
void DroidStoreAPI::parseResultsJSON(QString jsonString, QString categoryOnly)
{
JsonDataAccess jda;
QVariant jsonDATA = jda.loadFromBuffer(jsonString);
_results = jsonDATA.toMap().value("results").toList();
QVariantList newResults = _results;
if(categoryOnly != "all")
{
newResults.clear();
foreach (QVariant app , _results)
{
if(categoryOnly == "game")
{
if(app.toMap().value("cat_int").toInt() >= 25) // if it's an game type
{
newResults.append(app);
}
}
else if(categoryOnly == "app")
{
if(app.toMap().value("cat_int").toInt() <= 26) // if it's a app type
{
newResults.append(app);
}
}
else
{
if(app.toMap().value("cat_int").toInt() == categoryOnly.toInt()) // if it's a specific type
{
newResults.append(app);
}
}
}
}
bool
PathGroups::keyPressEvent(QKeyEvent *event)
{
for(int i=0; i<m_paths.count(); i++)
{
if (m_paths[i]->grabsMouse())
{
if (event->key() == Qt::Key_G)
{
m_paths[i]->removeFromMouseGrabberPool();
return true;
}
if (event->key() == Qt::Key_C)
{
bool b = m_paths[i]->closed();
m_paths[i]->setClosed(!b);
return true;
}
else if (event->key() == Qt::Key_P)
{
bool b = m_paths[i]->showPoints();
m_paths[i]->setShowPoints(!b);
return true;
}
else if (event->key() == Qt::Key_L)
{
bool b = m_paths[i]->showLength();
m_paths[i]->setShowLength(!b);
return true;
}
else if (event->key() == Qt::Key_X)
{
m_paths[i]->setMoveAxis(PathGroupGrabber::MoveX);
return true;
}
else if (event->key() == Qt::Key_Y)
{
if (event->modifiers() & Qt::ControlModifier ||
event->modifiers() & Qt::MetaModifier)
m_paths[i]->redo();
else
m_paths[i]->setMoveAxis(PathGroupGrabber::MoveY);
return true;
}
else if (event->key() == Qt::Key_Z)
{
if (event->modifiers() & Qt::ControlModifier ||
event->modifiers() & Qt::MetaModifier)
m_paths[i]->undo();
else
m_paths[i]->setMoveAxis(PathGroupGrabber::MoveZ);
return true;
}
else if (event->key() == Qt::Key_W)
{
m_paths[i]->setMoveAxis(PathGroupGrabber::MoveAll);
return true;
}
else if (event->key() == Qt::Key_S)
{
int idx = m_paths[i]->pointPressed();
if (idx > -1)
{
float radx = m_paths[i]->getRadX(idx);
if (event->modifiers() & Qt::ShiftModifier)
radx--;
else
radx++;
radx = qMax(1.0f, radx);
m_paths[i]->setRadX(idx, radx, m_sameForAll);
return true;
}
}
else if (event->key() == Qt::Key_T)
{
int idx = m_paths[i]->pointPressed();
if (idx > -1)
{
float rady = m_paths[i]->getRadY(idx);
if (event->modifiers() & Qt::ShiftModifier)
rady--;
else
rady++;
rady = qMax(1.0f, rady);
m_paths[i]->setRadY(idx, rady, m_sameForAll);
}
else // switch to tube mode
{
if (event->modifiers() & Qt::ShiftModifier)
{
m_paths[i]->loadCaption();
}
else
{
bool b = m_paths[i]->tube();
m_paths[i]->setTube(!b);
}
}
return true;
}
else if (event->key() == Qt::Key_A)
{
int idx = m_paths[i]->pointPressed();
if (idx > -1)
{
float a = m_paths[i]->getAngle(idx);
if (event->modifiers() & Qt::ShiftModifier)
a--;
else
a++;
m_paths[i]->setAngle(idx, a, m_sameForAll);
return true;
}
}
else if (event->key() == Qt::Key_Delete ||
event->key() == Qt::Key_Backspace ||
event->key() == Qt::Key_Backtab)
{
m_paths[i]->removeFromMouseGrabberPool();
m_paths.removeAt(i);
return true;
}
if (event->key() == Qt::Key_Space)
{
PropertyEditor propertyEditor;
QMap<QString, QVariantList> plist;
QVariantList vlist;
vlist.clear();
vlist << QVariant("double");
vlist << QVariant(m_paths[i]->opacity());
vlist << QVariant(0.0);
vlist << QVariant(1.0);
vlist << QVariant(0.1); // singlestep
vlist << QVariant(1); // decimals
plist["opacity"] = vlist;
vlist.clear();
vlist << QVariant("colorgradient");
QGradientStops stops = m_paths[i]->stops();
for(int s=0; s<stops.size(); s++)
{
float pos = stops[s].first;
QColor color = stops[s].second;
int r = color.red();
int g = color.green();
int b = color.blue();
int a = color.alpha();
vlist << QVariant(pos);
vlist << QVariant(r);
vlist << QVariant(g);
vlist << QVariant(b);
vlist << QVariant(a);
}
plist["color"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->filterPathLen());
plist["filter on length"] = vlist;
float vmin, vmax;
m_paths[i]->userPathlenMinmax(vmin, vmax);
vlist.clear();
vlist << QVariant("string");
vlist << QVariant(QString("%1 %2").arg(vmin).arg(vmax));
plist["length bounds"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->scaleType());
plist["scale type"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->depthcue());
plist["depthcue"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_paths[i]->segments());
vlist << QVariant(1);
vlist << QVariant(100);
plist["smoothness"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_paths[i]->sections());
vlist << QVariant(1);
vlist << QVariant(100);
plist["sections"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_paths[i]->sparseness());
vlist << QVariant(1);
vlist << QVariant(100);
plist["sparseness"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_paths[i]->separation());
vlist << QVariant(0);
vlist << QVariant(10);
plist["screen separation"] = vlist;
vlist.clear();
vlist << QVariant("combobox");
vlist << QVariant(m_paths[i]->capType());
vlist << QVariant("flat");
vlist << QVariant("round");
vlist << QVariant("arrow");
plist["cap style"] = vlist;
vlist.clear();
vlist << QVariant("combobox");
vlist << QVariant(m_paths[i]->arrowDirection());
vlist << QVariant("forward");
vlist << QVariant("backward");
plist["arrow direction"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->animate());
plist["animate"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->allowInterpolate());
plist["interpolate"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_paths[i]->animateSpeed());
vlist << QVariant(10);
vlist << QVariant(100);
plist["animation speed"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->arrowForAll());
plist["arrows for all"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_sameForAll);
plist["same for all"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->clip());
plist["clip"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->allowEditing());
plist["allow editing"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_paths[i]->blendMode());
plist["blend with volume"] = vlist;
vlist.clear();
plist["command"] = vlist;
vlist.clear();
QFile helpFile(":/pathgroups.help");
if (helpFile.open(QFile::ReadOnly))
{
QTextStream in(&helpFile);
QString line = in.readLine();
while (!line.isNull())
{
if (line == "#begin")
{
QString keyword = in.readLine();
QString helptext;
line = in.readLine();
while (!line.isNull())
{
helptext += line;
helptext += "\n";
line = in.readLine();
if (line == "#end") break;
}
vlist << keyword << helptext;
}
line = in.readLine();
}
}
plist["commandhelp"] = vlist;
vlist.clear();
QString mesg;
float pmin, pmax;
m_paths[i]->pathlenMinmax(pmin, pmax);
mesg = QString("min/max path lengths : %1 %2\n").arg(pmin).arg(pmax);
float mins,maxs;
mins = m_paths[i]->minScale();
maxs = m_paths[i]->maxScale();
mesg += QString("min/max scale : %1 %2\n").arg(mins).arg(maxs);
vlist << mesg;
plist["message"] = vlist;
QStringList keys;
keys << "color";
keys << "opacity";
keys << "depthcue";
keys << "gap";
keys << "filter on length";
keys << "length bounds";
keys << "scale type";
keys << "gap";
keys << "smoothness";
keys << "sections";
keys << "sparseness";
keys << "screen separation";
keys << "gap";
keys << "cap style";
keys << "arrow direction";
keys << "arrows for all";
keys << "gap";
keys << "animate";
keys << "interpolate";
keys << "animation speed";
keys << "gap";
keys << "same for all";
keys << "clip";
keys << "blend with volume";
keys << "allow editing";
keys << "command";
keys << "commandhelp";
keys << "message";
propertyEditor.set("Path Group Parameters", plist, keys);
QMap<QString, QPair<QVariant, bool> > vmap;
if (propertyEditor.exec() == QDialog::Accepted)
vmap = propertyEditor.get();
else
return true;
keys = vmap.keys();
for(int ik=0; ik<keys.count(); ik++)
{
QPair<QVariant, bool> pair = vmap.value(keys[ik]);
if (pair.second)
{
if (keys[ik] == "color")
{
QGradientStops stops = propertyEditor.getGradientStops(keys[ik]);
m_paths[i]->setStops(stops);
}
else if (keys[ik] == "opacity")
m_paths[i]->setOpacity(pair.first.toDouble());
else if (keys[ik] == "scale type")
m_paths[i]->setScaleType(pair.first.toBool());
else if (keys[ik] == "sections")
m_paths[i]->setSections(pair.first.toInt());
else if (keys[ik] == "smoothness")
m_paths[i]->setSegments(pair.first.toInt());
else if (keys[ik] == "sparseness")
m_paths[i]->setSparseness(pair.first.toInt());
else if (keys[ik] == "screen separation")
m_paths[i]->setSeparation(pair.first.toInt());
else if (keys[ik] == "depthcue")
m_paths[i]->setDepthcue(pair.first.toBool());
else if (keys[ik] == "animate")
m_paths[i]->setAnimate(pair.first.toBool());
else if (keys[ik] == "interpolate")
m_paths[i]->setAllowInterpolate(pair.first.toBool());
else if (keys[ik] == "animation speed")
m_paths[i]->setAnimateSpeed(pair.first.toInt());
else if (keys[ik] == "cap style")
m_paths[i]->setCapType(pair.first.toInt());
else if (keys[ik] == "arrow direction")
m_paths[i]->setArrowDirection(pair.first.toInt());
else if (keys[ik] == "arrows for all")
m_paths[i]->setArrowForAll(pair.first.toBool());
else if (keys[ik] == "same for all")
{
m_sameForAll = pair.first.toBool();
m_paths[i]->setSameForAll(m_sameForAll);
}
else if (keys[ik] == "clip")
m_paths[i]->setClip(pair.first.toBool());
else if (keys[ik] == "allow editing")
m_paths[i]->setAllowEditing(pair.first.toBool());
else if (keys[ik] == "blend with volume")
m_paths[i]->setBlendMode(pair.first.toBool());
else if (keys[ik] == "filter on length")
m_paths[i]->setFilterPathLen(pair.first.toBool());
else if (keys[ik] == "length bounds")
{
QString vstr = pair.first.toString();
QStringList vl = vstr.split(" ", QString::SkipEmptyParts);
if (vl.count() == 2)
m_paths[i]->setUserPathlenMinmax(vl[0].toDouble(),
vl[1].toDouble());
}
}
}
QString cmd = propertyEditor.getCommandString();
if (!cmd.isEmpty())
processCommand(i, cmd);
updateGL();
}
}
}
return true;
}
bool
ClipObject::commandEditor()
{
PropertyEditor propertyEditor;
QMap<QString, QVariantList> plist;
QVariantList vlist;
vlist.clear();
plist["command"] = vlist;
vlist.clear();
vlist << QVariant("double");
vlist << QVariant(m_opacity);
vlist << QVariant(0.0);
vlist << QVariant(1.0);
vlist << QVariant(0.1); // singlestep
vlist << QVariant(1); // decimals
plist["opacity"] = vlist;
vlist.clear();
vlist << QVariant("color");
Vec pcolor = m_color;
QColor dcolor = QColor::fromRgbF(pcolor.x,
pcolor.y,
pcolor.z);
vlist << dcolor;
plist["color"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_apply);
plist["apply clipping"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_tfset);
vlist << QVariant(-1);
vlist << QVariant(15);
plist["tfset"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(m_thickness);
vlist << QVariant(0);
vlist << QVariant(200);
plist["thickness"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_solidColor);
plist["solid color"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_showSlice);
plist["show slice"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_showThickness);
plist["show thickness"] = vlist;
vlist.clear();
vlist << QVariant("combobox");
if (m_viewportType)
vlist << QVariant(1);
else
vlist << QVariant(0);
vlist << QVariant("orthographic");
vlist << QVariant("perspective");
plist["camera type"] = vlist;
vlist.clear();
vlist << QVariant("double");
vlist << QVariant(m_stereo);
vlist << QVariant(0.0);
vlist << QVariant(1.0);
vlist << QVariant(0.1); // singlestep
vlist << QVariant(1); // decimals
plist["stereo"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_showOtherSlice);
plist["show other slice"] = vlist;
QString vpstr = QString("%1 %2 %3 %4").\
arg(m_viewport.x()).\
arg(m_viewport.y()).\
arg(m_viewport.z()).\
arg(m_viewport.w());
vlist.clear();
vlist << QVariant("string");
vlist << QVariant(vpstr);
plist["viewport"] = vlist;
vlist.clear();
vlist << QVariant("double");
vlist << QVariant(m_viewportScale);
vlist << QVariant(0.5);
vlist << QVariant(30.0);
vlist << QVariant(0.1); // singlestep
vlist << QVariant(1); // decimals
plist["viewport scale"] = vlist;
vlist.clear();
QFile helpFile(":/clipobject.help");
if (helpFile.open(QFile::ReadOnly))
{
QTextStream in(&helpFile);
QString line = in.readLine();
while (!line.isNull())
{
if (line == "#begin")
{
QString keyword = in.readLine();
QString helptext;
line = in.readLine();
while (!line.isNull())
{
helptext += line;
helptext += "\n";
line = in.readLine();
if (line == "#end") break;
}
vlist << keyword << helptext;
}
line = in.readLine();
}
}
plist["commandhelp"] = vlist;
//---------------------
vlist.clear();
QString mesg;
if (m_scale1 < 0 || m_scale2 < 0)
mesg += QString("scales : %1 %2\n").arg(-m_scale1).arg(-m_scale2);
else
mesg += QString("vscales : %1 %2\n").arg(m_scale1).arg(m_scale2);
mesg += QString("opacity : %1\n").arg(m_opacity);
mesg += QString("position : %1 %2 %3\n"). \
arg(m_position.x).arg(m_position.y).arg(m_position.z);
Quaternion q = orientation();
Vec axis;
qreal angle;
q.getAxisAngle(axis, angle);
mesg += QString("rotation : %1 %2 %3 : %4\n"). \
arg(axis.x).arg(axis.y).arg(axis.z).arg(RAD2DEG(angle));
mesg += QString("Red axis : %1 %2 %3\n"). \
arg(m_xaxis.x).arg(m_xaxis.y).arg(m_xaxis.z);
mesg += QString("Green axis : %1 %2 %3\n"). \
arg(m_yaxis.x).arg(m_yaxis.y).arg(m_yaxis.z);
mesg += QString("Blue axis : %1 %2 %3\n"). \
arg(m_tang.x).arg(m_tang.y).arg(m_tang.z);
vlist << mesg;
plist["message"] = vlist;
//---------------------
QStringList keys;
keys << "apply clipping";
keys << "solid color";
keys << "show slice";
keys << "show thickness";
keys << "show other slice";
keys << "gap";
keys << "color";
keys << "opacity";
keys << "gap";
keys << "viewport";
keys << "tfset";
keys << "thickness";
keys << "viewport scale";
keys << "camera type";
keys << "stereo";
keys << "gap";
keys << "command";
keys << "commandhelp";
keys << "message";
propertyEditor.set("Clip Plane Dialog", plist, keys);
QMap<QString, QPair<QVariant, bool> > vmap;
if (propertyEditor.exec() == QDialog::Accepted)
vmap = propertyEditor.get();
else
return true;
keys = vmap.keys();
for(int ik=0; ik<keys.count(); ik++)
{
QPair<QVariant, bool> pair = vmap.value(keys[ik]);
if (pair.second)
{
if (keys[ik] == "color")
{
QColor color = pair.first.value<QColor>();
float r = color.redF();
float g = color.greenF();
float b = color.blueF();
m_color = Vec(r,g,b);
}
else if (keys[ik] == "opacity")
m_opacity = pair.first.toDouble();
else if (keys[ik] == "solid color")
m_solidColor = pair.first.toBool();
else if (keys[ik] == "apply clipping")
m_apply = pair.first.toBool();
else if (keys[ik] == "show slice")
m_showSlice = pair.first.toBool();
else if (keys[ik] == "show thickness")
m_showThickness = pair.first.toBool();
else if (keys[ik] == "show other slice")
m_showOtherSlice = pair.first.toBool();
else if (keys[ik] == "tfset")
m_tfset = pair.first.toInt();
else if (keys[ik] == "thickness")
m_thickness = pair.first.toInt();
else if (keys[ik] == "viewport scale")
m_viewportScale = pair.first.toDouble();
else if (keys[ik] == "camera type")
m_viewportType = (pair.first.toInt() == 1);
else if (keys[ik] == "stereo")
m_stereo = pair.first.toDouble();
else if (keys[ik] == "viewport")
{
vpstr = pair.first.toString();
QStringList list = vpstr.split(" ", QString::SkipEmptyParts);
if (list.count() == 4)
{
float x = list[0].toFloat();
float y = list[1].toFloat();
float z = list[2].toFloat();
float w = list[3].toFloat();
if (x < 0.0f || x > 1.0f ||
y < 0.0f || y > 1.0f ||
z < 0.0f || z > 1.0f ||
w < 0.0f || w > 1.0f)
QMessageBox::information(0, "",
QString("Values for viewport must be between 0.0 and 1.0 : %1 %2 %3 %4").\
arg(x).arg(y).arg(z).arg(w));
else
m_viewport = QVector4D(x,y,z,w);
}
else if (list.count() == 3)
{
float x = list[0].toFloat();
float y = list[1].toFloat();
float z = list[2].toFloat();
if (x < 0.0f || x > 1.0f ||
y < 0.0f || y > 1.0f ||
z < 0.0f || z > 1.0f)
QMessageBox::information(0, "",
QString("Values for viewport must be between 0.0 and 1.0 : %1 %2 %3").\
arg(x).arg(y).arg(z));
else
m_viewport = QVector4D(x,y,z,z);
}
else if (list.count() == 2)
{
float x = list[0].toFloat();
float y = list[1].toFloat();
if (x < 0.0f || x > 1.0f ||
y < 0.0f || y > 1.0f)
QMessageBox::information(0, "",
QString("Values for viewport must be between 0.0 and 1.0 : %1 %2").\
arg(x).arg(y));
else
m_viewport = QVector4D(x,y,0.5,0.5);
}
else
{
QMessageBox::information(0, "", "Switching off the viewport");
m_viewport = QVector4D(-1,-1,-1,-1);
}
}
}
}
QString cmd = propertyEditor.getCommandString();
if (!cmd.isEmpty())
return processCommand(cmd);
else
return true;
// if (propertyEditor.exec() == QDialog::Accepted)
// {
// QString cmd = propertyEditor.getCommandString();
// if (!cmd.isEmpty())
// return processCommand(cmd);
// }
// else
// return true;
}
RulesHandler::RulesHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap params;
QVariantMap returns;
params.clear(); returns.clear();
setDescription("GetRules", "Get the descriptions of all configured rules. If you need more information about a specific rule use the "
"method Rules.GetRuleDetails.");
setParams("GetRules", params);
returns.insert("ruleDescriptions", QVariantList() << JsonTypes::ruleDescriptionRef());
setReturns("GetRules", returns);
params.clear(); returns.clear();
setDescription("GetRuleDetails", "Get details for the rule identified by ruleId");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetRuleDetails", params);
returns.insert("o:rule", JsonTypes::ruleRef());
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("GetRuleDetails", returns);
params.clear(); returns.clear();
setDescription("AddRule", "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only "
"one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, "
"meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true.");
params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef());
params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef());
params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
QVariantList actions;
actions.append(JsonTypes::ruleActionRef());
params.insert("actions", actions);
setParams("AddRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
returns.insert("o:ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("AddRule", returns);
params.clear(); returns.clear(); actions.clear();
setDescription("EditRule", "Edit the parameters of a rule. The configuration of the rule with the given ruleId "
"will be replaced with the new given configuration. In ordert to enable or disable a Rule, please use the "
"methods \"Rules.EnableRule\" and \"Rules.DisableRule\". If successfull, the notification \"Rule.RuleConfigurationChanged\" "
"will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef());
params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef());
params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool));
actions.append(JsonTypes::ruleActionRef());
params.insert("actions", actions);
setParams("EditRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
returns.insert("o:rule", JsonTypes::ruleRef());
setReturns("EditRule", returns);
params.clear(); returns.clear();
setDescription("RemoveRule", "Remove a rule");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("RemoveRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("RemoveRule", returns);
params.clear(); returns.clear();
setDescription("FindRules", "Find a list of rules containing any of the given parameters.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("FindRules", params);
returns.insert("ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("FindRules", returns);
params.clear(); returns.clear();
setDescription("EnableRule", "Enabled a rule that has previously been disabled."
"If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("EnableRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("EnableRule", returns);
params.clear(); returns.clear();
setDescription("DisableRule", "Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled. "
"If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("DisableRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("DisableRule", returns);
params.clear(); returns.clear();
setDescription("ExecuteActions", "Execute the action list of the rule with the given ruleId.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("ExecuteActions", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("ExecuteActions", returns);
params.clear(); returns.clear();
setDescription("ExecuteExitActions", "Execute the exit action list of the rule with the given ruleId.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("ExecuteExitActions", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("ExecuteExitActions", returns);
// Notifications
params.clear(); returns.clear();
setDescription("RuleRemoved", "Emitted whenever a Rule was removed.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("RuleRemoved", params);
params.clear(); returns.clear();
setDescription("RuleAdded", "Emitted whenever a Rule was added.");
params.insert("rule", JsonTypes::ruleRef());
setParams("RuleAdded", params);
params.clear(); returns.clear();
setDescription("RuleActiveChanged", "Emitted whenever the active state of a Rule changed.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("active", JsonTypes::basicTypeToString(JsonTypes::Bool));
setParams("RuleActiveChanged", params);
params.clear(); returns.clear();
setDescription("RuleConfigurationChanged", "Emitted whenever the configuration of a Rule changed.");
params.insert("rule", JsonTypes::ruleRef());
setParams("RuleConfigurationChanged", params);
connect(GuhCore::instance(), &GuhCore::ruleAdded, this, &RulesHandler::ruleAddedNotification);
connect(GuhCore::instance(), &GuhCore::ruleRemoved, this, &RulesHandler::ruleRemovedNotification);
connect(GuhCore::instance(), &GuhCore::ruleActiveChanged, this, &RulesHandler::ruleActiveChangedNotification);
connect(GuhCore::instance(), &GuhCore::ruleConfigurationChanged, this, &RulesHandler::ruleConfigurationChangedNotification);
}
int main( int argc, char * argv[] ) {
signal( SIGINT, cleanup );
signal( SIGTERM, cleanup );
signal( SIGABRT, cleanup );
#ifndef Q_OS_WIN
signal( SIGQUIT, cleanup );
signal( SIGHUP, cleanup );
#endif
QCoreApplication a( argc, argv );
QTextCodec::setCodecForCStrings( QTextCodec::codecForName( "UTF-8" ) );
QTextCodec::setCodecForTr( QTextCodec::codecForName( "UTF-8" ) );
using qbtd::utility::Settings;
using qbtd::control::ControlServer;
using qbtd::exception::Exception;
try {
Settings::initialize( "/tmp/qbtd.json" );
} catch( Exception & e ) {
QVariantMap settings;
QVariantList list;
list.push_back( QString( "pipe:/tmp/qbtd.socket" ) );
list.push_back( QString( "0.0.0.0:9527" ) );
settings.insert( "control", list );
list.clear();
settings.insert( "storage", QString( "/tmp" ) );
list.append( 6881 );
list.append( 6889 );
settings.insert( "listen", list );
list.clear();
Settings::initialize( "/tmp/qbtd.json", settings );
}
qbtd::torrent::TorrentSession::initialize();
ControlServer::initialize();
QVariantList ctrls = Settings::instance().get( "control" ).toList();
for( auto it = ctrls.begin(); it != ctrls.end(); ++it ) {
QString socket = it->toString();
QRegExp pipePattern( "^pipe:(.+)$" );
QRegExp tcpPattern( "^(.+):(0|[1-9][0-9]*)$" );
if( pipePattern.exactMatch( socket ) ) {
socket = pipePattern.cap( 1 );
if( !ControlServer::instance().listen( socket ) ) {
a.exit( 1 );
}
} else if( tcpPattern.exactMatch( socket ) ) {
QHostAddress address( tcpPattern.cap( 1 ) );
quint16 port = tcpPattern.cap( 2 ).toUShort();
if( !ControlServer::instance().listen( address, port ) ) {
a.exit( 1 );
}
} else {
// NOTE ignore invalid settings
}
}
return a.exec();
}
bool
Grids::keyPressEvent(QKeyEvent *event)
{
for(int i=0; i<m_grids.count(); i++)
{
if (m_grids[i]->grabsMouse())
{
if (event->key() == Qt::Key_P)
{
bool b = m_grids[i]->showPoints();
m_grids[i]->setShowPoints(!b);
return true;
}
else if (event->key() == Qt::Key_N)
{
bool b = m_grids[i]->showPointNumbers();
m_grids[i]->setShowPointNumbers(!b);
return true;
}
else if (event->key() == Qt::Key_X)
{
m_grids[i]->setMoveAxis(GridGrabber::MoveX);
return true;
}
else if (event->key() == Qt::Key_Y)
{
if (event->modifiers() & Qt::ControlModifier ||
event->modifiers() & Qt::MetaModifier)
m_grids[i]->redo();
else
m_grids[i]->setMoveAxis(GridGrabber::MoveY);
return true;
}
else if (event->key() == Qt::Key_Z)
{
if (event->modifiers() & Qt::ControlModifier ||
event->modifiers() & Qt::MetaModifier)
m_grids[i]->undo();
else
m_grids[i]->setMoveAxis(GridGrabber::MoveZ);
return true;
}
else if (event->key() == Qt::Key_W)
{
m_grids[i]->setMoveAxis(GridGrabber::MoveAll);
return true;
}
else if (event->key() == Qt::Key_Delete ||
event->key() == Qt::Key_Backspace ||
event->key() == Qt::Key_Backtab)
{
m_grids[i]->removeFromMouseGrabberPool();
m_grids.removeAt(i);
return true;
}
if (event->key() == Qt::Key_Space)
{
PropertyEditor propertyEditor;
QMap<QString, QVariantList> plist;
QVariantList vlist;
vlist.clear();
vlist << QVariant("double");
vlist << QVariant(m_grids[i]->opacity());
vlist << QVariant(0.0);
vlist << QVariant(1.0);
vlist << QVariant(0.1); // singlestep
vlist << QVariant(1); // decimals
plist["opacity"] = vlist;
vlist.clear();
vlist << QVariant("color");
Vec pcolor = m_grids[i]->color();
QColor dcolor = QColor::fromRgbF(pcolor.x,
pcolor.y,
pcolor.z);
vlist << dcolor;
plist["color"] = vlist;
vlist.clear();
plist["command"] = vlist;
vlist.clear();
QFile helpFile(":/grids.help");
if (helpFile.open(QFile::ReadOnly))
{
QTextStream in(&helpFile);
QString line = in.readLine();
while (!line.isNull())
{
if (line == "#begin")
{
QString keyword = in.readLine();
QString helptext;
line = in.readLine();
while (!line.isNull())
{
helptext += line;
helptext += "\n";
line = in.readLine();
if (line == "#end") break;
}
vlist << keyword << helptext;
}
line = in.readLine();
}
}
plist["commandhelp"] = vlist;
QStringList keys;
keys << "color";
keys << "opacity";
keys << "gap";
keys << "command";
keys << "commandhelp";
propertyEditor.set("Grid Parameters", plist, keys);
QMap<QString, QPair<QVariant, bool> > vmap;
if (propertyEditor.exec() == QDialog::Accepted)
vmap = propertyEditor.get();
else
return true;
keys = vmap.keys();
for(int ik=0; ik<keys.count(); ik++)
{
QPair<QVariant, bool> pair = vmap.value(keys[ik]);
if (pair.second)
{
if (keys[ik] == "color")
{
QColor color = pair.first.value<QColor>();
float r = color.redF();
float g = color.greenF();
float b = color.blueF();
pcolor = Vec(r,g,b);
m_grids[i]->setColor(pcolor);
}
else if (keys[ik] == "opacity")
m_grids[i]->setOpacity(pair.first.toDouble());
}
}
QString cmd = propertyEditor.getCommandString();
if (!cmd.isEmpty())
processCommand(i, cmd);
emit updateGL();
}
}
}
return true;
}
void tableTemplateWidget::savePrivateData(void)
{
int lastId = 0, cc = 0;
crossInfo *cross;
QSqlQuery query, query2;
QSqlError le;
query.prepare("DELETE FROM crossword.private_data WHERE _template = ?;");
query.addBindValue(QVariant(templateId));
query.exec();
le = query.lastError();
if (le.type() == QSqlError::NoError)
{
query.prepare("DELETE FROM crossword.crosses WHERE _template = ?;");
query.addBindValue(QVariant(templateId));
query.exec();
le = query.lastError();
if (le.type() != QSqlError::NoError)
qDebug() << "2. savePrivateData: " << le.text();
}
else
qDebug() << "1. savePrivateData: " << le.text();
QVariantList tmp;
QVariantList pdid;
QVariantList cpos;
QVariantList ctype;
QVariantList nw;
QSqlDriver *drv = db->driver();
drv->beginTransaction();
for (int i = 0; i < wi.count(); i++)
{
query.prepare("INSERT INTO crossword.private_data (_template, _numword, "
"_row, _column, _lenght, _crosscount, _orientation) "
"VALUES (?, ?, ?, ?, ?, ?, ?);");
query.addBindValue(QVariant(templateId));
query.addBindValue(QVariant(wi[i]->numWord));
query.addBindValue(QVariant(wi[i]->row));
query.addBindValue(QVariant(wi[i]->col));
query.addBindValue(QVariant(wi[i]->length));
query.addBindValue(QVariant(wi[i]->crossCount));
query.addBindValue(QVariant(wi[i]->orient));
query.exec();
le = query.lastError();
if (le.type() == QSqlError::NoError)
{
lastId = query.lastInsertId().toInt();
query2.prepare("INSERT INTO crossword.crosses (_template, _pd_id, _cpos, "
"_ctype, _numword) VALUES (?, ?, ?, ?, ?);");
cc = wi[i]->crossCount;
for (int j = 0; j < cc; j++)
{
cross = wi[i]->cil[j];
tmp << templateId;
pdid << lastId;
cpos << cross->crossPos;
ctype << cross->crossType;
nw << cross->numWord2;
}
query2.addBindValue(tmp);
query2.addBindValue(pdid);
query2.addBindValue(cpos);
query2.addBindValue(ctype);
query2.addBindValue(nw);
query2.execBatch(QSqlQuery::ValuesAsRows);
tmp.clear();
pdid.clear();
cpos.clear();
ctype.clear();
nw.clear();
}
else
qDebug() << "3. savePrivateData: " << le.text();
}
drv->commitTransaction();
}
DeviceHandler::DeviceHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap returns;
QVariantMap params;
params.clear(); returns.clear();
setDescription("GetSupportedVendors", "Returns a list of supported Vendors.");
setParams("GetSupportedVendors", params);
QVariantList vendors;
vendors.append(JsonTypes::vendorRef());
returns.insert("vendors", vendors);
setReturns("GetSupportedVendors", returns);
params.clear(); returns.clear();
setDescription("GetSupportedDevices", "Returns a list of supported Device classes, optionally filtered by vendorId.");
params.insert("o:vendorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetSupportedDevices", params);
QVariantList deviceClasses;
deviceClasses.append(JsonTypes::deviceClassRef());
returns.insert("deviceClasses", deviceClasses);
setReturns("GetSupportedDevices", returns);
params.clear(); returns.clear();
setDescription("GetPlugins", "Returns a list of loaded plugins.");
setParams("GetPlugins", params);
QVariantList plugins;
plugins.append(JsonTypes::pluginRef());
returns.insert("plugins", plugins);
setReturns("GetPlugins", returns);
params.clear(); returns.clear();
setDescription("GetPluginConfiguration", "Get a plugin's params.");
params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetPluginConfiguration", params);
QVariantList pluginParams;
pluginParams.append(JsonTypes::paramRef());
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:configuration", pluginParams);
setReturns("GetPluginConfiguration", returns);
params.clear(); returns.clear();
setDescription("SetPluginConfiguration", "Set a plugin's params.");
params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("configuration", pluginParams);
setParams("SetPluginConfiguration", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
setReturns("SetPluginConfiguration", returns);
params.clear(); returns.clear();
setDescription("AddConfiguredDevice", "Add a configured device with a setupMethod of SetupMethodJustAdd. "
"For devices with a setupMethod different than SetupMethodJustAdd, use PairDevice. "
"Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. "
"CreateMethodJustAdd takes the parameters you want to have with that device. "
"CreateMethodDiscovery requires the use of a deviceDescriptorId."
);
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList deviceParams;
deviceParams.append(JsonTypes::paramRef());
params.insert("o:deviceParams", deviceParams);
setParams("AddConfiguredDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("AddConfiguredDevice", returns);
returns.clear(); // Reused params from above!
setDescription("PairDevice", "Pair a device. "
"Use this for DeviceClasses with a setupMethod different than SetupMethodJustAdd. "
"Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. "
"CreateMethodJustAdd takes the parameters you want to have with that device. "
"CreateMethodDiscovery requires the use of a deviceDescriptorId. "
"If success is true, the return values will contain a pairingTransactionId, a displayMessage and "
"the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice "
"or PairDevice."
);
setParams("PairDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
returns.insert("o:displayMessage", JsonTypes::basicTypeToString(JsonTypes::String));
returns.insert("o:setupMethod", JsonTypes::setupMethodRef());
setReturns("PairDevice", returns);
params.clear(); returns.clear();
setDescription("ConfirmPairing", "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.");
params.insert("pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:secret", JsonTypes::basicTypeToString(JsonTypes::String));
setParams("ConfirmPairing", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("ConfirmPairing", returns);
params.clear(); returns.clear();
setDescription("GetConfiguredDevices", "Returns a list of configured devices.");
setParams("GetConfiguredDevices", params);
QVariantList devices;
devices.append(JsonTypes::deviceRef());
returns.insert("devices", devices);
setReturns("GetConfiguredDevices", returns);
params.clear(); returns.clear();
setDescription("GetDiscoveredDevices", "Performs a device discovery and returns the results. This function may take a while to return.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList discoveryParams;
discoveryParams.append(JsonTypes::paramRef());
params.insert("o:discoveryParams", discoveryParams);
setParams("GetDiscoveredDevices", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
QVariantList deviceDescriptors;
deviceDescriptors.append(JsonTypes::deviceDescriptorRef());
returns.insert("o:deviceDescriptors", deviceDescriptors);
setReturns("GetDiscoveredDevices", returns);
params.clear(); returns.clear();
setDescription("EditDevice", "Edit the parameters of a device. The device params will be set to the "
"passed parameters and the setup device will be called. If the device is discoverable, "
"you can perform a GetDiscoveredDevices before calling this method and pass "
"the new DeviceDescriptor (rediscover). If a parameter is not writable, you will find a "
"'readOnly': true in the ParamType. By default, every Param is writable.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList newDeviceParams;
newDeviceParams.append(JsonTypes::paramRef());
params.insert("o:deviceParams", newDeviceParams);
setParams("EditDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
setReturns("EditDevice", returns);
params.clear(); returns.clear();
setDescription("RemoveConfiguredDevice", "Remove a device from the system.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList removePolicyList;
QVariantMap policy;
policy.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
policy.insert("policy", JsonTypes::removePolicyRef());
removePolicyList.append(policy);
params.insert("o:removePolicy", JsonTypes::removePolicyRef());
params.insert("o:removePolicyList", removePolicyList);
setParams("RemoveConfiguredDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("RemoveConfiguredDevice", returns);
params.clear(); returns.clear();
setDescription("GetEventTypes", "Get event types for a specified deviceClassId.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetEventTypes", params);
QVariantList events;
events.append(JsonTypes::eventTypeRef());
returns.insert("eventTypes", events);
setReturns("GetEventTypes", returns);
params.clear(); returns.clear();
setDescription("GetActionTypes", "Get action types for a specified deviceClassId.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetActionTypes", params);
QVariantList actions;
actions.append(JsonTypes::actionTypeRef());
returns.insert("actionTypes", actions);
setReturns("GetActionTypes", returns);
params.clear(); returns.clear();
setDescription("GetStateTypes", "Get state types for a specified deviceClassId.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateTypes", params);
QVariantList states;
states.append(JsonTypes::stateTypeRef());
returns.insert("stateTypes", states);
setReturns("GetStateTypes", returns);
params.clear(); returns.clear();
setDescription("GetStateValue", "Get the value of the given device and the given stateType");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateValue", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:value", JsonTypes::basicTypeToString(JsonTypes::Variant));
setReturns("GetStateValue", returns);
params.clear(); returns.clear();
setDescription("GetStateValues", "Get all the state values of the given device.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateValues", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
states.clear();
QVariantMap state;
state.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
state.insert("value", JsonTypes::basicTypeToString(JsonTypes::Variant));
states.append(state);
returns.insert("o:values", states);
setReturns("GetStateValues", returns);
// Notifications
params.clear(); returns.clear();
setDescription("StateChanged", "Emitted whenever a State of a device changes.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("value", JsonTypes::basicTypeToString(JsonTypes::Variant));
setParams("StateChanged", params);
params.clear(); returns.clear();
setDescription("DeviceRemoved", "Emitted whenever a Device was removed.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("DeviceRemoved", params);
params.clear(); returns.clear();
setDescription("DeviceAdded", "Emitted whenever a Device was added.");
params.insert("device", JsonTypes::deviceRef());
setParams("DeviceAdded", params);
params.clear(); returns.clear();
setDescription("DeviceParamsChanged", "Emitted whenever the params of a Device changed (by editing or rediscovering).");
params.insert("device", JsonTypes::deviceRef());
setParams("DeviceParamsChanged", params);
connect(GuhCore::instance(), &GuhCore::deviceStateChanged, this, &DeviceHandler::deviceStateChanged);
connect(GuhCore::instance(), &GuhCore::deviceRemoved, this, &DeviceHandler::deviceRemovedNotification);
connect(GuhCore::instance(), &GuhCore::deviceAdded, this, &DeviceHandler::deviceAddedNotification);
connect(GuhCore::instance(), &GuhCore::deviceParamsChanged, this, &DeviceHandler::deviceParamsChangedNotification);
connect(GuhCore::instance(), &GuhCore::devicesDiscovered, this, &DeviceHandler::devicesDiscovered, Qt::QueuedConnection);
connect(GuhCore::instance(), &GuhCore::deviceSetupFinished, this, &DeviceHandler::deviceSetupFinished);
connect(GuhCore::instance(), &GuhCore::deviceEditFinished, this, &DeviceHandler::deviceEditFinished);
connect(GuhCore::instance(), &GuhCore::pairingFinished, this, &DeviceHandler::pairingFinished);
}
/*!
* Returns a map of identifier to detail definition which are valid for contacts whose type is the given \a contactType
* which are valid for the contacts in this store
*/
QMap<QString, QContactDetailDefinition> CntSymbianSimEngine::detailDefinitions(const QString& contactType, QContactManager::Error* error) const
{
if (!supportedContactTypes().contains(contactType)) {
// Should never happen
*error = QContactManager::NotSupportedError;
return QMap<QString, QContactDetailDefinition>();
}
// Get store information
SimStoreInfo storeInfo = d->m_simStore->storeInfo();
// the map we will eventually return
QMap<QString, QContactDetailDefinition> retn;
// local variables for reuse
QMap<QString, QContactDetailFieldDefinition> fields;
QContactDetailFieldDefinition f;
QContactDetailDefinition def;
QVariantList subTypes;
// sync target
def.setName(QContactSyncTarget::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
subTypes.clear();
subTypes << QString(QLatin1String(KSimSyncTarget));
f.setAllowableValues(subTypes);
fields.insert(QContactSyncTarget::FieldSyncTarget, f);
def.setFields(fields);
def.setUnique(true);
retn.insert(def.name(), def);
// type
def.setName(QContactType::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
subTypes.clear();
// groups are not supported
subTypes << QString(QLatin1String(QContactType::TypeContact));
f.setAllowableValues(subTypes);
fields.insert(QContactType::FieldType, f); // note: NO CONTEXT!!
def.setFields(fields);
def.setUnique(true);
retn.insert(def.name(), def);
/* TODO
// guid
def.setName(QContactGuid::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
f.setAllowableValues(QVariantList());
fields.insert(QContactGuid::FieldGuid, f);
f.setDataType(QVariant::StringList);
f.setAllowableValues(contexts);
fields.insert(QContactDetail::FieldContext, f);
def.setFields(fields);
def.setUnique(false);
def.setAccessConstraint(QContactDetailDefinition::CreateOnly);
retn.insert(def.name(), def);
*/
// display label
def.setName(QContactDisplayLabel::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
f.setAllowableValues(QVariantList());
fields.insert(QContactDisplayLabel::FieldLabel, f);
def.setFields(fields);
def.setUnique(true);
retn.insert(def.name(), def);
// email support needs to be checked run-time, because it is SIM specific
if (storeInfo.m_emailSupported) {
def.setName(QContactEmailAddress::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
f.setAllowableValues(QVariantList());
fields.insert(QContactEmailAddress::FieldEmailAddress, f);
def.setFields(fields);
def.setUnique(true);
retn.insert(def.name(), def);
}
// phone number
def.setName(QContactPhoneNumber::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
f.setAllowableValues(QVariantList());
fields.insert(QContactPhoneNumber::FieldNumber, f);
// TODO: subtypes supported in case a sim contact can have multiple phone numbers?
def.setFields(fields);
if (storeInfo.m_additionalNumberSupported) {
// multiple numbers supported
def.setUnique(false);
} else {
// only one phone number allowed
def.setUnique(true);
}
retn.insert(def.name(), def);
// nickname support needs to be checked run-time, because it is SIM specific
if (storeInfo.m_secondNameSupported) {
def.setName(QContactNickname::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
f.setAllowableValues(QVariantList());
fields.insert(QContactNickname::FieldNickname, f);
def.setFields(fields);
def.setUnique(true);
retn.insert(def.name(), def);
}
// name
def.setName(QContactName::DefinitionName);
fields.clear();
f.setDataType(QVariant::String);
f.setAllowableValues(QVariantList());
fields.insert(QContactName::FieldCustomLabel, f);
def.setFields(fields);
def.setUnique(true);
retn.insert(def.name(), def);
return retn;
}
bool
MeshGenerator::getValues(int &depth,
int &fillValue,
bool &checkForMore,
bool &lookInside,
QGradientStops &stops,
bool doBorder,
int &chan,
bool &avgColor)
{
chan = 0;
depth = 1;
fillValue = -1;
checkForMore = true;
lookInside = false;
avgColor = false;
m_useTagColors = false;
m_scaleModel = 1.0;
QGradientStops vstops;
vstops << QGradientStop(0.0, QColor(50 ,50 ,50 ,255))
<< QGradientStop(0.5, QColor(200,150,100,255))
<< QGradientStop(1.0, QColor(255,255,255,255));
if (doBorder) fillValue = 0;
PropertyEditor propertyEditor;
QMap<QString, QVariantList> plist;
QVariantList vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(avgColor);
plist["average color"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(m_useTagColors);
plist["apply tag colors"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(chan);
vlist << QVariant(0);
vlist << QVariant(2);
plist["mop channel"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(depth);
vlist << QVariant(0);
vlist << QVariant(200);
plist["depth"] = vlist;
vlist.clear();
vlist << QVariant("int");
vlist << QVariant(fillValue);
vlist << QVariant(-1);
vlist << QVariant(255);
plist["fillvalue"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(checkForMore);
plist["greater"] = vlist;
vlist.clear();
vlist << QVariant("checkbox");
vlist << QVariant(lookInside);
plist["look inside"] = vlist;
vlist.clear();
vlist << QVariant("float");
vlist << QVariant(m_scaleModel);
vlist << QVariant(0.001);
vlist << QVariant(1.0);
vlist << QVariant(0.005); // singlestep
vlist << QVariant(3); // decimals
plist["scale"] = vlist;
vlist.clear();
vlist << QVariant("colorgradient");
for(int s=0; s<vstops.size(); s++)
{
float pos = vstops[s].first;
QColor color = vstops[s].second;
int r = color.red();
int g = color.green();
int b = color.blue();
int a = color.alpha();
vlist << QVariant(pos);
vlist << QVariant(r);
vlist << QVariant(g);
vlist << QVariant(b);
vlist << QVariant(a);
}
plist["color gradient"] = vlist;
vlist.clear();
QFile helpFile(":/mesh.help");
if (helpFile.open(QFile::ReadOnly))
{
QTextStream in(&helpFile);
QString line = in.readLine();
while (!line.isNull())
{
if (line == "#begin")
{
QString keyword = in.readLine();
QString helptext;
line = in.readLine();
while (!line.isNull())
{
helptext += line;
helptext += "\n";
line = in.readLine();
if (line == "#end") break;
}
vlist << keyword << helptext;
}
line = in.readLine();
}
}
plist["commandhelp"] = vlist;
vlist.clear();
QString mesg;
mesg += "File : "+m_vfm->fileName()+"\n";
int d = m_vfm->depth();
int w = m_vfm->width();
int h = m_vfm->height();
mesg += QString("Volume Size : %1 %2 %3\n").arg(h).arg(w).arg(d);
mesg += QString("Data Min : %1 %2 %3\n").arg(m_dataMin.x).arg(m_dataMin.y).arg(m_dataMin.z);
mesg += QString("Data Max : %1 %2 %3\n").arg(m_dataMax.x).arg(m_dataMax.y).arg(m_dataMax.z);
if (m_voxelType > 0)
mesg += "\n ** Only opacity based surface generation available for unsigned short data **\n";
mesg += "\n* You can keep on working while this process is running.\n";
vlist << mesg;
plist["message"] = vlist;
QStringList keys;
keys << "average color";
keys << "apply tag colors";
keys << "mop channel";
keys << "isosurface value";
keys << "depth";
keys << "fillvalue";
keys << "scale";
keys << "greater";
keys << "look inside";
keys << "color gradient";
keys << "commandhelp";
keys << "message";
propertyEditor.set("Mesh Repainting Parameters", plist, keys);
QMap<QString, QPair<QVariant, bool> > vmap;
if (propertyEditor.exec() == QDialog::Accepted)
vmap = propertyEditor.get();
else
return false;
for(int ik=0; ik<keys.count(); ik++)
{
QPair<QVariant, bool> pair = vmap.value(keys[ik]);
if (pair.second)
{
if (keys[ik] == "average color")
avgColor = pair.first.toBool();
else if (keys[ik] == "apply tag colors")
m_useTagColors = pair.first.toBool();
else if (keys[ik] == "mop channel")
chan = pair.first.toInt();
else if (keys[ik] == "color gradient")
vstops = propertyEditor.getGradientStops(keys[ik]);
else if (keys[ik] == "scale")
m_scaleModel = pair.first.toFloat();
else if (keys[ik] == "depth")
depth = pair.first.toInt();
else if (keys[ik] == "fillvalue")
fillValue = pair.first.toInt();
else if (keys[ik] == "greater")
checkForMore = pair.first.toBool();
else if (keys[ik] == "look inside")
lookInside = pair.first.toBool();
}
}
stops = resampleGradientStops(vstops);
return true;
}
int QDBusInterfacePrivate::metacall(QMetaObject::Call c, int id, void **argv)
{
Q_Q(QDBusInterface);
if (c == QMetaObject::InvokeMetaMethod) {
int offset = metaObject->methodOffset();
QMetaMethod mm = metaObject->method(id + offset);
if (mm.methodType() == QMetaMethod::Signal) {
// signal relay from D-Bus world to Qt world
QMetaObject::activate(q, metaObject, id, argv);
} else if (mm.methodType() == QMetaMethod::Slot) {
// method call relay from Qt world to D-Bus world
// get D-Bus equivalent signature
QString methodName = QLatin1String(metaObject->dbusNameForMethod(id));
const int *inputTypes = metaObject->inputTypesForMethod(id);
int inputTypesCount = *inputTypes;
// we will assume that the input arguments were passed correctly
QVariantList args;
for (int i = 1; i <= inputTypesCount; ++i)
args << QVariant(inputTypes[i], argv[i]);
// make the call
QPointer<QDBusInterface> qq = q;
QDBusMessage reply = q->callWithArgumentList(QDBus::Block, methodName, args);
args.clear();
// we ignore return values
// access to "this" or to "q" below this point must check for "qq"
// we may have been deleted!
if (!qq.isNull())
lastError = reply;
// done
return -1;
}
} else if (c == QMetaObject::ReadProperty) {
// Qt doesn't support non-readable properties
// we have to re-check
QMetaProperty mp = metaObject->property(id + metaObject->propertyOffset());
if (!mp.isReadable())
return -1; // don't read
QVariant *value = reinterpret_cast<QVariant*>(argv[1]);
argv[1] = 0;
*value = property(mp);
return -1; // handled, error or not
} else if (c == QMetaObject::WriteProperty) {
// QMetaProperty::write has already checked that we're writable
// it has also checked that the type is right
QVariant *value = reinterpret_cast<QVariant *>(argv[1]);
QMetaProperty mp = metaObject->property(id + metaObject->propertyOffset());
setProperty(mp, *value);
return -1;
}
return id;
}
void tstTabRow::testUpdate()
{
printStartMsg("testUpdate");
QList<dbOverlay::GenericDatabase::DB_ENGINE> dbTypes;
dbTypes.append(dbOverlay::GenericDatabase::SQLITE);
dbTypes.append(dbOverlay::GenericDatabase::MYSQL);
QList<dbOverlay::GenericDatabase::DB_ENGINE>::iterator i;
for (i = dbTypes.begin(); i != dbTypes.end(); ++i)
{
SampleDB db = getScenario01(*i);
QSqlDatabase check = getDbConn(*i);
TabRow r(&db, "t1", 2);
QVariantList qvl;
// regular update
qvl << "i" << 666;
CPPUNIT_ASSERT(r.update(qvl));
QSqlQuery q = check.exec("SELECT * FROM t1 WHERE id=2");
CPPUNIT_ASSERT(q.first());
CPPUNIT_ASSERT(q.value(0).toInt() == 2);
CPPUNIT_ASSERT(q.value(1).toInt() == 666);
CPPUNIT_ASSERT(q.value(2).toDouble() == 666.66);
CPPUNIT_ASSERT(q.value(3).toString() == "Hi");
q.clear();
// update more than one column, including NULL values
qvl.clear();
qvl << "i" << QVariant::Int;
qvl << "s" << ",,,";
CPPUNIT_ASSERT(r.update(qvl));
q = check.exec("SELECT * FROM t1 WHERE id=2");
CPPUNIT_ASSERT(q.first());
CPPUNIT_ASSERT(q.value(0).toInt() == 2);
CPPUNIT_ASSERT(q.value(1).isNull());
CPPUNIT_ASSERT(q.value(2).toDouble() == 666.66);
CPPUNIT_ASSERT(q.value(3).toString() == ",,,");
q.clear();
// try to update the id column
qvl.clear();
qvl << "id" << 666;
qvl << "i" << -5;
qvl << "f" << -5.55;
qvl << "s" << "Noooo";
CPPUNIT_ASSERT_THROW(r.update(qvl), std::invalid_argument);
q = check.exec("SELECT * FROM t1 WHERE id=2");
CPPUNIT_ASSERT(q.first());
CPPUNIT_ASSERT(q.value(0).toInt() == 2);
CPPUNIT_ASSERT(q.value(1).isNull());
CPPUNIT_ASSERT(q.value(2).toDouble() == 666.66);
CPPUNIT_ASSERT(q.value(3).toString() == ",,,");
q.clear();
// invalid number of args
qvl.clear();
qvl << "i" << -5;
qvl << "f" << -5.55;
qvl << "s";
CPPUNIT_ASSERT_THROW(r.update(qvl), std::invalid_argument);
q = check.exec("SELECT * FROM t1 WHERE id=2");
CPPUNIT_ASSERT(q.first());
CPPUNIT_ASSERT(q.value(0).toInt() == 2);
CPPUNIT_ASSERT(q.value(1).isNull());
CPPUNIT_ASSERT(q.value(2).toDouble() == 666.66);
CPPUNIT_ASSERT(q.value(3).toString() == ",,,");
q.clear();
// invalid column names
qvl.clear();
qvl << "x" << -5;
qvl << "y" << -5.55;
qvl << "z" << "qqq";
CPPUNIT_ASSERT(!(r.update(qvl)));
q = check.exec("SELECT * FROM t1 WHERE id=2");
CPPUNIT_ASSERT(q.first());
CPPUNIT_ASSERT(q.value(0).toInt() == 2);
CPPUNIT_ASSERT(q.value(1).isNull());
CPPUNIT_ASSERT(q.value(2).toDouble() == 666.66);
CPPUNIT_ASSERT(q.value(3).toString() == ",,,");
q.clear();
// remove the connection of the "Object under test"
db.close();
// remove the connection of the unittest framework
removeDbConn();
}
printEndMsg();
}
