This reverts commit a6000e2b66.
Temporarily remove this to unblock the qtdeclarative dev CI.
While Windows 8 VMs are fixed by this patch, Windows 7 has different
problems.
Change-Id: I45ef064ed953cc4b7bbf19657300d4fc43d82452
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
That header defines those constants outside of the math.h include guard,
so if someone #define'd _USE_MATH_DEFINES and #include'd math.h later,
they would get VC++ warnings about constants like M_PI being redefined
with different values (ours have parentheses, VS2010's math.h don't).
Instead, let's define _USE_MATH_DEFINES ourselves so we get the M_*
macros from math.h. That way, we won't redefine them outselves.
Task-number: QTBUG-45935
Change-Id: Idf715b895bac4d56b4afffff13db2c98ba8345c2
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
This prevents the building of dysfunctional plugins that don't define
a loader function, or won't compile at all.
Change-Id: Ib62edb8db4a8917effa05292cb702bb4022f552c
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
Without library support we don't try to load any symbols and the
function is unused. This results in a compiler warning.
Change-Id: I82ad46a478debe48cf9a8311f5e5ec299baa1af8
Reviewed-by: Richard J. Moore <rich@kde.org>
This prevents qdoc from getting lost and reporting
extraneous errors.
Change-Id: I8edf11dec67c39d7aa314fe6748acf6df4e646c8
Task-number: QTBUG-46794
Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com>
The PNG image plugin has the capability of applying gamma correction
to read PNGs, but doesn't do so by default, and we export no way of
accessing this through the qimagereader API.
This patch adds the ability to read the PNG file gamma, and overriding
decoded gamma to get gamma correction.
Change-Id: Iaf9eaac0827516db6bc02247c58026270cd1f610
Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
While this is not what the EGL spec says, we can get EGL_CONTEXT_LOST in
eglCreateWindowSurface too with ANGLE. Handle it the same way like we do
for eglMakeCurrent and eglSwapBuffers (no warning, just return the error
code silently since we may recover from this).
Change-Id: I6b6c57ffd4fca23e1a14a90ef7b18b33f4c96fd2
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
QImage is larger than a void*, so holding them in a QList is needlessly
inefficient.
Use QVector instead.
Change-Id: Ifcc9eca18a87e29327586506e3a3bb7874c8b3a7
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
QPointer is larger than a void*, so holding them in a QList is needlessly
inefficient. Worse, the code could come to depend on the fragile property
of (inefficient) QLists that references to elements therein never are
invalidated.
Change-Id: I104d11cc530c9c1579e82bf4e28e3353c00b34b4
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Location is self-referential, so explicitly mark it as Q_COMPLEX_TYPE.
Location::StackEntry is held in QVector, by way of QStack.
Change-Id: I4d9001b55b86f0387ae41b93da17d06fb2857ee4
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Reviewed-by: Martin Smith <martin.smith@digia.com>
QImage is larger than a void*, so holding them in a QList is needlessly
inefficient. Worse, the code could come to depend on the fragile property
of (inefficient) QLists that references to elements therein never are
invalidated.
Also added a reserve() call.
Change-Id: I36388f2efbc6ca025f123c30bc7f1dd312bf4ab2
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
Location is a self-referential type that is very expensive to copy.
So don't.
Instead, just remember the iterator, and use value()->location()
(which returns a reference, so doesn't copy).
Change-Id: I9a2b72b05b8051e793cf67179a0195f2f3551a10
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Reviewed-by: Martin Smith <martin.smith@digia.com>
QImage is larger than a void*, so holding them in a QList is needlessly
inefficient.
In this case, the maximum size of the container is a small compile-time
constant, so the best container to hold those QImages is a C array, even
though it will default-construct all 12 QImages before even starting the
loop, since the QImage constructor does not allocate memory.
Change-Id: I83ca65aa1ca51c400ca696202d24cfaeab505a5b
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
Commit 3ce99adf replaced DEPLOYMENT with INSTALLS and introduced
the "install target not created" warning when running qmake on
WinRt projects.
The code path in qt.prf that was responsible for filling the
DEPLOYMENT variable was never functional in Qt5. We're turning
the code path off until this is properly fixed.
Change-Id: If836ef648f9fb601b7597d39e3d00665d4cf01b0
Reviewed-by: Oliver Wolff <oliver.wolff@theqtcompany.com>
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
QQmlJS::AST::SourceLocation wasn't marked as movable, and it is larger
than void*, so QList<SourceLocation> is horribly inefficient.
Fix by marking as movable primitive and holding in QVector instead.
The same fix probably is required in QtDeclarative, too.
Change-Id: I4e0d2cd32b7e03205d59cbc9900287f77045154a
Reviewed-by: Martin Smith <martin.smith@digia.com>
... with iteration over the hash itself.
gesturesByType is a local variable, so there's no way
functions called in the loop can modify it.
This dividing operation would greatly benefit from
a splice operation in QHash...
Change-Id: Ifd241d2da9c6998c2ad0b08294fca84d5b188d0f
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
QBenchmarkResult is larger than a void*, so holding them in a QList is
needlessly inefficient. Worse, the code could come to depend on the
fragile property of (inefficient) QLists that references to elements
therein never are invalidated.
Also saves ~1.2KiB of text size on GCC 4.9 optimized C++11 AMD64
Linux builds.
Change-Id: I0c99e591bb9b4405aa1bb78ec095dcaf9277993f
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
... with iteration over the hash itself.
gesturesByType is a local variable, so there's no way
functions called in the loop can modify it.
Change-Id: I5971c404f4ae8473d4926b68eb7a9c60801f208d
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
QQmlJS::Engine::comments() returns a QList<QQmlJ::AST::SourceLocation> by value.
The QList is horribly inefficient, but that will be topic of a separate patch.
The loop in QmlMarkupVisitor did not store the result of comments() in a local
variable, it called engine->comments() whenever it referenced it, which was
_three_ times per loop iteration. Two of those references applied op[] to
the rvalue engine->comments(), which, being mutable, detaches. _Twice_ per
loop, with a QList that heap-allocates its elements!.
And that was followed by a similar loop.
Fix by using a local const copy of the list to iterate over.
The loop termination condition also looks fishy (j is used to index into
the comments, but is not checked against comments.size()), but apparently
qdoc works fine with it so far, so don't try to fix.
The copy of QQmlJS in QtDeclarative is not affected by this (qdoc-specific
code).
Change-Id: I133c35dc9293609dfb8ad633e2d82399223b508b
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
This isn't specific to an Ubuntu version, unfortunately. It also fails
on OpenSuSE occasionally and other Ubuntu versions.
Change-Id: I6a1ca55a198270f1a1e8a9916e9f768762211550
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
When the test fails, show the actual signals spy count.
Change-Id: Id7312bfbfb6531404a9df73234031f13295c80ea
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
It's flakey with 'current > 42' sometimes succeeding and sometimes failing.
Change-Id: I86f52b0d0cecd345ed6c5852c822d12eae6acb26
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
The failure of this test is not architecture specific but rather
Windows specific. It is failing on either type of Windows machine at random
intervals.
Change-Id: Ie3ab1d868053b22ee5b0d965a8cd6b923985b019
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
All variants of the tests are timing out randomly on all platforms :(
Change-Id: I9244602a8d06fd07d3cc99b2fb8fdf6e07e92cf2
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
...instead of coding the loop by hand.
Change-Id: Ieaa066de1ff8552b737cf27cf0d4236efb7296eb
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Since commit a6000e2b66 tests run in the
CI now disable D3D11 and are intended to fall back to warp. This
causes additional output, which confuses tests in qtdeclarative
that look closely at the output of processes. So let's make these
debug messages instead of warnings.
Change-Id: I91d2f88c66e2e7368c8cbbfb3aec7ad0c47b8bee
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
Introduce two methods to set set error and errorString, and optionally
emit the error() signal. This also fixes two places where errorString
hasn't been set previously.
Change-Id: Ib7c27ff2daff898745e8e20ff8f11eaae568697f
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
The previous implementation performed reading in two steps:
- flush the internal buffer
- request the rest of the data by calling the read() function
It would resize the result buffer separately at each step, even if its
total size was known in advance. This is important for random-access
devices, which may have big chunks of cached data. Also, possible
failures during the second step would cause a loss of result data from
the first stage. This patch eliminates the initial flush, which improves
performance and prevents data loss.
Change-Id: I3da4c24ee33dca6afc4ba519d078b86068de43b9
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
The QMap<QString, QString> was only used to create a sorted,
unique list of keys. The associativeness was never used (the
value was always the null QString).
Better to use a QStringList instead and sort-unique the
whole thing at the end.
Saves ~1.6K in text size on Linux AMD64 GCC 4.9 release C++11
builds, and a tremendous amount of heap allocations.
Change-Id: Idf749dd8924b3894e436aa1cee0304002b898975
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
There is a good chance that in every program, command line options
that have only one name and those that have multiple names are
used. Make better use of the icache by not inlining the Private
ctors into the QCommandLineOption ones.
Saves 400B in text size on Linux GCC 4.9 C++11 release
builds.
Change-Id: I6247d4a2330c5fff75d06f5a40223d972b267e85
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Virtually all of these types are too large to fit into a QList.
Change-Id: If55496ef3fb26d6531e9ef1bb1558887d9077a3b
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
Looping over QList::contains() constitutes O(N²) behavior,
the more so as this QList is horribly inefficient since
WritingSystem is not a Q_MOVABLE_TYPE.
Since the range of possible unique values in the result
is severly limited (by virtue of being enumerated values),
use a bitmask to remember which WritingSystems were
encountered, then, after releaseing the mutex again, use
that bitmask to populate the QList.
Change-Id: I1d12eb487513ec17faa6f38942f8b681819dc0e8
Reviewed-by: Adam Majer <adamm@zombino.com>
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
By adding support for the driver description, we can detect if
we are in VMware. In this case D3D9 and 11 get disabled, so only
the software-based options are in use.
This allows running autotests like tst_qopengl, tst_qopenglwidget,
tst_qgl, etc. in the Qt CI system. There OpenGL 2.x is not available,
so ANGLE is the only option. D3D11 is not an option, so it picks D3D9
by default. However, this results in mystic failures. The stable solution
seems to be to use WARP. This can be achieved by setting disable_d3d9 in
the built-in GPU blacklist.
Change-Id: I937c4b3fa82fc1a2d524b4eb712732722df2070c
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
The default constructor already sets the d-pointer to nullptr,
so the move constructor does not introduce a new state.
Change-Id: Icd47952bdf76d2106992d6babea40d68f18d067e
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Just iterate over the QMultiMap directly. Also, now that we use
iterators, the remove operation becomes amortized O(1) instead
of O(logN). The loop could be even O(N) (clean, not amortized)
if QMap had range-erase.
Change-Id: I0cf3511adc3a558e551ddd91e47dabcab376001a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Resolving d- and q-pointers in code branches where we don't use them is
wasteful and leads to compile warnings.
Change-Id: Ib5dadd247acfe48722121e0e95ffcac61e7a2e09
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
...by moving common code into the Private ctor,
and catering for C++11 move semantics a bit.
Saves ~1.5KiB in text size on Linux GCC 4.9 C++11 release
builds.
Change-Id: I52ed7e47f76b69500a871844c0920e27fe51a127
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
