+ Q_ENUMS(GestureType)

+ : public QSharedData

+ QDirPrivate(const QString &path,

+ const QStringList &nameFilters_ = QStringList(),

+ QDir::SortFlags sort_ = QDir::SortFlags(QDir::Name | QDir::IgnoreCase),

+ QDir::Filters filters_ = QDir::AllEntries)

+ : QSharedData()

+ , nameFilters(nameFilters_)

+ , sort(sort_)

+ , filters(filters_)

+#ifdef QT3_SUPPORT

+ , filterSepChar(0)

+ , matchAllDirs(false)

+#endif

+ , fileListsInitialized(false)

+ {

+ setPath(path.isEmpty() ? QString::fromLatin1(".") : path);

+

+ bool empty = nameFilters.isEmpty();

+ if (!empty) {

+ empty = true;

+ for (int i = 0; i < nameFilters.size(); ++i) {

+ if (!nameFilters.at(i).isEmpty()) {

+ empty = false;

+ break;

+ }

+ }

+ }

+ if (empty)

+ nameFilters = QStringList(QString::fromLatin1("*"));

+ }

+ QDirPrivate(const QDirPrivate &copy)

+ : QSharedData(copy)

+ , path(copy.path)

+ , nameFilters(copy.nameFilters)

+ , sort(copy.sort)

+ , filters(copy.filters)

+ , filterSepChar(copy.filterSepChar)

+ , matchAllDirs(copy.matchAllDirs)

+ , fileListsInitialized(false)

+ {

+ }

+

+ bool exists() const

+ {

+ const QAbstractFileEngine::FileFlags info =

+ fileEngine->fileFlags(QAbstractFileEngine::DirectoryType

+ | QAbstractFileEngine::ExistsFlag

+ | QAbstractFileEngine::Refresh);

+ if (!(info & QAbstractFileEngine::DirectoryType))

+ return false;

+ return info & QAbstractFileEngine::ExistsFlag;

+ }

+

+ void initFileEngine();

+ void initFileLists() const;

+

+ static void sortFileList(QDir::SortFlags, QFileInfoList &, QStringList *, QFileInfoList *);

+

+

+ static inline QStringList splitFilters(const QString &nameFilter, QChar sep = 0)

