QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_gridlayout)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_metallicbrush_svgbutton)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_securesocketclient)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_EquationOfTime)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_qtpropertybrowser)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_qwt_designer_plugin)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_PointerCoordinates)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_customcompleter)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_desktopservices)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int QT_MANGLE_NAMESPACE(qInitResources_beryl_svgtoggleswitch)() { QT_PREPEND_NAMESPACE(qRegisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
QT_END_NAMESPACE int main(int argc, char *argv[]) { // rcc uses a QHash to store files in the resource system. // we must force a certain hash order when testing or tst_rcc will fail, see QTBUG-25078 if (!qEnvironmentVariableIsEmpty("QT_RCC_TEST") && !qt_qhash_seed.testAndSetRelaxed(-1, 0)) qFatal("Cannot force QHash seed for testing as requested"); return QT_PREPEND_NAMESPACE(runRcc)(argc, argv); }
/*! Returns the hash value for \a key. \since 1.1 */ uint qHash(const QOrganizerCollection &key) { uint hash = qHash(key.id()); QVariantMap metadata = key.metaData(); QVariantMap::const_iterator it; for (it = metadata.constBegin(); it != metadata.constEnd(); ++it) { hash += qHash(it.key()) + QT_PREPEND_NAMESPACE(qHash)(it.value().toString()); } return hash; }
AudioEncoderControl::AudioEncoderControl(QObject *parent) :QAudioEncoderSettingsControl(parent) { m_session = qobject_cast<AudioCaptureSession*>(parent); QT_PREPEND_NAMESPACE(QAudioFormat) fmt; fmt.setSampleSize(8); fmt.setChannelCount(1); fmt.setSampleRate(8000); fmt.setSampleType(QT_PREPEND_NAMESPACE(QAudioFormat)::SignedInt); fmt.setCodec("audio/pcm"); fmt.setByteOrder(QAudioFormat::LittleEndian); m_session->setFormat(fmt); m_settings.setEncodingMode(QMultimedia::ConstantQualityEncoding); m_settings.setCodec("audio/pcm"); m_settings.setBitRate(8000); m_settings.setChannelCount(1); m_settings.setSampleRate(8000); m_settings.setQuality(QMultimedia::LowQuality); }
static QFontEngine *loadWin(const QFontPrivate *d, int script, const QFontDef &req) { // list of families to try QStringList family_list = familyList(req); const char *stylehint = styleHint(d->request); if (stylehint) family_list << QLatin1String(stylehint); // append the default fallback font for the specified script // family_list << ... ; ########### // add the default family QString defaultFamily = QApplication::font().family(); if (! family_list.contains(defaultFamily)) family_list << defaultFamily; // add QFont::defaultFamily() to the list, for compatibility with // previous versions family_list << QApplication::font().defaultFamily(); // null family means find the first font matching the specified script family_list << QString(); QtFontDesc desc; QFontEngine *fe = 0; QList<int> blacklistedFamilies; while (!fe) { for (int i = 0; i < family_list.size(); ++i) { QString family, foundry; parseFontName(family_list.at(i), foundry, family); FM_DEBUG("loadWin: >>>>>>>>>>>>>>trying to match '%s'", family.toLatin1().data()); QT_PREPEND_NAMESPACE(match)(script, req, family, foundry, -1, &desc, blacklistedFamilies); if (desc.family) break; } if (!desc.family) break; fe = loadEngine(script, req, d->hdc, d->dpi, d->rawMode, &desc, family_list); if (!fe) blacklistedFamilies.append(desc.familyIndex); } return fe; }
uint QOrganizerCollectionSkeletonEngineId::hash() const { /* TODO Provide a hash function for your engine-specific id. Note that the hash doesn't strictly need to be unique, since isEqualTo() ensures that individual id's in a single hash-bucket can be uniquely determined; however a better hash function will result in better performance because the ids will be distributed more randomly in a hash table. In the example implementation below, we could simply return the id, since the id is a quint32. In more complex id classes, however, you may need to qHash() individual data members and combine the results somehow. */ return QT_PREPEND_NAMESPACE(qHash)(m_collectionId); }
int runMoc(int _argc, char **_argv) { bool autoInclude = true; Preprocessor pp; Moc moc; pp.macros["Q_MOC_RUN"]; pp.macros["__cplusplus"]; QByteArray filename; QByteArray output; FILE *in = 0; FILE *out = 0; bool ignoreConflictingOptions = false; QVector<QByteArray> argv; argv.resize(_argc - 1); for (int n = 1; n < _argc; ++n) argv[n - 1] = _argv[n]; int argc = argv.count(); for (int n = 0; n < argv.count(); ++n) { if (argv.at(n).startsWith('@')) { QByteArray optionsFile = argv.at(n); optionsFile.remove(0, 1); if (optionsFile.isEmpty()) error("The @ option requires an input file"); QFile f(QString::fromLatin1(optionsFile.constData())); if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) error("Cannot open options file specified with @"); argv.remove(n); while (!f.atEnd()) { QByteArray line = f.readLine().trimmed(); if (!line.isEmpty()) argv.insert(n++, line); } } } argc = argv.count(); for (int n = 0; n < argc; ++n) { QByteArray arg(argv[n]); if (arg[0] != '-') { if (filename.isEmpty()) { filename = arg; continue; } error("Too many input files specified"); } QByteArray opt = arg.mid(1); bool more = (opt.size() > 1); switch (opt[0]) { case 'o': // output redirection if (!more) { if (!(n < argc-1)) error("Missing output file name"); output = argv[++n]; } else output = opt.mid(1); break; case 'E': // only preprocessor pp.preprocessOnly = true; break; case 'i': // no #include statement if (more) error(); moc.noInclude = true; autoInclude = false; break; case 'f': // produce #include statement if (ignoreConflictingOptions) break; moc.noInclude = false; autoInclude = false; if (opt[1]) // -fsomething.h moc.includeFiles.append(opt.mid(1)); break; case 'p': // include file path if (ignoreConflictingOptions) break; if (!more) { if (!(n < argc-1)) error("Missing path name for the -p option."); moc.includePath = argv[++n]; } else { moc.includePath = opt.mid(1); } break; case 'I': // produce #include statement if (!more) { if (!(n < argc-1)) error("Missing path name for the -I option."); pp.includes += Preprocessor::IncludePath(argv[++n]); } else { pp.includes += Preprocessor::IncludePath(opt.mid(1)); } break; case 'F': // minimalistic framework support for the mac if (!more) { if (!(n < argc-1)) error("Missing path name for the -F option."); Preprocessor::IncludePath p(argv[++n]); p.isFrameworkPath = true; pp.includes += p; } else { Preprocessor::IncludePath p(opt.mid(1)); p.isFrameworkPath = true; pp.includes += p; } break; case 'D': // define macro { QByteArray name; QByteArray value("1"); if (!more) { if (n < argc-1) name = argv[++n]; } else name = opt.mid(1); int eq = name.indexOf('='); if (eq >= 0) { value = name.mid(eq + 1); name = name.left(eq); } if (name.isEmpty()) error("Missing macro name"); Macro macro; macro.symbols += Symbol(0, PP_IDENTIFIER, value); pp.macros.insert(name, macro); } break; case 'U': { QByteArray macro; if (!more) { if (n < argc-1) macro = argv[++n]; } else macro = opt.mid(1); if (macro.isEmpty()) error("Missing macro name"); pp.macros.remove(macro); } break; case 'v': // version number if (more && opt != "version") error(); fprintf(stderr, "Qt Meta Object Compiler version %d (Qt %s)\n", mocOutputRevision, QT_VERSION_STR); return 1; case 'n': // don't display warnings if (ignoreConflictingOptions) break; if (opt != "nw") error(); moc.displayWarnings = false; break; case 'h': // help if (more && opt != "help") error(); else error(0); // 0 means usage only break; case '-': if (more && arg == "--ignore-option-clashes") { // -- ignore all following moc specific options that conflict // with for example gcc, like -pthread conflicting with moc's // -p option. ignoreConflictingOptions = true; break; } // fall through default: error(); } } if (autoInclude) { int ppos = filename.lastIndexOf('.'); moc.noInclude = (ppos >= 0 && tolower(filename[ppos + 1]) != 'h' && tolower(filename[ppos + 1]) != QDir::separator().toLatin1() ); } if (moc.includeFiles.isEmpty()) { if (moc.includePath.isEmpty()) { if (filename.size()) { if (output.size()) moc.includeFiles.append(combinePath(filename, output)); else moc.includeFiles.append(filename); } } else { moc.includeFiles.append(combinePath(filename, filename)); } } if (filename.isEmpty()) { filename = "standard input"; in = stdin; } else { #if defined(_MSC_VER) && _MSC_VER >= 1400 if (fopen_s(&in, filename.data(), "rb")) { #else in = fopen(filename.data(), "rb"); if (!in) { #endif fprintf(stderr, "moc: %s: No such file\n", (const char*)filename); return 1; } moc.filename = filename; } moc.currentFilenames.push(filename); // 1. preprocess moc.symbols = pp.preprocessed(moc.filename, in); fclose(in); if (!pp.preprocessOnly) { // 2. parse moc.parse(); } // 3. and output meta object code if (output.size()) { // output file specified #if defined(_MSC_VER) && _MSC_VER >= 1400 if (fopen_s(&out, output.data(), "w")) #else out = fopen(output.data(), "w"); // create output file if (!out) #endif { fprintf(stderr, "moc: Cannot create %s\n", (const char*)output); return 1; } } else { // use stdout out = stdout; } if (pp.preprocessOnly) { fprintf(out, "%s\n", composePreprocessorOutput(moc.symbols).constData()); } else { if (moc.classList.isEmpty()) moc.warning("No relevant classes found. No output generated."); else moc.generate(out); } if (output.size()) fclose(out); return 0; } QT_END_NAMESPACE int main(int _argc, char **_argv) { return QT_PREPEND_NAMESPACE(runMoc)(_argc, _argv); }
uint qHash(const Locator::FilterEntry &entry) { if (entry.internalData.canConvert(QVariant::String)) return QT_PREPEND_NAMESPACE(qHash)(entry.internalData.toString()); return QT_PREPEND_NAMESPACE(qHash)(entry.internalData.constData()); }
QT_END_NAMESPACE int main(int argc, char **argv) { return QT_PREPEND_NAMESPACE(runQMake)(argc, argv); }
QT_END_NAMESPACE int main( int argc, char *argv[] ) { return QT_PREPEND_NAMESPACE(runQVfb)(argc, argv); }
int QT_MANGLE_NAMESPACE(qCleanupResources_treemodelcompleter)() { QT_PREPEND_NAMESPACE(qUnregisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
int QT_MANGLE_NAMESPACE(qCleanupResources_edit_hole)() { QT_PREPEND_NAMESPACE(qUnregisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
static uint qHash(const StringHolder &sh) { return QT_PREPEND_NAMESPACE(qHash)(sh.h, 0); }
inline uint qHash(Hashable h, uint seed = 0) { return QT_PREPEND_NAMESPACE(qHash)(h.i, seed); }
/*! * Returns the hash value for \a key. * \since 1.0 */ uint qHash(const QContactRelationship &key) { return qHash(key.first()) + qHash(key.second()) + QT_PREPEND_NAMESPACE(qHash)(key.relationshipType()); }
int QT_MANGLE_NAMESPACE(qCleanupResources_search_and_replace)() { QT_PREPEND_NAMESPACE(qUnregisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
static inline int SHA224_256AddLength(SHA256Context *context, unsigned int length) { QT_PREPEND_NAMESPACE(quint32) addTemp; return SHA224_256AddLengthM(context, length); }
int QT_MANGLE_NAMESPACE(qCleanupResources_SmartTraderQTMVC)() { QT_PREPEND_NAMESPACE(qUnregisterResourceData) (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); return 1; }
static inline int SHA384_512AddLength(SHA512Context *context, unsigned int length) { QT_PREPEND_NAMESPACE(quint64) addTemp; return SHA384_512AddLengthM(context, length); }
/*! * Returns the hash value for \a key. * \since 1.0 */ uint qHash(const QContactId &key) { return QT_PREPEND_NAMESPACE(qHash)(key.managerUri()) + QT_PREPEND_NAMESPACE(qHash)(key.localId()); }
QNode *n = nodePtr.data(); QAbstractAspect::clearBackendNode(n); } void QCollisionAspect::setRootEntity(QEntity *rootObject) { QNodeVisitor visitor; visitor.traverse(rootObject, this, &QCollisionAspect::visitNode); } void QCollisionAspect::onInitialize(const QVariantMap &data) { Q_UNUSED(data); } void QCollisionAspect::onCleanup() { } void QCollisionAspect::visitNode(QNode *node) { QAbstractAspect::createBackendNode(node); } } // Qt3D QT_END_NAMESPACE QT3D_REGISTER_NAMESPACED_ASPECT("collision", QT_PREPEND_NAMESPACE(Qt3D), QCollisionAspect)