void PropertyEditDelegate::setModelData(QWidget* editor_,
QAbstractItemModel* model_,
const QModelIndex& index) const
{
const QVariant& data = index.data();
GeneratorPropertiesModel* model =
static_cast<GeneratorPropertiesModel*>(model_);
switch (data.type())
{
case QVariant::Double:
{
QLineEdit* editor = static_cast<QLineEdit*>(editor_);
model->setData(index, editor->text().toDouble(), Qt::EditRole);
break;
}
case QVariant::Int:
{
QSpinBox* editor = static_cast<QSpinBox*>(editor_);
editor->interpretText();
model->setData(index, editor->value(), Qt::EditRole);
break;
}
case QVariant::Bool:
{
QCheckBox* editor = static_cast<QCheckBox*>(editor_);
const bool value = editor->checkState() == Qt::Checked;
model->setData(index, value, Qt::EditRole);
break;
}
case QVariant::List:
{
QLineEdit* editor = static_cast<QLineEdit*>(editor_);
QStringList list = editor->text().split(",");
QVariantList varList;
QDoubleValidator validator;
for (QString& str : list)
{
if (str == "")
continue;
int pos = 0;
if (validator.validate(str, pos) == QValidator::Acceptable)
varList.push_back(QVariant(str.toDouble()));
else
varList.push_back(QVariant(-1.0));
}
model->setData(index, varList, Qt::EditRole);
break;
}
default:
{
break;
}
}
}
QVariantList WorkflowModel::getTests(int conditionId) const
{
try {
QVariantList result;
if (_workflow.isValid()){
SPWorkFlowNode node = _workflow->nodeById(conditionId) ;
if (!node || !hasType(node->type(),WorkFlowNode::ntCONDITION |WorkFlowNode::ntRANGE))
return result;
std::shared_ptr<WorkFlowCondition> condition = std::static_pointer_cast<WorkFlowCondition>(node);
for(int i=0; i < condition->testCount(); ++i){
WorkFlowCondition::Test test = condition->test(i);
std::shared_ptr<OperationNode> operNode = std::static_pointer_cast<OperationNode>(test._operation);
QVariantMap testEntry;
testEntry["name2"] =operNode->name();
testEntry["pre"] = MathHelper::logicalOperator2string(test._pre);
testEntry["post"] = MathHelper::logicalOperator2string(test._post);
QVariantList parameters;
for(int j=0; j < operNode->inputCount(); ++j){
QVariantMap parameterKeys;
QString value;
if ( test._operation->inputRef(j).inputLink()){
int n = test._operation->inputRef(j).outputParameterIndex();
value = "link=" + QString::number(test._operation->inputRef(j).inputLink()->id()) + ":" + QString::number(n);
}else
value = operNode->inputRef(j).value();
QString label = operNode->inputRef(j).label();
testEntry["name2"] = testEntry["name2"].toString() + " " + value;
parameterKeys["value"] = value;
parameterKeys["label"] = label;
QStringList choices = operNode->operation()->choiceList(j);
QVariantList lst;
for(QString choice : choices)
lst.append(choice);
parameterKeys["choicelist"] = lst;
parameters.push_back(parameterKeys);
}
testEntry["parameters"] = parameters;
result.push_back(testEntry);
}
}
return result;
} catch (const ErrorObject&){
kernel()->issues()->log(TR("Could not create condition tests"));
}
return QVariantList();
}
QVariantList ModelChooser::getRoutesNum(){
QVariantList routesNum;
for(int i=0;i < routes.size(); i++ ){
routesNum.push_back(prevLegCost[routes[i]]);
}
return routesNum;
}
void MainWindow::saveOpenedFileList()
{
// 填入comboBox;
auto comboBox_exportPaths = this->findChild<QComboBox *>(tr("comboBox_exportPaths"));
if (!comboBox_exportPaths)
{
Q_ASSERT(false);
return;
}
QVariantList vallist;
int count = comboBox_exportPaths->maxVisibleItems();
for (int i=0; i<count; ++i)
{
const auto &s = comboBox_exportPaths->itemText(i);
const auto &val = QVariant(s);
vallist.push_back(val);
}
QString latest_file = comboBox_exportPaths->currentText();
// 写配置文件;
QString settingsFileName = QDir::currentPath() + tr("/settings.ini");
auto &settings = QSettings(settingsFileName, QSettings::IniFormat);
settings.beginGroup("config");
settings.setValue(tr("opened_file_list"), vallist);
settings.setValue(tr("latest_file"), latest_file);
settings.endGroup();
}
QVariantList PolygonVertexAttributeArray::getValuesAsVariantList() const {
QVariantList variants;
for (float value : mValues) {
variants.push_back(value);
}
return variants;
}
QVariantList Communicator::getDayCount()
{
QVariantList result;
QVariantList params = authParams();
if (params.size() == 0)
return result;
QMap<QString, QVariant> param = params.takeAt(0).toMap();
param["ver"] = 1;
params.push_back(param);
request("LJ.XMLRPC.getdaycounts", params);
std::auto_ptr<QBuffer> buffer(m_responses.take(m_currentRequestId));
QByteArray buf = buffer->buffer();
xmlrpc::Response response;
QVariant responceData = response.parse(buf);
if (response.isValid()) {
QMap<QString, QVariant> data = responceData.toMap();
result = data["daycounts"].toList();
}
return result;
}
QVariantMap CaptureSettings::toJSON() const
{
QVariantMap ret;
ret["AutoStart"] = AutoStart;
ret["Executable"] = Executable;
ret["WorkingDir"] = WorkingDir;
ret["CmdLine"] = CmdLine;
QVariantList env;
for(int i = 0; i < Environment.size(); i++)
env.push_back(Environment[i].toJSON());
ret["Environment"] = env;
QVariantMap opts;
opts["AllowVSync"] = Options.AllowVSync;
opts["AllowFullscreen"] = Options.AllowFullscreen;
opts["APIValidation"] = Options.APIValidation;
opts["CaptureCallstacks"] = Options.CaptureCallstacks;
opts["CaptureCallstacksOnlyDraws"] = Options.CaptureCallstacksOnlyDraws;
opts["DelayForDebugger"] = Options.DelayForDebugger;
opts["VerifyMapWrites"] = Options.VerifyMapWrites;
opts["HookIntoChildren"] = Options.HookIntoChildren;
opts["RefAllResources"] = Options.RefAllResources;
opts["SaveAllInitials"] = Options.SaveAllInitials;
opts["CaptureAllCmdLists"] = Options.CaptureAllCmdLists;
opts["DebugOutputMute"] = Options.DebugOutputMute;
ret["Options"] = opts;
return ret;
}
void LineEditPropertyFactory::OnButtonClicked()
{
QPushButton *button = qobject_cast<QPushButton*>(sender());
if (!button)
return;
QString function;
for(uint i = 0; i < (uint)buttons_.size(); ++i)
{
if (buttons_[i].objectName == button->objectName())
{
function = buttons_[i].method;
break;
}
}
if(!function.isNull())
{
foreach(const ComponentWeakPtr &comp_ptr, components_)
{
ComponentPtr comp = comp_ptr.lock();
if (comp)
{
QVariantList list;
list.push_back(QVariant(button->objectName()));
FunctionInvoker::Invoke(comp.get(), function, list);
}
}
QVariant DiscreteVariable_Impl::toServerFormulationVariant() const {
QVariantMap map;
map["uuid"] = toQString(removeBraces(uuid()));
map["version_uuid"] = toQString(removeBraces(uuid()));
map["name"] = toQString(name());
map["display_name"] = toQString(displayName());
map["type"] = QString("Integer"); // could be Discrete instead
// determine minimum, maximum from all values
IntVector allValues = validValues(false);
// right now, only have MeasureGroup, this will always be contiguous listing
map["minimum"] = 0;
map["maximum"] = int(allValues.size()) - 1;
// no initial_value implemented right now
// if selected values are subset, list them separately
IntVector selectedValues = validValues(true);
if (selectedValues.size() < allValues.size()) {
QVariantList selectedList;
for (int val : selectedValues) {
selectedList.push_back(QVariant(val));
}
map["selected_values"] = selectedList;
}
return QVariant(map);
}
QVariant AttributesModel::headerData ( int section,
Qt::Orientation orientation,
int role/* = Qt::DisplayRole */ ) const
{
if( sourceModel() ) {
const QVariant sourceData = sourceModel()->headerData( section, orientation, role );
if ( sourceData.isValid() ) return sourceData;
}
if( orientation == Qt::Horizontal && role == ColumnDataRole )
{
// it seems the source model doesn't like the idea of handing out all the column data at once...
// so we have to do it manually.
QVariantList result;
const int rows = sourceModel()->rowCount();
for( int row = 0; row < rows; ++row )
result.push_back( sourceModel()->index( row, section ).data() );
return result;
}
// the source model didn't have data set, let's use our stored values
const QMap<int, QMap<int, QVariant> >& map = orientation == Qt::Horizontal ? mHorizontalHeaderDataMap : mVerticalHeaderDataMap;
if ( map.contains( section ) ) {
const QMap<int, QVariant> &dataMap = map[ section ];
if ( dataMap.contains( role ) ) {
return dataMap[ role ];
}
}
return defaultHeaderData( section, orientation, role );
}
//------------------------------------------------------------------------------
// Name: toVariantList
//------------------------------------------------------------------------------
QVariantList QJsonArray::toVariantList() const {
QVariantList a;
Q_FOREACH(const QJsonValue &v, *this) {
a.push_back(v.toVariant());
}
return a;
}
QVariantList WorkflowModel::getConditions(int containerId)
{
ConditionContainer container = _workflow->getContainer(containerId);
QVariantList results;
int i = 0;
for (Condition condition : container.conditions) {
QVariantMap map;
map.insert("xId", i);
map.insert("name", "");
QString value = condition._operation->source()["keyword"].toString();
if (value.contains("condition")){
map.insert("first", !condition._inputAssignments[0].value.isEmpty());
map.insert("condition", condition._inputAssignments[1].value);
map.insert("second", !condition._inputAssignments[2].value.isEmpty());
} else {
bool set = true;
for (AssignedInputData input : condition._inputAssignments){
if (input.value.isEmpty()) {
set = false;
}
}
map.insert("name", condition._operation->name());
map.insert("set", set);
}
results.push_back(map);
++i;
}
return results;
}
Events Communicator::getDayEvents(const QString &dateStr)
{
QVariantList params = authParams();
if (params.size() == 0)
return Events();
QDate date = QDate::fromString(dateStr, "yyyy-MM-dd");
if (!date.isValid())
return Events();
// Modify params by adding the item id.
QMap<QString, QVariant> param = params.takeAt(0).toMap();
// Make sure we use utf-8 encoded strings in response.
param["ver"] = 1;
param["prefersubject"] = 0;
param["selecttype"] = "day";
param["year"] = date.year();
param["month"] = date.month();
param["day"] = date.day();
params.push_back(param);
request("LJ.XMLRPC.getevents", params);
std::auto_ptr<QBuffer> buffer(m_responses.take(m_currentRequestId));
QByteArray buf = buffer->buffer();
Events events(buf);
return events;
}
QVariantList SecurityManager::generateCredentials()
{
QVariantList credentials;
KeyGen key_gen;
QString auth_key = key_gen.generateKey(32, KeyGen::COMPLEX);
QString otp = key_gen.generateKey(8, KeyGen::SIMPLE);
credentials.push_back(auth_key);
credentials.push_back(otp);
PrivateConfig private_conf;
QStringList credential_strings;
credential_strings.push_back(auth_key);
credential_strings.push_back(otp);
private_conf.setCredentials(credential_strings);
return credentials;
}
Events Communicator::getEvents(int howmany, const QString &beforedate)
{
QVariantList params = authParams();
if (params.size() == 0)
return Events();
// Modify params by adding the item id.
QMap<QString, QVariant> param = params.takeAt(0).toMap();
// Make sure we use utf-8 encoded strings in response.
param["ver"] = 1;
param["prefersubject"] = 0;
param["selecttype"] = "lastn";
param["howmany"] = howmany;
if (!beforedate.isEmpty()) {
param["beforedate"] = beforedate;
}
params.push_back(param);
request("LJ.XMLRPC.getevents", params);
std::auto_ptr<QBuffer> buffer(m_responses.take(m_currentRequestId));
QByteArray buf = buffer->buffer();
Events events(buf);
return events;
}
EventData Communicator::postEvent(const QString &subject, const QString &event,
const Security &security, const QDateTime &dt,
const EventProperties &props,
const QString &journal)
{
QVariantList params = authParams();
if (params.size() == 0)
EventData();
// Modify params by adding the item id.
QMap<QString, QVariant> param = params.takeAt(0).toMap();
// Make sure we use utf-8 encoded strings in response.
param["ver"] = 1;
param["subject"] = subject;
param["event"] = event;
param["year"] = dt.date().year();
param["mon"] = dt.date().month();
param["day"] = dt.date().day();
param["hour"] = dt.time().hour();
param["min"] = dt.time().minute();
param["usejournal"] = journal;
param["props"] = props.data();
param["security"] = security.selectedMajorLJName();
if (security.type() == Security::UseMask) {
param["allowmask"] = security.mask();
}
params.push_back(param);
request("LJ.XMLRPC.postevent", params);
std::auto_ptr<QBuffer> buffer(m_responses.take(m_currentRequestId));
QByteArray buf = buffer->buffer();
return EventData(buf);
}
void DirectoryScanner::endElement()
{
switch (--depth) {
case 1:
{
QString basePath(
type == "registry"
? regBaseFinder.GetBasePath()
: fsBaseFinder.GetBasePath());
if(!basePath.isEmpty()) {
dirs.push_back(QVariantList() << basePath << include.join('|') << exclude.join('|'));
}
include.clear();
exclude.clear();
break;
}
case 0:
if (dirs.length() > 0) {
QVariantList entry;
entry << name << title;
entry.push_back(dirs);
result.push_back(entry);
dirs.clear();
}
break;
default:
break;
}
}
QMap<QString, QVariant> Communicator::getComments(int postid)
{
QMap<QString, QVariant> result;
QVariantList params = authParams();
if (params.size() == 0)
return result;
// Modify params by adding the item id.
QMap<QString, QVariant> param = params.takeAt(0).toMap();
param["ditemid"] = postid;
params.push_back(param);
request("LJ.XMLRPC.getcomments", params);
std::auto_ptr<QBuffer> buffer(m_responses.take(m_currentRequestId));
QByteArray buf = buffer->buffer();
xmlrpc::Response response;
QVariant responceData = response.parse(buf);
if (response.isValid()) {
result = responceData.toMap();
}
return result;
}
QVariantMap ActorSystem::editingAttributes(int) const
{
QVariantMap ret;
{
QVariantMap types;
{
QVariantMap sphere;
{
QVariantMap psphere;
{
psphere["Radius"] = 0.5f;
psphere["Color"] = QColor(0,255,0,255);
psphere["Center"] = toVarMap(osg::Vec3(0.5f,0,0));
}
sphere["prototype"] = psphere;
}
types["Sphere"] = sphere;
QVariantMap box;
{
QVariantMap pbox;
{
pbox["HalfLengths"] = toVarMap(osg::Vec3(0.5f,0.5f,0.5f));
pbox["Color"] = QColor(255,0,0,255);
pbox["Center"] = toVarMap(osg::Vec3(-0.5f,0,0));
}
box["prototype"] = pbox;
}
types["Box"] = box;
}
ret["__types"] = types;
QVariantMap shapesattr;
{
QVariantList shapesproto;
{
shapesproto.push_back("Box");
shapesproto.push_back("Sphere");
}
shapesattr["prototypes"] = shapesproto;
}
ret["shapes"] = shapesattr;
}
return ret;
}
void WidgetArea::keyReleaseEvent(QKeyEvent *k)
{
if(k->isAutoRepeat())
return;
QVariantList args;
args.push_back(k->key());
emit onScriptEvent("keyReleased", args);
}
QVariantList convertToVariant(const QList<QString> &val)
{
QVariantList ret;
ret.reserve(val.count());
for(const QString &s : val)
ret.push_back(s);
return ret;
}
void MainWindow::on_actionExtTypes_triggered()
{
QVariant v1(QLatin1String("hallo"));
QVariant v2(QStringList(QLatin1String("hallo")));
QVector<QString> vec;
vec.push_back("Hallo");
vec.push_back("Hallo2");
std::set<std::string> stdSet;
stdSet.insert("s1");
QWidget *ww = this;
QWidget &wwr = *ww;
QSharedPointer<QString> sps(new QString("hallo"));
QList<QSharedPointer<QString> > spsl;
spsl.push_back(sps);
QMap<QString,QString> stringmap;
QMap<int,int> intmap;
std::map<std::string, std::string> stdstringmap;
stdstringmap[std::string("A")] = std::string("B");
int hidden = 45;
if (1 == 1 ) {
int hidden = 7;
qDebug() << hidden;
}
QLinkedList<QString> lls;
lls << "link1" << "link2";
QStandardItemModel *model =new QStandardItemModel;
model->appendRow(new QStandardItem("i1"));
QList <QList<int> > nestedIntList;
nestedIntList << QList<int>();
nestedIntList.front() << 1 << 2;
QVariantList vList;
vList.push_back(QVariant(42));
vList.push_back(QVariant("HALLO"));
stringmap.insert("A", "B");
intmap.insert(3,4);
QSet<QString> stringSet;
stringSet.insert("S1");
stringSet.insert("S2");
qDebug() << *(spsl.front()) << hidden;
}
QVariantMap toJson(const PokeBattle &poke)
{
QVariantMap ret;
ret.insert("num", poke.num().pokenum);
if (poke.num().subnum) {
ret.insert("forme", poke.num().subnum);
}
ret.insert("name", poke.nick());
ret.insert("level", poke.level());
if (poke.gender()) {
ret.insert("gender", poke.gender());
}
if (poke.shiny()) {
ret.insert("shiny", poke.shiny());
}
ret.insert("percent", poke.lifePercent());
if (poke.status() != Pokemon::Fine) {
ret.insert("status", poke.status());
}
ret.insert("life", poke.lifePoints());
ret.insert("totalLife", poke.totalLifePoints());
ret.insert("happiness", poke.happiness());
ret.insert("item", poke.item());
ret.insert("ability", poke.ability());
QVariantList moves;
for (int i = 0; i < 4; i++) {
moves.push_back(toJson(poke.move(i)));
}
ret.insert("moves", moves);
QVariantList evs;
for (int i = 0; i < 6; i++) {
evs.push_back(poke.evs()[i]);
}
QVariantList ivs;
for (int i = 0; i < 6; i++) {
ivs.push_back(poke.dvs()[i]);
}
ret.insert("evs", evs);
ret.insert("ivs", ivs);
return ret;
}
void BattleToJson::onDynamicStats(int spot, const BattleStats& stats)
{
makeCommand("stats");
QVariantList vstats;
for (int i = 0; i < 6; i++) {
vstats.push_back(int(stats.stats[i]));
}
map.insert("stats", vstats);
}
json::helper::helper_base* new_child()
{
type = LIST;
QVariant tmp;
list.push_back(tmp);
return new qvariant_helper(list.last());
}
static QVariantList JsonToList(const JsonVector & json)
{
QVariantList list;
for (auto & entry : json)
{
list.push_back(JsonUtils::toVariant(entry));
}
return list;
}
QVariantList Ilwis::Ui::LayerManager::linkProperties() const
{
QVariantList result;
QVariantMap mp;
mp["name"] = "zoomextent";
mp["modelid"] = modelId();
result.push_back(mp);
return result;
}
QVariantList ModelBuilder::analysisModels() const
{
QVariantList result;
for (auto analysis : _analysisModelCreators) {
QVariantMap mp;
mp["name"] = analysis.first;
result.push_back(mp);
}
return result;
}
int main(int argc, char ** argv)
{
// get the input filenames
std::string inputFolder = argv[1];
utils::Directory::FilenamesType filenames = utils::Directory::GetFiles(inputFolder, ".txt");
for(unsigned int i = 0; i < filenames.size(); i++)
{
// read the file
QFile * file = new QFile(QString::fromStdString(filenames[i]));
file->open(QIODevice::ReadOnly | QIODevice::Text);
QJson::Parser parser;
bool ok;
QVariantList list = parser.parse(file, &ok).toList();
QVariantList outputList;
file->close();
delete file;
for(int j = 0; j < list.size(); j++)
{
QString fname = list[j].toString();
QDir input(fname);
QDir output(QString::fromStdString(inputFolder));
QString outputLine = output.absoluteFilePath(input.dirName());
outputList.push_back(outputLine);
}
// save the output
QFile * outFile = new QFile(QString::fromStdString(filenames[i]));
outFile->open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate);
QJson::Serializer serialiser;
bool ok2;
QString json = serialiser.serialize(outputList, &ok2);
QTextStream out(outFile);
out << json;
outFile->close();
}
return 0;
}
static int dumpQVariantList()
{
QVariantList test;
if (!optEmptyContainers) {
test.push_back(QVariant(QLatin1String("hallo")));
test.push_back(QVariant(42));
test.push_back(QVariant(3.141));
}
// As a list
prepareInBuffer("QList", "local.qvariantlist", "local.qvariantlist", "QVariant");
qDumpObjectData440(2, 42, testAddress(&test), 1, sizeof(QVariant), 0,0 ,0);
fputs(qDumpOutBuffer, stdout);
// As typedef
fputs("\n\n", stdout);
prepareInBuffer("QVariantList", "local.qvariantlist", "local.qvariantlist", "");
qDumpObjectData440(2, 42, testAddress(&test), 1, 0, 0,0 ,0);
fputs(qDumpOutBuffer, stdout);
fputc('\n', stdout);
return 0;
}