+ {

+ inline void setPath(QString p)

+ if ((p.endsWith(QLatin1Char('/')) || p.endsWith(QLatin1Char('\\')))

+ && p.length() > 1) {

+ if (!(p.length() == 3 && p.at(1) == QLatin1Char(':')))

+ p.truncate(p.length() - 1);

+ path = p;

+ initFileEngine();

+ path = fileEngine->fileName(QAbstractFileEngine::DefaultName);

+ clearFileLists();

+

+ inline void clearFileLists() {

+ fileListsInitialized = false;

+ files.clear();

+ fileInfos.clear();

+ QString path;

+ QStringList nameFilters;

+ QDir::SortFlags sort;

+ QDir::Filters filters;

+

+ QChar filterSepChar;

+ bool matchAllDirs;

+ QScopedPointer<QAbstractFileEngine> fileEngine;

+

+ mutable bool fileListsInitialized;

+ mutable QStringList files;

+ mutable QFileInfoList fileInfos;

+};

+ QStringList *names, QFileInfoList *infos)

+inline void QDirPrivate::initFileLists() const

+ if (!fileListsInitialized) {

+ QDirIterator it(path, nameFilters, filters);

+ sortFileList(sort, l, &files, &fileInfos);

+ fileListsInitialized = true;

+inline void QDirPrivate::initFileEngine()

+ fileEngine.reset(QAbstractFileEngine::create(path));

+QDir::QDir(const QString &path) : d_ptr(new QDirPrivate(path))

+ SortFlags sort, Filters filters)

+ : d_ptr(new QDirPrivate(path, QDir::nameFiltersFromString(nameFilter), sort, filters))

+{

+QDir::QDir(const QDir &dir)

+ : d_ptr(dir.d_ptr)

+ d_ptr->setPath(path);

+ const QDirPrivate* d = d_ptr.constData();

+ return d->path;

+ const QDirPrivate* d = d_ptr.constData();

+ QString ret = d->path;

+ return cleanPath(d_ptr->fileEngine->fileName(QAbstractFileEngine::CanonicalName));

+ const QDirPrivate* d = d_ptr.constData();

+ int pos = d->path.lastIndexOf(QLatin1Char('/'));

+ return d->path;

+ return d->path.mid(pos + 1);

+ const QDirPrivate* d = d_ptr.constData();

+ QString ret = d->path;

+ const QDirPrivate* d = d_ptr.constData();

+ if (isRelativePath(d->path)) //get pwd

+ if (!d->path.isEmpty() && d->path != QLatin1String(".")) {

+ ret += d->path;

+ // Don't detach just yet.

+ const QDirPrivate * const d = d_ptr.constData();

+ QString newPath = d->path;

+ || d->path == QLatin1String(".")

+ QScopedPointer<QDirPrivate> dir(new QDirPrivate(*d_ptr.constData()));

+ dir->setPath(newPath);

+

+ if (!dir->exists())

+ d_ptr = dir.take();

+ const QDirPrivate* d = d_ptr.constData();

+ return d->nameFilters;

+ QDirPrivate* d = d_ptr.data();

+ d->initFileEngine();

+ d->clearFileLists();

+ d->nameFilters = nameFilters;

+ const QDirPrivate* d = d_ptr.constData();

+ return d->filters;

+ QDirPrivate* d = d_ptr.data();

+ d->initFileEngine();

+ d->clearFileLists();

+ d->filters = filters;

+ const QDirPrivate* d = d_ptr.constData();

+ return d->sort;

+ QDirPrivate* d = d_ptr.data();

+ d->initFileEngine();

+ d->clearFileLists();

+ d->sort = sort;

+ const QDirPrivate* d = d_ptr.constData();

+ d->initFileLists();

+ return d->files.count();

+ const QDirPrivate* d = d_ptr.constData();

+ d->initFileLists();

+ return d->files[pos];

+ const QDirPrivate* d = d_ptr.constData();

+ return entryList(d->nameFilters, filters, sort);

+ const QDirPrivate* d = d_ptr.constData();

+ return entryInfoList(d->nameFilters, filters, sort);

+ const QDirPrivate* d = d_ptr.constData();

+ filters = d->filters;

+ sort = d->sort;

+ if (filters == d->filters && sort == d->sort && nameFilters == d->nameFilters) {

+ d->initFileLists();

+ return d->files;

+ QDirIterator it(d->path, nameFilters, filters);

+ const QDirPrivate* d = d_ptr.constData();

+ filters = d->filters;

+ sort = d->sort;

+ if (filters == d->filters && sort == d->sort && nameFilters == d->nameFilters) {

+ d->initFileLists();

+ return d->fileInfos;

+ QDirIterator it(d->path, nameFilters, filters);

+ const QDirPrivate* d = d_ptr.constData();

+ return d->fileEngine->mkdir(fn, false);

+ const QDirPrivate* d = d_ptr.constData();

+ return d->fileEngine->rmdir(fn, false);

+ const QDirPrivate* d = d_ptr.constData();

+ return d->fileEngine->mkdir(fn, true);

+ const QDirPrivate* d = d_ptr.constData();

+ return d->fileEngine->rmdir(fn, true);

+ const QDirPrivate* d = d_ptr.constData();

+ d->fileEngine->fileFlags(QAbstractFileEngine::DirectoryType

+ return d_ptr->exists();

+ return d_ptr->fileEngine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::RootFlag;

+ return d_ptr->fileEngine->isRelativePath();

+ QString absolutePath = d_ptr.constData()->fileEngine->fileName(QAbstractFileEngine::AbsoluteName);

+

+ QScopedPointer<QDirPrivate> dir(new QDirPrivate(*d_ptr.constData()));

+ dir->setPath(absolutePath);

+

+ if (!(dir->fileEngine->fileFlags(QAbstractFileEngine::TypesMask) & QAbstractFileEngine::DirectoryType))

+

+ d_ptr = dir.take();

+ const QDirPrivate *d = d_ptr.constData();

+ const QDirPrivate *other = dir.d_ptr.constData();

+ if (d == other)

+ if (d->fileEngine->caseSensitive() != other->fileEngine->caseSensitive())

+ if (d->filters == other->filters

+ && d->sort == other->sort

+ && d->nameFilters == other->nameFilters) {

+ if (!other->fileEngine->caseSensitive())

+ d_ptr = dir.d_ptr;

+ d_ptr->setPath(path);

+ QDirPrivate *d = const_cast<QDir*>(this)->d_ptr.data();

+ d->initFileEngine();

+ d->clearFileLists();

+ const QDirPrivate* d = d_ptr.constData();

+ QDirPrivate* d = d_ptr.data();

+ d->initFileEngine();

+ d->clearFileLists();

+ const QDirPrivate* d = d_ptr.constData();

+ QDirPrivate* d = d_ptr.data();

+ d->initFileEngine();

+ d->clearFileLists();

+ d->nameFilters = QDirPrivate::splitFilters(nameFilter, d->filterSepChar);

+#include <QtCore/qshareddata.h>

+ QSharedDataPointer<QDirPrivate> d_ptr;

+

+ if (cache_enabled && !fileNames[(int)name].isNull())

+ return fileNames[(int)name];

+ QString ret = fileEngine->fileName(name);

+ if (cache_enabled)

+ fileNames[(int)name] = ret;

+ if (cache_enabled && !fileOwners[(int)own].isNull())

+ return fileOwners[(int)own];

+ QString ret = fileEngine->owner(own);

+ if (cache_enabled)

+ fileOwners[(int)own] = ret;

+ if (!getCachedFlag(CachedFileFlags)) {

+ if (!getCachedFlag(CachedLinkTypeFlag)) {

+ if (!getCachedFlag(CachedBundleTypeFlag)) {

+ if (!getCachedFlag(CachedPerms)) {

+ if (cache_enabled)

+ QAbstractFileEngine::FileFlags flags = fileEngine->fileFlags(req);

+ fileFlags |= uint(flags);

+ setCachedFlag(cachedFlags);

+ return fileFlags & request;

+ if (!cache_enabled)

+ clearFlags();

+ if (!getCachedFlag(cf)) {

+ fileTimes[request] = fileEngine->fileTime(request);

+ setCachedFlag(cf);

+ return fileTimes[request];

+QFileInfo::QFileInfo(const QString &file) : d_ptr(new QFileInfoPrivate(file))

+QFileInfo::QFileInfo(const QFile &file) : d_ptr(new QFileInfoPrivate(file.fileName()))

+QFileInfo::QFileInfo(const QDir &dir, const QString &file)

+ : d_ptr(new QFileInfoPrivate(dir.filePath(file)))

+QFileInfo::QFileInfo(const QFileInfo &fileinfo)

+ : d_ptr(fileinfo.d_ptr)

+ if (fileinfo.d_ptr == d_ptr)

+ if (d->isDefaultConstructed || fileinfo.d_ptr->isDefaultConstructed)

+ if (d->fileEngine->caseSensitive() != fileinfo.d_ptr->fileEngine->caseSensitive())

+ if (!fileinfo.d_ptr->fileEngine->caseSensitive()) {

+ d_ptr = fileinfo.d_ptr;

+ bool caching = d_ptr.constData()->cache_enabled;

+ d_ptr->cache_enabled = caching;

+ setFile(file.fileName());

+ setFile(dir.filePath(file));

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed) {

+ } else if (d->fileName.isEmpty()) {

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ return d->fileEngine->isRelativePath();

+ if (d_ptr.constData()->isDefaultConstructed

+ || !d_ptr.constData()->fileEngine->isRelativePath())

+ QString absFileName = d_ptr.constData()->getFileName(QAbstractFileEngine::AbsoluteName);

+ // QSharedDataPointer::operator->() will detach.

+

+ setFile(absFileName);

+ if (d->isDefaultConstructed)

+ d->clear();

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ return d->fileEngine->ownerId(QAbstractFileEngine::OwnerUser);

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ return d->fileEngine->ownerId(QAbstractFileEngine::OwnerGroup);

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (!d->getCachedFlag(QFileInfoPrivate::CachedSize)) {

+ d->setCachedFlag(QFileInfoPrivate::CachedSize);

+ d->fileSize = d->fileEngine->size();

+ return d->fileSize;

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ if (d->isDefaultConstructed)

+ d_ptr.detach();

+ return d->cache_enabled;

+ d->cache_enabled = enable;

+#include <QtCore/qshareddata.h>

+ QSharedDataPointer<QFileInfoPrivate> d_ptr;

+ inline QFileInfoPrivate* d_func()

+ {

+ detach();

+ return const_cast<QFileInfoPrivate *>(d_ptr.constData());

+ }

+

+ inline const QFileInfoPrivate* d_func() const

+ {

+ return d_ptr.constData();

+ }

+

+#include "qshareddata.h"

+class QFileInfoPrivate : public QSharedData

+ enum { CachedFileFlags=0x01, CachedLinkTypeFlag=0x02, CachedBundleTypeFlag=0x04,

+ CachedMTime=0x10, CachedCTime=0x20, CachedATime=0x40,

+ CachedSize =0x08, CachedPerms=0x80 };

+

+ inline QFileInfoPrivate()

+ : QSharedData(), fileEngine(0),

+ cachedFlags(0),

+ isDefaultConstructed(true),

+ cache_enabled(true), fileFlags(0), fileSize(0)

+ {}

+ inline QFileInfoPrivate(const QFileInfoPrivate &copy)

+ : QSharedData(copy), fileEngine(QAbstractFileEngine::create(copy.fileName)),

+ fileName(copy.fileName),

+ cachedFlags(0),

+#ifndef QT_NO_FSFILEENGINE

+ isDefaultConstructed(false),

+#else

+ isDefaultConstructed(!fileEngine),

+#endif

+ cache_enabled(copy.cache_enabled), fileFlags(0), fileSize(0)

+ {}

+ inline QFileInfoPrivate(const QString &file)

+ : QSharedData(), fileEngine(QAbstractFileEngine::create(file)),

+ fileName(file),

+ cachedFlags(0),

+#ifndef QT_NO_FSFILEENGINE

+ isDefaultConstructed(false),

+#else

+ isDefaultConstructed(!fileEngine),

+#endif

+ cache_enabled(true), fileFlags(0), fileSize(0)

+ {

+ }

+

+ inline void clearFlags() const {

+ fileFlags = 0;

+ cachedFlags = 0;

+ if (fileEngine)

+ (void)fileEngine->fileFlags(QAbstractFileEngine::Refresh);

+ }

+ inline void clear() {

+ clearFlags();

+ for (int i = QAbstractFileEngine::NFileNames - 1 ; i >= 0 ; --i)

+ fileNames[i].clear();

+ fileOwners[1].clear();

+ fileOwners[0].clear();

+ }

+ QScopedPointer<QAbstractFileEngine> const fileEngine;

+ mutable QString fileName;

+ mutable QString fileNames[QAbstractFileEngine::NFileNames];

+ mutable QString fileOwners[2];

+ mutable uint cachedFlags : 30;

+ bool const isDefaultConstructed : 1; // QFileInfo is a default constructed instance

+ bool cache_enabled : 1;

+ mutable uint fileFlags;

+ mutable qint64 fileSize;

+ mutable QDateTime fileTimes[3];

+ inline bool getCachedFlag(uint c) const

+ { return cache_enabled ? (cachedFlags & c) : 0; }

+ inline void setCachedFlag(uint c) const

+ { if (cache_enabled) cachedFlags |= c; }

+#include <private/qsystemlibrary_p.h>

+ HINSTANCE advapiHnd = QSystemLibrary::load(L"advapi32");

+ HINSTANCE userenvHnd = QSystemLibrary::load(L"userenv");

+ HINSTANCE hLib = QSystemLibrary::load(L"Netapi32");

+#include <private/qsystemlibrary_p.h>

+ QSystemLibrary library(QLatin1String("shell32"));

+ QSystemLibrary library(QLatin1String("coredll"));

+ case REG_QWORD: {

+ Q_ASSERT(data.size() == sizeof(qint64));

+ qint64 i;

+ memcpy((char*)&i, data.constData(), sizeof(qint64));

+ if (value != 0)

+ *value = i;

+ break;

+ }

+

+ case QVariant::Int:

+ case QVariant::UInt: {

+ qint32 i = value.toInt();

+ regValueBuff = QByteArray((const char*)&i, sizeof(qint32));

+ break;

+ }

+

+ case QVariant::LongLong:

+ case QVariant::ULongLong: {

+ type = REG_QWORD;

+ qint64 i = value.toLongLong();

+ regValueBuff = QByteArray((const char*)&i, sizeof(qint64));

+ bool needsBraces = false;

+ needsBraces = true;

+ else if (needsBraces)

+ that->host = QString::fromLatin1(ba.toLower());

+ that->isHostValid = !that->host.isNull();

+ // authority() calls canonicalHost() which sets this

+ if (!isHostValid)

+ return;

+

+ QString savedHost = host; // pre-validation, may be invalid!

+ if ((options & QUrl::RemoveAuthority) != QUrl::RemoveAuthority && (!auth.isEmpty() || doFileScheme || !savedHost.isEmpty())) {

+ } else if (host.isEmpty() && !savedHost.isEmpty()) {

+ // this case is only possible with an invalid URL

+ // it's here only so that we can keep the original, invalid hostname

+ // in encodedOriginal.

+ // QUrl::isValid() will return false, so toEncoded() can be anything (it's not valid)

+ url += savedHost.toUtf8();

+ if (isValid && isHostValid)

+ if (isHostValid)

+ errorString += QLatin1String(errorInfo._message);

+ else

+ errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "invalid hostname"));

+ QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized | QUrlPrivate::HostCanonicalized);

+ QAbstractItemModelPrivate::Change sourceChange(sourceParent, sourceFirst, sourceLast);

+ sourceChange.needsAdjust = sourceParent.isValid() && sourceParent.row() >= destinationChild && sourceParent.parent() == destinationParent;

+ d->changes.push(sourceChange);

+ QAbstractItemModelPrivate::Change destinationChange(destinationParent, destinationChild, destinationLast);

+ destinationChange.needsAdjust = destinationParent.isValid() && destinationParent.row() >= sourceLast && destinationParent.parent() == sourceParent;

+ d->changes.push(destinationChange);

+ QModelIndex adjustedSource = removeChange.parent;

+ QModelIndex adjustedDestination = insertChange.parent;

+

+ const int numMoved = removeChange.last - removeChange.first + 1;

+ if (insertChange.needsAdjust)

+ adjustedDestination = createIndex(adjustedDestination.row() - numMoved, adjustedDestination.column(), adjustedDestination.internalPointer());

+

+ if (removeChange.needsAdjust)

+ adjustedSource = createIndex(adjustedSource.row() + numMoved, adjustedSource.column(), adjustedSource.internalPointer());

+

+ emit rowsMoved(adjustedSource, removeChange.first, removeChange.last, adjustedDestination, insertChange.first);

+ QAbstractItemModelPrivate::Change sourceChange(sourceParent, sourceFirst, sourceLast);

+ sourceChange.needsAdjust = sourceParent.isValid() && sourceParent.row() >= destinationChild && sourceParent.parent() == destinationParent;

+ d->changes.push(sourceChange);

+ QAbstractItemModelPrivate::Change destinationChange(destinationParent, destinationChild, destinationLast);

+ destinationChange.needsAdjust = destinationParent.isValid() && destinationParent.row() >= sourceLast && destinationParent.parent() == sourceParent;

+ d->changes.push(destinationChange);

+ QModelIndex adjustedSource = removeChange.parent;

+ QModelIndex adjustedDestination = insertChange.parent;

+

+ const int numMoved = removeChange.last - removeChange.first + 1;

+ if (insertChange.needsAdjust)

+ adjustedDestination = createIndex(adjustedDestination.row(), adjustedDestination.column() - numMoved, adjustedDestination.internalPointer());

+

+ if (removeChange.needsAdjust)

+ adjustedSource = createIndex(adjustedSource.row(), adjustedSource.column() + numMoved, adjustedSource.internalPointer());

+

+ emit columnsMoved(adjustedSource, removeChange.first, removeChange.last, adjustedDestination, insertChange.first);

+ Change(const Change &c) : parent(c.parent), first(c.first), last(c.last), needsAdjust(c.needsAdjust) {}

+ Change(const QModelIndex &p, int f, int l) : parent(p), first(f), last(l), needsAdjust(false) {}

+

+ // In cases such as this:

+ // - A

+ // - B

+ // - C

+ // - - D

+ // - - E

+ // - - F

+ //

+ // If B is moved to above E, C is the source parent in the signal and its row is 2. When the move is

+ // completed however, C is at row 1 and there is no row 2 at the same level in the model at all.

+ // The QModelIndex is adjusted to correct that in those cases before reporting it though the

+ // rowsMoved signal.

+ bool needsAdjust;

+

+

+ // Duplicate lib handle to enable process wide access to it. Since Duplicate overwrites

+ // existing handle without closing it, store original for subsequent closing.

+ RLibrary origHandleCloser = lib;

+ lib.Duplicate(RThread(), EOwnerProcess);

+ origHandleCloser.Close();

+ int n_act = 0, maxCount = 0;

+ timeval currentTime = updateCurrentTime();

+ repairTimersIfNeeded();

+

+ // Find out how many timer have expired

+ for (QTimerInfoList::const_iterator it = constBegin(); it != constEnd(); ++it) {

+ if (currentTime < (*it)->timeout)

+ break;

+ maxCount++;

+ }

+

+ //fire the timers.

+ while (maxCount--) {

+#include <private/qsystemlibrary_p.h>

+# ifdef Q_OS_WINCE

+# define QS_RAWINPUT 0x0000

+# else

+# endif

+ WM_QT_SENDPOSTEDEVENTS = WM_USER + 1

+ qtimeSetEvent = (ptimeSetEvent)QSystemLibrary::resolve(QLatin1String("winmm"), "timeSetEvent");

+ qtimeKillEvent = (ptimeKillEvent)QSystemLibrary::resolve(QLatin1String("winmm"), "timeKillEvent");

+ qtimeSetEvent = (ptimeSetEvent)QSystemLibrary::resolve(QLatin1String("Mmtimer"), "timeSetEvent");

+ qtimeKillEvent = (ptimeKillEvent)QSystemLibrary::resolve(QLatin1String("Mmtimer"), "timeKillEvent");

+ MSG unused;

+ if ((HIWORD(GetQueueStatus(QS_INPUT | QS_RAWINPUT)) == 0

+ && PeekMessage(&unused, 0, WM_TIMER, WM_TIMER, PM_NOREMOVE) == 0)

+#ifndef Q_OS_WINCE

+ waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);

+ plugin/qfactoryloader_p.h \

+ plugin/qsystemlibrary_p.h

+ SOURCES += \

+ plugin/qlibrary_win.cpp \

+ plugin/qsystemlibrary.cpp

+#ifdef Q_WS_X11

+QLibraryPrivate *QFactoryLoader::library(const QString &key) const

+{

+ Q_D(const QFactoryLoader);

+ return d->keyMap.value(d->cs ? key : key.toLower());

+}

+#endif

+

+#ifdef Q_WS_X11

+ QLibraryPrivate *library(const QString &key) const;

+#endif

+

+/****************************************************************************

+**

+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

+** All rights reserved.

+** Contact: Nokia Corporation (qt-info@nokia.com)

+**

+** This file is part of the QtCore module of the Qt Toolkit.

+**

+** $QT_BEGIN_LICENSE:LGPL$

+** No Commercial Usage

+** This file contains pre-release code and may not be distributed.

+** You may use this file in accordance with the terms and conditions

+** contained in the Technology Preview License Agreement accompanying

+** this package.

+**

+** GNU Lesser General Public License Usage

+** Alternatively, this file may be used under the terms of the GNU Lesser

+** General Public License version 2.1 as published by the Free Software

+** Foundation and appearing in the file LICENSE.LGPL included in the

+** packaging of this file. Please review the following information to

+** ensure the GNU Lesser General Public License version 2.1 requirements

+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

+**

+** In addition, as a special exception, Nokia gives you certain additional

+** rights. These rights are described in the Nokia Qt LGPL Exception

+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

+**

+** If you have questions regarding the use of this file, please contact

+** Nokia at qt-info@nokia.com.

+**

+**

+**

+**

+**

+**

+**

+**

+** $QT_END_LICENSE$

+**

+****************************************************************************/

+

+#include "qsystemlibrary_p.h"

+#include <QtCore/qvarlengtharray.h>

+#include <QtCore/qstringlist.h>

+#include <QtCore/qfileinfo.h>

+

+/*!

+

+ \internal

+ \class QSystemLibrary

+

+ The purpose of this class is to load only libraries that are located in

+ well-known and trusted locations on the filesystem. It does not suffer from

+ the security problem that QLibrary has, therefore it will never search in

+ the current directory.

+

+ The search order is the same as the order in DLL Safe search mode Windows,

+ except that we don't search:

+ * The current directory

+ * The 16-bit system directory. (normally c:\windows\system)

+ * The Windows directory. (normally c:\windows)

+

+ This means that the effective search order is:

+ 1. Application path.

+ 2. System libraries path.

+ 3. Trying all paths inside the PATH environment variable.

+

+ Note, when onlySystemDirectory is true it will skip 1) and 3).

+

+ DLL Safe search mode is documented in the "Dynamic-Link Library Search

+ Order" document on MSDN.

+

+ Since library loading code is sometimes shared between Windows and WinCE,

+ this class can also be used on WinCE. However, its implementation just

+ calls the LoadLibrary() function. This is ok since it is documented as not

+ loading from the current directory on WinCE. This behaviour is documented

+ in the documentation for LoadLibrary for Windows CE at MSDN.

+ (http://msdn.microsoft.com/en-us/library/ms886736.aspx)

+*/

+#if defined(Q_OS_WINCE)

+HINSTANCE QSystemLibrary::load(const wchar_t *libraryName, bool onlySystemDirectory /* = true */)

+{

+ return ::LoadLibrary(libraryName);

+}

+#else

+

+#if !defined(QT_BOOTSTRAPPED)

+extern QString qAppFileName();

+#endif

+

+static QString qSystemDirectory()

+{

+ QVarLengthArray<wchar_t, MAX_PATH> fullPath;

+

+ UINT retLen = ::GetSystemDirectory(fullPath.data(), MAX_PATH);

+ if (retLen > MAX_PATH) {

+ fullPath.resize(retLen);

+ retLen = ::GetSystemDirectory(fullPath.data(), retLen);

+ }

+ // in some rare cases retLen might be 0

+ return QString::fromWCharArray(fullPath.constData(), int(retLen));

+}

+

+HINSTANCE QSystemLibrary::load(const wchar_t *libraryName, bool onlySystemDirectory /* = true */)

+{

+ QStringList searchOrder;

+

+#if !defined(QT_BOOTSTRAPPED)

+ if (!onlySystemDirectory)

+ searchOrder << QFileInfo(qAppFileName()).path();

+#endif

+ searchOrder << qSystemDirectory();

+

+ if (!onlySystemDirectory) {

+ const QString PATH(QLatin1String(qgetenv("PATH").constData()));

+ searchOrder << PATH.split(QLatin1Char(';'), QString::SkipEmptyParts);

+ }

+ QString fileName = QString::fromWCharArray(libraryName);

+ fileName.append(QLatin1String(".dll"));

+

+ // Start looking in the order specified

+ for (int i = 0; i < searchOrder.count(); ++i) {

+ QString fullPathAttempt = searchOrder.at(i);

+ if (!fullPathAttempt.endsWith(QLatin1Char('\\'))) {

+ fullPathAttempt.append(QLatin1Char('\\'));

+ }

+ fullPathAttempt.append(fileName);

+ HINSTANCE inst = ::LoadLibrary((const wchar_t *)fullPathAttempt.utf16());

+ if (inst != 0)

+ return inst;

+ }

+ return 0;

+

+}

+

+#endif //Q_OS_WINCE

+/****************************************************************************

+**

+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

+** All rights reserved.

+** Contact: Nokia Corporation (qt-info@nokia.com)

+**

+** This file is part of the QtCore module of the Qt Toolkit.

+**

+** $QT_BEGIN_LICENSE:LGPL$

+** No Commercial Usage

+** This file contains pre-release code and may not be distributed.

+** You may use this file in accordance with the terms and conditions

+** contained in the Technology Preview License Agreement accompanying

+** this package.

+**

+** GNU Lesser General Public License Usage

+** Alternatively, this file may be used under the terms of the GNU Lesser

+** General Public License version 2.1 as published by the Free Software

+** Foundation and appearing in the file LICENSE.LGPL included in the

+** packaging of this file. Please review the following information to

+** ensure the GNU Lesser General Public License version 2.1 requirements

+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

+**

+** In addition, as a special exception, Nokia gives you certain additional

+** rights. These rights are described in the Nokia Qt LGPL Exception

+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

+**

+** If you have questions regarding the use of this file, please contact

+** Nokia at qt-info@nokia.com.

+**

+**

+**

+**

+**

+**

+**

+**

+** $QT_END_LICENSE$

+**

+****************************************************************************/

+

+#ifndef QSYSTEMLIBRARY_P_H

+#define QSYSTEMLIBRARY_P_H

+

+#include <QtCore/qglobal.h>

+#ifdef Q_OS_WIN

+#include <qt_windows.h>

+#include <QtCore/qstring.h>

+

+class QSystemLibrary

+{

+public:

+ explicit QSystemLibrary(const QString &libraryName)

+ {

+ m_libraryName = libraryName;

+ m_handle = 0;

+ m_didLoad = false;

+ }

+

+ explicit QSystemLibrary(const wchar_t *libraryName)

+ {

+ m_libraryName = QString::fromWCharArray(libraryName);

+ m_handle = 0;

+ m_didLoad = false;

+ }

+

+ bool load(bool onlySystemDirectory = true)

+ {

+ m_handle = load((const wchar_t *)m_libraryName.utf16(), onlySystemDirectory);

+ m_didLoad = true;

+ return (m_handle != 0);

+ }

+

+ bool isLoaded()

+ {

+ return (m_handle != 0);

+ }

+

+ void *resolve(const char *symbol)

+ {

+ if (!m_didLoad)

+ load();

+ if (!m_handle)

+ return 0;

+#ifdef Q_OS_WINCE

+ return (void*)GetProcAddress(m_handle, (const wchar_t*)QString::fromLatin1(symbol).utf16());

+#else

+ return (void*)GetProcAddress(m_handle, symbol);

+#endif

+ }

+

+ static void *resolve(const QString &libraryName, const char *symbol)

+ {

+ return QSystemLibrary(libraryName).resolve(symbol);

+ }

+

+ static Q_CORE_EXPORT HINSTANCE load(const wchar_t *lpFileName, bool onlySystemDirectory = true);

+private:

+ HINSTANCE m_handle;

+ QString m_libraryName;

+ bool m_didLoad;

+};

+

+#endif //Q_OS_WIN

+

+#endif //QSYSTEMLIBRARY_P_H

+#ifdef Q_OS_SYMBIAN

+static void init_symbian_thread_handle(RThread &thread)

+{

+ thread = RThread();

+ TThreadId threadId = thread.Id();

+ thread.Open(threadId);

+

+ // Make thread handle accessible process wide

+ RThread originalCloser = thread;

+ thread.Duplicate(thread, EOwnerProcess);

+ originalCloser.Close();

+}

+#endif

+

+ init_symbian_thread_handle(d->data->symbian_thread_handle);

+ init_symbian_thread_handle(data->symbian_thread_handle);

+

+#ifdef Q_OS_SYMBIAN

+ // Check if thread still exists. Needed because kernel will kill it without notification

+ // before global statics are deleted at application exit.

+ if (d->data->symbian_thread_handle.Handle()

+ && d->data->symbian_thread_handle.ExitType() != EExitPending) {

+ // Cannot call finish here as wait is typically called from another thread.

+ // It won't be necessary anyway, as we should never get here under normal operations;

+ // all QThreads are EProcessCritical and therefore cannot normally exit

+ // undetected (i.e. panic) as long as all thread control is via QThread.

+ return true;

+ }

+#endif

+ copied (copy-on-write), taking \l{linear time}.

+ Note: QByteArray is an \l{implicitly shared} class. Consequently,

+ if \e this is an empty QByteArray, then \e this will just share

+ the data held in \a ba. In this case, no copying of data is done,

+ taking \l{constant time}. If a shared instance is modified, it will

+ be copied (copy-on-write), taking \l{linear time}.

+

+ If \e this is not an empty QByteArray, a deep copy of the data is

+ performed, taking \l{linear time}.

+

+ This operation typically does not suffer from allocation overhead,

+ because QByteArray preallocates extra space at the end of the data

+ so that it may grow without reallocating for each append operation.

+ the data held in \a ba. In this case, no copying of data is done,

+ taking \l{constant time}. If a shared instance is modified, it will

+ be copied (copy-on-write), taking \l{linear time}.

+

+ If \e this is not an empty QByteArray, a deep copy of the data is

+ performed, taking \l{linear time}.

+ the data held in \a ba. In this case, no copying of data is done,

+ taking \l{constant time}. If a shared instance is modified, it will

+ be copied (copy-on-write), taking \l{linear time}.

+

+ If \e this is not an empty QByteArray, a deep copy of the data is

+ performed, taking \l{linear time}.

+

+ This operation typically does not suffer from allocation overhead,

+ because QByteArray preallocates extra space at the end of the data

+ so that it may grow without reallocating for each append operation.

+ qreal overshoot = 1.70158)

+ qFuzzyCompare(_p, other._p) &&

+ qFuzzyCompare(_a, other._a) &&

+ qFuzzyCompare(_o, other._o);

+ qreal p = (_p < 0) ? qreal(0.3) : _p;

+ qreal a = (_a < 0) ? qreal(1.0) : _a;

+ : QEasingCurveFunction(type, qreal(0.3), qreal(1.0))

+ qreal a = (_a < 0) ? qreal(1.0) : _a;

+ : QEasingCurveFunction(type, qreal(0.3), qreal(1.0), qreal(1.70158))

+ qreal o = (_o < 0) ? qreal(1.70158) : _o;

+ curveFunc = new QEasingCurveFunction(QEasingCurveFunction::In, qreal(0.3), qreal(1.0), qreal(1.70158));

+ if (res) {

+ if (d_ptr->config && other.d_ptr->config) {

+ res = d_ptr->config->operator==(*(other.d_ptr->config));

+

+ } else if (d_ptr->config || other.d_ptr->config) {

+ // one one has a config object, which could contain default values

+ res = qFuzzyCompare(amplitude(), other.amplitude()) &&

+ qFuzzyCompare(period(), other.period()) &&

+ qFuzzyCompare(overshoot(), other.overshoot());

+ }

+ return d_ptr->config ? d_ptr->config->_a : qreal(1.0);

+ return d_ptr->config ? d_ptr->config->_p : qreal(0.3);

+ return d_ptr->config ? d_ptr->config->_o : qreal(1.70158) ;

+ long tmp;

+ asm ("xchg %%rbx, %1\n"

+ "cpuid\n"

+ "xchg %%rbx, %1\n"

+ : "=c" (feature_result), "=&r" (tmp)

+ : "%edx"

+ { QVector<T> tmp; tmp.reserve(vector.size()); qCopy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; }

+ { std::vector<T> tmp; tmp.reserve(size()); qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }