コード例 #1
0
/*!
 * Modifies the detail definitions. The default detail definitions are
 * queried from QContactManagerEngine::schemaDefinitions and then modified
 * with this function in the transform leaf classes.
 *
 * \a definitions The detail definitions to modify.
 * \a contactType The contact type the definitions apply for.
 */
void CntTransformPhoneNumber::detailDefinitions(QMap<QString, QContactDetailDefinition> &definitions, const QString& contactType) const
{
    Q_UNUSED(contactType);

    if(definitions.contains(QContactPhoneNumber::DefinitionName)) {
        QContactDetailDefinition d = definitions.value(QContactPhoneNumber::DefinitionName);
        QMap<QString, QContactDetailFieldDefinition> fields = d.fields();
        
        // Don't support "ContextOther"
        QContactDetailFieldDefinition f;
        f.setDataType(QVariant::StringList);
        f.setAllowableValues(QVariantList() 
            << QLatin1String(QContactDetail::ContextHome) 
            << QLatin1String(QContactDetail::ContextWork));
        fields[QContactDetail::FieldContext] = f;
        d.setFields(fields);

        // Replace original definitions
        definitions.insert(d.name(), d);
    }
}
コード例 #2
0
ファイル: decorationtest.cpp プロジェクト: KDE/kdecoration
void DecorationTest::testCreate()
{
    // just test that creating the Decoration doesn't crash
    MockBridge bridge;
    const QString bridgeKey = QStringLiteral("bridge");
    MockDecoration deco1(nullptr, QVariantList({
#ifdef _MSC_VER
                                                makeMap(bridgeKey, QVariant::fromValue(5)),
#else
                                                QVariantMap({ {bridgeKey, QVariant::fromValue(5)} }),
#endif
                                                QVariant::fromValue(bridgeKey),
                                                QVariantMap(),
#ifdef _MSC_VER
                                                makeMap(bridgeKey, QVariant::fromValue(&bridge)),
#else
                                                QVariantMap({ {bridgeKey, QVariant::fromValue(&bridge)} })
#endif
                                               }));
    QVERIFY(!deco1.client().isNull());
}
コード例 #3
0
ファイル: itemtags.cpp プロジェクト: amosbird/CopyQ
void ItemTagsScriptable::clearTags()
{
    const auto args = currentArguments();

    if ( args.isEmpty() ) {
        const auto dataValueList = call("selectedItemsData").toList();

        QVariantList dataList;
        for (const auto &itemDataValue : dataValueList) {
            auto itemData = itemDataValue.toMap();
            itemData.remove(mimeTags);
            dataList.append(itemData);
        }

        call( "setSelectedItemsData", QVariantList() << QVariant(dataList) );
    } else {
        const auto rows = this->rows(args, 0);
        for (int row : rows)
            setTags(row, QStringList());
    }
}
コード例 #4
0
/*!
 * Modifies the detail definitions. The default detail definitions are
 * queried from QContactManagerEngine::schemaDefinitions and then modified
 * with this function in the transform leaf classes.
 *
 * \a definitions The detail definitions to modify.
 * \a contactType The contact type the definitions apply for.
 */
void CntTransformFamily::detailDefinitions(QMap<QString, QContactDetailDefinition> &definitions, const QString& contactType) const
{
    Q_UNUSED(contactType);

    // Note: Family is not defined in the default schema
    QMap<QString, QContactDetailFieldDefinition> fields;
    QContactDetailFieldDefinition f;
    QContactDetailDefinition d;

    d.setName(QContactFamily::DefinitionName);
    f.setDataType(QVariant::String);
    f.setAllowableValues(QVariantList());
    fields.insert(QContactFamily::FieldSpouse, f);
    f.setDataType(QVariant::StringList);
    fields.insert(QContactFamily::FieldChildren, f);

    d.setFields(fields);
    d.setUnique(true);

    definitions.insert(d.name(), d);
}
コード例 #5
0
ファイル: spotifyio.cpp プロジェクト: CODeRUS/spotacular
void SpotifyIO::sendTrackEnd()
{
    int ms_played = mediaPlayer->duration();
    int ms_played_union = ms_played;
    int n_seeks_forward = 0;
    int n_seeks_backward = 0;
    int ms_seeks_forward = 0;
    int ms_seeks_backward = 0;
    int ms_latency = 100;
    bool display_track = false;
    QString play_context = "unknown";
    QString source_start = "unknown";
    QString source_end = "unknown";
    QString reason_start = "unknown";
    QString reason_end = "unknown";
    QString referrer = "unknown";
    QString referrer_version = "0.1.0";
    QString referrer_vendor = "com.spotify";
    int max_continuous = ms_played;
    sendCommand("sp/track_end",
                QVariantList()
                << mediaPlayer->getSession()
                << ms_played
                << ms_played_union
                << n_seeks_forward
                << n_seeks_backward
                << ms_seeks_forward
                << ms_seeks_backward
                << ms_latency
                << display_track
                << play_context
                << source_start
                << source_end
                << reason_start
                << reason_end
                << referrer
                << referrer_version
                << referrer_vendor
                << max_continuous);
}
コード例 #6
0
void PlasmaRunner::match(Plasma::RunnerContext &context)
{
    QList<Plasma::QueryMatch> matches;

    const QString query = context.query();

    bool success = false;
    // TODO: how to estimate that input is in Degree, not Radian?
    GeoDataCoordinates coordinates = GeoDataCoordinates::fromString(query, success);

    if (success) {
        const QVariant coordinatesData = QVariantList()
            << QVariant(coordinates.longitude(GeoDataCoordinates::Degree))
            << QVariant(coordinates.latitude(GeoDataCoordinates::Degree))
            << QVariant(0.1); // TODO: make this distance value configurable

        Plasma::QueryMatch match(this);
        match.setIcon(QIcon::fromTheme(QStringLiteral("marble")));
        match.setText(i18n("Show the coordinates %1 in OpenStreetMap with Marble", query));
        match.setData(coordinatesData);
        match.setId(query);
        match.setRelevance(1.0);
        match.setType(Plasma::QueryMatch::ExactMatch);

        matches << match;
    }

    // TODO: BookmarkManager does not yet listen to updates, also does not sync between processes :(
    // So for now always load on demand, even if expensive possibly
    BookmarkManager bookmarkManager(new GeoDataTreeModel);
    bookmarkManager.loadFile( QStringLiteral("bookmarks/bookmarks.kml") );

    for (GeoDataFolder* folder: bookmarkManager.folders()) {
        collectMatches(matches, query, folder);
    }

    if ( ! matches.isEmpty() ) {
        context.addMatches(matches);
    }
}
コード例 #7
0
QVariantList CTransaction::structToJson()
{
    if(changing)
        return QVariantList();
    //changing = true;
    QList<ROBOT_DATA> tmpData = statusDataBuf;
    QVariantList list;
    for(int i = 0; i < tmpData.count(); i++){
        qDebug()<<"get data";
        robotStatusData * deviceData= new robotStatusData(tmpData.at(i));
        QVariantMap deviceMap = toVariantMap(deviceData);
        QVariant deviceJson = toJsonVariant(deviceMap);
        list.append(deviceJson);
        if(deviceData != NULL)
            delete deviceData;
        deviceData = NULL;
        qDebug()<<"get done";
    }
    tmpData.clear();
    //changing = false;
    return list;
}
コード例 #8
0
ファイル: libraryui.cpp プロジェクト: realbardia/silicon
void LibraryUI::burnCurrentItem()
{
    QListWidgetItem *item = item_list->currentItem();
    if( item == 0 )
        return ;

    QString path = item->statusTip();

    SAboutData about;
    QList<SAboutData> apps_list = Silicon::appsList();
    for( int i=0 ; i<apps_list.count() ; i++ )
        if( apps_list[i].name() == "Copy Disc" )
        {
            about = apps_list[i];
            break;
        }

    if( about.name().isEmpty() )
        return ;

    Silicon::loadApp( about , QVariantList()<< path );
}
コード例 #9
0
void WebDavInventoryDataModel::UploadBuffer(const QString &filename, QByteArray& buffer, AbstractInventoryItem *parent_folder)
{
    if (!parent_folder)
        parent_folder = GetFirstChildFolderByName("My Inventory");

    InventoryFolder *parentFolder = dynamic_cast<InventoryFolder *>(parent_folder);
    if (!parentFolder)
        return;

    QString parentPath = ValidateFolderPath(parentFolder->GetID());
    QStringList result = webdavclient_.call("uploadFileBuffer", QVariantList() << buffer << parentPath << filename).toStringList();
    if (result.count() >= 1)
    {
        if (result[0] == "True")
        {
            FetchInventoryDescendents(parent_folder);
            InventoryModule::LogInfo(QString("Webdav | Upload of file %1 to path %2%3 succeeded\n").arg(filename, parentPath, filename).toStdString());
        }
        else
            InventoryModule::LogInfo(QString("Webdav | Upload of file %1 to path %2%3 failed\n").arg(filename, parentPath, filename).toStdString());
    }
}
コード例 #10
0
void InstructionFactoryTest::testCreateCallAndAssignInstruction()
{
    QVariantList words;
    words << "id"
          << "callandassign"
          << "symbol"
          << "instance"
          << "method"
          << "arg1"
          << "arg2";

    Instruction *abstractInstruction = InstructionFactory::createInstruction(words);

    CallAndAssignInstruction *instruction = dynamic_cast<CallAndAssignInstruction*>(abstractInstruction);
    QVERIFY(instruction != nullptr);

    QCOMPARE(instruction->instructionId(), QString("id"));
    QCOMPARE(instruction->symbolName(), QString("symbol"));
    QCOMPARE(instruction->instanceName(), QString("instance"));
    QCOMPARE(instruction->methodName(), QString("method"));
    QCOMPARE(instruction->arguments(), QVariantList() << "arg1" << "arg2");
}
コード例 #11
0
void WebDavInventoryDataModel::DownloadFile(const QString &store_folder, AbstractInventoryItem *selected_item)
{
    InventoryAsset *item = dynamic_cast<InventoryAsset *>(selected_item);
    if (!item)
        return;

    QString storePath = store_folder;
    QString parentPath = ValidateFolderPath(item->GetParent()->GetID());
    QString filename = item->GetName();
    //emit DownloadStarted(id);
    QStringList result = webdavclient_.call("downloadFile", QVariantList() << storePath << parentPath << filename).toStringList();
    if (result.count() >= 1)
    {
        if (result[0] == "True")
        {
            InventoryModule::LogInfo(QString("Webdav | Downloaded file %1%2 to path %3\n").arg(parentPath, filename, storePath).toStdString());
            //emit DownloadCompleted(id);
        }
        else
            InventoryModule::LogInfo(QString("Webdav | Downloaded of file %1%2 to path %3 failed\n").arg(parentPath, filename, storePath).toStdString());
    }
}
コード例 #12
0
QVariantList CBAttachmentsProvider::attributesForId(const QString &recId)
{
    if (QDir(pathForId(recId)).exists()){
        QString filename=attributePath(recId);
         QFile file(filename);
         if (!file.open(QIODevice::ReadOnly)){
             qWarning("Cannot open attribute json");
         }
         QString jsonData = file.readAll();
         file.close();

         QJsonDocument sd = QJsonDocument::fromJson(jsonData.toUtf8());

         if (sd.isNull()){
            qWarning("Wrong file attribute json format");
         }
         return sd.array().toVariantList();
    }
    else{
        return QVariantList();
    }
}
コード例 #13
0
ファイル: datasetparser.cpp プロジェクト: TinaSeifpoor/repo
QVariantList DatasetParser::parseDataFile(QFileInfo dataFileInfo)
{
    QVariantList datasetDescriptor;
    QHash<int,int> instanceDescriptor;
    QHash<int,QString> classDescriptor;
    QFile dataFile(dataFileInfo.filePath());
    QString datasetDescriptionPlain;
    if (dataFile.open(QIODevice::ReadOnly))
        datasetDescriptionPlain = dataFile.readAll();
    else
    {
        qDebug(QString("Can't open file: %1").arg(dataFileInfo.absoluteFilePath()).toAscii());
        return QVariantList();
    }

    QStringList instanceDescriptionPlainList = datasetDescriptionPlain.split(instanceSeperator);
    QStringList headerList = instanceDescriptionPlainList.takeFirst().split(headerSeperator);
    int instanceUniqueIDIndex = headerList.indexOf(instanceUniqueIDHeader);
    int classNameIndex = headerList.indexOf(classNameHeader);
    int classIDIndex = headerList.indexOf(classIDHeader);

    foreach (QString instanceDescriptionPlain, instanceDescriptionPlainList)
    {
        QStringList instanceDescriptionList = instanceDescriptionPlain.split(headerSeperator);
        QString className = instanceDescriptionList[classNameIndex];
        int classID = instanceDescriptionList[classIDIndex].toInt();
        if (!classDescriptor[classID].isEmpty())
        {
            if (classDescriptor[classID] != className)
            {
                qDebug(QString("Class ID %1 is matched to classes with names %2 & %3").arg(classID).arg(classDescriptor[classIDIndex]).arg(className).toAscii());
            }
        }
        else
            classDescriptor[classID] = className;
        QString instanceUniqueID = instanceDescriptionList[instanceUniqueIDIndex];
        instanceDescriptor.unite(this->parseInstanceUniqueID(instanceUniqueID, classID));
    }
コード例 #14
0
ファイル: MashouList.cpp プロジェクト: ArbalestX/megatendb
QVariant MashouList::listAction() const
{
	QVariantList columns;
	columns << QString("id") << QString("name_en") << QString("name_ja")
		<< QString("icon") << QString("equip_type");

	QVariantMap orderby_equip_type;
	orderby_equip_type["column"] = "equip_type";
	orderby_equip_type["direction"] = "asc";

	QVariantMap orderby_id;
	orderby_id["column"] = "id";
	orderby_id["direction"] = "asc";

	QVariantMap action;
	action["action"] = QString("select");
	action["table"] = QString("db_mashou");
	action["columns"] = columns;
	action["order_by"] = QVariantList() << orderby_equip_type << orderby_id;
	action["user_data"] = listUserData();

	return action;
}
コード例 #15
0
ファイル: Account.cpp プロジェクト: KDE/calligra
QVariant Scripting::Account::actualEffortCostPrDay( const QVariant &start, const QVariant &end, const QVariant &schedule )
{
    //kDebug(planDbg())<<start<<end<<schedule;
    QVariantMap map;
    QDate s = start.toDate();
    QDate e = end.toDate();
    if ( ! s.isValid() ) {
        s = QDate::currentDate();
    }
    if ( ! e.isValid() ) {
        e = QDate::currentDate();
    }
    KPlato::Accounts *a = m_account->list();
    if ( a == 0 ) {
        return QVariant();
    }
    KPlato::EffortCostMap ec = a->actualCost( *m_account, s, e, schedule.toLongLong() );
    KPlato::EffortCostDayMap::ConstIterator it = ec.days().constBegin();
    for (; it != ec.days().constEnd(); ++it ) {
        map.insert( it.key().toString( Qt::ISODate ), QVariantList() << it.value().effort().toDouble( KPlato::Duration::Unit_h ) << it.value().cost() );
    }
    return map;
}
コード例 #16
0
QStringList QDocumentServerContentStore::contentMimeTypes( QContentId contentId )
{
    if( contentId == QContent::InvalidId )
        return QStringList();

    QDocumentServerMessage response = d->callWithArgumentList( "contentMimeTypes(QContentId)",
                                      QVariantList() << QVariant::fromValue( contentId ) );

    if( response.type() == QDocumentServerMessage::ReplyMessage )
    {
        Q_ASSERT( response.arguments().count() == 1 );

        return qvariant_cast< QStringList >( response.arguments().first() );
    }
    else if( response.type() == QDocumentServerMessage::ErrorMessage )
    {
        Q_ASSERT( response.arguments().count() == 1 );

        setErrorString( qvariant_cast< QString >( response.arguments().first() ) );
    }

    return QStringList();
}
コード例 #17
0
ファイル: qjsonvalue.cpp プロジェクト: venkatarajasekhar/Qt
/*!
    Converts the value to a \l {QVariant::}{QVariant()}.

    The QJsonValue types will be converted as follows:

    \value Null     {QVariant::}{QVariant()}
    \value Bool     QMetaType::Bool
    \value Double   QMetaType::Double
    \value String   QString
    \value Array    QVariantList
    \value Object   QVariantMap
    \value Undefined {QVariant::}{QVariant()}

    \sa fromVariant()
 */
QVariant QJsonValue::toVariant() const
{
    switch (t) {
    case Bool:
        return b;
    case Double:
        return dbl;
    case String:
        return toString();
    case Array:
        return d ?
               QJsonArray(d, static_cast<QJsonPrivate::Array *>(base)).toVariantList() :
               QVariantList();
    case Object:
        return d ?
               QJsonObject(d, static_cast<QJsonPrivate::Object *>(base)).toVariantMap() :
               QVariantMap();
    case Null:
    case Undefined:
        break;
    }
    return QVariant();
}
コード例 #18
0
void KBuildSycocaProgressDialog::rebuildKSycoca(QWidget *parent)
{
  KBuildSycocaProgressDialog dlg(parent,
                                 i18n("Updating System Configuration"),
                                 i18n("Updating system configuration."));

  QDBusInterface kbuildsycoca("org.kde.kded", "/kbuildsycoca",
                              "org.kde.kbuildsycoca");
  if (kbuildsycoca.isValid()) {
     kbuildsycoca.callWithCallback("recreate", QVariantList(), &dlg, SLOT(_k_slotFinished()));
  } else {
      // kded not running, e.g. when using keditfiletype out of a KDE session
      QObject::connect(KSycoca::self(), SIGNAL(databaseChanged(QStringList)), &dlg, SLOT(_k_slotFinished()));
#ifndef EMSCRIPTEN
      KProcess* proc = new KProcess(&dlg);
      (*proc) << KStandardDirs::findExe(KBUILDSYCOCA_EXENAME);
      proc->start();
#else
      kWarning() << "Running " << KBUILDSYCOCA_EXENAME << " not supported in Emscripten!";
#endif
  }
  dlg.exec();
}
コード例 #19
0
/*!
    \reimp
*/
QContentSetEngine *QDocumentServerContentStore::contentSet( const QContentFilter &filter, const QContentSortCriteria &order, QContentSet::UpdateMode mode )
{
    QDocumentServerMessage response = d->callWithArgumentList(
                                          "createContentSet(QContentFilter,QContentSortCriteria,QContentSet::UpdateMode)",
                                          QVariantList()
                                          << QVariant::fromValue(filter)
                                          << QVariant::fromValue(order)
                                          << QVariant::fromValue(mode));

    if( response.type() == QDocumentServerMessage::ReplyMessage )
    {
        Q_ASSERT( response.arguments().count() == 1 );

        int setId = response.arguments().first().toInt();

        QDocumentServerContentSetEngine *contentSet = new QDocumentServerContentSetEngine( filter, order, mode, setId, this );

        d->contentSets.insert( setId, contentSet );

        connect( contentSet, SIGNAL(releaseContentSet(int)), this, SLOT(releaseContentSet(int)) );

        return contentSet;
    }
コード例 #20
0
ファイル: httpconnection.cpp プロジェクト: Paukert/quickbox
void HttpConnection::processRequest()
{
	if(!m_getPath.isEmpty()) {
		if(!m_getPath.startsWith('/'))
			m_getPath = '/' + m_getPath;
		Application *app = Application::instance();
		AppCliOptions *cliopts = app->cliOptions();
		QString html_dir = cliopts->htmlDir();
		QFileInfo fi(html_dir + m_getPath);
		qfInfo() << "GET" << m_getPath << "abs:" << fi.absoluteFilePath();
		if(fi.isDir()) {
			if(!m_getPath.endsWith('/'))
				m_getPath += '/';
			QVariantList html_body = QVariantList() << QStringLiteral("body");
			QDir dir(fi.absoluteFilePath());
			QVariantList class_links;
			qfInfo() << "dir of:" << dir.absolutePath();
			for(const QString &fn : dir.entryList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot)) {
				class_links.insert(class_links.length(), QVariantList{"a", QVariantMap{{"href", m_getPath + fn}}, fn});
			}
			html_body.insert(html_body.length(), QVariantList{"p"} << class_links);

			qf::core::utils::HtmlUtils::FromHtmlListOptions opts;
			opts.setDocumentTitle(tr("Dir list %1").arg(m_getPath));
			QString html = qf::core::utils::HtmlUtils::fromHtmlList(html_body, opts);
			responseOK(html.toUtf8());
		}
		else {
			QFile f(fi.absoluteFilePath());
			if(f.open(QFile::ReadOnly)) {
				QByteArray ba = f.readAll();
				responseOK(ba);
			}
		}
	}
	m_socket->close();
}
コード例 #21
0
QContent QDocumentServerContentStore::contentFromId( QContentId contentId )
{
    if( contentId == QContent::InvalidId )
        return QContent();

    QContent content = QContentCache::instance()->lookup( contentId );

    if( content.isNull() )
    {
        QDocumentServerMessage response = d->callWithArgumentList( "contentFromId(QContentId)",
                                          QVariantList() << QVariant::fromValue( contentId ) );

        if( response.type() == QDocumentServerMessage::ReplyMessage )
        {
            Q_ASSERT( response.arguments().count() == 1 );

            content = qvariant_cast< QContent >( response.arguments().first() );

            QContentCache::instance()->cache( content );
        }
    }

    return content;
}
コード例 #22
0
void PulseAudioControl::openConnection()
{
    //! If the connection already exists, do nothing
    if ((dbusConnection != NULL) && (dbus_connection_get_is_connected(dbusConnection))) {
        return;
    }

    // Establish a connection to the server
    char *pa_bus_address = getenv("PULSE_DBUS_SERVER");
    QByteArray addressArray;
    if (pa_bus_address == NULL) {
        QDBusMessage message = QDBusMessage::createMethodCall("org.pulseaudio.Server", "/org/pulseaudio/server_lookup1", "org.freedesktop.DBus.Properties", "Get");
        message.setArguments(QVariantList() << "org.PulseAudio.ServerLookup1" << "Address");
        QDBusMessage reply = QDBusConnection::sessionBus().call(message);
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() > 0) {
            addressArray = reply.arguments().first().value<QDBusVariant>().variant().toString().toAscii();
            pa_bus_address = addressArray.data();
        }
    }

    if (pa_bus_address != NULL) {
        DBusError dbus_err;
        dbus_error_init(&dbus_err);

        dbusConnection = dbus_connection_open(pa_bus_address, &dbus_err);

        DBUS_ERR_CHECK(dbus_err);
    }

    if (dbusConnection != NULL) {
        dbus_connection_setup_with_g_main(dbusConnection, NULL);
        dbus_connection_add_filter(dbusConnection, PulseAudioControl::stepsUpdatedSignalHandler, (void *)this, NULL);

        addSignalMatch();
    }
}
コード例 #23
0
DigitallyImportedClient::ChannelList DigitallyImportedClient::ParseChannelList(
    QNetworkReply* reply) const {
  ChannelList ret;

  QJson::Parser parser;
  QVariantMap data = parser.parse(reply).toMap();

  if (!data.contains("channel_filters")) return ret;

  QVariantList filters = data["channel_filters"].toList();

  for (const QVariant& filter : filters) {
    // Find the filter called "All"
    QVariantMap filter_map = filter.toMap();
    if (filter_map.value("name", QString()).toString() != "All") continue;

    // Add all its stations to the result
    QVariantList channels =
        filter_map.value("channels", QVariantList()).toList();
    for (const QVariant& channel_var : channels) {
      QVariantMap channel_map = channel_var.toMap();

      Channel channel;
      channel.art_url_ = QUrl(channel_map.value("asset_url").toString());
      channel.description_ = channel_map.value("description").toString();
      channel.director_ = channel_map.value("channel_director").toString();
      channel.key_ = channel_map.value("key").toString();
      channel.name_ = channel_map.value("name").toString();
      ret << channel;
    }

    break;
  }

  return ret;
}
コード例 #24
0
ファイル: qppsobject.cpp プロジェクト: RSATom/Qt
QVariant QPpsObjectPrivate::variantFromPpsAttribute(const QPpsAttribute &attribute)
{
    switch (attribute.type()) {
    case QPpsAttribute::Number:
        switch (attribute.toVariant().type()) {
        case QVariant::Int:
            return attribute.toInt();
        case QVariant::LongLong:
            return attribute.toLongLong();
        default:
            return attribute.toDouble();
        }
        break;
    case QPpsAttribute::Bool:
        return attribute.toBool();
    case QPpsAttribute::String:
        return attribute.toString();
    case QPpsAttribute::Array: {
        QVariantList variantList;
        const auto attrs = attribute.toList();
        for (const QPpsAttribute &attr : attrs) {
            QVariant variant = variantFromPpsAttribute(attr);
            if (!variant.isValid())
                return QVariantList();
            variantList << variant;
        }
        return variantList;
    }
    case QPpsAttribute::Object:
        return variantMapFromPpsAttributeMap(attribute.toMap());
    case QPpsAttribute::None:
    default:
        qWarning("QPpsObjectPrivate::variantFromPpsAttribute: invalid attribute parameter");
        return QVariant();
    }
}
コード例 #25
0
bool QDocumentServerContentStore::moveContentTo( QContent *content, const QString &newFileName )
{
    QDocumentServerMessage response = d->callWithArgumentList( "moveContentTo(QContentId,QString)",
                                      QVariantList() << QVariant::fromValue( content->id() ) << newFileName );

    if( response.type() == QDocumentServerMessage::ReplyMessage )
    {
        Q_ASSERT( response.arguments().count() == 1 );

        *content = qvariant_cast< QContent >( response.arguments().first() );

        QContentCache::instance()->cache( *content );

        return true;
    }
    else if( response.type() == QDocumentServerMessage::ErrorMessage )
    {
        Q_ASSERT( response.arguments().count() == 1 );

        setErrorString( qvariant_cast< QString >( response.arguments().first() ) );
    }

    return false;
}
コード例 #26
0
ファイル: filetemplates.cpp プロジェクト: pussbb/QWebDevIde
    QTextStream stream ( &file );
    JsonReader reader;
    reader.parse(stream.readAll());
    if(reader.errorString().isEmpty())
        buildMenu(reader.result());

}

void FileTemplates::buildMenu(QVariant v)
{
    foreach(QVariant rootIndex,v.toList()){
        QVariantMap root = rootIndex.toMap();
        QMenu *m = new QMenu();
        m->setTitle(root.value("catagory_name","Empty").toString());

        QVariantList childs = root.value("items",QVariantList()).toList();
        if(childs.count() == 0)
            continue;
        foreach(QVariant child,childs){
            QVariantMap item = child.toMap();
            QAction *action = new QAction(this);
            action->setText(item.value("title").toString());
            action->setData(item);
            m->addAction(action);
            connect(action, SIGNAL(triggered()), this, SLOT(create()));
            qDebug()<<item.value("default_name");
        }
        m_menu.addMenu(m);
    }
}
コード例 #27
0
ファイル: eqpassmblbomdatatype.cpp プロジェクト: hks2002/AM
EqpAssmblBomDataType EqpAssmblBomDataType::get(int assmblBomId, int dataTypeId)
{
    TSqlORMapper<EqpAssmblBomDataTypeObject> mapper;
    return EqpAssmblBomDataType(mapper.findByPrimaryKey(QVariantList()<<QVariant(assmblBomId)<<QVariant(dataTypeId)));
}
コード例 #28
0
void GraphicalTimetableLine::init()
{
    if ( !m_svg.hasElement("background") ) {
        setFailedToLaunch( true, i18n("No 'background' element found in the SVG") );
    }

    m_zoomInButton = new Plasma::ToolButton( this );
    m_zoomOutButton = new Plasma::ToolButton( this );
    m_zoomInButton->setIcon( KIcon("zoom-in") );
    m_zoomOutButton->setIcon( KIcon("zoom-out") );
    m_zoomInButton->setZValue( 999999 );
    m_zoomOutButton->setZValue( 999999 );
    connect( m_zoomInButton, SIGNAL(clicked()), this, SLOT(zoomIn()) );
    connect( m_zoomOutButton, SIGNAL(clicked()), this, SLOT(zoomOut()) );

    m_title = new Plasma::Label( this );
    QFont font = Plasma::Theme::defaultTheme()->font( Plasma::Theme::DefaultFont );
    font.setPixelSize( 14 );
    font.setBold( true );
    m_title->setFont( font );
    m_title->setWordWrap( false );
    m_title->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
    m_title->setZValue( 999999 );

    m_courtesy = new Plasma::Label;
    m_courtesy->setAlignment( Qt::AlignVCenter | Qt::AlignRight );
    connect( m_courtesy, SIGNAL(linkActivated(QString)),
                KToolInvocation::self(), SLOT(invokeBrowser(QString)) );
    QLabel *labelInfo = m_courtesy->nativeWidget();
    labelInfo->setOpenExternalLinks( true );
    labelInfo->setWordWrap( true );
    m_courtesy->setText( courtesyText() );
    m_courtesy->setZValue( 999999 );

    m_departureView = new QGraphicsWidget( this );
    m_departureView->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
    m_departureView->translate( 0, -m_title->size().height() - 25 );

    QGraphicsGridLayout *l = new QGraphicsGridLayout( this );
    l->addItem( m_zoomInButton, 0, 0 );
    l->addItem( m_zoomOutButton, 0, 1 );
    l->addItem( m_title, 0, 2 );
    l->addItem( m_departureView, 1, 0, 1, 3 );
    l->addItem( m_courtesy, 2, 0, 1, 3 );

    m_stopSettings.set( ServiceProviderSetting,
                        config().readEntry(QLatin1String("serviceProvider"), QString()) );
    m_stopSettings.set( StopNameSetting,
                        config().readEntry(QLatin1String("stopName"), QString()) );

    m_timelineLength = config().readEntry( QLatin1String("timelineLength"), 10 );
    m_showTimetable = config().readEntry( QLatin1String("showTimetable"), true );
    m_drawTransportLine = config().readEntry( QLatin1String("drawTransportLine"), true );

    QVariantList vehicleTypes = config().readEntry( QLatin1String("vehicleTypes"), QVariantList() );
    if ( vehicleTypes.isEmpty() ) {
        m_vehicleTypes << UnknownVehicleType << Tram << Bus << TrolleyBus << InterurbanTrain
                << Subway << Metro << RegionalTrain << RegionalExpressTrain << InterregionalTrain
                << IntercityTrain << HighSpeedTrain << Ship << Plane << Feet;
    } else {
        foreach ( const QVariant &vehicleType, vehicleTypes ) {
            m_vehicleTypes << static_cast<VehicleType>( vehicleType.toInt() );
        }
    }

    if ( m_stopSettings.stopList().isEmpty() ) {
        setConfigurationRequired( true, i18n("Please select a stop name") );
    } else if ( m_stopSettings.get<QString>(ServiceProviderSetting).isEmpty() ) {
        setConfigurationRequired( true, i18n("Please select a service provider") );
    } else {
        setConfigurationRequired( false );
    }

    if ( !configurationRequired() ) {
        m_sourceName = QString("Departures %1|stop=%2|timeoffset=0")
                    .arg(m_stopSettings.get<QString>(ServiceProviderSetting))
                    .arg(m_stopSettings.stop(0).nameOrId());
        dataEngine("publictransport")->connectSource( m_sourceName,
                this, 60000, Plasma::AlignToMinute );
    }

    createTooltip();
}
コード例 #29
0
ファイル: evtvendor.cpp プロジェクト: hks2002/AM
EvtVendor EvtVendor::get(int eventId, int vendorId)
{
    TSqlORMapper<EvtVendorObject> mapper;
    return EvtVendor(mapper.findByPrimaryKey(QVariantList()<<QVariant(eventId)<<QVariant(vendorId)));
}
コード例 #30
0
ファイル: ModelPackager.cpp プロジェクト: Nex-Pro/hifi
void ModelPackager::populateBasicMapping(QVariantHash& mapping, QString filename, const hfm::Model& hfmModel) {

    // mixamo files - in the event that a mixamo file was edited by some other tool, it's likely the applicationName will
    // be rewritten, so we detect the existence of several different blendshapes which indicate we're likely a mixamo file
    bool likelyMixamoFile = hfmModel.applicationName == "mixamo.com" ||
                            (hfmModel.blendshapeChannelNames.contains("BrowsDown_Right") &&
                             hfmModel.blendshapeChannelNames.contains("MouthOpen") &&
                             hfmModel.blendshapeChannelNames.contains("Blink_Left") &&
                             hfmModel.blendshapeChannelNames.contains("Blink_Right") &&
                             hfmModel.blendshapeChannelNames.contains("Squint_Right"));
    
    if (!mapping.contains(NAME_FIELD)) {
        mapping.insert(NAME_FIELD, QFileInfo(filename).baseName());
    }
    
    if (!mapping.contains(FILENAME_FIELD)) {
        QDir root(_modelFile.path());
        mapping.insert(FILENAME_FIELD, root.relativeFilePath(filename));
    }
    if (!mapping.contains(TEXDIR_FIELD)) {
        mapping.insert(TEXDIR_FIELD, ".");
    }
    if (!mapping.contains(SCRIPT_FIELD)) {
        mapping.insert(SCRIPT_FIELD, ".");
    }
    // mixamo/autodesk defaults
    if (!mapping.contains(SCALE_FIELD)) {
        mapping.insert(SCALE_FIELD, 1.0);
    }
    QVariantHash joints = mapping.value(JOINT_FIELD).toHash();
    if (!joints.contains("jointEyeLeft")) {
        joints.insert("jointEyeLeft", hfmModel.jointIndices.contains("jointEyeLeft") ? "jointEyeLeft" :
                      (hfmModel.jointIndices.contains("EyeLeft") ? "EyeLeft" : "LeftEye"));
    }
    if (!joints.contains("jointEyeRight")) {
        joints.insert("jointEyeRight", hfmModel.jointIndices.contains("jointEyeRight") ? "jointEyeRight" :
                      hfmModel.jointIndices.contains("EyeRight") ? "EyeRight" : "RightEye");
    }
    if (!joints.contains("jointNeck")) {
        joints.insert("jointNeck", hfmModel.jointIndices.contains("jointNeck") ? "jointNeck" : "Neck");
    }
    
    if (!joints.contains("jointRoot")) {
        joints.insert("jointRoot", "Hips");
    }
    if (!joints.contains("jointLean")) {
        joints.insert("jointLean", "Spine");
    }
    if (!joints.contains("jointLeftHand")) {
        joints.insert("jointLeftHand", "LeftHand");
    }
    if (!joints.contains("jointRightHand")) {
        joints.insert("jointRightHand", "RightHand");
    }
    
    if (!joints.contains("jointHead")) {
        const char* topName = likelyMixamoFile ? "HeadTop_End" : "HeadEnd";
        joints.insert("jointHead", hfmModel.jointIndices.contains(topName) ? topName : "Head");
    }

    mapping.insert(JOINT_FIELD, joints);

    if (!mapping.contains(FREE_JOINT_FIELD)) {
        mapping.insertMulti(FREE_JOINT_FIELD, "LeftArm");
        mapping.insertMulti(FREE_JOINT_FIELD, "LeftForeArm");
        mapping.insertMulti(FREE_JOINT_FIELD, "RightArm");
        mapping.insertMulti(FREE_JOINT_FIELD, "RightForeArm");
    }
    
    // If there are no blendshape mappings, and we detect that this is likely a mixamo file,
    // then we can add the default mixamo to "faceshift" mappings
    if (!mapping.contains(BLENDSHAPE_FIELD) && likelyMixamoFile) {
        QVariantHash blendshapes;
        blendshapes.insertMulti("BrowsD_L", QVariantList() << "BrowsDown_Left" << 1.0);
        blendshapes.insertMulti("BrowsD_R", QVariantList() << "BrowsDown_Right" << 1.0);
        blendshapes.insertMulti("BrowsU_C", QVariantList() << "BrowsUp_Left" << 1.0);
        blendshapes.insertMulti("BrowsU_C", QVariantList() << "BrowsUp_Right" << 1.0);
        blendshapes.insertMulti("BrowsU_L", QVariantList() << "BrowsUp_Left" << 1.0);
        blendshapes.insertMulti("BrowsU_R", QVariantList() << "BrowsUp_Right" << 1.0);
        blendshapes.insertMulti("ChinLowerRaise", QVariantList() << "Jaw_Up" << 1.0);
        blendshapes.insertMulti("ChinUpperRaise", QVariantList() << "UpperLipUp_Left" << 0.5);
        blendshapes.insertMulti("ChinUpperRaise", QVariantList() << "UpperLipUp_Right" << 0.5);
        blendshapes.insertMulti("EyeBlink_L", QVariantList() << "Blink_Left" << 1.0);
        blendshapes.insertMulti("EyeBlink_R", QVariantList() << "Blink_Right" << 1.0);
        blendshapes.insertMulti("EyeOpen_L", QVariantList() << "EyesWide_Left" << 1.0);
        blendshapes.insertMulti("EyeOpen_R", QVariantList() << "EyesWide_Right" << 1.0);
        blendshapes.insertMulti("EyeSquint_L", QVariantList() << "Squint_Left" << 1.0);
        blendshapes.insertMulti("EyeSquint_R", QVariantList() << "Squint_Right" << 1.0);
        blendshapes.insertMulti("JawFwd", QVariantList() << "JawForeward" << 1.0);
        blendshapes.insertMulti("JawLeft", QVariantList() << "JawRotateY_Left" << 0.5);
        blendshapes.insertMulti("JawOpen", QVariantList() << "MouthOpen" << 0.7);
        blendshapes.insertMulti("JawRight", QVariantList() << "Jaw_Right" << 1.0);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "JawForeward" << 0.39);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "Jaw_Down" << 0.36);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthNarrow_Left" << 1.0);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthNarrow_Right" << 1.0);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthWhistle_NarrowAdjust_Left" << 0.5);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthWhistle_NarrowAdjust_Right" << 0.5);
        blendshapes.insertMulti("LipsFunnel", QVariantList() << "TongueUp" << 1.0);
        blendshapes.insertMulti("LipsLowerClose", QVariantList() << "LowerLipIn" << 1.0);
        blendshapes.insertMulti("LipsLowerDown", QVariantList() << "LowerLipDown_Left" << 0.7);
        blendshapes.insertMulti("LipsLowerDown", QVariantList() << "LowerLipDown_Right" << 0.7);
        blendshapes.insertMulti("LipsLowerOpen", QVariantList() << "LowerLipOut" << 1.0);
        blendshapes.insertMulti("LipsPucker", QVariantList() << "MouthNarrow_Left" << 1.0);
        blendshapes.insertMulti("LipsPucker", QVariantList() << "MouthNarrow_Right" << 1.0);
        blendshapes.insertMulti("LipsUpperClose", QVariantList() << "UpperLipIn" << 1.0);
        blendshapes.insertMulti("LipsUpperOpen", QVariantList() << "UpperLipOut" << 1.0);
        blendshapes.insertMulti("LipsUpperUp", QVariantList() << "UpperLipUp_Left" << 0.7);
        blendshapes.insertMulti("LipsUpperUp", QVariantList() << "UpperLipUp_Right" << 0.7);
        blendshapes.insertMulti("MouthDimple_L", QVariantList() << "Smile_Left" << 0.25);
        blendshapes.insertMulti("MouthDimple_R", QVariantList() << "Smile_Right" << 0.25);
        blendshapes.insertMulti("MouthFrown_L", QVariantList() << "Frown_Left" << 1.0);
        blendshapes.insertMulti("MouthFrown_R", QVariantList() << "Frown_Right" << 1.0);
        blendshapes.insertMulti("MouthLeft", QVariantList() << "Midmouth_Left" << 1.0);
        blendshapes.insertMulti("MouthRight", QVariantList() << "Midmouth_Right" << 1.0);
        blendshapes.insertMulti("MouthSmile_L", QVariantList() << "Smile_Left" << 1.0);
        blendshapes.insertMulti("MouthSmile_R", QVariantList() << "Smile_Right" << 1.0);
        blendshapes.insertMulti("Puff", QVariantList() << "CheekPuff_Left" << 1.0);
        blendshapes.insertMulti("Puff", QVariantList() << "CheekPuff_Right" << 1.0);
        blendshapes.insertMulti("Sneer", QVariantList() << "NoseScrunch_Left" << 0.75);
        blendshapes.insertMulti("Sneer", QVariantList() << "NoseScrunch_Right" << 0.75);
        blendshapes.insertMulti("Sneer", QVariantList() << "Squint_Left" << 0.5);
        blendshapes.insertMulti("Sneer", QVariantList() << "Squint_Right" << 0.5);
        mapping.insert(BLENDSHAPE_FIELD, blendshapes);
    }
}