From 0e4c33be13c94a0eee3d91a857e332cee67d6acf Mon Sep 17 00:00:00 2001 From: Thiago Macieira Date: Fri, 8 May 2009 20:42:44 +0200 Subject: Reorganize the qatomic_armv6.h file to receive the RVCT inline assembly. Move the *Relaxed, *Acquire and *Release functions (which are simply forwarding calls to the *Ordered version) to the bottom of the file. Reviewed-By: Shane Kearns --- src/corelib/arch/qatomic_armv6.h | 171 ++++++++++++++++++++------------------- 1 file changed, 90 insertions(+), 81 deletions(-) diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h index 6862638..6eb9a7b 100644 --- a/src/corelib/arch/qatomic_armv6.h +++ b/src/corelib/arch/qatomic_armv6.h @@ -101,6 +101,8 @@ template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() { return false; } +#ifdef !Q_CC_RVCT + inline bool QBasicAtomicInt::ref() { register int newValue; @@ -155,21 +157,6 @@ inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) return result == 0; } -inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) { register int originalValue; @@ -188,21 +175,6 @@ inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) return originalValue; } -inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) -{ - return fetchAndStoreOrdered(newValue); -} - inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) { register int originalValue; @@ -224,21 +196,6 @@ inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) return originalValue; } -inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) -{ - return fetchAndAddOrdered(valueToAdd); -} - -inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) -{ - return fetchAndAddOrdered(valueToAdd); -} - -inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) -{ - return fetchAndAddOrdered(valueToAdd); -} - template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) { @@ -259,24 +216,6 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValu } template -Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -template -Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -template -Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -template Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) { register T *originalValue; @@ -296,24 +235,6 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) } template -Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -template -Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -template -Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -template Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) { register T *originalValue; @@ -335,6 +256,94 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueTo return originalValue; } +#else +// This is Q_CC_RVCT + +#endif + +// common code + +inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + template Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddRelaxed(qptrdiff valueToAdd) { -- cgit v0.12 From d3ecece1432a3b0a2cb579270d7b3f5a2afaa674 Mon Sep 17 00:00:00 2001 From: Thiago Macieira Date: Fri, 8 May 2009 20:45:24 +0200 Subject: Add the ARMv6 inline assembly code for compiling with RVCT. This is basically a copy & paste of the GCC inline assembly above, switched to the RVCT inline assembly model (which is actually easier to write and understand). I verified that this code compiles and assembles as expected. The output generated by RVCT is pretty much on the mark. However, I have not executed this code yet to see if it performs as expected. To be noted: - when expanding the inline template code, RVCT may be tempted to switch your entire function to ARM mode. Should we add __attribute__((noinline)) to prevent that? - There's no equivalent to GCC inline assembler's clobber, especially of "memory". Also, there's no "volatile" qualifier to the assembly. Does the compiler know it can't reorder the code? Does it know it shouldn't trust the value of the memory after this? My test indicates the code is fine... Reviewed-By: Shane Kearns --- src/corelib/arch/qatomic_armv6.h | 132 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h index 6eb9a7b..28655df 100644 --- a/src/corelib/arch/qatomic_armv6.h +++ b/src/corelib/arch/qatomic_armv6.h @@ -259,6 +259,138 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueTo #else // This is Q_CC_RVCT +// RVCT inline assembly documentation: +// http://www.keil.com/support/man/docs/armcc/armcc_chdcffdb.htm +// RVCT embedded assembly documentation: +// http://www.keil.com/support/man/docs/armcc/armcc_chddbeib.htm + +// save our pragma state and switch to ARM mode +#pragma push +#pragma arm + +inline bool QBasicAtomicInt::ref() +{ + register int newValue; + register int result; + retry: + __asm { + ldrex newValue, [&_q_value] + add newValue, newValue, #1 + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return newValue != 0; +} + +inline bool QBasicAtomicInt::deref() +{ + register int newValue; + register int result; + retry: + __asm { + ldrex newValue, [&_q_value] + sub newValue, newValue, #1 + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return newValue != 0; +} + +inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) +{ + register int result; + retry: + __asm { + ldrex result, [&_q_value] + eors result, result, expectedValue + strexeq result, newValue, [&_q_value] + teqeq result, #1 + beq retry + } + return result == 0; +} + +inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +{ + register int originalValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) +{ + register int originalValue; + register int newValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + add newValue, originalValue, valueToAdd + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) +{ + register T *result; + retry: + __asm { + ldrex result, [&_q_value] + eors result, result, expectedValue + strexeq result, newValue, [&_q_value] + teqeq result, #1 + beq retry + } + return result == 0; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) +{ + register T *originalValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) +{ + register T *originalValue; + register T *newValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + add newValue, originalValue, valueToAdd * sizeof(T) + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +// go back to the previous pragma state (probably Thumb mode) +#pragma pop #endif // common code -- cgit v0.12 From 7442be794787c710812d46052b74d73042795aac Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Wed, 4 Nov 2009 22:26:00 +0100 Subject: Binary compatibility of Symbian ARMv5 and ARMv6 builds Use ARMv6 atomics where available Use OS atomics otherwise Integrate ARMV6 atomics to Symbian builds Use compiler defined macros to detect if ARMv6 instructions are available This defines the QT_HAVE_ARMV6 macro, replacing the way it was defined by the Symbian build system previously in qpainting.pri. qatomic_symbian now uses qatomic_arm or qatomic_armv6 automatically Port armv6 atomics to implement generic atomics interface The inline atomics are not inlined when we build for thumb using RVCT. So there is no performance improvement of using the "inline" versions vs a shared version called through a function call. The generic atomics interface is good for binary compatibility, as the same symbols are exported in all versions now. Changed the fallback generic atomics implementation from the unix one to a symbian specific one using RFastLock (identical code to the windows generic atomics, except for RFastLock replaces Win32 CRITICAL_SECTION) Note: GCCE atomics still need porting Tell git to ignore .lst listing files (produced by sbs/abld listing) ARMv6 support for GCCE compiler and fallback implementation using OS When building corelib with GCCE and -march=armv6, QT_HAVE_ARMV6 will be defined. This patch adds copies of the asm functions in GCC syntax. When building for the Symbian emulator, or ARMv5, then Symbian OS atomic functions are used as a fallback - these are more efficient than the unix atomics, and don't require data import (which the ARMv5 atomics use, but the OS loader doesn't support fully) Symbian OS functions are always used for QBasicAtomicInt::ref / deref, because these are faster than the generic function in all cases. They are machine coded for ARMv6, and are used internally by RFastLock. Reviewed-By: axis Reviewed-By: Brad --- .gitignore | 1 + src/corelib/arch/armv6/qatomic_generic_armv6.cpp | 260 +++++++++++++++++++++++ src/corelib/arch/qatomic_armv6.h | 3 +- src/corelib/arch/qatomic_symbian.h | 240 ++++++++++++++++++++- src/corelib/arch/symbian/arch.pri | 2 +- src/corelib/arch/symbian/qatomic_symbian.cpp | 104 +++++++-- src/corelib/global/qglobal.h | 7 +- src/gui/painting/painting.pri | 1 - src/s60installs/eabi/QtCoreu.def | 8 +- 9 files changed, 587 insertions(+), 39 deletions(-) create mode 100644 src/corelib/arch/armv6/qatomic_generic_armv6.cpp diff --git a/.gitignore b/.gitignore index feb1ea4..33c9b7c 100644 --- a/.gitignore +++ b/.gitignore @@ -191,6 +191,7 @@ plugin_commonU.def *.qtplugin *.sis *.sisx +*.lst # Generated by abldfast.bat from devtools. .abldsteps.* diff --git a/src/corelib/arch/armv6/qatomic_generic_armv6.cpp b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp new file mode 100644 index 0000000..3078662 --- /dev/null +++ b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp @@ -0,0 +1,260 @@ +/**************************************************************************** +** +** Copyright (C) 2009 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$ +** +** This file implements the generic atomics interface using ARMv6 assembly +** instructions. It is more efficent than the inline versions when Qt is +** built for the THUMB instruction set, as the required instructions are +** only available in ARM state. +****************************************************************************/ + +#include + +#ifdef QT_HAVE_ARMV6 + +QT_BEGIN_NAMESPACE + +QT_USE_NAMESPACE + +#ifdef Q_CC_RVCT +#pragma push +#pragma arm +Q_CORE_EXPORT asm +bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue) +{ + CODE32 + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue +retry_testAndSetOrdered + LDREX r3,[r0] //r3 = *_q_value + EORS r3,r3,r1 //if (r3 == expectedValue) { + STREXEQ r3,r2,[r0] //*_q_value = newvalue, r3 = error + TEQEQ r3,#1 //if error + BEQ retry_testAndSetOrdered //then goto retry } + RSBS r0,r3,#1 //return (r3 == 0) + MOVCC r0,#0 + BX r14 +} + +Q_CORE_EXPORT asm +int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue) +{ + CODE32 +//R0 = _q_value +//R1 = newValue +retry_fetchAndStoreOrdered + LDREX r3,[r0] //r3 = *_q_value + STREX r2,r1,[r0] //*_q_value = newValue, r2 = error + TEQ r2,#0 //if error + BNE retry_fetchAndStoreOrdered //then goto retry + MOV r0,r3 //return r3 + BX r14 +} + +Q_CORE_EXPORT asm +int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd) +{ + CODE32 + //R0 = _q_value + //R1 = valueToAdd + STMDB sp!,{r12,lr} +retry_fetchAndAddOrdered + LDREX r2,[r0] //r2 = *_q_value + ADD r3,r2,r1 //r3 = r2 + r1 + STREX r12,r3,[r0] //*_q_value = r3, r12 = error + TEQ r12,#0 //if error + BNE retry_fetchAndAddOrdered //then retry + MOV r0,r2 //return r2 + LDMIA sp!,{r12,pc} +} + +Q_CORE_EXPORT asm +bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value, + void *expectedValue, + void *newValue) +{ + CODE32 + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue +retryPointer_testAndSetOrdered + LDREX r3,[r0] //r3 = *_q_value + EORS r3,r3,r1 //if (r3 == expectedValue) { + STREXEQ r3,r2,[r0] //*_q_value = newvalue, r3 = error + TEQEQ r3,#1 //if error + BEQ retryPointer_testAndSetOrdered //then goto retry } + RSBS r0,r3,#1 //return (r3 == 0) + MOVCC r0,#0 + BX r14 +} + +Q_CORE_EXPORT asm +void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue) +{ + CODE32 + //R0 = _q_value + //R1 = newValue +retryPointer_fetchAndStoreOrdered + LDREX r3,[r0] //r3 = *_q_value + STREX r2,r1,[r0] //*_q_value = newValue, r2 = error + TEQ r2,#0 //if error + BNE retryPointer_fetchAndStoreOrdered //then goto retry + MOV r0,r3 //return r3 + BX r14 +} + +Q_CORE_EXPORT asm +void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd) +{ + CODE32 + //R0 = _q_value + //R1 = valueToAdd + STMDB sp!,{r12,lr} +retryPointer_fetchAndAddOrdered + LDREX r2,[r0] //r2 = *_q_value + ADD r3,r2,r1 //r3 = r2 + r1 + STREX r12,r3,[r0] //*_q_value = r3, r12 = error + TEQ r12,#0 //if error + BNE retryPointer_fetchAndAddOrdered //then retry + MOV r0,r2 //return r2 + LDMIA sp!,{r12,pc} +} + +#pragma pop +#elif defined (Q_CC_GCCE) +Q_CORE_EXPORT __declspec( naked ) +bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue) +{ + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue + asm("retry_testAndSetOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" EORS r3,r3,r1"); //if (r3 == expectedValue) { + asm(" STREXEQ r3,r2,[r0]"); //*_q_value = newvalue, r3 = error + asm(" TEQEQ r3,#1"); //if error + asm(" BEQ retry_testAndSetOrdered"); //then goto retry } + asm(" RSBS r0,r3,#1"); //return (r3 == 0) + asm(" MOVCC r0,#0"); + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue) +{ +//R0 = _q_value +//R1 = newValue + asm("retry_fetchAndStoreOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" STREX r2,r1,[r0]"); //*_q_value = newValue, r2 = error + asm(" TEQ r2,#0"); //if error + asm(" BNE retry_fetchAndStoreOrdered"); //then goto retry + asm(" MOV r0,r3"); //return r3 + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd) +{ + //R0 = _q_value + //R1 = valueToAdd + asm(" STMDB sp!,{r12,lr}"); + asm("retry_fetchAndAddOrdered:"); + asm(" LDREX r2,[r0]"); //r2 = *_q_value + asm(" ADD r3,r2,r1 "); //r3 = r2 + r1 + asm(" STREX r12,r3,[r0]"); //*_q_value = r3, r12 = error + asm(" TEQ r12,#0"); //if error + asm(" BNE retry_fetchAndAddOrdered"); //then retry + asm(" MOV r0,r2"); //return r2 + asm(" LDMIA sp!,{r12,pc}"); +} + +Q_CORE_EXPORT __declspec( naked ) +bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value, + void *expectedValue, + void *newValue) +{ + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue + asm("retryPointer_testAndSetOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" EORS r3,r3,r1"); //if (r3 == expectedValue) { + asm(" STREXEQ r3,r2,[r0]"); //*_q_value = newvalue, r3 = error + asm(" TEQEQ r3,#1"); //if error + asm(" BEQ retryPointer_testAndSetOrdered"); //then goto retry } + asm(" RSBS r0,r3,#1"); //return (r3 == 0) + asm(" MOVCC r0,#0"); + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue) +{ + //R0 = _q_value + //R1 = newValue + asm("retryPointer_fetchAndStoreOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" STREX r2,r1,[r0]"); //*_q_value = newValue, r2 = error + asm(" TEQ r2,#0"); //if error + asm(" BNE retryPointer_fetchAndStoreOrdered"); //then goto retry + asm(" MOV r0,r3"); //return r3 + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd) +{ + //R0 = _q_value + //R1 = valueToAdd + asm(" STMDB sp!,{r12,lr}"); + asm("retryPointer_fetchAndAddOrdered:"); + asm(" LDREX r2,[r0]"); //r2 = *_q_value + asm(" ADD r3,r2,r1"); //r3 = r2 + r1 + asm(" STREX r12,r3,[r0]"); //*_q_value = r3, r12 = error + asm(" TEQ r12,#0"); //if error + asm(" BNE retryPointer_fetchAndAddOrdered"); //then retry + asm(" MOV r0,r2"); //return r2 + asm(" LDMIA sp!,{r12,pc}"); +} +#else +#error unknown arm compiler +#endif +QT_END_NAMESPACE +#endif diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h index 28655df..1e9f0c4 100644 --- a/src/corelib/arch/qatomic_armv6.h +++ b/src/corelib/arch/qatomic_armv6.h @@ -45,7 +45,6 @@ QT_BEGIN_HEADER QT_BEGIN_NAMESPACE - #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE inline bool QBasicAtomicInt::isReferenceCountingNative() @@ -101,7 +100,7 @@ template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() { return false; } -#ifdef !Q_CC_RVCT +#ifndef Q_CC_RVCT inline bool QBasicAtomicInt::ref() { diff --git a/src/corelib/arch/qatomic_symbian.h b/src/corelib/arch/qatomic_symbian.h index 3721aca..571f628 100644 --- a/src/corelib/arch/qatomic_symbian.h +++ b/src/corelib/arch/qatomic_symbian.h @@ -42,12 +42,8 @@ #ifndef QATOMIC_SYMBIAN_H #define QATOMIC_SYMBIAN_H -#if defined(Q_CC_RVCT) -# define QT_NO_ARM_EABI -# include -#elif defined(Q_CC_NOKIAX86) || defined(Q_CC_GCCE) -# include -#endif +#include +#include QT_BEGIN_HEADER @@ -55,7 +51,237 @@ QT_BEGIN_NAMESPACE QT_MODULE(Core) -// Empty, but needed to avoid warnings +#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isReferenceCountingNative() +{ return false; } +inline bool QBasicAtomicInt::isReferenceCountingWaitFree() +{ return false; } + +#define Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isTestAndSetNative() +{ return false; } +inline bool QBasicAtomicInt::isTestAndSetWaitFree() +{ return false; } + +#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isFetchAndStoreNative() +{ return false; } +inline bool QBasicAtomicInt::isFetchAndStoreWaitFree() +{ return false; } + +#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isFetchAndAddNative() +{ return false; } +inline bool QBasicAtomicInt::isFetchAndAddWaitFree() +{ return false; } + +#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_NOT_NATIVE + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetNative() +{ return false; } +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetWaitFree() +{ return false; } + +#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_NOT_NATIVE + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreNative() +{ return false; } +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreWaitFree() +{ return false; } + +#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_NOT_NATIVE + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddNative() +{ return false; } +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() +{ return false; } + +Q_CORE_EXPORT bool QBasicAtomicInt_testAndSetOrdered(volatile int *, int, int); +Q_CORE_EXPORT int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *, int); +Q_CORE_EXPORT int QBasicAtomicInt_fetchAndAddOrdered(volatile int *, int); + +Q_CORE_EXPORT bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *, void *, void *); +Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *, void *); +Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *, qptrdiff); + +// Reference counting + +//LockedInc and LockedDec are machine coded for ARMv6 (and future proof) +inline bool QBasicAtomicInt::ref() +{ + int original = User::LockedInc((TInt&)_q_value); + return original != -1; +} + +inline bool QBasicAtomicInt::deref() +{ + int original = User::LockedDec((TInt&)_q_value); + return original != 1; +} + +// Test and set for integers + +inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) +{ + return QBasicAtomicInt_testAndSetOrdered(&_q_value, expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +// Fetch and store for integers + +inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +{ + return QBasicAtomicInt_fetchAndStoreOrdered(&_q_value, newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +// Fetch and add for integers + +inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) +{ + return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +// Test and set for pointers + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) +{ + union { T * volatile * typed; void * volatile * voidp; } pointer; + pointer.typed = &_q_value; + return QBasicAtomicPointer_testAndSetOrdered(pointer.voidp, expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +// Fetch and store for pointers + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) +{ + union { T * volatile * typed; void * volatile * voidp; } pointer; + union { T *typed; void *voidp; } returnValue; + pointer.typed = &_q_value; + returnValue.voidp = QBasicAtomicPointer_fetchAndStoreOrdered(pointer.voidp, newValue); + return returnValue.typed; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +// Fetch and add for pointers + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) +{ + union { T * volatile *typed; void * volatile *voidp; } pointer; + union { T *typed; void *voidp; } returnValue; + pointer.typed = &_q_value; + returnValue.voidp = QBasicAtomicPointer_fetchAndAddOrdered(pointer.voidp, valueToAdd * sizeof(T)); + return returnValue.typed; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddRelaxed(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddAcquire(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddRelease(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} QT_END_NAMESPACE diff --git a/src/corelib/arch/symbian/arch.pri b/src/corelib/arch/symbian/arch.pri index deb94b1..3ef1c9e 100644 --- a/src/corelib/arch/symbian/arch.pri +++ b/src/corelib/arch/symbian/arch.pri @@ -2,4 +2,4 @@ # Symbian architecture # SOURCES += $$QT_ARCH_CPP/qatomic_symbian.cpp \ - $$QT_ARCH_CPP/../generic/qatomic_generic_unix.cpp + $$QT_ARCH_CPP/../armv6/qatomic_generic_armv6.cpp diff --git a/src/corelib/arch/symbian/qatomic_symbian.cpp b/src/corelib/arch/symbian/qatomic_symbian.cpp index 8f02155..2ab5ae9 100644 --- a/src/corelib/arch/symbian/qatomic_symbian.cpp +++ b/src/corelib/arch/symbian/qatomic_symbian.cpp @@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE // This way we can report on heap cells and handles that are really not owned by anything which still exists. // This information can be used to detect whether memory leaks are happening, particularly if these numbers grow as the app is used more. // This code is placed here as it happens to make it the very last static to be destroyed in a Qt app. The -// reason assumed is that this file appears before any other file declaring static data in the generated +// reason assumed is that this file appears before any other file declaring static data in the generated // Symbian MMP file. This particular file was chosen as it is the earliest symbian specific file. struct QSymbianPrintExitInfo { @@ -77,37 +77,95 @@ struct QSymbianPrintExitInfo TInt initThreadHandleCount; } symbian_printExitInfo; -QT_END_NAMESPACE +//For ARMv6, the generic atomics are machine coded +#ifndef QT_HAVE_ARMV6 +class QCriticalSection +{ +public: + QCriticalSection() { fastlock.CreateLocal(); } + ~QCriticalSection() { fastlock.Close(); } + void lock() { fastlock.Wait(); } + void unlock() { fastlock.Signal(); } -#if defined(Q_CC_RVCT) +private: + RFastLock fastlock; +}; -#include "../arm/qatomic_arm.cpp" +QCriticalSection qAtomicCriticalSection; -QT_BEGIN_NAMESPACE +Q_CORE_EXPORT +bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue) +{ + bool returnValue = false; + qAtomicCriticalSection.lock(); + if (*_q_value == expectedValue) { + *_q_value = newValue; + returnValue = true; + } + qAtomicCriticalSection.unlock(); + return returnValue; +} -Q_CORE_EXPORT __asm char q_atomic_swp(volatile char *ptr, char newval) +Q_CORE_EXPORT +int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue) { - add r2, pc, #0 - bx r2 - arm - swpb r2,r1,[r0] - mov r0, r2 - bx lr - thumb + int returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value = newValue; + qAtomicCriticalSection.unlock(); + return returnValue; } -Q_CORE_EXPORT __asm int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +Q_CORE_EXPORT +int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd) { - add r2, pc, #0 - bx r2 - arm - swp r2,r1,[r0] - mov r0, r2 - bx lr - thumb + int returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value += valueToAdd; + qAtomicCriticalSection.unlock(); + return returnValue; } -QT_END_NAMESPACE +Q_CORE_EXPORT +bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value, + void *expectedValue, + void *newValue) +{ + bool returnValue = false; + qAtomicCriticalSection.lock(); + if (*_q_value == expectedValue) { + *_q_value = newValue; + returnValue = true; + } + qAtomicCriticalSection.unlock(); + return returnValue; +} -#endif // Q_CC_RVCT +Q_CORE_EXPORT +void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue) +{ + void *returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value = newValue; + qAtomicCriticalSection.unlock(); + return returnValue; +} + +Q_CORE_EXPORT +void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd) +{ + void *returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value = reinterpret_cast(returnValue) + valueToAdd; + qAtomicCriticalSection.unlock(); + return returnValue; +} + +#endif // QT_HAVE_ARMV6 + +QT_END_NAMESPACE diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h index d113e02..9558256 100644 --- a/src/corelib/global/qglobal.h +++ b/src/corelib/global/qglobal.h @@ -437,13 +437,18 @@ namespace QT_NAMESPACE {} #elif defined(__GCCE__) # define Q_CC_GCCE # define QT_VISIBILITY_AVAILABLE +# if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) +# define QT_HAVE_ARMV6 +# endif /* ARM Realview Compiler Suite RVCT compiler also defines __EDG__ and __GNUC__ (if --gnu flag is given), so check for it before that */ #elif defined(__ARMCC__) || defined(__CC_ARM) # define Q_CC_RVCT - +# if __TARGET_ARCH_ARM >= 6 +# define QT_HAVE_ARMV6 +# endif #elif defined(__GNUC__) # define Q_CC_GNU # define Q_C_CALLBACKS diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri index c35c33a..628a109 100644 --- a/src/gui/painting/painting.pri +++ b/src/gui/painting/painting.pri @@ -370,7 +370,6 @@ symbian { SOURCES += painting/qwindowsurface_s60.cpp armccIfdefBlock = \ "$${LITERAL_HASH}if defined(ARMV6)" \ - "MACRO QT_HAVE_ARMV6" \ "SOURCEPATH painting" \ "SOURCE qblendfunctions_armv6_rvct.s" \ "SOURCE qdrawhelper_armv6_rvct.s" \ diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index 487d989..e6345cb 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -13,7 +13,7 @@ EXPORTS _Z11qt_int_sqrtj @ 12 NONAME _Z12noforcepointR11QTextStream @ 13 NONAME _Z12qSharedBuildv @ 14 NONAME - _Z12q_atomic_swpPVcc @ 15 NONAME + _Z12q_atomic_swpPVcc @ 15 NONAME ABSENT _Z12qt_s60GetRFsv @ 16 NONAME _Z13lowercasebaseR11QTextStream @ 17 NONAME _Z13qErrnoWarningPKcz @ 18 NONAME @@ -24,7 +24,7 @@ EXPORTS _Z15lowercasedigitsR11QTextStream @ 23 NONAME _Z15qAddPostRoutinePFvvE @ 24 NONAME _Z15qInitResourceIOv @ 25 NONAME - _Z15qt_atomic_yieldPi @ 26 NONAME + _Z15qt_atomic_yieldPi @ 26 NONAME ABSENT _Z15qt_error_stringi @ 27 NONAME _Z15uppercasedigitsR11QTextStream @ 28 NONAME _Z16qt_QString2HBufCRK7QString @ 29 NONAME @@ -706,7 +706,7 @@ EXPORTS _ZN15QAnimationGroupD0Ev @ 705 NONAME _ZN15QAnimationGroupD1Ev @ 706 NONAME _ZN15QAnimationGroupD2Ev @ 707 NONAME - _ZN15QBasicAtomicInt20fetchAndStoreOrderedEi @ 708 NONAME + _ZN15QBasicAtomicInt20fetchAndStoreOrderedEi @ 708 NONAME ABSENT _ZN15QDateTimeParser11parseFormatERK7QString @ 709 NONAME _ZN15QLinkedListData11shared_nullE @ 710 NONAME DATA 20 _ZN15QObjectUserDataD0Ev @ 711 NONAME @@ -3566,7 +3566,7 @@ EXPORTS inflateSync @ 3565 NONAME inflateSyncPoint @ 3566 NONAME qMetaTypeGuiHelper @ 3567 NONAME DATA 4 - q_atomic_lock @ 3568 NONAME DATA 1 + q_atomic_lock @ 3568 NONAME DATA 1 ABSENT qt_addObject @ 3569 NONAME qt_global_mutexpool @ 3570 NONAME DATA 4 qt_locale_initialized @ 3571 NONAME DATA 1 -- cgit v0.12 From d92084a576c0f85e64da7ac5c1a51bfb0969af75 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Fri, 6 Nov 2009 13:44:04 +0100 Subject: Fix functions that return whether atomics are natives following review comments Reviewed-By: Brad --- src/corelib/arch/qatomic_symbian.h | 31 ++++++-------- src/corelib/arch/symbian/qatomic_symbian.cpp | 63 ++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 18 deletions(-) diff --git a/src/corelib/arch/qatomic_symbian.h b/src/corelib/arch/qatomic_symbian.h index 571f628..92f6ef9 100644 --- a/src/corelib/arch/qatomic_symbian.h +++ b/src/corelib/arch/qatomic_symbian.h @@ -51,57 +51,52 @@ QT_BEGIN_NAMESPACE QT_MODULE(Core) -#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE +#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isReferenceCountingNative() -{ return false; } inline bool QBasicAtomicInt::isReferenceCountingWaitFree() { return false; } -#define Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE +#define Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isTestAndSetNative() -{ return false; } inline bool QBasicAtomicInt::isTestAndSetWaitFree() { return false; } -#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE +#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isFetchAndStoreNative() -{ return false; } inline bool QBasicAtomicInt::isFetchAndStoreWaitFree() { return false; } -#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE +#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isFetchAndAddNative() -{ return false; } inline bool QBasicAtomicInt::isFetchAndAddWaitFree() { return false; } -#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_NOT_NATIVE +#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_SOMETIMES_NATIVE +Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative(); template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetNative() -{ return false; } +{ return QBasicAtomicPointer_isTestAndSetNative(); } template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetWaitFree() { return false; } -#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_NOT_NATIVE +#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_SOMETIMES_NATIVE +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative(); template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreNative() -{ return false; } +{ return QBasicAtomicPointer_isFetchAndStoreNative(); } template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreWaitFree() { return false; } -#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_NOT_NATIVE +#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_SOMETIMES_NATIVE +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative(); template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddNative() -{ return false; } +{ return QBasicAtomicPointer_isFetchAndAddNative(); } template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() { return false; } diff --git a/src/corelib/arch/symbian/qatomic_symbian.cpp b/src/corelib/arch/symbian/qatomic_symbian.cpp index 2ab5ae9..91b49c7 100644 --- a/src/corelib/arch/symbian/qatomic_symbian.cpp +++ b/src/corelib/arch/symbian/qatomic_symbian.cpp @@ -77,6 +77,69 @@ struct QSymbianPrintExitInfo TInt initThreadHandleCount; } symbian_printExitInfo; +Q_CORE_EXPORT bool QBasicAtomicInt::isReferenceCountingNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicInt::isTestAndSetNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndStoreNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndAddNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + //For ARMv6, the generic atomics are machine coded #ifndef QT_HAVE_ARMV6 -- cgit v0.12 From d34cd74f7f338a85a72e192766c5973264f7c208 Mon Sep 17 00:00:00 2001 From: Frans Englich Date: Fri, 6 Nov 2009 14:42:20 +0100 Subject: Fix qdoc errors in the MMF Phonon backend. Task-number: QTBUG-5355 Reviewed-by: TrustMe --- src/3rdparty/phonon/mmf/abstractaudioeffect.cpp | 4 ++++ src/3rdparty/phonon/mmf/ancestormovemonitor.cpp | 7 ++++++- src/3rdparty/phonon/mmf/utils.cpp | 16 ++++++++++++---- 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp b/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp index a793390..a559249 100644 --- a/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp +++ b/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp @@ -29,6 +29,10 @@ using namespace Phonon::MMF; \internal */ +/*! \namespace Phonon::MMF + \internal +*/ + AbstractAudioEffect::AbstractAudioEffect(QObject *parent, const QList ¶ms) : MediaNode::MediaNode(parent) , m_params(params) diff --git a/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp b/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp index 0447d57..18ced94 100644 --- a/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp +++ b/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp @@ -26,7 +26,7 @@ QT_BEGIN_NAMESPACE using namespace Phonon::MMF; -/*! \class MMF::AncestorMoveMonitor +/*! \class Phonon::MMF::AncestorMoveMonitor \internal \brief Class which installs a global event filter, and listens for move events which may affect the absolute position of widgets registered with @@ -34,6 +34,11 @@ using namespace Phonon::MMF; See QTBUG-4956 */ + +/*! \class Phonon::MMF::VideoOutputObserver + \internal +*/ + //----------------------------------------------------------------------------- // Constructor / destructor //----------------------------------------------------------------------------- diff --git a/src/3rdparty/phonon/mmf/utils.cpp b/src/3rdparty/phonon/mmf/utils.cpp index 58d1ece..d728fcf 100644 --- a/src/3rdparty/phonon/mmf/utils.cpp +++ b/src/3rdparty/phonon/mmf/utils.cpp @@ -24,16 +24,24 @@ QT_BEGIN_NAMESPACE using namespace Phonon; using namespace Phonon::MMF; -/*! \namespace MMF::Utils +/*! \namespace Phonon::MMF::Utils \internal */ -/*! \class MMF::TTraceContext +/*! \class Phonon::MMF::TTraceContext \internal */ -/*! \class MMF::Utils - \internal +/*! \enum Phonon::MMF::PanicCode + \internal +*/ + +/*! \enum Phonon::MMF::TTraceCategory + \internal +*/ + +/*! \enum Phonon::MMF::MediaType + \internal */ _LIT(PanicCategory, "Phonon::MMF"); -- cgit v0.12 From c92670dc8b2e5cf727c33943dde0755c17d0dac2 Mon Sep 17 00:00:00 2001 From: Tom Cooksey Date: Fri, 6 Nov 2009 15:12:36 +0100 Subject: Enable & fix qgl autotests on 16-bpp systems Introduce a fuzzy pixel and image compare which changes it's allowed fuzz based on the system's color depth. If the compared images are different, the autotests will also save the two images to the current directory for comparison. Reviewed-By: Samuel --- tests/auto/qgl/tst_qgl.cpp | 160 +++++++++++++++++++++++++++++++-------------- 1 file changed, 111 insertions(+), 49 deletions(-) diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp index c680dec..6286c30 100644 --- a/tests/auto/qgl/tst_qgl.cpp +++ b/tests/auto/qgl/tst_qgl.cpp @@ -711,6 +711,79 @@ void tst_QGL::openGLVersionCheck() #endif //QT_BUILD_INTERNAL } +static bool fuzzyComparePixels(const QRgb testPixel, const QRgb refPixel, const char* file, int line, int x = -1, int y = -1) +{ + static int maxFuzz = 1; + static bool maxFuzzSet = false; + + // On 16 bpp systems, we need to allow for more fuzz: + if (!maxFuzzSet) { + maxFuzzSet = true; + if (appDefaultDepth() < 24) + maxFuzz = 32; + } + + int redFuzz = qAbs(qRed(testPixel) - qRed(refPixel)); + int greenFuzz = qAbs(qGreen(testPixel) - qGreen(refPixel)); + int blueFuzz = qAbs(qBlue(testPixel) - qBlue(refPixel)); + int alphaFuzz = qAbs(qAlpha(testPixel) - qAlpha(refPixel)); + + if (refPixel != 0 && testPixel == 0) { + QString msg; + if (x >= 0) { + msg = QString("Test pixel [%1, %2] is null (black) when it should be (%3,%4,%5,%6)") + .arg(x).arg(y) + .arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel)); + } else { + msg = QString("Test pixel is null (black) when it should be (%2,%3,%4,%5)") + .arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel)); + } + + QTest::qFail(msg.toLatin1(), file, line); + return false; + } + + if (redFuzz > maxFuzz || greenFuzz > maxFuzz || blueFuzz > maxFuzz || alphaFuzz > maxFuzz) { + QString msg; + + if (x >= 0) + msg = QString("Pixel [%1,%2]: ").arg(x).arg(y); + else + msg = QString("Pixel "); + + msg += QString("Max fuzz (%1) exceeded: (%2,%3,%4,%5) vs (%6,%7,%8,%9)") + .arg(maxFuzz) + .arg(qRed(testPixel)).arg(qGreen(testPixel)).arg(qBlue(testPixel)).arg(qAlpha(testPixel)) + .arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel)); + QTest::qFail(msg.toLatin1(), file, line); + return false; + } + return true; +} + +static void fuzzyCompareImages(const QImage &testImage, const QImage &referenceImage, const char* file, int line) +{ + QCOMPARE(testImage.width(), referenceImage.width()); + QCOMPARE(testImage.height(), referenceImage.height()); + + for (int y = 0; y < testImage.height(); y++) { + for (int x = 0; x < testImage.width(); x++) { + if (!fuzzyComparePixels(testImage.pixel(x, y), referenceImage.pixel(x, y), file, line, x, y)) { + // Might as well save the images for easier debugging: + referenceImage.save("referenceImage.png"); + testImage.save("testImage.png"); + return; + } + } + } +} + +#define QFUZZY_COMPARE_IMAGES(A,B) \ + fuzzyCompareImages(A, B, __FILE__, __LINE__) + +#define QFUZZY_COMPARE_PIXELS(A,B) \ + fuzzyComparePixels(A, B, __FILE__, __LINE__) + class UnclippedWidget : public QWidget { public: @@ -723,8 +796,6 @@ public: void tst_QGL::graphicsViewClipping() { - if (appDefaultDepth() < 24) - QSKIP("This test won't work for bit depths < 24", SkipAll); const int size = 64; UnclippedWidget *widget = new UnclippedWidget; widget->setFixedSize(size, size); @@ -758,7 +829,7 @@ void tst_QGL::graphicsViewClipping() p.fillRect(QRect(0, 0, size, size), Qt::black); p.end(); - QCOMPARE(image, expected); + QFUZZY_COMPARE_IMAGES(image, expected); } void tst_QGL::partialGLWidgetUpdates_data() @@ -849,7 +920,7 @@ void tst_QGL::glPBufferRendering() p.fillRect(32, 32, 64, 64, Qt::blue); p.end(); - QCOMPARE(fb, reference); + QFUZZY_COMPARE_IMAGES(fb, reference); } class GLWidget : public QGLWidget @@ -877,9 +948,8 @@ public: void tst_QGL::glWidgetRendering() { - if (appDefaultDepth() < 24) - QSKIP("This test won't work for bit depths < 24", SkipAll); GLWidget w; + w.setGeometry(100, 100, 200, 200); w.show(); #ifdef Q_WS_X11 @@ -894,7 +964,7 @@ void tst_QGL::glWidgetRendering() QImage reference(fb.size(), QImage::Format_RGB32); reference.fill(0xffff0000); - QCOMPARE(fb, reference); + QFUZZY_COMPARE_IMAGES(fb, reference); } // NOTE: This tests that CombinedDepthStencil attachment works by assuming the @@ -949,14 +1019,14 @@ void tst_QGL::glFBORendering() // As we're doing more than trivial painting, we can't just compare to // an image rendered with raster. Instead, we sample at well-defined // test-points: - QCOMPARE(fb.pixel(39, 64), QColor(Qt::red).rgb()); - QCOMPARE(fb.pixel(89, 64), QColor(Qt::red).rgb()); - QCOMPARE(fb.pixel(64, 39), QColor(Qt::blue).rgb()); - QCOMPARE(fb.pixel(64, 89), QColor(Qt::blue).rgb()); - - QCOMPARE(fb.pixel(167, 39), QColor(Qt::red).rgb()); - QCOMPARE(fb.pixel(217, 39), QColor(Qt::red).rgb()); - QCOMPARE(fb.pixel(192, 64), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb.pixel(39, 64), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb.pixel(89, 64), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb.pixel(64, 39), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb.pixel(64, 89), QColor(Qt::blue).rgb()); + + QFUZZY_COMPARE_PIXELS(fb.pixel(167, 39), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb.pixel(217, 39), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb.pixel(192, 64), QColor(Qt::green).rgb()); } @@ -1047,29 +1117,29 @@ void tst_QGL::multipleFBOInterleavedRendering() // As we're doing more than trivial painting, we can't just compare to // an image rendered with raster. Instead, we sample at well-defined // test-points: - QCOMPARE(fb1.pixel(39, 64), QColor(Qt::red).rgb()); - QCOMPARE(fb1.pixel(89, 64), QColor(Qt::red).rgb()); - QCOMPARE(fb1.pixel(64, 39), QColor(Qt::blue).rgb()); - QCOMPARE(fb1.pixel(64, 89), QColor(Qt::blue).rgb()); - QCOMPARE(fb1.pixel(167, 39), QColor(Qt::red).rgb()); - QCOMPARE(fb1.pixel(217, 39), QColor(Qt::red).rgb()); - QCOMPARE(fb1.pixel(192, 64), QColor(Qt::green).rgb()); - - QCOMPARE(fb2.pixel(39, 64), QColor(Qt::green).rgb()); - QCOMPARE(fb2.pixel(89, 64), QColor(Qt::green).rgb()); - QCOMPARE(fb2.pixel(64, 39), QColor(Qt::red).rgb()); - QCOMPARE(fb2.pixel(64, 89), QColor(Qt::red).rgb()); - QCOMPARE(fb2.pixel(167, 39), QColor(Qt::green).rgb()); - QCOMPARE(fb2.pixel(217, 39), QColor(Qt::green).rgb()); - QCOMPARE(fb2.pixel(192, 64), QColor(Qt::blue).rgb()); - - QCOMPARE(fb3.pixel(39, 64), QColor(Qt::blue).rgb()); - QCOMPARE(fb3.pixel(89, 64), QColor(Qt::blue).rgb()); - QCOMPARE(fb3.pixel(64, 39), QColor(Qt::green).rgb()); - QCOMPARE(fb3.pixel(64, 89), QColor(Qt::green).rgb()); - QCOMPARE(fb3.pixel(167, 39), QColor(Qt::blue).rgb()); - QCOMPARE(fb3.pixel(217, 39), QColor(Qt::blue).rgb()); - QCOMPARE(fb3.pixel(192, 64), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(39, 64), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(89, 64), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(64, 39), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(64, 89), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(167, 39), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(217, 39), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb1.pixel(192, 64), QColor(Qt::green).rgb()); + + QFUZZY_COMPARE_PIXELS(fb2.pixel(39, 64), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb2.pixel(89, 64), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb2.pixel(64, 39), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb2.pixel(64, 89), QColor(Qt::red).rgb()); + QFUZZY_COMPARE_PIXELS(fb2.pixel(167, 39), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb2.pixel(217, 39), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb2.pixel(192, 64), QColor(Qt::blue).rgb()); + + QFUZZY_COMPARE_PIXELS(fb3.pixel(39, 64), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb3.pixel(89, 64), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb3.pixel(64, 39), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb3.pixel(64, 89), QColor(Qt::green).rgb()); + QFUZZY_COMPARE_PIXELS(fb3.pixel(167, 39), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb3.pixel(217, 39), QColor(Qt::blue).rgb()); + QFUZZY_COMPARE_PIXELS(fb3.pixel(192, 64), QColor(Qt::red).rgb()); } class FBOUseInGLWidget : public QGLWidget @@ -1102,8 +1172,6 @@ protected: void tst_QGL::glFBOUseInGLWidget() { - if (appDefaultDepth() < 24) - QSKIP("This test won't work for bit depths < 24", SkipAll); if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()) QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle); @@ -1122,17 +1190,15 @@ void tst_QGL::glFBOUseInGLWidget() QImage widgetFB = w.grabFrameBuffer(false); QImage widgetReference(widgetFB.size(), widgetFB.format()); widgetReference.fill(0xff0000ff); - QCOMPARE(widgetFB, widgetReference); + QFUZZY_COMPARE_IMAGES(widgetFB, widgetReference); QImage fboReference(w.fboImage.size(), w.fboImage.format()); fboReference.fill(0xffff0000); - QCOMPARE(w.fboImage, fboReference); + QFUZZY_COMPARE_IMAGES(w.fboImage, fboReference); } void tst_QGL::glWidgetReparent() { - if (appDefaultDepth() < 24) - QSKIP("This test won't work for bit depths < 24", SkipAll); // Try it as a top-level first: GLWidget *widget = new GLWidget; widget->setGeometry(0, 0, 200, 30); @@ -1222,7 +1288,7 @@ void tst_QGL::glWidgetRenderPixmap() QImage reference(fb.size(), QImage::Format_RGB32); reference.fill(0xffff0000); - QCOMPARE(fb, reference); + QFUZZY_COMPARE_IMAGES(fb, reference); } class ColormapExtended : public QGLColormap @@ -1495,8 +1561,6 @@ protected: void tst_QGL::replaceClipping() { - if (appDefaultDepth() < 24) - QSKIP("This test won't work for bit depths < 24", SkipAll); ReplaceClippingGLWidget glw; glw.resize(300, 300); glw.show(); @@ -1622,8 +1686,6 @@ protected: void tst_QGL::clipTest() { - if (appDefaultDepth() < 24) - QSKIP("This test won't work for bit depths < 24", SkipAll); ClipTestGLWidget glw; glw.resize(220, 220); glw.show(); -- cgit v0.12 From 18a3daf86118bd23a28f05fcf1721969c4ba491b Mon Sep 17 00:00:00 2001 From: Tom Cooksey Date: Fri, 6 Nov 2009 15:18:13 +0100 Subject: Make qgl autotests more stable & passing in test farm There were problems with false-failures due to the test farm's GL implementation having off-by-one pixel errors. To fix this, we don't compare every pixel but rather sample pixels in a grid pattern which avoids boundries. Reviewed-By: Samuel --- tests/auto/qgl/tst_qgl.cpp | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp index 6286c30..2c60eb2 100644 --- a/tests/auto/qgl/tst_qgl.cpp +++ b/tests/auto/qgl/tst_qgl.cpp @@ -939,8 +939,8 @@ public: // This test only ensures it's possible to paint onto a QGLWidget. Full // paint engine feature testing is way out of scope! + p.fillRect(-1, -1, width()+2, height()+2, Qt::red); - p.fillRect(0, 0, width(), height(), Qt::red); // No p.end() or swap buffers, should be done automatically } @@ -1159,11 +1159,11 @@ protected: QPainter fboPainter; fboPainterBeginOk = fboPainter.begin(fbo); - fboPainter.fillRect(0, 0, 128, 128, Qt::red); + fboPainter.fillRect(-1, -1, 130, 130, Qt::red); fboPainter.end(); fboImage = fbo->toImage(); - widgetPainter.fillRect(rect(), Qt::blue); + widgetPainter.fillRect(-1, -1, width()+2, width()+2, Qt::blue); delete fbo; } @@ -1577,7 +1577,13 @@ void tst_QGL::replaceClipping() const QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32); - QCOMPARE(widgetFB, reference); + // Sample pixels in a grid pattern which avoids false failures due to + // off-by-one pixel errors on some buggy GL implementations + for (int x = 25; x < reference.width(); x += 50) { + for (int y = 25; y < reference.width(); y += 50) { + QFUZZY_COMPARE_PIXELS(widgetFB.pixel(x, y), reference.pixel(x, y)); + } + } } class ClipTestGLWidget : public QGLWidget @@ -1585,7 +1591,7 @@ class ClipTestGLWidget : public QGLWidget public: void paint(QPainter *painter) { - painter->fillRect(rect(), Qt::white); + painter->fillRect(-1, -1, width()+2, height()+2, Qt::white); painter->setClipRect(10, 10, width()-20, height()-20); painter->fillRect(rect(), Qt::cyan); @@ -1702,7 +1708,13 @@ void tst_QGL::clipTest() const QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32); - QCOMPARE(widgetFB, reference); + // Sample pixels in a grid pattern which avoids false failures due to + // off-by-one pixel errors on some buggy GL implementations + for (int x = 2; x < reference.width(); x += 5) { + for (int y = 2; y < reference.width(); y += 5) { + QFUZZY_COMPARE_PIXELS(widgetFB.pixel(x, y), reference.pixel(x, y)); + } + } } void tst_QGL::destroyFBOAfterContext() -- cgit v0.12 From 03b19519768b504e5c7f5fd3923a14591e58b365 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Fri, 6 Nov 2009 16:07:58 +0100 Subject: Update def files Reviewed-by: Trust Me --- src/s60installs/bwins/QtCoreu.def | 18 ++-- src/s60installs/bwins/QtGuiu.def | 141 +++++++++++++++++++++----------- src/s60installs/bwins/QtMultimediau.def | 31 ++++--- src/s60installs/eabi/QtCoreu.def | 19 ++++- src/s60installs/eabi/QtGuiu.def | 79 ++++++++++++------ src/s60installs/eabi/QtMultimediau.def | 31 ++++--- 6 files changed, 219 insertions(+), 100 deletions(-) diff --git a/src/s60installs/bwins/QtCoreu.def b/src/s60installs/bwins/QtCoreu.def index 9d3db41..a787be9 100644 --- a/src/s60installs/bwins/QtCoreu.def +++ b/src/s60installs/bwins/QtCoreu.def @@ -153,7 +153,7 @@ EXPORTS ?trimmed@QByteArray@@QBE?AV1@XZ @ 152 NONAME ; class QByteArray QByteArray::trimmed(void) const ??1QObjectUserData@@UAE@XZ @ 153 NONAME ; QObjectUserData::~QObjectUserData(void) ?event@QAbstractState@@MAE_NPAVQEvent@@@Z @ 154 NONAME ; bool QAbstractState::event(class QEvent *) - ?qShapeItem@@YAEPAUHB_ShaperItem@@@Z @ 155 NONAME ; unsigned char qShapeItem(struct HB_ShaperItem *) + ?qShapeItem@@YAEPAUHB_ShaperItem@@@Z @ 155 NONAME ABSENT ; unsigned char qShapeItem(struct HB_ShaperItem *) ??9QLocale@@QBE_NABV0@@Z @ 156 NONAME ; bool QLocale::operator!=(class QLocale const &) const ?started@QThread@@IAEXXZ @ 157 NONAME ; void QThread::started(void) ?postEvent@QStateMachine@@QAEXPAVQEvent@@W4EventPriority@1@@Z @ 158 NONAME ; void QStateMachine::postEvent(class QEvent *, enum QStateMachine::EventPriority) @@ -235,7 +235,7 @@ EXPORTS ?columnsInserted@QAbstractItemModel@@AAEXABVQModelIndex@@HH@Z @ 234 NONAME ; void QAbstractItemModel::columnsInserted(class QModelIndex const &, int, int) ?getStaticMetaObject@QState@@SAABUQMetaObject@@XZ @ 235 NONAME ; struct QMetaObject const & QState::getStaticMetaObject(void) ?getStaticMetaObject@QAnimationGroup@@SAABUQMetaObject@@XZ @ 236 NONAME ; struct QMetaObject const & QAnimationGroup::getStaticMetaObject(void) - ?setAnimationsEnabled@QStateMachine@@QAEX_N@Z @ 237 NONAME ; void QStateMachine::setAnimationsEnabled(bool) + ?setAnimationsEnabled@QStateMachine@@QAEX_N@Z @ 237 NONAME ABSENT ; void QStateMachine::setAnimationsEnabled(bool) ??MQLatin1String@@QBE_NABVQString@@@Z @ 238 NONAME ; bool QLatin1String::operator<(class QString const &) const ?contains@QSettings@@QBE_NABVQString@@@Z @ 239 NONAME ; bool QSettings::contains(class QString const &) const ?wrap@QNonContiguousByteDeviceFactory@@SAPAVQIODevice@@PAVQNonContiguousByteDevice@@@Z @ 240 NONAME ; class QIODevice * QNonContiguousByteDeviceFactory::wrap(class QNonContiguousByteDevice *) @@ -724,7 +724,7 @@ EXPORTS ?fileEngine@QFile@@UBEPAVQAbstractFileEngine@@XZ @ 723 NONAME ; class QAbstractFileEngine * QFile::fileEngine(void) const ??1QAbstractState@@UAE@XZ @ 724 NONAME ; QAbstractState::~QAbstractState(void) ?resume@QAbstractAnimation@@QAEXXZ @ 725 NONAME ; void QAbstractAnimation::resume(void) - ?addTransition@QState@@QAEPAVQAbstractTransition@@PAV2@@Z @ 726 NONAME ; class QAbstractTransition * QState::addTransition(class QAbstractTransition *) + ?addTransition@QState@@QAEPAVQAbstractTransition@@PAV2@@Z @ 726 NONAME ABSENT ; class QAbstractTransition * QState::addTransition(class QAbstractTransition *) ?rowsRemoved@QAbstractItemModel@@AAEXABVQModelIndex@@HH@Z @ 727 NONAME ; void QAbstractItemModel::rowsRemoved(class QModelIndex const &, int, int) ?intersects@QRect@@QBE_NABV1@@Z @ 728 NONAME ; bool QRect::intersects(class QRect const &) const ?size@QRect@@QBE?AVQSize@@XZ @ 729 NONAME ; class QSize QRect::size(void) const @@ -1449,7 +1449,7 @@ EXPORTS ??0QTextStreamManipulator@@QAE@P8QTextStream@@AEXVQChar@@@Z0@Z @ 1448 NONAME ; QTextStreamManipulator::QTextStreamManipulator(void (*)(class QChar), class QChar) ??6QDebug@@QAEAAV0@PBX@Z @ 1449 NONAME ; class QDebug & QDebug::operator<<(void const *) ?d_func@QXmlStreamWriter@@AAEPAVQXmlStreamWriterPrivate@@XZ @ 1450 NONAME ; class QXmlStreamWriterPrivate * QXmlStreamWriter::d_func(void) - ?animationsEnabled@QStateMachine@@QBE_NXZ @ 1451 NONAME ; bool QStateMachine::animationsEnabled(void) const + ?animationsEnabled@QStateMachine@@QBE_NXZ @ 1451 NONAME ABSENT ; bool QStateMachine::animationsEnabled(void) const ?scale@QSize@@QAEXHHW4AspectRatioMode@Qt@@@Z @ 1452 NONAME ; void QSize::scale(int, int, enum Qt::AspectRatioMode) ?fileFlags@QFSFileEngine@@UBE?AV?$QFlags@W4FileFlag@QAbstractFileEngine@@@@V2@@Z @ 1453 NONAME ; class QFlags QFSFileEngine::fileFlags(class QFlags) const ??1QReadLocker@@QAE@XZ @ 1454 NONAME ; QReadLocker::~QReadLocker(void) @@ -2195,7 +2195,7 @@ EXPORTS ??0QString@@QAE@VQChar@@@Z @ 2194 NONAME ; QString::QString(class QChar) ?namespaceUri@QXmlStreamNamespaceDeclaration@@QBE?AVQStringRef@@XZ @ 2195 NONAME ; class QStringRef QXmlStreamNamespaceDeclaration::namespaceUri(void) const ?patternSyntax@QRegExp@@QBE?AW4PatternSyntax@1@XZ @ 2196 NONAME ; enum QRegExp::PatternSyntax QRegExp::patternSyntax(void) const - ?polished@QState@@IAEXXZ @ 2197 NONAME ; void QState::polished(void) + ?polished@QState@@IAEXXZ @ 2197 NONAME ABSENT ; void QState::polished(void) ?finished@QProcess@@IAEXHW4ExitStatus@1@@Z @ 2198 NONAME ; void QProcess::finished(int, enum QProcess::ExitStatus) ?autoRemove@QTemporaryFile@@QBE_NXZ @ 2199 NONAME ; bool QTemporaryFile::autoRemove(void) const ?createLocalFile@QTemporaryFile@@SAPAV1@AAVQFile@@@Z @ 2200 NONAME ; class QTemporaryFile * QTemporaryFile::createLocalFile(class QFile &) @@ -4380,4 +4380,12 @@ EXPORTS ?toHistoryState@QStateMachinePrivate@@SAPAVQHistoryState@@PAVQAbstractState@@@Z @ 4379 NONAME ; class QHistoryState * QStateMachinePrivate::toHistoryState(class QAbstractState *) ?toStandardState@QStateMachinePrivate@@SAPAVQState@@PAVQAbstractState@@@Z @ 4380 NONAME ; class QState * QStateMachinePrivate::toStandardState(class QAbstractState *) ?toStandardState@QStateMachinePrivate@@SAPBVQState@@PBVQAbstractState@@@Z @ 4381 NONAME ; class QState const * QStateMachinePrivate::toStandardState(class QAbstractState const *) + ?QBasicAtomicPointer_isFetchAndAddNative@@YA_NXZ @ 4382 NONAME ; bool QBasicAtomicPointer_isFetchAndAddNative(void) + ?QBasicAtomicPointer_isFetchAndStoreNative@@YA_NXZ @ 4383 NONAME ; bool QBasicAtomicPointer_isFetchAndStoreNative(void) + ?QBasicAtomicPointer_isTestAndSetNative@@YA_NXZ @ 4384 NONAME ; bool QBasicAtomicPointer_isTestAndSetNative(void) + ?addTransition@QState@@QAEXPAVQAbstractTransition@@@Z @ 4385 NONAME ; void QState::addTransition(class QAbstractTransition *) + ?isAnimated@QStateMachine@@QBE_NXZ @ 4386 NONAME ; bool QStateMachine::isAnimated(void) const + ?propertiesAssigned@QState@@IAEXXZ @ 4387 NONAME ; void QState::propertiesAssigned(void) + ?qShapeItem@@YAEPAUHB_ShaperItem_@@@Z @ 4388 NONAME ; unsigned char qShapeItem(struct HB_ShaperItem_ *) + ?setAnimated@QStateMachine@@QAEX_N@Z @ 4389 NONAME ; void QStateMachine::setAnimated(bool) diff --git a/src/s60installs/bwins/QtGuiu.def b/src/s60installs/bwins/QtGuiu.def index 69a95f0..2728210 100644 --- a/src/s60installs/bwins/QtGuiu.def +++ b/src/s60installs/bwins/QtGuiu.def @@ -168,7 +168,7 @@ EXPORTS ?changeEvent@QMenuBar@@MAEXPAVQEvent@@@Z @ 167 NONAME ; void QMenuBar::changeEvent(class QEvent *) ?tr@QActionGroup@@SA?AVQString@@PBD0@Z @ 168 NONAME ; class QString QActionGroup::tr(char const *, char const *) ?messageChanged@QStatusBar@@IAEXABVQString@@@Z @ 169 NONAME ; void QStatusBar::messageChanged(class QString const &) - ?mapToScene@QGestureEvent@@QBE?AVQPointF@@ABV2@@Z @ 170 NONAME ; class QPointF QGestureEvent::mapToScene(class QPointF const &) const + ?mapToScene@QGestureEvent@@QBE?AVQPointF@@ABV2@@Z @ 170 NONAME ABSENT ; class QPointF QGestureEvent::mapToScene(class QPointF const &) const ?quality@QImageWriter@@QBEHXZ @ 171 NONAME ; int QImageWriter::quality(void) const ?setGeometry@QSpacerItem@@UAEXABVQRect@@@Z @ 172 NONAME ; void QSpacerItem::setGeometry(class QRect const &) ?isActive@QGraphicsItem@@QBE_NXZ @ 173 NONAME ; bool QGraphicsItem::isActive(void) const @@ -260,7 +260,7 @@ EXPORTS ?gridSize@QListView@@QBE?AVQSize@@XZ @ 259 NONAME ; class QSize QListView::gridSize(void) const ?staticMetaObject@QStylePlugin@@2UQMetaObject@@B @ 260 NONAME ; struct QMetaObject const QStylePlugin::staticMetaObject ??8QFontMetricsF@@QBE_NABV0@@Z @ 261 NONAME ; bool QFontMetricsF::operator==(class QFontMetricsF const &) const - ?perspective@QMatrix4x4@@QAEAAV1@MMMM@Z @ 262 NONAME ; class QMatrix4x4 & QMatrix4x4::perspective(float, float, float, float) + ?perspective@QMatrix4x4@@QAEAAV1@MMMM@Z @ 262 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::perspective(float, float, float, float) ?isScaling@QTransform@@QBE_NXZ @ 263 NONAME ; bool QTransform::isScaling(void) const ?drawLines@QPainter@@QAEXABV?$QVector@VQPointF@@@@@Z @ 264 NONAME ; void QPainter::drawLines(class QVector const &) ??0QCloseEvent@@QAE@XZ @ 265 NONAME ; QCloseEvent::QCloseEvent(void) @@ -303,7 +303,7 @@ EXPORTS ?mode@QColormap@@QBE?AW4Mode@1@XZ @ 302 NONAME ; enum QColormap::Mode QColormap::mode(void) const ??_EQGraphicsOpacityEffect@@UAE@I@Z @ 303 NONAME ; QGraphicsOpacityEffect::~QGraphicsOpacityEffect(unsigned int) ?clearColumnWidthConstraints@QTextTableFormat@@QAEXXZ @ 304 NONAME ; void QTextTableFormat::clearColumnWidthConstraints(void) - ?setModifiersMask@QMouseEventTransition@@QAEXV?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 305 NONAME ; void QMouseEventTransition::setModifiersMask(class QFlags) + ?setModifiersMask@QMouseEventTransition@@QAEXV?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 305 NONAME ABSENT ; void QMouseEventTransition::setModifiersMask(class QFlags) ?setColor@QBrush@@QAEXW4GlobalColor@Qt@@@Z @ 306 NONAME ; void QBrush::setColor(enum Qt::GlobalColor) ?setBrush@QAbstractGraphicsShapeItem@@QAEXABVQBrush@@@Z @ 307 NONAME ; void QAbstractGraphicsShapeItem::setBrush(class QBrush const &) ?sort@QFileSystemModel@@UAEXHW4SortOrder@Qt@@@Z @ 308 NONAME ; void QFileSystemModel::sort(int, enum Qt::SortOrder) @@ -576,7 +576,7 @@ EXPORTS ?showEvent@QMdiSubWindow@@MAEXPAVQShowEvent@@@Z @ 575 NONAME ; void QMdiSubWindow::showEvent(class QShowEvent *) ?setPageSize@QTextDocument@@QAEXABVQSizeF@@@Z @ 576 NONAME ; void QTextDocument::setPageSize(class QSizeF const &) ?selectAll@QTextControl@@QAEXXZ @ 577 NONAME ; void QTextControl::selectAll(void) - ?rotate@QMatrix4x4@@QAEAAV1@ABVQQuaternion@@@Z @ 578 NONAME ; class QMatrix4x4 & QMatrix4x4::rotate(class QQuaternion const &) + ?rotate@QMatrix4x4@@QAEAAV1@ABVQQuaternion@@@Z @ 578 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::rotate(class QQuaternion const &) ?setFont@QStandardItem@@QAEXABVQFont@@@Z @ 579 NONAME ; void QStandardItem::setFont(class QFont const &) ?checkOverflow@QLCDNumber@@QBE_NN@Z @ 580 NONAME ; bool QLCDNumber::checkOverflow(double) const ?dropMimeData@QTreeWidget@@MAE_NPAVQTreeWidgetItem@@HPBVQMimeData@@W4DropAction@Qt@@@Z @ 581 NONAME ; bool QTreeWidget::dropMimeData(class QTreeWidgetItem *, int, class QMimeData const *, enum Qt::DropAction) @@ -1031,14 +1031,14 @@ EXPORTS ?tr@QComboBox@@SA?AVQString@@PBD0H@Z @ 1030 NONAME ; class QString QComboBox::tr(char const *, char const *, int) ?setModel@QCompleter@@QAEXPAVQAbstractItemModel@@@Z @ 1031 NONAME ; void QCompleter::setModel(class QAbstractItemModel *) ?accept@QDragMoveEvent@@QAEXABVQRect@@@Z @ 1032 NONAME ; void QDragMoveEvent::accept(class QRect const &) - ?totalOffset@QPanGesture@@QBE?AVQPointF@@XZ @ 1033 NONAME ; class QPointF QPanGesture::totalOffset(void) const + ?totalOffset@QPanGesture@@QBE?AVQPointF@@XZ @ 1033 NONAME ABSENT ; class QPointF QPanGesture::totalOffset(void) const ?trUtf8@QUndoStack@@SA?AVQString@@PBD0H@Z @ 1034 NONAME ; class QString QUndoStack::trUtf8(char const *, char const *, int) ?d_func@QStyledItemDelegate@@ABEPBVQStyledItemDelegatePrivate@@XZ @ 1035 NONAME ; class QStyledItemDelegatePrivate const * QStyledItemDelegate::d_func(void) const ?staticMetaObject@QIconEnginePluginV2@@2UQMetaObject@@B @ 1036 NONAME ; struct QMetaObject const QIconEnginePluginV2::staticMetaObject ?geometriesChanged@QHeaderView@@IAEXXZ @ 1037 NONAME ; void QHeaderView::geometriesChanged(void) ?rawMode@QFont@@QBE_NXZ @ 1038 NONAME ; bool QFont::rawMode(void) const ??4QTreeWidgetItemIterator@@QAEAAV0@ABV0@@Z @ 1039 NONAME ; class QTreeWidgetItemIterator & QTreeWidgetItemIterator::operator=(class QTreeWidgetItemIterator const &) - ?whatChanged@QPinchGesture@@QBE?AV?$QFlags@W4WhatChange@QPinchGesture@@@@XZ @ 1040 NONAME ; class QFlags QPinchGesture::whatChanged(void) const + ?whatChanged@QPinchGesture@@QBE?AV?$QFlags@W4WhatChange@QPinchGesture@@@@XZ @ 1040 NONAME ABSENT ; class QFlags QPinchGesture::whatChanged(void) const ?actionTriggered@QAbstractSlider@@IAEXH@Z @ 1041 NONAME ; void QAbstractSlider::actionTriggered(int) ?setDirectory@QFileDialog@@QAEXABVQString@@@Z @ 1042 NONAME ; void QFileDialog::setDirectory(class QString const &) ??YQVector2D@@QAEAAV0@ABV0@@Z @ 1043 NONAME ; class QVector2D & QVector2D::operator+=(class QVector2D const &) @@ -1794,7 +1794,7 @@ EXPORTS ?setBorderBrush@QTextFrameFormat@@QAEXABVQBrush@@@Z @ 1793 NONAME ; void QTextFrameFormat::setBorderBrush(class QBrush const &) ?isMovable@QTabBar@@QBE_NXZ @ 1794 NONAME ; bool QTabBar::isMovable(void) const ?columnCount@QStandardItemModel@@UBEHABVQModelIndex@@@Z @ 1795 NONAME ; int QStandardItemModel::columnCount(class QModelIndex const &) const - ?rotate@QMatrix4x4@@QAEAAV1@MMMM@Z @ 1796 NONAME ; class QMatrix4x4 & QMatrix4x4::rotate(float, float, float, float) + ?rotate@QMatrix4x4@@QAEAAV1@MMMM@Z @ 1796 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::rotate(float, float, float, float) ?alignment@QTextTableFormat@@QBE?AV?$QFlags@W4AlignmentFlag@Qt@@@@XZ @ 1797 NONAME ; class QFlags QTextTableFormat::alignment(void) const ?copy@QRegion@@ABE?AV1@XZ @ 1798 NONAME ; class QRegion QRegion::copy(void) const ?height@QLineControl@@QBEHXZ @ 1799 NONAME ; int QLineControl::height(void) const @@ -2018,7 +2018,7 @@ EXPORTS ?getOpenFileNames@QFileDialog@@SA?AVQStringList@@PAVQWidget@@ABVQString@@11PAV4@V?$QFlags@W4Option@QFileDialog@@@@@Z @ 2017 NONAME ; class QStringList QFileDialog::getOpenFileNames(class QWidget *, class QString const &, class QString const &, class QString const &, class QString *, class QFlags) ?qt_filedialog_save_filename_hook@@3P6A?AVQString@@PAVQWidget@@ABV1@11PAV1@V?$QFlags@W4Option@QFileDialog@@@@@ZA @ 2018 NONAME ; class QString (*qt_filedialog_save_filename_hook)(class QWidget *, class QString const &, class QString const &, class QString const &, class QString *, class QFlags) ?getStaticMetaObject@QTextObject@@SAABUQMetaObject@@XZ @ 2019 NONAME ; struct QMetaObject const & QTextObject::getStaticMetaObject(void) - ?ortho@QMatrix4x4@@QAEAAV1@MMMMMM@Z @ 2020 NONAME ; class QMatrix4x4 & QMatrix4x4::ortho(float, float, float, float, float, float) + ?ortho@QMatrix4x4@@QAEAAV1@MMMMMM@Z @ 2020 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::ortho(float, float, float, float, float, float) ?textAlignment@QStandardItem@@QBE?AV?$QFlags@W4AlignmentFlag@Qt@@@@XZ @ 2021 NONAME ; class QFlags QStandardItem::textAlignment(void) const ?source@QGraphicsEffect@@QBEPAVQGraphicsEffectSource@@XZ @ 2022 NONAME ; class QGraphicsEffectSource * QGraphicsEffect::source(void) const ??0QBitmap@@QAE@XZ @ 2023 NONAME ; QBitmap::QBitmap(void) @@ -3598,7 +3598,7 @@ EXPORTS ?data@QListWidgetItem@@UBE?AVQVariant@@H@Z @ 3597 NONAME ; class QVariant QListWidgetItem::data(int) const ?metaObject@QEventDispatcherS60@@UBEPBUQMetaObject@@XZ @ 3598 NONAME ; struct QMetaObject const * QEventDispatcherS60::metaObject(void) const ?setIntStep@QInputDialog@@QAEXH@Z @ 3599 NONAME ; void QInputDialog::setIntStep(int) - ?modifiersMask@QKeyEventTransition@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 3600 NONAME ; class QFlags QKeyEventTransition::modifiersMask(void) const + ?modifiersMask@QKeyEventTransition@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 3600 NONAME ABSENT ; class QFlags QKeyEventTransition::modifiersMask(void) const ?metaObject@QSessionManager@@UBEPBUQMetaObject@@XZ @ 3601 NONAME ; struct QMetaObject const * QSessionManager::metaObject(void) const ??0QGraphicsItem@@IAE@AAVQGraphicsItemPrivate@@PAV0@PAVQGraphicsScene@@@Z @ 3602 NONAME ; QGraphicsItem::QGraphicsItem(class QGraphicsItemPrivate &, class QGraphicsItem *, class QGraphicsScene *) ?insertPermanentWidget@QStatusBar@@QAEHHPAVQWidget@@H@Z @ 3603 NONAME ; int QStatusBar::insertPermanentWidget(int, class QWidget *, int) @@ -3698,7 +3698,7 @@ EXPORTS ?rect@QWindowSurface@@QBE?AVQRect@@PBVQWidget@@@Z @ 3697 NONAME ; class QRect QWindowSurface::rect(class QWidget const *) const ?textValueSelected@QInputDialog@@IAEXABVQString@@@Z @ 3698 NONAME ; void QInputDialog::textValueSelected(class QString const &) ?qt_metacall@QMainWindow@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 3699 NONAME ; int QMainWindow::qt_metacall(enum QMetaObject::Call, int, void * *) - ?modifiersMask@QMouseEventTransition@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 3700 NONAME ; class QFlags QMouseEventTransition::modifiersMask(void) const + ?modifiersMask@QMouseEventTransition@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 3700 NONAME ABSENT ; class QFlags QMouseEventTransition::modifiersMask(void) const ?trUtf8@QFileDialog@@SA?AVQString@@PBD0@Z @ 3701 NONAME ; class QString QFileDialog::trUtf8(char const *, char const *) ??0QGraphicsRectItem@@QAE@MMMMPAVQGraphicsItem@@PAVQGraphicsScene@@@Z @ 3702 NONAME ; QGraphicsRectItem::QGraphicsRectItem(float, float, float, float, class QGraphicsItem *, class QGraphicsScene *) ?alignment@QGraphicsLinearLayout@@QBE?AV?$QFlags@W4AlignmentFlag@Qt@@@@PAVQGraphicsLayoutItem@@@Z @ 3703 NONAME ; class QFlags QGraphicsLinearLayout::alignment(class QGraphicsLayoutItem *) const @@ -3732,7 +3732,7 @@ EXPORTS ?drawEllipse@QPainter@@QAEXABVQPointF@@MM@Z @ 3731 NONAME ; void QPainter::drawEllipse(class QPointF const &, float, float) ?alignment@QTextEdit@@QBE?AV?$QFlags@W4AlignmentFlag@Qt@@@@XZ @ 3732 NONAME ; class QFlags QTextEdit::alignment(void) const ?currentBlockUserData@QSyntaxHighlighter@@IBEPAVQTextBlockUserData@@XZ @ 3733 NONAME ; class QTextBlockUserData * QSyntaxHighlighter::currentBlockUserData(void) const - ?translate@QMatrix4x4@@QAEAAV1@MM@Z @ 3734 NONAME ; class QMatrix4x4 & QMatrix4x4::translate(float, float) + ?translate@QMatrix4x4@@QAEAAV1@MM@Z @ 3734 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::translate(float, float) ?metaObject@QTabBar@@UBEPBUQMetaObject@@XZ @ 3735 NONAME ; struct QMetaObject const * QTabBar::metaObject(void) const ?focusInEvent@QGraphicsView@@MAEXPAVQFocusEvent@@@Z @ 3736 NONAME ; void QGraphicsView::focusInEvent(class QFocusEvent *) ?createExtendedMouseEvent@QMouseEvent@@SAPAV1@W4Type@QEvent@@ABVQPointF@@ABVQPoint@@W4MouseButton@Qt@@V?$QFlags@W4MouseButton@Qt@@@@V?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 3737 NONAME ; class QMouseEvent * QMouseEvent::createExtendedMouseEvent(enum QEvent::Type, class QPointF const &, class QPoint const &, enum Qt::MouseButton, class QFlags, class QFlags) @@ -3777,7 +3777,7 @@ EXPORTS ?matchesFlags@QTreeWidgetItemIterator@@ABE_NPBVQTreeWidgetItem@@@Z @ 3776 NONAME ; bool QTreeWidgetItemIterator::matchesFlags(class QTreeWidgetItem const *) const ?heightForWidth@QWidget@@UBEHH@Z @ 3777 NONAME ; int QWidget::heightForWidth(int) const ?createMaskFromColor@QImage@@QBE?AV1@IW4MaskMode@Qt@@@Z @ 3778 NONAME ; class QImage QImage::createMaskFromColor(unsigned int, enum Qt::MaskMode) const - ?path@QMouseEventTransition@@QBE?AVQPainterPath@@XZ @ 3779 NONAME ; class QPainterPath QMouseEventTransition::path(void) const + ?path@QMouseEventTransition@@QBE?AVQPainterPath@@XZ @ 3779 NONAME ABSENT ; class QPainterPath QMouseEventTransition::path(void) const ?validate@QRegExpValidator@@UBE?AW4State@QValidator@@AAVQString@@AAH@Z @ 3780 NONAME ; enum QValidator::State QRegExpValidator::validate(class QString &, int &) const ?shear@QGraphicsItem@@QAEXMM@Z @ 3781 NONAME ; void QGraphicsItem::shear(float, float) ?foregroundBrush@QGraphicsView@@QBE?AVQBrush@@XZ @ 3782 NONAME ; class QBrush QGraphicsView::foregroundBrush(void) const @@ -3819,7 +3819,7 @@ EXPORTS ?cursorRect@QPlainTextEdit@@QBE?AVQRect@@XZ @ 3818 NONAME ; class QRect QPlainTextEdit::cursorRect(void) const ?paint@QGraphicsItemGroup@@UAEXPAVQPainter@@PBVQStyleOptionGraphicsItem@@PAVQWidget@@@Z @ 3819 NONAME ; void QGraphicsItemGroup::paint(class QPainter *, class QStyleOptionGraphicsItem const *, class QWidget *) ?setTabOrder@QWidget@@SAXPAV1@0@Z @ 3820 NONAME ; void QWidget::setTabOrder(class QWidget *, class QWidget *) - ?grabGesture@QWidget@@QAEXW4GestureType@Qt@@W4GestureContext@3@@Z @ 3821 NONAME ; void QWidget::grabGesture(enum Qt::GestureType, enum Qt::GestureContext) + ?grabGesture@QWidget@@QAEXW4GestureType@Qt@@W4GestureContext@3@@Z @ 3821 NONAME ABSENT ; void QWidget::grabGesture(enum Qt::GestureType, enum Qt::GestureContext) ??0QGraphicsRectItem@@QAE@ABVQRectF@@PAVQGraphicsItem@@PAVQGraphicsScene@@@Z @ 3822 NONAME ; QGraphicsRectItem::QGraphicsRectItem(class QRectF const &, class QGraphicsItem *, class QGraphicsScene *) ??0QStyleOptionTabV2@@QAE@XZ @ 3823 NONAME ; QStyleOptionTabV2::QStyleOptionTabV2(void) ?clearString@QLineControl@@ABE?AVQString@@II@Z @ 3824 NONAME ; class QString QLineControl::clearString(unsigned int, unsigned int) const @@ -3953,7 +3953,7 @@ EXPORTS ?addAction@QToolBar@@QAEPAVQAction@@ABVQString@@@Z @ 3952 NONAME ; class QAction * QToolBar::addAction(class QString const &) ?d_func@QToolBar@@AAEPAVQToolBarPrivate@@XZ @ 3953 NONAME ; class QToolBarPrivate * QToolBar::d_func(void) ?trUtf8@QWidget@@SA?AVQString@@PBD0@Z @ 3954 NONAME ; class QString QWidget::trUtf8(char const *, char const *) - ?grabGesture@QGraphicsObject@@QAEXW4GestureType@Qt@@W4GestureContext@3@@Z @ 3955 NONAME ; void QGraphicsObject::grabGesture(enum Qt::GestureType, enum Qt::GestureContext) + ?grabGesture@QGraphicsObject@@QAEXW4GestureType@Qt@@W4GestureContext@3@@Z @ 3955 NONAME ABSENT ; void QGraphicsObject::grabGesture(enum Qt::GestureType, enum Qt::GestureContext) ?button@QMouseEvent@@QBE?AW4MouseButton@Qt@@XZ @ 3956 NONAME ; enum Qt::MouseButton QMouseEvent::button(void) const ?setItemHidden@QTreeWidget@@QAEXPBVQTreeWidgetItem@@_N@Z @ 3957 NONAME ; void QTreeWidget::setItemHidden(class QTreeWidgetItem const *, bool) ?selectorMatches@StyleSelector@QCss@@AAE_NABUSelector@2@TNodePtr@12@@Z @ 3958 NONAME ; bool QCss::StyleSelector::selectorMatches(struct QCss::Selector const &, union QCss::StyleSelector::NodePtr) @@ -4120,7 +4120,7 @@ EXPORTS ?buttons@QMessageBox@@QBE?AV?$QList@PAVQAbstractButton@@@@XZ @ 4119 NONAME ; class QList QMessageBox::buttons(void) const ?trUtf8@QSyntaxHighlighter@@SA?AVQString@@PBD0@Z @ 4120 NONAME ; class QString QSyntaxHighlighter::trUtf8(char const *, char const *) ?animate_ui@QApplicationPrivate@@2_NA @ 4121 NONAME ; bool QApplicationPrivate::animate_ui - ?rotate@QMatrix4x4@@QAEAAV1@MABVQVector3D@@@Z @ 4122 NONAME ; class QMatrix4x4 & QMatrix4x4::rotate(float, class QVector3D const &) + ?rotate@QMatrix4x4@@QAEAAV1@MABVQVector3D@@@Z @ 4122 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::rotate(float, class QVector3D const &) ?paint@QGraphicsEllipseItem@@UAEXPAVQPainter@@PBVQStyleOptionGraphicsItem@@PAVQWidget@@@Z @ 4123 NONAME ; void QGraphicsEllipseItem::paint(class QPainter *, class QStyleOptionGraphicsItem const *, class QWidget *) ??6@YA?AVQDebug@@V0@ABVQPen@@@Z @ 4124 NONAME ; class QDebug operator<<(class QDebug, class QPen const &) ?data@QGraphicsItem@@QBE?AVQVariant@@H@Z @ 4125 NONAME ; class QVariant QGraphicsItem::data(int) const @@ -4460,7 +4460,7 @@ EXPORTS ?drawCursor@QTextLayout@@QBEXPAVQPainter@@ABVQPointF@@H@Z @ 4459 NONAME ; void QTextLayout::drawCursor(class QPainter *, class QPointF const &, int) const ?trUtf8@QTabWidget@@SA?AVQString@@PBD0@Z @ 4460 NONAME ; class QString QTabWidget::trUtf8(char const *, char const *) ?viewportEvent@QAbstractScrollArea@@MAE_NPAVQEvent@@@Z @ 4461 NONAME ; bool QAbstractScrollArea::viewportEvent(class QEvent *) - ?scale@QMatrix4x4@@QAEAAV1@MM@Z @ 4462 NONAME ; class QMatrix4x4 & QMatrix4x4::scale(float, float) + ?scale@QMatrix4x4@@QAEAAV1@MM@Z @ 4462 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::scale(float, float) ?x@QWidget@@QBEHXZ @ 4463 NONAME ; int QWidget::x(void) const ?hideColumn@QTableView@@QAEXH@Z @ 4464 NONAME ; void QTableView::hideColumn(int) ??4QStyleOptionButton@@QAEAAV0@ABV0@@Z @ 4465 NONAME ; class QStyleOptionButton & QStyleOptionButton::operator=(class QStyleOptionButton const &) @@ -4742,7 +4742,7 @@ EXPORTS ?modifiers@QInputEvent@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 4741 NONAME ; class QFlags QInputEvent::modifiers(void) const ?transformed@QBitmap@@QBE?AV1@ABVQTransform@@@Z @ 4742 NONAME ; class QBitmap QBitmap::transformed(class QTransform const &) const ?tr@QGraphicsGrayscaleEffect@@SA?AVQString@@PBD0@Z @ 4743 NONAME ABSENT ; class QString QGraphicsGrayscaleEffect::tr(char const *, char const *) - ?setBlurHint@QGraphicsBlurEffect@@QAEXW4RenderHint@Qt@@@Z @ 4744 NONAME ; void QGraphicsBlurEffect::setBlurHint(enum Qt::RenderHint) + ?setBlurHint@QGraphicsBlurEffect@@QAEXW4RenderHint@Qt@@@Z @ 4744 NONAME ABSENT ; void QGraphicsBlurEffect::setBlurHint(enum Qt::RenderHint) ?event@QDockWidget@@MAE_NPAVQEvent@@@Z @ 4745 NONAME ; bool QDockWidget::event(class QEvent *) ??_EQStyle@@UAE@I@Z @ 4746 NONAME ; QStyle::~QStyle(unsigned int) ?addWidget@QGridLayout@@QAEXPAVQWidget@@@Z @ 4747 NONAME ; void QGridLayout::addWidget(class QWidget *) @@ -4805,7 +4805,7 @@ EXPORTS ?translate@QPolygon@@QAEXHH@Z @ 4804 NONAME ; void QPolygon::translate(int, int) ??0QTextEdit@@QAE@PAVQWidget@@@Z @ 4805 NONAME ; QTextEdit::QTextEdit(class QWidget *) ?handle@QSplitter@@QBEPAVQSplitterHandle@@H@Z @ 4806 NONAME ; class QSplitterHandle * QSplitter::handle(int) const - ?extractAxisRotation@QMatrix4x4@@QBEXAAMAAVQVector3D@@@Z @ 4807 NONAME ; void QMatrix4x4::extractAxisRotation(float &, class QVector3D &) const + ?extractAxisRotation@QMatrix4x4@@QBEXAAMAAVQVector3D@@@Z @ 4807 NONAME ABSENT ; void QMatrix4x4::extractAxisRotation(float &, class QVector3D &) const ?docHandle@QTextBlock@@QBEPAVQTextDocumentPrivate@@XZ @ 4808 NONAME ; class QTextDocumentPrivate * QTextBlock::docHandle(void) const ?d_func@QMdiSubWindow@@ABEPBVQMdiSubWindowPrivate@@XZ @ 4809 NONAME ; class QMdiSubWindowPrivate const * QMdiSubWindow::d_func(void) const ?setData@QGraphicsItem@@QAEXHABVQVariant@@@Z @ 4810 NONAME ; void QGraphicsItem::setData(int, class QVariant const &) @@ -4931,7 +4931,7 @@ EXPORTS ?setModel@QTreeView@@UAEXPAVQAbstractItemModel@@@Z @ 4930 NONAME ; void QTreeView::setModel(class QAbstractItemModel *) ?itemPixmapRect@QProxyStyle@@UBE?AVQRect@@ABV2@HABVQPixmap@@@Z @ 4931 NONAME ; class QRect QProxyStyle::itemPixmapRect(class QRect const &, int, class QPixmap const &) const ??1QSound@@UAE@XZ @ 4932 NONAME ; QSound::~QSound(void) - ?blurHintChanged@QGraphicsBlurEffect@@IAEXW4RenderHint@Qt@@@Z @ 4933 NONAME ; void QGraphicsBlurEffect::blurHintChanged(enum Qt::RenderHint) + ?blurHintChanged@QGraphicsBlurEffect@@IAEXW4RenderHint@Qt@@@Z @ 4933 NONAME ABSENT ; void QGraphicsBlurEffect::blurHintChanged(enum Qt::RenderHint) ?ascent@QTextLine@@QBEMXZ @ 4934 NONAME ; float QTextLine::ascent(void) const ??0QContextMenuEvent@@QAE@W4Reason@0@ABVQPoint@@@Z @ 4935 NONAME ; QContextMenuEvent::QContextMenuEvent(enum QContextMenuEvent::Reason, class QPoint const &) ?viewportEvent@QMdiArea@@MAE_NPAVQEvent@@@Z @ 4936 NONAME ; bool QMdiArea::viewportEvent(class QEvent *) @@ -5297,7 +5297,7 @@ EXPORTS ?addItems@QListWidget@@QAEXABVQStringList@@@Z @ 5296 NONAME ; void QListWidget::addItems(class QStringList const &) ??_EQGraphicsGridLayout@@UAE@I@Z @ 5297 NONAME ; QGraphicsGridLayout::~QGraphicsGridLayout(unsigned int) ?topLevelChanged@QDockWidget@@IAEX_N@Z @ 5298 NONAME ; void QDockWidget::topLevelChanged(bool) - ?flipCoordinates@QMatrix4x4@@QAEAAV1@XZ @ 5299 NONAME ; class QMatrix4x4 & QMatrix4x4::flipCoordinates(void) + ?flipCoordinates@QMatrix4x4@@QAEAAV1@XZ @ 5299 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::flipCoordinates(void) ?actionGeometry@QMenuBar@@QBE?AVQRect@@PAVQAction@@@Z @ 5300 NONAME ; class QRect QMenuBar::actionGeometry(class QAction *) const ??_EQPainterReplayer@@UAE@I@Z @ 5301 NONAME ; QPainterReplayer::~QPainterReplayer(unsigned int) ??0QStyleOptionTabBarBaseV2@@QAE@XZ @ 5302 NONAME ; QStyleOptionTabBarBaseV2::QStyleOptionTabBarBaseV2(void) @@ -5968,7 +5968,7 @@ EXPORTS ?movie@QLabel@@QBEPAVQMovie@@XZ @ 5967 NONAME ; class QMovie * QLabel::movie(void) const ??1QGuiPlatformPlugin@@UAE@XZ @ 5968 NONAME ; QGuiPlatformPlugin::~QGuiPlatformPlugin(void) ?eraseRect@QPainter@@QAEXABVQRectF@@@Z @ 5969 NONAME ; void QPainter::eraseRect(class QRectF const &) - ?toValueArray@QMatrix4x4@@QBEXPAM@Z @ 5970 NONAME ; void QMatrix4x4::toValueArray(float *) const + ?toValueArray@QMatrix4x4@@QBEXPAM@Z @ 5970 NONAME ABSENT ; void QMatrix4x4::toValueArray(float *) const ?isLeftToRight@QApplication@@SA_NXZ @ 5971 NONAME ; bool QApplication::isLeftToRight(void) ?setRowMaximumHeight@QGraphicsGridLayout@@QAEXHM@Z @ 5972 NONAME ; void QGraphicsGridLayout::setRowMaximumHeight(int, float) ?mapFromItem@QGraphicsItem@@QBE?AVQPolygonF@@PBV1@ABVQRectF@@@Z @ 5973 NONAME ; class QPolygonF QGraphicsItem::mapFromItem(class QGraphicsItem const *, class QRectF const &) const @@ -6108,7 +6108,7 @@ EXPORTS ??0QPolygon@@QAE@ABV?$QVector@VQPoint@@@@@Z @ 6107 NONAME ; QPolygon::QPolygon(class QVector const &) ?wordWrapMode@QTextEdit@@QBE?AW4WrapMode@QTextOption@@XZ @ 6108 NONAME ; enum QTextOption::WrapMode QTextEdit::wordWrapMode(void) const ?columnCount@QTableWidget@@QBEHXZ @ 6109 NONAME ; int QTableWidget::columnCount(void) const - ?ortho@QMatrix4x4@@QAEAAV1@ABVQRectF@@@Z @ 6110 NONAME ; class QMatrix4x4 & QMatrix4x4::ortho(class QRectF const &) + ?ortho@QMatrix4x4@@QAEAAV1@ABVQRectF@@@Z @ 6110 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::ortho(class QRectF const &) ?open@QFontDialog@@QAEXPAVQObject@@PBD@Z @ 6111 NONAME ; void QFontDialog::open(class QObject *, char const *) ?tr@QGridLayout@@SA?AVQString@@PBD0H@Z @ 6112 NONAME ; class QString QGridLayout::tr(char const *, char const *, int) ?flags@QStandardItem@@QBE?AV?$QFlags@W4ItemFlag@Qt@@@@XZ @ 6113 NONAME ; class QFlags QStandardItem::flags(void) const @@ -6347,7 +6347,7 @@ EXPORTS ?tr@QFocusFrame@@SA?AVQString@@PBD0@Z @ 6346 NONAME ; class QString QFocusFrame::tr(char const *, char const *) ?setBackgroundColor@QListWidgetItem@@UAEXABVQColor@@@Z @ 6347 NONAME ; void QListWidgetItem::setBackgroundColor(class QColor const &) ?setStrength@QGraphicsColorizeEffect@@QAEXM@Z @ 6348 NONAME ; void QGraphicsColorizeEffect::setStrength(float) - ?allGestures@QGestureEvent@@QBE?AV?$QList@PAVQGesture@@@@XZ @ 6349 NONAME ; class QList QGestureEvent::allGestures(void) const + ?allGestures@QGestureEvent@@QBE?AV?$QList@PAVQGesture@@@@XZ @ 6349 NONAME ABSENT ; class QList QGestureEvent::allGestures(void) const ?setCacheMode@QMovie@@QAEXW4CacheMode@1@@Z @ 6350 NONAME ; void QMovie::setCacheMode(enum QMovie::CacheMode) ?setAlignment@QProgressBar@@QAEXV?$QFlags@W4AlignmentFlag@Qt@@@@@Z @ 6351 NONAME ; void QProgressBar::setAlignment(class QFlags) ?model@QComboBox@@QBEPAVQAbstractItemModel@@XZ @ 6352 NONAME ; class QAbstractItemModel * QComboBox::model(void) const @@ -6357,7 +6357,7 @@ EXPORTS ?qt_metacast@QTreeView@@UAEPAXPBD@Z @ 6356 NONAME ; void * QTreeView::qt_metacast(char const *) ?d_func@QAbstractSlider@@ABEPBVQAbstractSliderPrivate@@XZ @ 6357 NONAME ; class QAbstractSliderPrivate const * QAbstractSlider::d_func(void) const ?isFloatable@QToolBar@@QBE_NXZ @ 6358 NONAME ; bool QToolBar::isFloatable(void) const - ?inferSpecialType@QMatrix4x4@@QAEXXZ @ 6359 NONAME ; void QMatrix4x4::inferSpecialType(void) + ?inferSpecialType@QMatrix4x4@@QAEXXZ @ 6359 NONAME ABSENT ; void QMatrix4x4::inferSpecialType(void) ?faceId@QFontEngine@@UBE?AUFaceId@1@XZ @ 6360 NONAME ; struct QFontEngine::FaceId QFontEngine::faceId(void) const ?mouseReleaseEvent@QTextEdit@@MAEXPAVQMouseEvent@@@Z @ 6361 NONAME ; void QTextEdit::mouseReleaseEvent(class QMouseEvent *) ?registerField@QWizardPage@@IAEXABVQString@@PAVQWidget@@PBD2@Z @ 6362 NONAME ; void QWizardPage::registerField(class QString const &, class QWidget *, char const *, char const *) @@ -6588,7 +6588,7 @@ EXPORTS ?display@QLCDNumber@@QAEXN@Z @ 6587 NONAME ; void QLCDNumber::display(double) ?hasClipping@QPainter@@QBE_NXZ @ 6588 NONAME ; bool QPainter::hasClipping(void) const ?staticMetaObject@QMovie@@2UQMetaObject@@B @ 6589 NONAME ; struct QMetaObject const QMovie::staticMetaObject - ?setWhatChanged@QPinchGesture@@QAEXV?$QFlags@W4WhatChange@QPinchGesture@@@@@Z @ 6590 NONAME ; void QPinchGesture::setWhatChanged(class QFlags) + ?setWhatChanged@QPinchGesture@@QAEXV?$QFlags@W4WhatChange@QPinchGesture@@@@@Z @ 6590 NONAME ABSENT ; void QPinchGesture::setWhatChanged(class QFlags) ?validator@QComboBox@@QBEPBVQValidator@@XZ @ 6591 NONAME ; class QValidator const * QComboBox::validator(void) const ?intMaximum@QInputDialog@@QBEHXZ @ 6592 NONAME ; int QInputDialog::intMaximum(void) const ?setFilterCaseSensitivity@QSortFilterProxyModel@@QAEXW4CaseSensitivity@Qt@@@Z @ 6593 NONAME ; void QSortFilterProxyModel::setFilterCaseSensitivity(enum Qt::CaseSensitivity) @@ -6603,7 +6603,7 @@ EXPORTS ?eventFilter@QWidgetAction@@MAE_NPAVQObject@@PAVQEvent@@@Z @ 6602 NONAME ; bool QWidgetAction::eventFilter(class QObject *, class QEvent *) ??1QGuiPlatformPluginInterface@@UAE@XZ @ 6603 NONAME ; QGuiPlatformPluginInterface::~QGuiPlatformPluginInterface(void) ??0QMatrix@@QAE@XZ @ 6604 NONAME ; QMatrix::QMatrix(void) - ?blurHint@QPixmapBlurFilter@@QBE?AW4RenderHint@Qt@@XZ @ 6605 NONAME ; enum Qt::RenderHint QPixmapBlurFilter::blurHint(void) const + ?blurHint@QPixmapBlurFilter@@QBE?AW4RenderHint@Qt@@XZ @ 6605 NONAME ABSENT ; enum Qt::RenderHint QPixmapBlurFilter::blurHint(void) const ?metaObject@QMouseEventTransition@@UBEPBUQMetaObject@@XZ @ 6606 NONAME ; struct QMetaObject const * QMouseEventTransition::metaObject(void) const ?quality@QPictureIO@@QBEHXZ @ 6607 NONAME ; int QPictureIO::quality(void) const ?tr@QLineControl@@SA?AVQString@@PBD0@Z @ 6608 NONAME ; class QString QLineControl::tr(char const *, char const *) @@ -6743,7 +6743,7 @@ EXPORTS ?effectiveRectFor@QWidgetPrivate@@QBE?AVQRect@@ABV2@@Z @ 6742 NONAME ; class QRect QWidgetPrivate::effectiveRectFor(class QRect const &) const ?scrollContentsBy@QGraphicsView@@MAEXHH@Z @ 6743 NONAME ; void QGraphicsView::scrollContentsBy(int, int) ??0QMimeSource@@QAE@ABV0@@Z @ 6744 NONAME ; QMimeSource::QMimeSource(class QMimeSource const &) - ?rotateVector@QQuaternion@@QBE?AVQVector3D@@ABV2@@Z @ 6745 NONAME ; class QVector3D QQuaternion::rotateVector(class QVector3D const &) const + ?rotateVector@QQuaternion@@QBE?AVQVector3D@@ABV2@@Z @ 6745 NONAME ABSENT ; class QVector3D QQuaternion::rotateVector(class QVector3D const &) const ?setSource@QGraphicsSceneDragDropEvent@@QAEXPAVQWidget@@@Z @ 6746 NONAME ; void QGraphicsSceneDragDropEvent::setSource(class QWidget *) ??0QScrollBar@@QAE@PAVQWidget@@@Z @ 6747 NONAME ; QScrollBar::QScrollBar(class QWidget *) ??8QPainterPath@@QBE_NABV0@@Z @ 6748 NONAME ; bool QPainterPath::operator==(class QPainterPath const &) const @@ -7151,7 +7151,7 @@ EXPORTS ?isVisible@QAction@@QBE_NXZ @ 7150 NONAME ; bool QAction::isVisible(void) const ?setLayoutDirection@QLineControl@@QAEXW4LayoutDirection@Qt@@@Z @ 7151 NONAME ; void QLineControl::setLayoutDirection(enum Qt::LayoutDirection) ??0QQuaternion@@QAE@MMMM@Z @ 7152 NONAME ; QQuaternion::QQuaternion(float, float, float, float) - ?setIdentity@QMatrix4x4@@QAEXXZ @ 7153 NONAME ; void QMatrix4x4::setIdentity(void) + ?setIdentity@QMatrix4x4@@QAEXXZ @ 7153 NONAME ABSENT ; void QMatrix4x4::setIdentity(void) ?setDirtyRegion@QAbstractItemView@@IAEXABVQRegion@@@Z @ 7154 NONAME ; void QAbstractItemView::setDirtyRegion(class QRegion const &) ?toFrameFormat@QTextFormat@@QBE?AVQTextFrameFormat@@XZ @ 7155 NONAME ; class QTextFrameFormat QTextFormat::toFrameFormat(void) const ??0QStyleOptionToolBox@@QAE@ABV0@@Z @ 7156 NONAME ; QStyleOptionToolBox::QStyleOptionToolBox(class QStyleOptionToolBox const &) @@ -7679,7 +7679,7 @@ EXPORTS ?qSmartMaxSize@@YA?AVQSize@@PBVQWidgetItem@@V?$QFlags@W4AlignmentFlag@Qt@@@@@Z @ 7678 NONAME ; class QSize qSmartMaxSize(class QWidgetItem const *, class QFlags) ??BQSizePolicy@@QBE?AVQVariant@@XZ @ 7679 NONAME ; QSizePolicy::operator class QVariant(void) const ?devType@QWidget@@UBEHXZ @ 7680 NONAME ; int QWidget::devType(void) const - ?translate@QMatrix4x4@@QAEAAV1@ABVQVector3D@@@Z @ 7681 NONAME ; class QMatrix4x4 & QMatrix4x4::translate(class QVector3D const &) + ?translate@QMatrix4x4@@QAEAAV1@ABVQVector3D@@@Z @ 7681 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::translate(class QVector3D const &) ?trUtf8@QFileSystemModel@@SA?AVQString@@PBD0H@Z @ 7682 NONAME ; class QString QFileSystemModel::trUtf8(char const *, char const *, int) ?setOption@QColorDialog@@QAEXW4ColorDialogOption@1@_N@Z @ 7683 NONAME ; void QColorDialog::setOption(enum QColorDialog::ColorDialogOption, bool) ??0QPictureIO@@QAE@XZ @ 7684 NONAME ; QPictureIO::QPictureIO(void) @@ -8021,7 +8021,7 @@ EXPORTS ?style@QPen@@QBE?AW4PenStyle@Qt@@XZ @ 8020 NONAME ; enum Qt::PenStyle QPen::style(void) const ?d_func@QTextDocument@@AAEPAVQTextDocumentPrivate@@XZ @ 8021 NONAME ; class QTextDocumentPrivate * QTextDocument::d_func(void) ?clear@QGraphicsScene@@QAEXXZ @ 8022 NONAME ; void QGraphicsScene::clear(void) - ?setModifiersMask@QKeyEventTransition@@QAEXV?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 8023 NONAME ; void QKeyEventTransition::setModifiersMask(class QFlags) + ?setModifiersMask@QKeyEventTransition@@QAEXV?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 8023 NONAME ABSENT ; void QKeyEventTransition::setModifiersMask(class QFlags) ?hideEvent@QMenu@@MAEXPAVQHideEvent@@@Z @ 8024 NONAME ; void QMenu::hideEvent(class QHideEvent *) ?splitAtIntersections@QBezier@@QAE?AV?$QVector@V?$QList@VQBezier@@@@@@AAV1@@Z @ 8025 NONAME ; class QVector > QBezier::splitAtIntersections(class QBezier &) ?lastCenterPoint@QPinchGesture@@QBE?AVQPointF@@XZ @ 8026 NONAME ; class QPointF QPinchGesture::lastCenterPoint(void) const @@ -8797,7 +8797,7 @@ EXPORTS ?serialNumber@QPalette@@QBEHXZ @ 8796 NONAME ; int QPalette::serialNumber(void) const ?d_func@QFileDialog@@AAEPAVQFileDialogPrivate@@XZ @ 8797 NONAME ; class QFileDialogPrivate * QFileDialog::d_func(void) ??_EQDashStroker@@UAE@I@Z @ 8798 NONAME ; QDashStroker::~QDashStroker(unsigned int) - ?extractTranslation@QMatrix4x4@@QBE?AVQVector3D@@XZ @ 8799 NONAME ; class QVector3D QMatrix4x4::extractTranslation(void) const + ?extractTranslation@QMatrix4x4@@QBE?AVQVector3D@@XZ @ 8799 NONAME ABSENT ; class QVector3D QMatrix4x4::extractTranslation(void) const ?trUtf8@QGraphicsDropShadowEffect@@SA?AVQString@@PBD0@Z @ 8800 NONAME ; class QString QGraphicsDropShadowEffect::trUtf8(char const *, char const *) ?orientation@QGraphicsSceneWheelEvent@@QBE?AW4Orientation@Qt@@XZ @ 8801 NONAME ; enum Qt::Orientation QGraphicsSceneWheelEvent::orientation(void) const ?dataChanged@QListView@@MAEXABVQModelIndex@@0@Z @ 8802 NONAME ; void QListView::dataChanged(class QModelIndex const &, class QModelIndex const &) @@ -9368,7 +9368,7 @@ EXPORTS ?emitLineTo@QStrokerOps@@IAEXMM@Z @ 9367 NONAME ; void QStrokerOps::emitLineTo(float, float) ?trUtf8@QRubberBand@@SA?AVQString@@PBD0H@Z @ 9368 NONAME ; class QString QRubberBand::trUtf8(char const *, char const *, int) ?setHeader@QTreeView@@QAEXPAVQHeaderView@@@Z @ 9369 NONAME ; void QTreeView::setHeader(class QHeaderView *) - ?createGesture@QGestureRecognizer@@UAEPAVQGesture@@PAVQObject@@@Z @ 9370 NONAME ; class QGesture * QGestureRecognizer::createGesture(class QObject *) + ?createGesture@QGestureRecognizer@@UAEPAVQGesture@@PAVQObject@@@Z @ 9370 NONAME ABSENT ; class QGesture * QGestureRecognizer::createGesture(class QObject *) ?trUtf8@QGraphicsEffectSource@@SA?AVQString@@PBD0H@Z @ 9371 NONAME ; class QString QGraphicsEffectSource::trUtf8(char const *, char const *, int) ?tr@QTableWidget@@SA?AVQString@@PBD0@Z @ 9372 NONAME ; class QString QTableWidget::tr(char const *, char const *) ?metaObject@QInputDialog@@UBEPBUQMetaObject@@XZ @ 9373 NONAME ; struct QMetaObject const * QInputDialog::metaObject(void) const @@ -10097,7 +10097,7 @@ EXPORTS ?iconProvider@QFileDialog@@QBEPAVQFileIconProvider@@XZ @ 10096 NONAME ; class QFileIconProvider * QFileDialog::iconProvider(void) const ?resetInputContext@QWidget@@IAEXXZ @ 10097 NONAME ; void QWidget::resetInputContext(void) ?convertToFormat@QImage@@QBE?AV1@W4Format@1@ABV?$QVector@I@@V?$QFlags@W4ImageConversionFlag@Qt@@@@@Z @ 10098 NONAME ; class QImage QImage::convertToFormat(enum QImage::Format, class QVector const &, class QFlags) const - ?scale@QMatrix4x4@@QAEAAV1@MMM@Z @ 10099 NONAME ; class QMatrix4x4 & QMatrix4x4::scale(float, float, float) + ?scale@QMatrix4x4@@QAEAAV1@MMM@Z @ 10099 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::scale(float, float, float) ?setTransformOriginPoint@QGraphicsItem@@QAEXMM@Z @ 10100 NONAME ; void QGraphicsItem::setTransformOriginPoint(float, float) ??0QTextInlineObject@@QAE@HPAVQTextEngine@@@Z @ 10101 NONAME ; QTextInlineObject::QTextInlineObject(int, class QTextEngine *) ?trUtf8@QTextEdit@@SA?AVQString@@PBD0@Z @ 10102 NONAME ; class QString QTextEdit::trUtf8(char const *, char const *) @@ -10325,7 +10325,7 @@ EXPORTS ??1QDateEdit@@UAE@XZ @ 10324 NONAME ; QDateEdit::~QDateEdit(void) ?rect@TouchPoint@QTouchEvent@@QBE?AVQRectF@@XZ @ 10325 NONAME ; class QRectF QTouchEvent::TouchPoint::rect(void) const ?updateGeometry@QWidget@@QAEXXZ @ 10326 NONAME ; void QWidget::updateGeometry(void) - ?scale@QMatrix4x4@@QAEAAV1@ABVQVector3D@@@Z @ 10327 NONAME ; class QMatrix4x4 & QMatrix4x4::scale(class QVector3D const &) + ?scale@QMatrix4x4@@QAEAAV1@ABVQVector3D@@@Z @ 10327 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::scale(class QVector3D const &) ?setBottom@QDoubleValidator@@QAEXN@Z @ 10328 NONAME ; void QDoubleValidator::setBottom(double) ?icon@QFileIconProvider@@UBE?AVQIcon@@ABVQFileInfo@@@Z @ 10329 NONAME ; class QIcon QFileIconProvider::icon(class QFileInfo const &) const ?totalMaximumSize@QLayout@@QBE?AVQSize@@XZ @ 10330 NONAME ; class QSize QLayout::totalMaximumSize(void) const @@ -10619,7 +10619,7 @@ EXPORTS ?reset@QCoeFepInputContext@@UAEXXZ @ 10618 NONAME ABSENT ; void QCoeFepInputContext::reset(void) ?load@QImage@@QAE_NABVQString@@PBD@Z @ 10619 NONAME ; bool QImage::load(class QString const &, char const *) ?staticMetaObject@QProxyStyle@@2UQMetaObject@@B @ 10620 NONAME ; struct QMetaObject const QProxyStyle::staticMetaObject - ?translate@QMatrix4x4@@QAEAAV1@MMM@Z @ 10621 NONAME ; class QMatrix4x4 & QMatrix4x4::translate(float, float, float) + ?translate@QMatrix4x4@@QAEAAV1@MMM@Z @ 10621 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::translate(float, float, float) ?setShowGrid@QTableView@@QAEX_N@Z @ 10622 NONAME ; void QTableView::setShowGrid(bool) ?allowedAreas@QToolBar@@QBE?AV?$QFlags@W4ToolBarArea@Qt@@@@XZ @ 10623 NONAME ; class QFlags QToolBar::allowedAreas(void) const ?addAction@QMenu@@QAEPAVQAction@@ABVQIcon@@ABVQString@@@Z @ 10624 NONAME ; class QAction * QMenu::addAction(class QIcon const &, class QString const &) @@ -10847,7 +10847,7 @@ EXPORTS ?qt_metacast@QMenu@@UAEPAXPBD@Z @ 10846 NONAME ; void * QMenu::qt_metacast(char const *) ?background@QStandardItem@@QBE?AVQBrush@@XZ @ 10847 NONAME ; class QBrush QStandardItem::background(void) const ?dropMimeData@QDirModel@@UAE_NPBVQMimeData@@W4DropAction@Qt@@HHABVQModelIndex@@@Z @ 10848 NONAME ; bool QDirModel::dropMimeData(class QMimeData const *, enum Qt::DropAction, int, int, class QModelIndex const &) - ?frustum@QMatrix4x4@@QAEAAV1@MMMMMM@Z @ 10849 NONAME ; class QMatrix4x4 & QMatrix4x4::frustum(float, float, float, float, float, float) + ?frustum@QMatrix4x4@@QAEAAV1@MMMMMM@Z @ 10849 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::frustum(float, float, float, float, float, float) ?sectionCountChanged@QHeaderView@@IAEXHH@Z @ 10850 NONAME ; void QHeaderView::sectionCountChanged(int, int) ??0QTableWidget@@QAE@HHPAVQWidget@@@Z @ 10851 NONAME ; QTableWidget::QTableWidget(int, int, class QWidget *) ??0QGraphicsLayoutItem@@QAE@PAV0@_N@Z @ 10852 NONAME ; QGraphicsLayoutItem::QGraphicsLayoutItem(class QGraphicsLayoutItem *, bool) @@ -10866,7 +10866,7 @@ EXPORTS ?qt_metacall@QDateEdit@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 10865 NONAME ; int QDateEdit::qt_metacall(enum QMetaObject::Call, int, void * *) ?setNameFilterDisables@QFileSystemModel@@QAEX_N@Z @ 10866 NONAME ; void QFileSystemModel::setNameFilterDisables(bool) ?resizeAnchor@QGraphicsView@@QBE?AW4ViewportAnchor@1@XZ @ 10867 NONAME ; enum QGraphicsView::ViewportAnchor QGraphicsView::resizeAnchor(void) const - ?scale@QMatrix4x4@@QAEAAV1@M@Z @ 10868 NONAME ; class QMatrix4x4 & QMatrix4x4::scale(float) + ?scale@QMatrix4x4@@QAEAAV1@M@Z @ 10868 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::scale(float) ?SetStateTransferingOwnershipL@QCoeFepInputContext@@UAEXPAVCState@MCoeFepAwareTextEditor_Extension1@@VTUid@@@Z @ 10869 NONAME ABSENT ; void QCoeFepInputContext::SetStateTransferingOwnershipL(class MCoeFepAwareTextEditor_Extension1::CState *, class TUid) ??0QStyle@@QAE@XZ @ 10870 NONAME ; QStyle::QStyle(void) ?mouseDoubleClickEvent@QHeaderView@@MAEXPAVQMouseEvent@@@Z @ 10871 NONAME ; void QHeaderView::mouseDoubleClickEvent(class QMouseEvent *) @@ -11384,7 +11384,7 @@ EXPORTS ?collapseItem@QTreeWidget@@QAEXPBVQTreeWidgetItem@@@Z @ 11383 NONAME ; void QTreeWidget::collapseItem(class QTreeWidgetItem const *) ?labelForField@QFormLayout@@QBEPAVQWidget@@PAVQLayout@@@Z @ 11384 NONAME ; class QWidget * QFormLayout::labelForField(class QLayout *) const ?getPaintContext@QPlainTextEdit@@IBE?AUPaintContext@QAbstractTextDocumentLayout@@XZ @ 11385 NONAME ; struct QAbstractTextDocumentLayout::PaintContext QPlainTextEdit::getPaintContext(void) const - ?setTotalOffset@QPanGesture@@QAEXABVQPointF@@@Z @ 11386 NONAME ; void QPanGesture::setTotalOffset(class QPointF const &) + ?setTotalOffset@QPanGesture@@QAEXABVQPointF@@@Z @ 11386 NONAME ABSENT ; void QPanGesture::setTotalOffset(class QPointF const &) ?tr@QProxyStyle@@SA?AVQString@@PBD0H@Z @ 11387 NONAME ; class QString QProxyStyle::tr(char const *, char const *, int) ?mouseMoveEvent@QListView@@MAEXPAVQMouseEvent@@@Z @ 11388 NONAME ; void QListView::mouseMoveEvent(class QMouseEvent *) ?minimumDate@QDateTimeEdit@@QBE?AVQDate@@XZ @ 11389 NONAME ; class QDate QDateTimeEdit::minimumDate(void) const @@ -11661,7 +11661,7 @@ EXPORTS ?dropEvent@QListView@@MAEXPAVQDropEvent@@@Z @ 11660 NONAME ; void QListView::dropEvent(class QDropEvent *) ?cleanupPage@QWizard@@MAEXH@Z @ 11661 NONAME ; void QWizard::cleanupPage(int) ?dropEvent@QAbstractItemView@@MAEXPAVQDropEvent@@@Z @ 11662 NONAME ; void QAbstractItemView::dropEvent(class QDropEvent *) - ?ortho@QMatrix4x4@@QAEAAV1@ABVQRect@@@Z @ 11663 NONAME ; class QMatrix4x4 & QMatrix4x4::ortho(class QRect const &) + ?ortho@QMatrix4x4@@QAEAAV1@ABVQRect@@@Z @ 11663 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::ortho(class QRect const &) ?setForeground@QStandardItem@@QAEXABVQBrush@@@Z @ 11664 NONAME ; void QStandardItem::setForeground(class QBrush const &) ?isDockNestingEnabled@QMainWindow@@QBE_NXZ @ 11665 NONAME ; bool QMainWindow::isDockNestingEnabled(void) const ??_EQTessellator@@UAE@I@Z @ 11666 NONAME ; QTessellator::~QTessellator(unsigned int) @@ -11850,7 +11850,7 @@ EXPORTS ??0QDateEdit@@QAE@PAVQWidget@@@Z @ 11849 NONAME ; QDateEdit::QDateEdit(class QWidget *) ?insertToolBarBreak@QMainWindow@@QAEXPAVQToolBar@@@Z @ 11850 NONAME ; void QMainWindow::insertToolBarBreak(class QToolBar *) ?d_func@QTextDocument@@ABEPBVQTextDocumentPrivate@@XZ @ 11851 NONAME ; class QTextDocumentPrivate const * QTextDocument::d_func(void) const - ?setBlurHint@QPixmapBlurFilter@@QAEXW4RenderHint@Qt@@@Z @ 11852 NONAME ; void QPixmapBlurFilter::setBlurHint(enum Qt::RenderHint) + ?setBlurHint@QPixmapBlurFilter@@QAEXW4RenderHint@Qt@@@Z @ 11852 NONAME ABSENT ; void QPixmapBlurFilter::setBlurHint(enum Qt::RenderHint) ?trUtf8@QGraphicsPixelizeEffect@@SA?AVQString@@PBD0@Z @ 11853 NONAME ABSENT ; class QString QGraphicsPixelizeEffect::trUtf8(char const *, char const *) ?adjustSize@QGraphicsTextItem@@QAEXXZ @ 11854 NONAME ; void QGraphicsTextItem::adjustSize(void) ??0QTextDocumentFragment@@QAE@PBVQTextDocument@@@Z @ 11855 NONAME ; QTextDocumentFragment::QTextDocumentFragment(class QTextDocument const *) @@ -11930,7 +11930,7 @@ EXPORTS ?setResizeMode@QHeaderView@@QAEXHW4ResizeMode@1@@Z @ 11929 NONAME ; void QHeaderView::setResizeMode(int, enum QHeaderView::ResizeMode) ?parentItem@QGraphicsItem@@QBEPAV1@XZ @ 11930 NONAME ; class QGraphicsItem * QGraphicsItem::parentItem(void) const ?supportedDropActions@QDirModel@@UBE?AV?$QFlags@W4DropAction@Qt@@@@XZ @ 11931 NONAME ; class QFlags QDirModel::supportedDropActions(void) const - ?setPath@QMouseEventTransition@@QAEXABVQPainterPath@@@Z @ 11932 NONAME ; void QMouseEventTransition::setPath(class QPainterPath const &) + ?setPath@QMouseEventTransition@@QAEXABVQPainterPath@@@Z @ 11932 NONAME ABSENT ; void QMouseEventTransition::setPath(class QPainterPath const &) ?showStatusText@QAction@@QAE_NPAVQWidget@@@Z @ 11933 NONAME ; bool QAction::showStatusText(class QWidget *) ?setAlignment@QAbstractSpinBox@@QAEXV?$QFlags@W4AlignmentFlag@Qt@@@@@Z @ 11934 NONAME ; void QAbstractSpinBox::setAlignment(class QFlags) ??0QPalette@@QAE@ABVQColor@@@Z @ 11935 NONAME ; QPalette::QPalette(class QColor const &) @@ -12030,7 +12030,7 @@ EXPORTS ?titleHeight@QDockWidgetLayout@@QBEHXZ @ 12029 NONAME ; int QDockWidgetLayout::titleHeight(void) const ?setTabKeyNavigation@QAbstractItemView@@QAEX_N@Z @ 12030 NONAME ; void QAbstractItemView::setTabKeyNavigation(bool) ?dragMoveEvent@QGraphicsView@@MAEXPAVQDragMoveEvent@@@Z @ 12031 NONAME ; void QGraphicsView::dragMoveEvent(class QDragMoveEvent *) - ?blurHint@QGraphicsBlurEffect@@QBE?AW4RenderHint@Qt@@XZ @ 12032 NONAME ; enum Qt::RenderHint QGraphicsBlurEffect::blurHint(void) const + ?blurHint@QGraphicsBlurEffect@@QBE?AW4RenderHint@Qt@@XZ @ 12032 NONAME ABSENT ; enum Qt::RenderHint QGraphicsBlurEffect::blurHint(void) const ?currentBlockState@QSyntaxHighlighter@@IBEHXZ @ 12033 NONAME ; int QSyntaxHighlighter::currentBlockState(void) const ?takeHorizontalHeaderItem@QStandardItemModel@@QAEPAVQStandardItem@@H@Z @ 12034 NONAME ; class QStandardItem * QStandardItemModel::takeHorizontalHeaderItem(int) ?setWidgetResizable@QScrollArea@@QAEX_N@Z @ 12035 NONAME ; void QScrollArea::setWidgetResizable(bool) @@ -12193,7 +12193,7 @@ EXPORTS ?setTextColor@QTreeWidgetItem@@QAEXHABVQColor@@@Z @ 12192 NONAME ; void QTreeWidgetItem::setTextColor(int, class QColor const &) ?addOutlineToPath@QFontEngine@@UAEXMMABUQGlyphLayout@@PAVQPainterPath@@V?$QFlags@W4RenderFlag@QTextItem@@@@@Z @ 12193 NONAME ; void QFontEngine::addOutlineToPath(float, float, struct QGlyphLayout const &, class QPainterPath *, class QFlags) ?hideRow@QTableView@@QAEXH@Z @ 12194 NONAME ; void QTableView::hideRow(int) - ?lookAt@QMatrix4x4@@QAEAAV1@ABVQVector3D@@00@Z @ 12195 NONAME ; class QMatrix4x4 & QMatrix4x4::lookAt(class QVector3D const &, class QVector3D const &, class QVector3D const &) + ?lookAt@QMatrix4x4@@QAEAAV1@ABVQVector3D@@00@Z @ 12195 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::lookAt(class QVector3D const &, class QVector3D const &, class QVector3D const &) ?takeTopLevelItem@QTreeWidget@@QAEPAVQTreeWidgetItem@@H@Z @ 12196 NONAME ; class QTreeWidgetItem * QTreeWidget::takeTopLevelItem(int) ?setPopupMode@QToolButton@@QAEXW4ToolButtonPopupMode@1@@Z @ 12197 NONAME ; void QToolButton::setPopupMode(enum QToolButton::ToolButtonPopupMode) ?setDragEnabled@QStandardItem@@QAEX_N@Z @ 12198 NONAME ; void QStandardItem::setDragEnabled(bool) @@ -12545,7 +12545,7 @@ EXPORTS ?fontEngine@QTextEngine@@QBEPAVQFontEngine@@ABUQScriptItem@@PAUQFixed@@11@Z @ 12544 NONAME ; class QFontEngine * QTextEngine::fontEngine(struct QScriptItem const &, struct QFixed *, struct QFixed *, struct QFixed *) const ?leading@QTextLine@@QBEMXZ @ 12545 NONAME ; float QTextLine::leading(void) const ?leadingIncluded@QTextLine@@QBE_NXZ @ 12546 NONAME ; bool QTextLine::leadingIncluded(void) const - ?projectedRotate@QMatrix4x4@@AAEAAV1@MMMM@Z @ 12547 NONAME ; class QMatrix4x4 & QMatrix4x4::projectedRotate(float, float, float, float) + ?projectedRotate@QMatrix4x4@@AAEAAV1@MMMM@Z @ 12547 NONAME ABSENT ; class QMatrix4x4 & QMatrix4x4::projectedRotate(float, float, float, float) ?setLeadingIncluded@QTextLine@@QAEX_N@Z @ 12548 NONAME ; void QTextLine::setLeadingIncluded(bool) ?toTransform@QMatrix4x4@@QBE?AVQTransform@@XZ @ 12549 NONAME ; class QTransform QMatrix4x4::toTransform(void) const ??0QStyleOptionTabWidgetFrameV2@@IAE@H@Z @ 12550 NONAME ; QStyleOptionTabWidgetFrameV2::QStyleOptionTabWidgetFrameV2(int) @@ -12572,7 +12572,7 @@ EXPORTS ?lookupCacheData@QVectorPath@@QBEPAUCacheEntry@1@PAVQPaintEngineEx@@@Z @ 12571 NONAME ; struct QVectorPath::CacheEntry * QVectorPath::lookupCacheData(class QPaintEngineEx *) const ?pixmap@QGraphicsEffectSource@@QBE?AVQPixmap@@W4CoordinateSystem@Qt@@PAVQPoint@@W4PixmapPadMode@1@@Z @ 12572 NONAME ; class QPixmap QGraphicsEffectSource::pixmap(enum Qt::CoordinateSystem, class QPoint *, enum QGraphicsEffectSource::PixmapPadMode) const ?radius@QPixmapBlurFilter@@QBEMXZ @ 12573 NONAME ; float QPixmapBlurFilter::radius(void) const - ?registerGestureRecognizer@QApplication@@SA?AW4GestureType@Qt@@PAVQGestureRecognizer@@@Z @ 12574 NONAME ; enum Qt::GestureType QApplication::registerGestureRecognizer(class QGestureRecognizer *) + ?registerGestureRecognizer@QApplication@@SA?AW4GestureType@Qt@@PAVQGestureRecognizer@@@Z @ 12574 NONAME ABSENT ; enum Qt::GestureType QApplication::registerGestureRecognizer(class QGestureRecognizer *) ?setAccepted@QGestureEvent@@QAEXW4GestureType@Qt@@_N@Z @ 12575 NONAME ; void QGestureEvent::setAccepted(enum Qt::GestureType, bool) ?setBlurRadius@QGraphicsBlurEffect@@QAEXM@Z @ 12576 NONAME ; void QGraphicsBlurEffect::setBlurRadius(float) ?setBlurRadius@QGraphicsDropShadowEffect@@QAEXM@Z @ 12577 NONAME ; void QGraphicsDropShadowEffect::setBlurRadius(float) @@ -12581,5 +12581,54 @@ EXPORTS ?setRadius@QPixmapBlurFilter@@QAEXM@Z @ 12580 NONAME ; void QPixmapBlurFilter::setRadius(float) ?topLevelChanged@QToolBar@@IAEX_N@Z @ 12581 NONAME ; void QToolBar::topLevelChanged(bool) ?ungrabGesture@QWidget@@QAEXW4GestureType@Qt@@@Z @ 12582 NONAME ; void QWidget::ungrabGesture(enum Qt::GestureType) - ?unregisterGestureRecognizer@QApplication@@SAXW4GestureType@Qt@@@Z @ 12583 NONAME ; void QApplication::unregisterGestureRecognizer(enum Qt::GestureType) + ?blurHint@QGraphicsBlurEffect@@QBE?AW4BlurHint@1@XZ @ 12583 NONAME ; enum QGraphicsBlurEffect::BlurHint QGraphicsBlurEffect::blurHint(void) const + ?blurHint@QPixmapBlurFilter@@QBE?AW4BlurHint@QGraphicsBlurEffect@@XZ @ 12584 NONAME ; enum QGraphicsBlurEffect::BlurHint QPixmapBlurFilter::blurHint(void) const + ?blurHintChanged@QGraphicsBlurEffect@@IAEXW4BlurHint@1@@Z @ 12585 NONAME ; void QGraphicsBlurEffect::blurHintChanged(enum QGraphicsBlurEffect::BlurHint) + ?changeFlags@QPinchGesture@@QBE?AV?$QFlags@W4ChangeFlag@QPinchGesture@@@@XZ @ 12586 NONAME ; class QFlags QPinchGesture::changeFlags(void) const + ?copyDataTo@QMatrix4x4@@QBEXPAM@Z @ 12587 NONAME ; void QMatrix4x4::copyDataTo(float *) const + ?create@QGestureRecognizer@@UAEPAVQGesture@@PAVQObject@@@Z @ 12588 NONAME ; class QGesture * QGestureRecognizer::create(class QObject *) + ?create@QPixmapData@@SAPAV1@HHW4PixelType@1@@Z @ 12589 NONAME ; class QPixmapData * QPixmapData::create(int, int, enum QPixmapData::PixelType) + ?delta@QPanGesture@@QBE?AVQPointF@@XZ @ 12590 NONAME ; class QPointF QPanGesture::delta(void) const + ?enableCleanupHooks@QImagePixmapCleanupHooks@@SAXABVQImage@@@Z @ 12591 NONAME ; void QImagePixmapCleanupHooks::enableCleanupHooks(class QImage const &) + ?enableCleanupHooks@QImagePixmapCleanupHooks@@SAXABVQPixmap@@@Z @ 12592 NONAME ; void QImagePixmapCleanupHooks::enableCleanupHooks(class QPixmap const &) + ?enableCleanupHooks@QImagePixmapCleanupHooks@@SAXPAVQPixmapData@@@Z @ 12593 NONAME ; void QImagePixmapCleanupHooks::enableCleanupHooks(class QPixmapData *) + ?flipCoordinates@QMatrix4x4@@QAEXXZ @ 12594 NONAME ; void QMatrix4x4::flipCoordinates(void) + ?frustum@QMatrix4x4@@QAEXMMMMMM@Z @ 12595 NONAME ; void QMatrix4x4::frustum(float, float, float, float, float, float) + ?gestures@QGestureEvent@@QBE?AV?$QList@PAVQGesture@@@@XZ @ 12596 NONAME ; class QList QGestureEvent::gestures(void) const + ?grabGesture@QGraphicsObject@@QAEXW4GestureType@Qt@@V?$QFlags@W4GestureFlag@Qt@@@@@Z @ 12597 NONAME ; void QGraphicsObject::grabGesture(enum Qt::GestureType, class QFlags) + ?grabGesture@QWidget@@QAEXW4GestureType@Qt@@V?$QFlags@W4GestureFlag@Qt@@@@@Z @ 12598 NONAME ; void QWidget::grabGesture(enum Qt::GestureType, class QFlags) + ?hitTestPath@QMouseEventTransition@@QBE?AVQPainterPath@@XZ @ 12599 NONAME ; class QPainterPath QMouseEventTransition::hitTestPath(void) const + ?lookAt@QMatrix4x4@@QAEXABVQVector3D@@00@Z @ 12600 NONAME ; void QMatrix4x4::lookAt(class QVector3D const &, class QVector3D const &, class QVector3D const &) + ?mapToGraphicsScene@QGestureEvent@@QBE?AVQPointF@@ABV2@@Z @ 12601 NONAME ; class QPointF QGestureEvent::mapToGraphicsScene(class QPointF const &) const + ?modifierMask@QKeyEventTransition@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 12602 NONAME ; class QFlags QKeyEventTransition::modifierMask(void) const + ?modifierMask@QMouseEventTransition@@QBE?AV?$QFlags@W4KeyboardModifier@Qt@@@@XZ @ 12603 NONAME ; class QFlags QMouseEventTransition::modifierMask(void) const + ?optimize@QMatrix4x4@@QAEXXZ @ 12604 NONAME ; void QMatrix4x4::optimize(void) + ?ortho@QMatrix4x4@@QAEXABVQRect@@@Z @ 12605 NONAME ; void QMatrix4x4::ortho(class QRect const &) + ?ortho@QMatrix4x4@@QAEXABVQRectF@@@Z @ 12606 NONAME ; void QMatrix4x4::ortho(class QRectF const &) + ?ortho@QMatrix4x4@@QAEXMMMMMM@Z @ 12607 NONAME ; void QMatrix4x4::ortho(float, float, float, float, float, float) + ?perspective@QMatrix4x4@@QAEXMMMM@Z @ 12608 NONAME ; void QMatrix4x4::perspective(float, float, float, float) + ?projectedRotate@QMatrix4x4@@AAEXMMMM@Z @ 12609 NONAME ; void QMatrix4x4::projectedRotate(float, float, float, float) + ?registerRecognizer@QGestureRecognizer@@SA?AW4GestureType@Qt@@PAV1@@Z @ 12610 NONAME ; enum Qt::GestureType QGestureRecognizer::registerRecognizer(class QGestureRecognizer *) + ?rotate@QMatrix4x4@@QAEXABVQQuaternion@@@Z @ 12611 NONAME ; void QMatrix4x4::rotate(class QQuaternion const &) + ?rotate@QMatrix4x4@@QAEXMABVQVector3D@@@Z @ 12612 NONAME ; void QMatrix4x4::rotate(float, class QVector3D const &) + ?rotate@QMatrix4x4@@QAEXMMMM@Z @ 12613 NONAME ; void QMatrix4x4::rotate(float, float, float, float) + ?rotatedVector@QQuaternion@@QBE?AVQVector3D@@ABV2@@Z @ 12614 NONAME ; class QVector3D QQuaternion::rotatedVector(class QVector3D const &) const + ?scale@QMatrix4x4@@QAEXABVQVector3D@@@Z @ 12615 NONAME ; void QMatrix4x4::scale(class QVector3D const &) + ?scale@QMatrix4x4@@QAEXM@Z @ 12616 NONAME ; void QMatrix4x4::scale(float) + ?scale@QMatrix4x4@@QAEXMM@Z @ 12617 NONAME ; void QMatrix4x4::scale(float, float) + ?scale@QMatrix4x4@@QAEXMMM@Z @ 12618 NONAME ; void QMatrix4x4::scale(float, float, float) + ?setBlurHint@QGraphicsBlurEffect@@QAEXW4BlurHint@1@@Z @ 12619 NONAME ; void QGraphicsBlurEffect::setBlurHint(enum QGraphicsBlurEffect::BlurHint) + ?setBlurHint@QPixmapBlurFilter@@QAEXW4BlurHint@QGraphicsBlurEffect@@@Z @ 12620 NONAME ; void QPixmapBlurFilter::setBlurHint(enum QGraphicsBlurEffect::BlurHint) + ?setChangeFlags@QPinchGesture@@QAEXV?$QFlags@W4ChangeFlag@QPinchGesture@@@@@Z @ 12621 NONAME ; void QPinchGesture::setChangeFlags(class QFlags) + ?setHitTestPath@QMouseEventTransition@@QAEXABVQPainterPath@@@Z @ 12622 NONAME ; void QMouseEventTransition::setHitTestPath(class QPainterPath const &) + ?setModifierMask@QKeyEventTransition@@QAEXV?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 12623 NONAME ; void QKeyEventTransition::setModifierMask(class QFlags) + ?setModifierMask@QMouseEventTransition@@QAEXV?$QFlags@W4KeyboardModifier@Qt@@@@@Z @ 12624 NONAME ; void QMouseEventTransition::setModifierMask(class QFlags) + ?setToIdentity@QMatrix4x4@@QAEXXZ @ 12625 NONAME ; void QMatrix4x4::setToIdentity(void) + ?setTotalChangeFlags@QPinchGesture@@QAEXV?$QFlags@W4ChangeFlag@QPinchGesture@@@@@Z @ 12626 NONAME ; void QPinchGesture::setTotalChangeFlags(class QFlags) + ?totalChangeFlags@QPinchGesture@@QBE?AV?$QFlags@W4ChangeFlag@QPinchGesture@@@@XZ @ 12627 NONAME ; class QFlags QPinchGesture::totalChangeFlags(void) const + ?translate@QMatrix4x4@@QAEXABVQVector3D@@@Z @ 12628 NONAME ; void QMatrix4x4::translate(class QVector3D const &) + ?translate@QMatrix4x4@@QAEXMM@Z @ 12629 NONAME ; void QMatrix4x4::translate(float, float) + ?translate@QMatrix4x4@@QAEXMMM@Z @ 12630 NONAME ; void QMatrix4x4::translate(float, float, float) + ?ungrabGesture@QGraphicsObject@@QAEXW4GestureType@Qt@@@Z @ 12631 NONAME ; void QGraphicsObject::ungrabGesture(enum Qt::GestureType) + ?unregisterRecognizer@QGestureRecognizer@@SAXW4GestureType@Qt@@@Z @ 12632 NONAME ; void QGestureRecognizer::unregisterRecognizer(enum Qt::GestureType) diff --git a/src/s60installs/bwins/QtMultimediau.def b/src/s60installs/bwins/QtMultimediau.def index 9bdd77b..98913c7 100644 --- a/src/s60installs/bwins/QtMultimediau.def +++ b/src/s60installs/bwins/QtMultimediau.def @@ -9,10 +9,10 @@ EXPORTS ?tr@QAudioOutput@@SA?AVQString@@PBD0@Z @ 8 NONAME ; class QString QAudioOutput::tr(char const *, char const *) ?tr@QAbstractVideoSurface@@SA?AVQString@@PBD0@Z @ 9 NONAME ; class QString QAbstractVideoSurface::tr(char const *, char const *) ?width@QVideoFrame@@QBEHXZ @ 10 NONAME ; int QVideoFrame::width(void) const - ?setFrameSize@QVideoSurfaceFormat@@QAEXABVQSize@@W4ViewportMode@1@@Z @ 11 NONAME ; void QVideoSurfaceFormat::setFrameSize(class QSize const &, enum QVideoSurfaceFormat::ViewportMode) + ?setFrameSize@QVideoSurfaceFormat@@QAEXABVQSize@@W4ViewportMode@1@@Z @ 11 NONAME ABSENT ; void QVideoSurfaceFormat::setFrameSize(class QSize const &, enum QVideoSurfaceFormat::ViewportMode) ?trUtf8@QAbstractAudioInput@@SA?AVQString@@PBD0H@Z @ 12 NONAME ; class QString QAbstractAudioInput::trUtf8(char const *, char const *, int) ?metaObject@QAbstractAudioDeviceInfo@@UBEPBUQMetaObject@@XZ @ 13 NONAME ; struct QMetaObject const * QAbstractAudioDeviceInfo::metaObject(void) const - ?isFormatSupported@QAbstractVideoSurface@@UBE_NABVQVideoSurfaceFormat@@PAV2@@Z @ 14 NONAME ; bool QAbstractVideoSurface::isFormatSupported(class QVideoSurfaceFormat const &, class QVideoSurfaceFormat *) const + ?isFormatSupported@QAbstractVideoSurface@@UBE_NABVQVideoSurfaceFormat@@PAV2@@Z @ 14 NONAME ABSENT ; bool QAbstractVideoSurface::isFormatSupported(class QVideoSurfaceFormat const &, class QVideoSurfaceFormat *) const ?setFieldType@QVideoFrame@@QAEXW4FieldType@1@@Z @ 15 NONAME ; void QVideoFrame::setFieldType(enum QVideoFrame::FieldType) ?trUtf8@QAbstractAudioDeviceInfo@@SA?AVQString@@PBD0@Z @ 16 NONAME ; class QString QAbstractAudioDeviceInfo::trUtf8(char const *, char const *) ?tr@QAbstractAudioOutput@@SA?AVQString@@PBD0@Z @ 17 NONAME ; class QString QAbstractAudioOutput::tr(char const *, char const *) @@ -31,7 +31,7 @@ EXPORTS ??4QVideoSurfaceFormat@@QAEAAV0@ABV0@@Z @ 30 NONAME ; class QVideoSurfaceFormat & QVideoSurfaceFormat::operator=(class QVideoSurfaceFormat const &) ??1QAbstractVideoBuffer@@UAE@XZ @ 31 NONAME ; QAbstractVideoBuffer::~QAbstractVideoBuffer(void) ?stop@QAudioOutput@@QAEXXZ @ 32 NONAME ; void QAudioOutput::stop(void) - ?setYuvColorSpace@QVideoSurfaceFormat@@QAEXW4YuvColorSpace@1@@Z @ 33 NONAME ; void QVideoSurfaceFormat::setYuvColorSpace(enum QVideoSurfaceFormat::YuvColorSpace) + ?setYuvColorSpace@QVideoSurfaceFormat@@QAEXW4YuvColorSpace@1@@Z @ 33 NONAME ABSENT ; void QVideoSurfaceFormat::setYuvColorSpace(enum QVideoSurfaceFormat::YuvColorSpace) ?bytesFree@QAudioOutput@@QBEHXZ @ 34 NONAME ; int QAudioOutput::bytesFree(void) const ?trUtf8@QAbstractAudioOutput@@SA?AVQString@@PBD0H@Z @ 35 NONAME ; class QString QAbstractAudioOutput::trUtf8(char const *, char const *, int) ??9QVideoSurfaceFormat@@QBE_NABV0@@Z @ 36 NONAME ; bool QVideoSurfaceFormat::operator!=(class QVideoSurfaceFormat const &) const @@ -50,7 +50,7 @@ EXPORTS ?property@QVideoSurfaceFormat@@QBE?AVQVariant@@PBD@Z @ 49 NONAME ; class QVariant QVideoSurfaceFormat::property(char const *) const ?qt_metacast@QAudioOutput@@UAEPAXPBD@Z @ 50 NONAME ; void * QAudioOutput::qt_metacast(char const *) ??_EQAudioOutput@@UAE@I@Z @ 51 NONAME ; QAudioOutput::~QAudioOutput(unsigned int) - ?yuvColorSpace@QVideoSurfaceFormat@@QBE?AW4YuvColorSpace@1@XZ @ 52 NONAME ; enum QVideoSurfaceFormat::YuvColorSpace QVideoSurfaceFormat::yuvColorSpace(void) const + ?yuvColorSpace@QVideoSurfaceFormat@@QBE?AW4YuvColorSpace@1@XZ @ 52 NONAME ABSENT ; enum QVideoSurfaceFormat::YuvColorSpace QVideoSurfaceFormat::yuvColorSpace(void) const ?supportedSampleTypes@QAudioDeviceInfo@@QBE?AV?$QList@W4SampleType@QAudioFormat@@@@XZ @ 53 NONAME ; class QList QAudioDeviceInfo::supportedSampleTypes(void) const ?sizeHint@QVideoSurfaceFormat@@QBE?AVQSize@@XZ @ 54 NONAME ; class QSize QVideoSurfaceFormat::sizeHint(void) const ?setError@QAbstractVideoSurface@@IAEXW4Error@1@@Z @ 55 NONAME ; void QAbstractVideoSurface::setError(enum QAbstractVideoSurface::Error) @@ -91,7 +91,7 @@ EXPORTS ?nearestFormat@QAudioDeviceInfo@@QBE?AVQAudioFormat@@ABV2@@Z @ 90 NONAME ; class QAudioFormat QAudioDeviceInfo::nearestFormat(class QAudioFormat const &) const ??0QVideoSurfaceFormat@@QAE@XZ @ 91 NONAME ; QVideoSurfaceFormat::QVideoSurfaceFormat(void) ?trUtf8@QAudioOutput@@SA?AVQString@@PBD0H@Z @ 92 NONAME ; class QString QAudioOutput::trUtf8(char const *, char const *, int) - ?numBytes@QVideoFrame@@QBEHXZ @ 93 NONAME ; int QVideoFrame::numBytes(void) const + ?numBytes@QVideoFrame@@QBEHXZ @ 93 NONAME ABSENT ; int QVideoFrame::numBytes(void) const ?isFormatSupported@QAudioDeviceInfo@@QBE_NABVQAudioFormat@@@Z @ 94 NONAME ; bool QAudioDeviceInfo::isFormatSupported(class QAudioFormat const &) const ?isNull@QAudioDeviceInfo@@QBE_NXZ @ 95 NONAME ; bool QAudioDeviceInfo::isNull(void) const ?supportedByteOrders@QAudioDeviceInfo@@QBE?AV?$QList@W4Endian@QAudioFormat@@@@XZ @ 96 NONAME ; class QList QAudioDeviceInfo::supportedByteOrders(void) const @@ -105,7 +105,7 @@ EXPORTS ?getStaticMetaObject@QAbstractAudioDeviceInfo@@SAABUQMetaObject@@XZ @ 104 NONAME ; struct QMetaObject const & QAbstractAudioDeviceInfo::getStaticMetaObject(void) ?notify@QAbstractAudioOutput@@IAEXXZ @ 105 NONAME ; void QAbstractAudioOutput::notify(void) ?handle@QVideoFrame@@QBE?AVQVariant@@XZ @ 106 NONAME ; class QVariant QVideoFrame::handle(void) const - ?equivalentPixelFormat@QVideoFrame@@SA?AW4PixelFormat@1@W4Format@QImage@@@Z @ 107 NONAME ; enum QVideoFrame::PixelFormat QVideoFrame::equivalentPixelFormat(enum QImage::Format) + ?equivalentPixelFormat@QVideoFrame@@SA?AW4PixelFormat@1@W4Format@QImage@@@Z @ 107 NONAME ABSENT ; enum QVideoFrame::PixelFormat QVideoFrame::equivalentPixelFormat(enum QImage::Format) ?setNotifyInterval@QAudioInput@@QAEXH@Z @ 108 NONAME ; void QAudioInput::setNotifyInterval(int) ?getStaticMetaObject@QAudioEnginePlugin@@SAABUQMetaObject@@XZ @ 109 NONAME ; struct QMetaObject const & QAudioEnginePlugin::getStaticMetaObject(void) ??0QVideoFrame@@QAE@PAVQAbstractVideoBuffer@@ABVQSize@@W4PixelFormat@0@@Z @ 110 NONAME ; QVideoFrame::QVideoFrame(class QAbstractVideoBuffer *, class QSize const &, enum QVideoFrame::PixelFormat) @@ -171,7 +171,7 @@ EXPORTS ?frameHeight@QVideoSurfaceFormat@@QBEHXZ @ 170 NONAME ; int QVideoSurfaceFormat::frameHeight(void) const ?unmap@QImageVideoBuffer@@UAEXXZ @ 171 NONAME ; void QImageVideoBuffer::unmap(void) ?tr@QAbstractAudioOutput@@SA?AVQString@@PBD0H@Z @ 172 NONAME ; class QString QAbstractAudioOutput::tr(char const *, char const *, int) - ?setFrameSize@QVideoSurfaceFormat@@QAEXHHW4ViewportMode@1@@Z @ 173 NONAME ; void QVideoSurfaceFormat::setFrameSize(int, int, enum QVideoSurfaceFormat::ViewportMode) + ?setFrameSize@QVideoSurfaceFormat@@QAEXHHW4ViewportMode@1@@Z @ 173 NONAME ABSENT ; void QVideoSurfaceFormat::setFrameSize(int, int, enum QVideoSurfaceFormat::ViewportMode) ??1QAbstractAudioInput@@UAE@XZ @ 174 NONAME ; QAbstractAudioInput::~QAbstractAudioInput(void) ?setViewport@QVideoSurfaceFormat@@QAEXABVQRect@@@Z @ 175 NONAME ; void QVideoSurfaceFormat::setViewport(class QRect const &) ?tr@QAbstractAudioDeviceInfo@@SA?AVQString@@PBD0H@Z @ 176 NONAME ; class QString QAbstractAudioDeviceInfo::tr(char const *, char const *, int) @@ -192,9 +192,9 @@ EXPORTS ?tr@QAbstractVideoSurface@@SA?AVQString@@PBD0H@Z @ 191 NONAME ; class QString QAbstractVideoSurface::tr(char const *, char const *, int) ?periodSize@QAudioInput@@QBEHXZ @ 192 NONAME ; int QAudioInput::periodSize(void) const ?setFrameRate@QVideoSurfaceFormat@@QAEXM@Z @ 193 NONAME ; void QVideoSurfaceFormat::setFrameRate(float) - ?equivalentImageFormat@QVideoFrame@@SA?AW4Format@QImage@@W4PixelFormat@1@@Z @ 194 NONAME ; enum QImage::Format QVideoFrame::equivalentImageFormat(enum QVideoFrame::PixelFormat) + ?equivalentImageFormat@QVideoFrame@@SA?AW4Format@QImage@@W4PixelFormat@1@@Z @ 194 NONAME ABSENT ; enum QImage::Format QVideoFrame::equivalentImageFormat(enum QVideoFrame::PixelFormat) ?handle@QAudioDeviceInfo@@ABE?AVQByteArray@@XZ @ 195 NONAME ; class QByteArray QAudioDeviceInfo::handle(void) const - ?startedChanged@QAbstractVideoSurface@@IAEX_N@Z @ 196 NONAME ; void QAbstractVideoSurface::startedChanged(bool) + ?startedChanged@QAbstractVideoSurface@@IAEX_N@Z @ 196 NONAME ABSENT ; void QAbstractVideoSurface::startedChanged(bool) ??0QVideoFrame@@QAE@HABVQSize@@HW4PixelFormat@0@@Z @ 197 NONAME ; QVideoFrame::QVideoFrame(int, class QSize const &, int, enum QVideoFrame::PixelFormat) ?handle@QAbstractVideoBuffer@@UBE?AVQVariant@@XZ @ 198 NONAME ; class QVariant QAbstractVideoBuffer::handle(void) const ?handleType@QAbstractVideoBuffer@@QBE?AW4HandleType@1@XZ @ 199 NONAME ; enum QAbstractVideoBuffer::HandleType QAbstractVideoBuffer::handleType(void) const @@ -232,7 +232,7 @@ EXPORTS ??1QAudioEngineFactoryInterface@@UAE@XZ @ 231 NONAME ; QAudioEngineFactoryInterface::~QAudioEngineFactoryInterface(void) ?notify@QAudioOutput@@IAEXXZ @ 232 NONAME ; void QAudioOutput::notify(void) ?stateChanged@QAudioOutput@@IAEXW4State@QAudio@@@Z @ 233 NONAME ; void QAudioOutput::stateChanged(enum QAudio::State) - ?isStarted@QAbstractVideoSurface@@QBE_NXZ @ 234 NONAME ; bool QAbstractVideoSurface::isStarted(void) const + ?isStarted@QAbstractVideoSurface@@QBE_NXZ @ 234 NONAME ABSENT ; bool QAbstractVideoSurface::isStarted(void) const ??0QAudioDeviceInfo@@QAE@ABV0@@Z @ 235 NONAME ; QAudioDeviceInfo::QAudioDeviceInfo(class QAudioDeviceInfo const &) ??1QAudioOutput@@UAE@XZ @ 236 NONAME ; QAudioOutput::~QAudioOutput(void) ?tr@QAudioInput@@SA?AVQString@@PBD0@Z @ 237 NONAME ; class QString QAudioInput::tr(char const *, char const *) @@ -270,4 +270,15 @@ EXPORTS ?qt_metacast@QAbstractAudioOutput@@UAEPAXPBD@Z @ 269 NONAME ; void * QAbstractAudioOutput::qt_metacast(char const *) ??1QVideoSurfaceFormat@@QAE@XZ @ 270 NONAME ; QVideoSurfaceFormat::~QVideoSurfaceFormat(void) ??_EQAudioDeviceInfo@@QAE@I@Z @ 271 NONAME ABSENT ; QAudioDeviceInfo::~QAudioDeviceInfo(unsigned int) + ?activeChanged@QAbstractVideoSurface@@IAEX_N@Z @ 272 NONAME ; void QAbstractVideoSurface::activeChanged(bool) + ?imageFormatFromPixelFormat@QVideoFrame@@SA?AW4Format@QImage@@W4PixelFormat@1@@Z @ 273 NONAME ; enum QImage::Format QVideoFrame::imageFormatFromPixelFormat(enum QVideoFrame::PixelFormat) + ?isActive@QAbstractVideoSurface@@QBE_NXZ @ 274 NONAME ; bool QAbstractVideoSurface::isActive(void) const + ?isFormatSupported@QAbstractVideoSurface@@UBE_NABVQVideoSurfaceFormat@@@Z @ 275 NONAME ; bool QAbstractVideoSurface::isFormatSupported(class QVideoSurfaceFormat const &) const + ?mappedBytes@QVideoFrame@@QBEHXZ @ 276 NONAME ; int QVideoFrame::mappedBytes(void) const + ?nearestFormat@QAbstractVideoSurface@@UBE?AVQVideoSurfaceFormat@@ABV2@@Z @ 277 NONAME ; class QVideoSurfaceFormat QAbstractVideoSurface::nearestFormat(class QVideoSurfaceFormat const &) const + ?pixelFormatFromImageFormat@QVideoFrame@@SA?AW4PixelFormat@1@W4Format@QImage@@@Z @ 278 NONAME ; enum QVideoFrame::PixelFormat QVideoFrame::pixelFormatFromImageFormat(enum QImage::Format) + ?setFrameSize@QVideoSurfaceFormat@@QAEXABVQSize@@@Z @ 279 NONAME ; void QVideoSurfaceFormat::setFrameSize(class QSize const &) + ?setFrameSize@QVideoSurfaceFormat@@QAEXHH@Z @ 280 NONAME ; void QVideoSurfaceFormat::setFrameSize(int, int) + ?setYCbCrColorSpace@QVideoSurfaceFormat@@QAEXW4YCbCrColorSpace@1@@Z @ 281 NONAME ; void QVideoSurfaceFormat::setYCbCrColorSpace(enum QVideoSurfaceFormat::YCbCrColorSpace) + ?yCbCrColorSpace@QVideoSurfaceFormat@@QBE?AW4YCbCrColorSpace@1@XZ @ 282 NONAME ; enum QVideoSurfaceFormat::YCbCrColorSpace QVideoSurfaceFormat::yCbCrColorSpace(void) const diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index e6345cb..2fd8d0c 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -3,7 +3,7 @@ EXPORTS _Z10noshowbaseR11QTextStream @ 2 NONAME _Z10qAllocMoreii @ 3 NONAME _Z10qHBNewFacePvPFY8HB_ErrorS_jPhPjE @ 4 NONAME - _Z10qShapeItemP13HB_ShaperItem @ 5 NONAME + _Z10qShapeItemP13HB_ShaperItem @ 5 NONAME ABSENT _Z10qvsnprintfPcjPKcSt9__va_list @ 6 NONAME _Z10scientificR11QTextStream @ 7 NONAME _Z11noforcesignR11QTextStream @ 8 NONAME @@ -556,7 +556,7 @@ EXPORTS _ZN13QStateMachine19addDefaultAnimationEP18QAbstractAnimation @ 555 NONAME _ZN13QStateMachine19getStaticMetaObjectEv @ 556 NONAME _ZN13QStateMachine20endSelectTransitionsEP6QEvent @ 557 NONAME - _ZN13QStateMachine20setAnimationsEnabledEb @ 558 NONAME + _ZN13QStateMachine20setAnimationsEnabledEb @ 558 NONAME ABSENT _ZN13QStateMachine22beginSelectTransitionsEP6QEvent @ 559 NONAME _ZN13QStateMachine22removeDefaultAnimationEP18QAbstractAnimation @ 560 NONAME _ZN13QStateMachine22setGlobalRestorePolicyENS_13RestorePolicyE @ 561 NONAME @@ -1694,7 +1694,7 @@ EXPORTS _ZN6QState6onExitEP6QEvent @ 1693 NONAME _ZN6QState7onEntryEP6QEvent @ 1694 NONAME _ZN6QState8finishedEv @ 1695 NONAME - _ZN6QState8polishedEv @ 1696 NONAME + _ZN6QState8polishedEv @ 1696 NONAME ABSENT _ZN6QStateC1ENS_9ChildModeEPS_ @ 1697 NONAME _ZN6QStateC1EPS_ @ 1698 NONAME _ZN6QStateC1ER13QStatePrivatePS_ @ 1699 NONAME @@ -2528,7 +2528,7 @@ EXPORTS _ZNK13QStateMachine10metaObjectEv @ 2527 NONAME _ZNK13QStateMachine11errorStringEv @ 2528 NONAME _ZNK13QStateMachine13configurationEv @ 2529 NONAME - _ZNK13QStateMachine17animationsEnabledEv @ 2530 NONAME + _ZNK13QStateMachine17animationsEnabledEv @ 2530 NONAME ABSENT _ZNK13QStateMachine17defaultAnimationsEv @ 2531 NONAME _ZNK13QStateMachine19globalRestorePolicyEv @ 2532 NONAME _ZNK13QStateMachine5errorEv @ 2533 NONAME @@ -3600,4 +3600,15 @@ EXPORTS _ZN8QMapData11node_createEPPNS_4NodeEii @ 3599 NONAME _ZN9QHashData12allocateNodeEi @ 3600 NONAME _ZN9QHashData14detach_helper2EPFvPNS_4NodeEPvEPFvS1_Eii @ 3601 NONAME + _Z10qShapeItemP14HB_ShaperItem_ @ 3602 NONAME + _Z38QBasicAtomicPointer_isTestAndSetNativev @ 3603 NONAME + _Z39QBasicAtomicPointer_isFetchAndAddNativev @ 3604 NONAME + _Z41QBasicAtomicPointer_isFetchAndStoreNativev @ 3605 NONAME + _ZN13QStateMachine11setAnimatedEb @ 3606 NONAME + _ZN15QBasicAtomicInt18isTestAndSetNativeEv @ 3607 NONAME + _ZN15QBasicAtomicInt19isFetchAndAddNativeEv @ 3608 NONAME + _ZN15QBasicAtomicInt21isFetchAndStoreNativeEv @ 3609 NONAME + _ZN15QBasicAtomicInt25isReferenceCountingNativeEv @ 3610 NONAME + _ZN6QState18propertiesAssignedEv @ 3611 NONAME + _ZNK13QStateMachine10isAnimatedEv @ 3612 NONAME diff --git a/src/s60installs/eabi/QtGuiu.def b/src/s60installs/eabi/QtGuiu.def index 5d66fb7..9ea9361 100644 --- a/src/s60installs/eabi/QtGuiu.def +++ b/src/s60installs/eabi/QtGuiu.def @@ -174,7 +174,7 @@ EXPORTS _ZN10QLCDNumberD2Ev @ 173 NONAME _ZN10QMatrix4x411perspectiveEffff @ 174 NONAME _ZN10QMatrix4x415flipCoordinatesEv @ 175 NONAME - _ZN10QMatrix4x416inferSpecialTypeEv @ 176 NONAME + _ZN10QMatrix4x416inferSpecialTypeEv @ 176 NONAME ABSENT _ZN10QMatrix4x45orthoERK5QRect @ 177 NONAME _ZN10QMatrix4x45orthoERK6QRectF @ 178 NONAME _ZN10QMatrix4x45orthoEffffff @ 179 NONAME @@ -1556,10 +1556,10 @@ EXPORTS _ZN12QApplication23keypadNavigationEnabledEv @ 1555 NONAME _ZN12QApplication23setDesktopSettingsAwareEb @ 1556 NONAME _ZN12QApplication24setKeyboardInputIntervalEi @ 1557 NONAME - _ZN12QApplication25registerGestureRecognizerEP18QGestureRecognizer @ 1558 NONAME + _ZN12QApplication25registerGestureRecognizerEP18QGestureRecognizer @ 1558 NONAME ABSENT _ZN12QApplication25setQuitOnLastWindowClosedEb @ 1559 NONAME _ZN12QApplication26setKeypadNavigationEnabledEb @ 1560 NONAME - _ZN12QApplication27unregisterGestureRecognizerEN2Qt11GestureTypeE @ 1561 NONAME + _ZN12QApplication27unregisterGestureRecognizerEN2Qt11GestureTypeE @ 1561 NONAME ABSENT _ZN12QApplication4beepEv @ 1562 NONAME _ZN12QApplication4execEv @ 1563 NONAME _ZN12QApplication4fontEPK7QWidget @ 1564 NONAME @@ -2547,7 +2547,7 @@ EXPORTS _ZN13QPinchGesture11qt_metacastEPKc @ 2546 NONAME _ZN13QPinchGesture14setCenterPointERK7QPointF @ 2547 NONAME _ZN13QPinchGesture14setScaleFactorEf @ 2548 NONAME - _ZN13QPinchGesture14setWhatChangedE6QFlagsINS_10WhatChangeEE @ 2549 NONAME + _ZN13QPinchGesture14setWhatChangedE6QFlagsINS_10WhatChangeEE @ 2549 NONAME ABSENT _ZN13QPinchGesture16setRotationAngleEf @ 2550 NONAME _ZN13QPinchGesture16staticMetaObjectE @ 2551 NONAME DATA 16 _ZN13QPinchGesture18setLastCenterPointERK7QPointF @ 2552 NONAME @@ -3342,7 +3342,7 @@ EXPORTS _ZN15QGraphicsLayoutD0Ev @ 3341 NONAME _ZN15QGraphicsLayoutD1Ev @ 3342 NONAME _ZN15QGraphicsLayoutD2Ev @ 3343 NONAME - _ZN15QGraphicsObject11grabGestureEN2Qt11GestureTypeENS0_14GestureContextE @ 3344 NONAME + _ZN15QGraphicsObject11grabGestureEN2Qt11GestureTypeENS0_14GestureContextE @ 3344 NONAME ABSENT _ZN15QGraphicsObject11qt_metacallEN11QMetaObject4CallEiPPv @ 3345 NONAME _ZN15QGraphicsObject11qt_metacastEPKc @ 3346 NONAME _ZN15QGraphicsObject12scaleChangedEv @ 3347 NONAME @@ -4057,7 +4057,7 @@ EXPORTS _ZN17QInputMethodEventC2Ev @ 4056 NONAME _ZN17QPixmapBlurFilter11qt_metacallEN11QMetaObject4CallEiPPv @ 4057 NONAME _ZN17QPixmapBlurFilter11qt_metacastEPKc @ 4058 NONAME - _ZN17QPixmapBlurFilter11setBlurHintEN2Qt10RenderHintE @ 4059 NONAME + _ZN17QPixmapBlurFilter11setBlurHintEN2Qt10RenderHintE @ 4059 NONAME ABSENT _ZN17QPixmapBlurFilter16staticMetaObjectE @ 4060 NONAME DATA 16 _ZN17QPixmapBlurFilter19getStaticMetaObjectEv @ 4061 NONAME _ZN17QPixmapBlurFilter9setRadiusEi @ 4062 NONAME ABSENT @@ -4118,7 +4118,7 @@ EXPORTS _ZN18QDragResponseEventD0Ev @ 4117 NONAME _ZN18QDragResponseEventD1Ev @ 4118 NONAME _ZN18QDragResponseEventD2Ev @ 4119 NONAME - _ZN18QGestureRecognizer13createGestureEP7QObject @ 4120 NONAME + _ZN18QGestureRecognizer13createGestureEP7QObject @ 4120 NONAME ABSENT _ZN18QGestureRecognizer5resetEP8QGesture @ 4121 NONAME _ZN18QGestureRecognizerC2Ev @ 4122 NONAME _ZN18QGestureRecognizerD0Ev @ 4123 NONAME @@ -4411,9 +4411,9 @@ EXPORTS _ZN19QEventDispatcherS60D2Ev @ 4410 NONAME _ZN19QGraphicsBlurEffect11qt_metacallEN11QMetaObject4CallEiPPv @ 4411 NONAME _ZN19QGraphicsBlurEffect11qt_metacastEPKc @ 4412 NONAME - _ZN19QGraphicsBlurEffect11setBlurHintEN2Qt10RenderHintE @ 4413 NONAME + _ZN19QGraphicsBlurEffect11setBlurHintEN2Qt10RenderHintE @ 4413 NONAME ABSENT _ZN19QGraphicsBlurEffect13setBlurRadiusEi @ 4414 NONAME ABSENT - _ZN19QGraphicsBlurEffect15blurHintChangedEN2Qt10RenderHintE @ 4415 NONAME + _ZN19QGraphicsBlurEffect15blurHintChangedEN2Qt10RenderHintE @ 4415 NONAME ABSENT _ZN19QGraphicsBlurEffect16staticMetaObjectE @ 4416 NONAME DATA 16 _ZN19QGraphicsBlurEffect17blurRadiusChangedEi @ 4417 NONAME ABSENT _ZN19QGraphicsBlurEffect19getStaticMetaObjectEv @ 4418 NONAME @@ -4535,7 +4535,7 @@ EXPORTS _ZN19QKeyEventTransition11qt_metacallEN11QMetaObject4CallEiPPv @ 4534 NONAME _ZN19QKeyEventTransition11qt_metacastEPKc @ 4535 NONAME _ZN19QKeyEventTransition12onTransitionEP6QEvent @ 4536 NONAME - _ZN19QKeyEventTransition16setModifiersMaskE6QFlagsIN2Qt16KeyboardModifierEE @ 4537 NONAME + _ZN19QKeyEventTransition16setModifiersMaskE6QFlagsIN2Qt16KeyboardModifierEE @ 4537 NONAME ABSENT _ZN19QKeyEventTransition16staticMetaObjectE @ 4538 NONAME DATA 16 _ZN19QKeyEventTransition19getStaticMetaObjectEv @ 4539 NONAME _ZN19QKeyEventTransition6setKeyEi @ 4540 NONAME @@ -4890,10 +4890,10 @@ EXPORTS _ZN21QMouseEventTransition11qt_metacallEN11QMetaObject4CallEiPPv @ 4889 NONAME _ZN21QMouseEventTransition11qt_metacastEPKc @ 4890 NONAME _ZN21QMouseEventTransition12onTransitionEP6QEvent @ 4891 NONAME - _ZN21QMouseEventTransition16setModifiersMaskE6QFlagsIN2Qt16KeyboardModifierEE @ 4892 NONAME + _ZN21QMouseEventTransition16setModifiersMaskE6QFlagsIN2Qt16KeyboardModifierEE @ 4892 NONAME ABSENT _ZN21QMouseEventTransition16staticMetaObjectE @ 4893 NONAME DATA 16 _ZN21QMouseEventTransition19getStaticMetaObjectEv @ 4894 NONAME - _ZN21QMouseEventTransition7setPathERK12QPainterPath @ 4895 NONAME + _ZN21QMouseEventTransition7setPathERK12QPainterPath @ 4895 NONAME ABSENT _ZN21QMouseEventTransition9eventTestEP6QEvent @ 4896 NONAME _ZN21QMouseEventTransition9setButtonEN2Qt11MouseButtonE @ 4897 NONAME _ZN21QMouseEventTransitionC1EP6QState @ 4898 NONAME @@ -6180,7 +6180,7 @@ EXPORTS _ZN7QWidget11actionEventEP12QActionEvent @ 6179 NONAME _ZN7QWidget11changeEventEP6QEvent @ 6180 NONAME _ZN7QWidget11createWinIdEv @ 6181 NONAME - _ZN7QWidget11grabGestureEN2Qt11GestureTypeENS0_14GestureContextE @ 6182 NONAME + _ZN7QWidget11grabGestureEN2Qt11GestureTypeENS0_14GestureContextE @ 6182 NONAME ABSENT _ZN7QWidget11qt_metacallEN11QMetaObject4CallEiPPv @ 6183 NONAME _ZN7QWidget11qt_metacastEPKc @ 6184 NONAME _ZN7QWidget11resizeEventEP12QResizeEvent @ 6185 NONAME @@ -7386,10 +7386,10 @@ EXPORTS _ZNK10QMatrix4x411determinantEv @ 7385 NONAME _ZNK10QMatrix4x411toTransformEf @ 7386 NONAME _ZNK10QMatrix4x412normalMatrixEv @ 7387 NONAME - _ZNK10QMatrix4x412toValueArrayEPf @ 7388 NONAME - _ZNK10QMatrix4x418extractTranslationEv @ 7389 NONAME + _ZNK10QMatrix4x412toValueArrayEPf @ 7388 NONAME ABSENT + _ZNK10QMatrix4x418extractTranslationEv @ 7389 NONAME ABSENT _ZNK10QMatrix4x418orthonormalInverseEv @ 7390 NONAME - _ZNK10QMatrix4x419extractAxisRotationERfR9QVector3D @ 7391 NONAME + _ZNK10QMatrix4x419extractAxisRotationERfR9QVector3D @ 7391 NONAME ABSENT _ZNK10QMatrix4x47mapRectERK5QRect @ 7392 NONAME _ZNK10QMatrix4x47mapRectERK6QRectF @ 7393 NONAME _ZNK10QMatrix4x48invertedEPb @ 7394 NONAME @@ -7780,7 +7780,7 @@ EXPORTS _ZNK11QMouseEvent4posFEv @ 7779 NONAME _ZNK11QPanGesture10lastOffsetEv @ 7780 NONAME _ZNK11QPanGesture10metaObjectEv @ 7781 NONAME - _ZNK11QPanGesture11totalOffsetEv @ 7782 NONAME + _ZNK11QPanGesture11totalOffsetEv @ 7782 NONAME ABSENT _ZNK11QPanGesture12accelerationEv @ 7783 NONAME _ZNK11QPanGesture6offsetEv @ 7784 NONAME _ZNK11QPixmapData11transformedERK10QTransformN2Qt18TransformationModeE @ 7785 NONAME @@ -7834,7 +7834,7 @@ EXPORTS _ZNK11QPushButton8sizeHintEv @ 7833 NONAME _ZNK11QPushButton9isDefaultEv @ 7834 NONAME _ZNK11QQuaternion10normalizedEv @ 7835 NONAME - _ZNK11QQuaternion12rotateVectorERK9QVector3D @ 7836 NONAME + _ZNK11QQuaternion12rotateVectorERK9QVector3D @ 7836 NONAME ABSENT _ZNK11QQuaternion13lengthSquaredEv @ 7837 NONAME _ZNK11QQuaternion6lengthEv @ 7838 NONAME _ZNK11QQuaternioncv8QVariantEv @ 7839 NONAME @@ -8394,7 +8394,7 @@ EXPORTS _ZNK13QFontMetricsF9lineWidthEv @ 8393 NONAME _ZNK13QFontMetricsFeqERKS_ @ 8394 NONAME _ZNK13QGestureEvent10isAcceptedEP8QGesture @ 8395 NONAME - _ZNK13QGestureEvent11allGesturesEv @ 8396 NONAME + _ZNK13QGestureEvent11allGesturesEv @ 8396 NONAME ABSENT _ZNK13QGestureEvent14activeGesturesEv @ 8397 NONAME _ZNK13QGestureEvent16canceledGesturesEv @ 8398 NONAME _ZNK13QGraphicsItem10childItemsEv @ 8399 NONAME @@ -8585,7 +8585,7 @@ EXPORTS _ZNK13QPinchGesture10metaObjectEv @ 8584 NONAME _ZNK13QPinchGesture11centerPointEv @ 8585 NONAME _ZNK13QPinchGesture11scaleFactorEv @ 8586 NONAME - _ZNK13QPinchGesture11whatChangedEv @ 8587 NONAME + _ZNK13QPinchGesture11whatChangedEv @ 8587 NONAME ABSENT _ZNK13QPinchGesture13rotationAngleEv @ 8588 NONAME _ZNK13QPinchGesture15lastCenterPointEv @ 8589 NONAME _ZNK13QPinchGesture15lastScaleFactorEv @ 8590 NONAME @@ -9340,7 +9340,7 @@ EXPORTS _ZNK19QItemSelectionRange7indexesEv @ 9339 NONAME _ZNK19QItemSelectionRange9intersectERKS_ @ 9340 NONAME _ZNK19QKeyEventTransition10metaObjectEv @ 9341 NONAME - _ZNK19QKeyEventTransition13modifiersMaskEv @ 9342 NONAME + _ZNK19QKeyEventTransition13modifiersMaskEv @ 9342 NONAME ABSENT _ZNK19QKeyEventTransition3keyEv @ 9343 NONAME _ZNK19QPainterPathStroker10dashOffsetEv @ 9344 NONAME _ZNK19QPainterPathStroker10miterLimitEv @ 9345 NONAME @@ -9442,8 +9442,8 @@ EXPORTS _ZNK21QGraphicsLinearLayout9alignmentEP19QGraphicsLayoutItem @ 9441 NONAME _ZNK21QGraphicsSystemPlugin10metaObjectEv @ 9442 NONAME _ZNK21QMouseEventTransition10metaObjectEv @ 9443 NONAME - _ZNK21QMouseEventTransition13modifiersMaskEv @ 9444 NONAME - _ZNK21QMouseEventTransition4pathEv @ 9445 NONAME + _ZNK21QMouseEventTransition13modifiersMaskEv @ 9444 NONAME ABSENT + _ZNK21QMouseEventTransition4pathEv @ 9445 NONAME ABSENT _ZNK21QMouseEventTransition6buttonEv @ 9446 NONAME _ZNK21QPaintEngineExPrivate17hasClipOperationsEv @ 9447 NONAME _ZNK21QPixmapColorizeFilter10metaObjectEv @ 9448 NONAME @@ -11616,7 +11616,7 @@ EXPORTS _ZNK14QDesktopWidget14screenGeometryEPK7QWidget @ 11615 NONAME _ZNK14QDesktopWidget17availableGeometryEPK7QWidget @ 11616 NONAME _ZN11QPanGesture13setLastOffsetERK7QPointF @ 11617 NONAME - _ZN11QPanGesture14setTotalOffsetERK7QPointF @ 11618 NONAME + _ZN11QPanGesture14setTotalOffsetERK7QPointF @ 11618 NONAME ABSENT _ZN11QPanGesture9setOffsetERK7QPointF @ 11619 NONAME _ZN13QGestureEvent6d_funcEv @ 11620 NONAME _ZN13QGestureEvent9setWidgetEP7QWidget @ 11621 NONAME @@ -11625,7 +11625,7 @@ EXPORTS _ZN13QGestureEventD2Ev @ 11624 NONAME _ZN14QWidgetPrivate36invalidateGraphicsEffectsRecursivelyEv @ 11625 NONAME _ZN20QGraphicsItemPrivate36invalidateGraphicsEffectsRecursivelyEv @ 11626 NONAME - _ZNK13QGestureEvent10mapToSceneERK7QPointF @ 11627 NONAME + _ZNK13QGestureEvent10mapToSceneERK7QPointF @ 11627 NONAME ABSENT _ZNK13QGestureEvent6d_funcEv @ 11628 NONAME _ZNK13QGestureEvent6widgetEv @ 11629 NONAME _Zls6QDebugP15QGraphicsObject @ 11630 NONAME @@ -11660,4 +11660,33 @@ EXPORTS _ZNK13QTextDocument18availableUndoStepsEv @ 11659 NONAME _ZNK21QGraphicsEffectSource6pixmapEN2Qt16CoordinateSystemEP6QPointNS_13PixmapPadModeE @ 11660 NONAME _ZNK8QGesture19gestureCancelPolicyEv @ 11661 NONAME + _ZN10QMatrix4x48optimizeEv @ 11662 NONAME + _ZN11QPixmapData6createEiiNS_9PixelTypeE @ 11663 NONAME + _ZN13QPinchGesture14setChangeFlagsE6QFlagsINS_10ChangeFlagEE @ 11664 NONAME + _ZN13QPinchGesture19setTotalChangeFlagsE6QFlagsINS_10ChangeFlagEE @ 11665 NONAME + _ZN15QGraphicsObject11grabGestureEN2Qt11GestureTypeE6QFlagsINS0_11GestureFlagEE @ 11666 NONAME + _ZN15QGraphicsObject13ungrabGestureEN2Qt11GestureTypeE @ 11667 NONAME + _ZN17QPixmapBlurFilter11setBlurHintEN19QGraphicsBlurEffect8BlurHintE @ 11668 NONAME + _ZN18QGestureRecognizer18registerRecognizerEPS_ @ 11669 NONAME + _ZN18QGestureRecognizer20unregisterRecognizerEN2Qt11GestureTypeE @ 11670 NONAME + _ZN18QGestureRecognizer6createEP7QObject @ 11671 NONAME + _ZN19QGraphicsBlurEffect11setBlurHintENS_8BlurHintE @ 11672 NONAME + _ZN19QGraphicsBlurEffect15blurHintChangedENS_8BlurHintE @ 11673 NONAME + _ZN19QKeyEventTransition15setModifierMaskE6QFlagsIN2Qt16KeyboardModifierEE @ 11674 NONAME + _ZN21QMouseEventTransition14setHitTestPathERK12QPainterPath @ 11675 NONAME + _ZN21QMouseEventTransition15setModifierMaskE6QFlagsIN2Qt16KeyboardModifierEE @ 11676 NONAME + _ZN24QImagePixmapCleanupHooks18enableCleanupHooksEP11QPixmapData @ 11677 NONAME + _ZN24QImagePixmapCleanupHooks18enableCleanupHooksERK6QImage @ 11678 NONAME + _ZN24QImagePixmapCleanupHooks18enableCleanupHooksERK7QPixmap @ 11679 NONAME + _ZN7QWidget11grabGestureEN2Qt11GestureTypeE6QFlagsINS0_11GestureFlagEE @ 11680 NONAME + _ZNK10QMatrix4x410copyDataToEPf @ 11681 NONAME + _ZNK11QPanGesture5deltaEv @ 11682 NONAME + _ZNK11QQuaternion13rotatedVectorERK9QVector3D @ 11683 NONAME + _ZNK13QGestureEvent18mapToGraphicsSceneERK7QPointF @ 11684 NONAME + _ZNK13QGestureEvent8gesturesEv @ 11685 NONAME + _ZNK13QPinchGesture11changeFlagsEv @ 11686 NONAME + _ZNK13QPinchGesture16totalChangeFlagsEv @ 11687 NONAME + _ZNK19QKeyEventTransition12modifierMaskEv @ 11688 NONAME + _ZNK21QMouseEventTransition11hitTestPathEv @ 11689 NONAME + _ZNK21QMouseEventTransition12modifierMaskEv @ 11690 NONAME diff --git a/src/s60installs/eabi/QtMultimediau.def b/src/s60installs/eabi/QtMultimediau.def index 30f921c..db9b761 100644 --- a/src/s60installs/eabi/QtMultimediau.def +++ b/src/s60installs/eabi/QtMultimediau.def @@ -22,8 +22,8 @@ EXPORTS _ZN11QVideoFrame10setEndTimeEx @ 21 NONAME _ZN11QVideoFrame12setFieldTypeENS_9FieldTypeE @ 22 NONAME _ZN11QVideoFrame12setStartTimeEx @ 23 NONAME - _ZN11QVideoFrame21equivalentImageFormatENS_11PixelFormatE @ 24 NONAME - _ZN11QVideoFrame21equivalentPixelFormatEN6QImage6FormatE @ 25 NONAME + _ZN11QVideoFrame21equivalentImageFormatENS_11PixelFormatE @ 24 NONAME ABSENT + _ZN11QVideoFrame21equivalentPixelFormatEN6QImage6FormatE @ 25 NONAME ABSENT _ZN11QVideoFrame3mapEN20QAbstractVideoBuffer7MapModeE @ 26 NONAME _ZN11QVideoFrame4bitsEv @ 27 NONAME _ZN11QVideoFrame5unmapEv @ 28 NONAME @@ -117,9 +117,9 @@ EXPORTS _ZN19QVideoSurfaceFormat11setViewportERK5QRect @ 116 NONAME _ZN19QVideoSurfaceFormat12setFrameRateERK5QPairIiiE @ 117 NONAME ABSENT _ZN19QVideoSurfaceFormat12setFrameRateEii @ 118 NONAME ABSENT - _ZN19QVideoSurfaceFormat12setFrameSizeERK5QSizeNS_12ViewportModeE @ 119 NONAME - _ZN19QVideoSurfaceFormat12setFrameSizeEiiNS_12ViewportModeE @ 120 NONAME - _ZN19QVideoSurfaceFormat16setYuvColorSpaceENS_13YuvColorSpaceE @ 121 NONAME + _ZN19QVideoSurfaceFormat12setFrameSizeERK5QSizeNS_12ViewportModeE @ 119 NONAME ABSENT + _ZN19QVideoSurfaceFormat12setFrameSizeEiiNS_12ViewportModeE @ 120 NONAME ABSENT + _ZN19QVideoSurfaceFormat16setYuvColorSpaceENS_13YuvColorSpaceE @ 121 NONAME ABSENT _ZN19QVideoSurfaceFormat19setPixelAspectRatioERK5QSize @ 122 NONAME _ZN19QVideoSurfaceFormat19setPixelAspectRatioEii @ 123 NONAME _ZN19QVideoSurfaceFormat20setScanLineDirectionENS_9DirectionE @ 124 NONAME @@ -145,7 +145,7 @@ EXPORTS _ZN20QAbstractVideoBufferD2Ev @ 144 NONAME _ZN21QAbstractVideoSurface11qt_metacallEN11QMetaObject4CallEiPPv @ 145 NONAME _ZN21QAbstractVideoSurface11qt_metacastEPKc @ 146 NONAME - _ZN21QAbstractVideoSurface14startedChangedEb @ 147 NONAME + _ZN21QAbstractVideoSurface14startedChangedEb @ 147 NONAME ABSENT _ZN21QAbstractVideoSurface16staticMetaObjectE @ 148 NONAME DATA 16 _ZN21QAbstractVideoSurface19getStaticMetaObjectEv @ 149 NONAME _ZN21QAbstractVideoSurface20surfaceFormatChangedERK19QVideoSurfaceFormat @ 150 NONAME @@ -186,7 +186,7 @@ EXPORTS _ZNK11QVideoFrame7isValidEv @ 185 NONAME _ZNK11QVideoFrame7mapModeEv @ 186 NONAME _ZNK11QVideoFrame8isMappedEv @ 187 NONAME - _ZNK11QVideoFrame8numBytesEv @ 188 NONAME + _ZNK11QVideoFrame8numBytesEv @ 188 NONAME ABSENT _ZNK11QVideoFrame9fieldTypeEv @ 189 NONAME _ZNK11QVideoFrame9startTimeEv @ 190 NONAME _ZNK12QAudioFormat10sampleSizeEv @ 191 NONAME @@ -231,7 +231,7 @@ EXPORTS _ZNK19QVideoSurfaceFormat11frameHeightEv @ 230 NONAME _ZNK19QVideoSurfaceFormat11pixelFormatEv @ 231 NONAME _ZNK19QVideoSurfaceFormat13propertyNamesEv @ 232 NONAME - _ZNK19QVideoSurfaceFormat13yuvColorSpaceEv @ 233 NONAME + _ZNK19QVideoSurfaceFormat13yuvColorSpaceEv @ 233 NONAME ABSENT _ZNK19QVideoSurfaceFormat16pixelAspectRatioEv @ 234 NONAME _ZNK19QVideoSurfaceFormat17scanLineDirectionEv @ 235 NONAME _ZNK19QVideoSurfaceFormat7isValidEv @ 236 NONAME @@ -247,9 +247,9 @@ EXPORTS _ZNK20QAbstractVideoBuffer6handleEv @ 246 NONAME _ZNK21QAbstractVideoSurface10metaObjectEv @ 247 NONAME _ZNK21QAbstractVideoSurface13surfaceFormatEv @ 248 NONAME - _ZNK21QAbstractVideoSurface17isFormatSupportedERK19QVideoSurfaceFormatPS0_ @ 249 NONAME + _ZNK21QAbstractVideoSurface17isFormatSupportedERK19QVideoSurfaceFormatPS0_ @ 249 NONAME ABSENT _ZNK21QAbstractVideoSurface5errorEv @ 250 NONAME - _ZNK21QAbstractVideoSurface9isStartedEv @ 251 NONAME + _ZNK21QAbstractVideoSurface9isStartedEv @ 251 NONAME ABSENT _ZNK24QAbstractAudioDeviceInfo10metaObjectEv @ 252 NONAME _ZTI11QAudioInput @ 253 NONAME _ZTI12QAudioOutput @ 254 NONAME @@ -277,4 +277,15 @@ EXPORTS _Zls6QDebugRK19QVideoSurfaceFormat @ 276 NONAME _ZTV28QAudioEngineFactoryInterface @ 277 NONAME ABSENT _ZN19QVideoSurfaceFormat12setFrameRateEf @ 278 NONAME + _ZN11QVideoFrame26imageFormatFromPixelFormatENS_11PixelFormatE @ 279 NONAME + _ZN11QVideoFrame26pixelFormatFromImageFormatEN6QImage6FormatE @ 280 NONAME + _ZN19QVideoSurfaceFormat12setFrameSizeERK5QSize @ 281 NONAME + _ZN19QVideoSurfaceFormat12setFrameSizeEii @ 282 NONAME + _ZN19QVideoSurfaceFormat18setYCbCrColorSpaceENS_15YCbCrColorSpaceE @ 283 NONAME + _ZN21QAbstractVideoSurface13activeChangedEb @ 284 NONAME + _ZNK11QVideoFrame11mappedBytesEv @ 285 NONAME + _ZNK19QVideoSurfaceFormat15yCbCrColorSpaceEv @ 286 NONAME + _ZNK21QAbstractVideoSurface13nearestFormatERK19QVideoSurfaceFormat @ 287 NONAME + _ZNK21QAbstractVideoSurface17isFormatSupportedERK19QVideoSurfaceFormat @ 288 NONAME + _ZNK21QAbstractVideoSurface8isActiveEv @ 289 NONAME -- cgit v0.12 From 676780d515cedca85829ae962e4f501c5e5b6581 Mon Sep 17 00:00:00 2001 From: Aleksandar Sasha Babic Date: Tue, 3 Nov 2009 10:36:52 +0100 Subject: Using qreal more consistently in code (prevent misuse of double) We want to force use of qreal where possible. This can lead to better performance on platforms where qreal -> float (i.e. ARM). To achieve this we: 1. changed from 'double' to 'qreal', where justified 2. using qreal() to intialize constants, where justified 3. adding helper functions that are overloaded for qreal like qAtan2(), qAcos(), qFabs() ... 4. defining QT_USE_MATH_H_FLOATS for Symbian platform In addtion we used opportunity to improve code with some small things 5. converting divisions to multiplications (i.e. '/ 2.0' -> '* qreal(0.5)') 6. defining new constants (i.e. 'Q_PI / 180.0' -> 'Q_PI180') 7. declaring variables as 'const', where justified Reviewed-by: Andreas Aardal Hanssen Reviewed-by: Gunnar Sletta Reviewed-by: Jan-Arve Reviewed-by: Kim Motoyoshi Kalland Reviewed-by: Alessandro Portale Reviewed-by: Janne Koskinen --- mkspecs/common/symbian/symbian.conf | 2 +- src/3rdparty/easing/easing.cpp | 180 ++++++++++++------------ src/corelib/global/qglobal.h | 4 +- src/corelib/global/qnumeric_p.h | 6 + src/corelib/kernel/qmath.h | 45 ++++-- src/corelib/tools/qdatetime.cpp | 2 +- src/corelib/tools/qeasingcurve.cpp | 20 +-- src/corelib/tools/qline.cpp | 12 +- src/gui/graphicsview/qgraphicsitem.cpp | 3 +- src/gui/graphicsview/qgraphicsitemanimation.cpp | 18 +-- src/gui/graphicsview/qgraphicsscene.cpp | 6 +- src/gui/graphicsview/qgraphicsview.cpp | 2 +- src/gui/graphicsview/qgraphicswidget_p.cpp | 6 +- src/gui/graphicsview/qgridlayoutengine.cpp | 88 ++++++------ src/gui/graphicsview/qsimplex_p.cpp | 4 +- src/gui/image/qimage.cpp | 30 ++-- src/gui/image/qpaintengine_pic.cpp | 4 +- src/gui/image/qpicture.cpp | 4 +- src/gui/image/qpixmap_raster.cpp | 4 +- src/gui/image/qpixmap_s60.cpp | 9 +- src/gui/image/qpnghandler.cpp | 4 +- src/gui/math3d/qmatrix4x4.cpp | 145 ++++++++++--------- src/gui/math3d/qquaternion.cpp | 29 ++-- src/gui/math3d/qvector2d.cpp | 6 +- src/gui/math3d/qvector3d.cpp | 8 +- src/gui/math3d/qvector4d.cpp | 16 ++- src/gui/painting/qbezier.cpp | 104 +++++++------- src/gui/painting/qbezier_p.h | 45 +++--- src/gui/painting/qblendfunctions.cpp | 18 +-- src/gui/painting/qbrush.cpp | 2 +- src/gui/painting/qcolor.cpp | 89 ++++++------ src/gui/painting/qdrawhelper.cpp | 111 +++++++-------- src/gui/painting/qdrawutil.cpp | 70 ++++----- src/gui/painting/qmath_p.h | 5 +- src/gui/painting/qpaintbuffer.cpp | 2 +- src/gui/painting/qpaintengine_raster.cpp | 32 +++-- src/gui/painting/qpaintengineex.cpp | 13 +- src/gui/painting/qpainter.cpp | 27 ++-- src/gui/painting/qpainterpath.cpp | 27 ++-- src/gui/painting/qpainterpath_p.h | 2 +- src/gui/painting/qpathclipper.cpp | 18 +-- src/gui/painting/qrasterizer.cpp | 32 +++-- src/gui/painting/qstroker.cpp | 25 ++-- src/gui/painting/qstroker_p.h | 2 +- src/gui/painting/qtransform.cpp | 27 ++-- src/gui/styles/qcommonstyle.cpp | 17 +-- src/gui/styles/qs60style.cpp | 16 +-- src/gui/styles/qstyle.cpp | 2 +- src/gui/styles/qstylehelper.cpp | 26 ++-- src/gui/styles/qstylesheetstyle.cpp | 8 +- src/gui/text/qfont.cpp | 6 +- src/gui/text/qfontdatabase.cpp | 6 +- src/svg/qsvggenerator.cpp | 9 +- src/svg/qsvggraphics.cpp | 11 +- src/svg/qsvghandler.cpp | 73 +++++----- src/svg/qsvgtinydocument.cpp | 13 +- 56 files changed, 789 insertions(+), 706 deletions(-) diff --git a/mkspecs/common/symbian/symbian.conf b/mkspecs/common/symbian/symbian.conf index 79bac42..0f06b92 100644 --- a/mkspecs/common/symbian/symbian.conf +++ b/mkspecs/common/symbian/symbian.conf @@ -7,7 +7,7 @@ CONFIG += qt warn_on release incremental QT += core gui QMAKE_INCREMENTAL_STYLE = sublib -DEFINES += UNICODE QT_KEYPAD_NAVIGATION QT_SOFTKEYS_ENABLED +DEFINES += UNICODE QT_KEYPAD_NAVIGATION QT_SOFTKEYS_ENABLED QT_USE_MATH_H_FLOATS QMAKE_COMPILER_DEFINES += SYMBIAN QMAKE_EXT_OBJ = .o diff --git a/src/3rdparty/easing/easing.cpp b/src/3rdparty/easing/easing.cpp index 81af40f..65e9f95 100644 --- a/src/3rdparty/easing/easing.cpp +++ b/src/3rdparty/easing/easing.cpp @@ -18,13 +18,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND */ #include -#include -#ifndef M_PI -#define M_PI 3.14159265358979323846 -#endif -#ifndef M_PI_2 -#define M_PI_2 (M_PI / 2) -#endif +#include QT_USE_NAMESPACE @@ -69,12 +63,12 @@ static qreal easeOutQuad(qreal t) */ static qreal easeInOutQuad(qreal t) { - t*=2.0; + t*=qreal(2.0); if (t < 1) { - return t*t/qreal(2); + return t*t*qreal(0.5); } else { --t; - return -0.5 * (t*(t-2) - 1); + return qreal(-0.5) * (t*(t-2) - 1); } } @@ -86,8 +80,8 @@ static qreal easeInOutQuad(qreal t) */ static qreal easeOutInQuad(qreal t) { - if (t < 0.5) return easeOutQuad (t*2)/2; - return easeInQuad((2*t)-1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutQuad (t*2) * qreal(0.5); + return easeInQuad((2*t)-1) * qreal(0.5) + qreal(0.5); } /** @@ -109,7 +103,7 @@ static qreal easeInCubic(qreal t) */ static qreal easeOutCubic(qreal t) { - t-=1.0; + t-=qreal(1.0); return t*t*t + 1; } @@ -121,12 +115,12 @@ static qreal easeOutCubic(qreal t) */ static qreal easeInOutCubic(qreal t) { - t*=2.0; + t*=qreal(2.0); if(t < 1) { - return 0.5*t*t*t; + return qreal(0.5)*t*t*t; } else { t -= qreal(2.0); - return 0.5*(t*t*t + 2); + return qreal(0.5)*(t*t*t + 2); } } @@ -138,8 +132,8 @@ static qreal easeInOutCubic(qreal t) */ static qreal easeOutInCubic(qreal t) { - if (t < 0.5) return easeOutCubic (2*t)/2; - return easeInCubic(2*t - 1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutCubic (2*t) * qreal(0.5); + return easeInCubic(2*t - 1) * qreal(0.5) + qreal(0.5); } /** @@ -174,10 +168,10 @@ static qreal easeOutQuart(qreal t) static qreal easeInOutQuart(qreal t) { t*=2; - if (t < 1) return 0.5*t*t*t*t; + if (t < 1) return qreal(0.5)*t*t*t*t; else { t -= 2.0f; - return -0.5 * (t*t*t*t- 2); + return qreal(-0.5) * (t*t*t*t- 2); } } @@ -189,8 +183,8 @@ static qreal easeInOutQuart(qreal t) */ static qreal easeOutInQuart(qreal t) { - if (t < 0.5) return easeOutQuart (2*t)/2; - return easeInQuart(2*t-1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutQuart (2*t) * qreal(0.5); + return easeInQuart(2*t-1) * qreal(0.5) + qreal(0.5); } /** @@ -212,7 +206,7 @@ static qreal easeInQuint(qreal t) */ static qreal easeOutQuint(qreal t) { - t-=1.0; + t-=qreal(1.0); return t*t*t*t*t + 1; } @@ -224,11 +218,11 @@ static qreal easeOutQuint(qreal t) */ static qreal easeInOutQuint(qreal t) { - t*=2.0; - if (t < 1) return 0.5*t*t*t*t*t; + t*=qreal(2.0); + if (t < 1) return qreal(0.5)*t*t*t*t*t; else { - t -= 2.0; - return 0.5*(t*t*t*t*t + 2); + t -= qreal(2.0); + return qreal(0.5)*(t*t*t*t*t + 2); } } @@ -240,8 +234,8 @@ static qreal easeInOutQuint(qreal t) */ static qreal easeOutInQuint(qreal t) { - if (t < 0.5) return easeOutQuint (2*t)/2; - return easeInQuint(2*t - 1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutQuint (2*t) * qreal(0.5); + return easeInQuint(2*t - 1) * qreal(0.5) + qreal(0.5); } /** @@ -252,7 +246,7 @@ static qreal easeOutInQuint(qreal t) */ static qreal easeInSine(qreal t) { - return (t == 1.0) ? 1.0 : -::cos(t * M_PI_2) + 1.0; + return (t == qreal(1.0)) ? qreal(1.0) : -qCos(t * Q_PI2) + qreal(1.0); } /** @@ -263,7 +257,7 @@ static qreal easeInSine(qreal t) */ static qreal easeOutSine(qreal t) { - return ::sin(t* M_PI_2); + return qSin(t* Q_PI2); } /** @@ -274,7 +268,7 @@ static qreal easeOutSine(qreal t) */ static qreal easeInOutSine(qreal t) { - return -0.5 * (::cos(M_PI*t) - 1); + return qreal(-0.5) * (qCos(Q_PI*t) - 1); } /** @@ -285,8 +279,8 @@ static qreal easeInOutSine(qreal t) */ static qreal easeOutInSine(qreal t) { - if (t < 0.5) return easeOutSine (2*t)/2; - return easeInSine(2*t - 1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutSine (2*t) * qreal(0.5); + return easeInSine(2*t - 1) * qreal(0.5) + qreal(0.5); } /** @@ -297,7 +291,7 @@ static qreal easeOutInSine(qreal t) */ static qreal easeInExpo(qreal t) { - return (t==0 || t == 1.0) ? t : ::qPow(2.0, 10 * (t - 1)) - qreal(0.001); + return (t==0 || t == qreal(1.0)) ? t : ::qPow(qreal(2.0), 10 * (t - 1)) - qreal(0.001); } /** @@ -308,7 +302,7 @@ static qreal easeInExpo(qreal t) */ static qreal easeOutExpo(qreal t) { - return (t==1.0) ? 1.0 : 1.001 * (-::qPow(2.0f, -10 * t) + 1); + return (t==qreal(1.0)) ? qreal(1.0) : qreal(1.001) * (-::qPow(2.0f, -10 * t) + 1); } /** @@ -319,11 +313,11 @@ static qreal easeOutExpo(qreal t) */ static qreal easeInOutExpo(qreal t) { - if (t==0.0) return qreal(0.0); - if (t==1.0) return qreal(1.0); - t*=2.0; - if (t < 1) return 0.5 * ::qPow(qreal(2.0), 10 * (t - 1)) - 0.0005; - return 0.5 * 1.0005 * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2); + if (t==qreal(0.0)) return qreal(0.0); + if (t==qreal(1.0)) return qreal(1.0); + t*=qreal(2.0); + if (t < 1) return qreal(0.5) * ::qPow(qreal(2.0), 10 * (t - 1)) - qreal(0.0005); + return qreal(0.5) * qreal(1.0005) * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2); } /** @@ -334,8 +328,8 @@ static qreal easeInOutExpo(qreal t) */ static qreal easeOutInExpo(qreal t) { - if (t < 0.5) return easeOutExpo (2*t)/2; - return easeInExpo(2*t - 1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutExpo (2*t) * qreal(0.5); + return easeInExpo(2*t - 1) * qreal(0.5) + qreal(0.5); } /** @@ -346,7 +340,7 @@ static qreal easeOutInExpo(qreal t) */ static qreal easeInCirc(qreal t) { - return -(::sqrt(1 - t*t) - 1); + return -(::qSqrt(1 - t*t) - 1); } /** @@ -358,7 +352,7 @@ static qreal easeInCirc(qreal t) static qreal easeOutCirc(qreal t) { t-= qreal(1.0); - return ::sqrt(1 - t* t); + return ::qSqrt(1 - t* t); } /** @@ -371,10 +365,10 @@ static qreal easeInOutCirc(qreal t) { t*=qreal(2.0); if (t < 1) { - return -0.5 * (::sqrt(1 - t*t) - 1); + return qreal(-0.5) * (::qSqrt(1 - t*t) - 1); } else { t -= qreal(2.0); - return 0.5 * (::sqrt(1 - t*t) + 1); + return qreal(0.5) * (::qSqrt(1 - t*t) + 1); } } @@ -386,26 +380,26 @@ static qreal easeInOutCirc(qreal t) */ static qreal easeOutInCirc(qreal t) { - if (t < 0.5) return easeOutCirc (2*t)/2; - return easeInCirc(2*t - 1)/2 + 0.5; + if (t < qreal(0.5)) return easeOutCirc (2*t)*qreal(0.5); + return easeInCirc(2*t - 1)*qreal(0.5) + qreal(0.5); } static qreal easeInElastic_helper(qreal t, qreal b, qreal c, qreal d, qreal a, qreal p) { if (t==0) return b; - qreal t_adj = (qreal)t / (qreal)d; + qreal t_adj = t / d; if (t_adj==1) return b+c; qreal s; - if(a < ::fabs(c)) { + if(a < ::qAbs(c)) { a = c; - s = p / 4.0f; + s = p * 0.25f; } else { - s = p / (2 * M_PI) * ::asin(c / a); + s = p / (Q_2PI) * ::qAsin(c / a); } t_adj -= 1.0f; - return -(a*::qPow(2.0f,10*t_adj) * ::sin( (t_adj*d-s)*(2*M_PI)/p )) + b; + return -(a*::qPow(2.0f,10*t_adj) * qSin( (t_adj*d-s)*(Q_2PI)/p )) + b; } /** @@ -429,12 +423,12 @@ static qreal easeOutElastic_helper(qreal t, qreal /*b*/, qreal c, qreal /*d*/, q qreal s; if(a < c) { a = c; - s = p / 4.0f; + s = p * 0.25f; } else { - s = p / (2 * M_PI) * ::asin(c / a); + s = p / (Q_2PI) * ::qAsin(c / a); } - return (a*::qPow(2.0f,-10*t) * ::sin( (t-s)*(2*M_PI)/p ) + c); + return (a*::qPow(2.0f,-10*t) * ::qSin( (t-s)*(Q_2PI)/p ) + c); } /** @@ -460,20 +454,20 @@ static qreal easeOutElastic(qreal t, qreal a, qreal p) */ static qreal easeInOutElastic(qreal t, qreal a, qreal p) { - if (t==0) return 0.0; - t*=2.0; - if (t==2) return 1.0; + if (t==0) return qreal(0.0); + t*=qreal(2.0); + if (t==2) return qreal(1.0); qreal s; - if(a < 1.0) { - a = 1.0; - s = p / 4.0f; + if(a < qreal(1.0)) { + a = qreal(1.0); + s = p * 0.25f; } else { - s = p / (2 * M_PI) * ::asin(1.0 / a); + s = p / (Q_2PI) * ::qAsin(qreal(1.0) / a); } - if (t < 1) return -.5*(a*::qPow(2.0f,10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p )); - return a*::qPow(2.0f,-10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p )*.5 + 1.0; + if (t < 1) return qreal(-.5)*(a*::qPow(2.0f,10*(t-1)) * ::qSin( (t-1-s)*(Q_2PI)/p )); + return a*::qPow(2.0f,-10*(t-1)) * ::qSin( (t-1-s)*(Q_2PI)/p )*qreal(.5) + qreal(1.0); } /** @@ -486,8 +480,8 @@ static qreal easeInOutElastic(qreal t, qreal a, qreal p) */ static qreal easeOutInElastic(qreal t, qreal a, qreal p) { - if (t < 0.5) return easeOutElastic_helper(t*2, 0, 0.5, 1.0, a, p); - return easeInElastic_helper(2*t - 1.0, 0.5, 0.5, 1.0, a, p); + if (t < qreal(0.5)) return easeOutElastic_helper(t*2, 0, qreal(0.5), qreal(1.0), a, p); + return easeInElastic_helper(2*t - qreal(1.0), qreal(0.5), qreal(0.5), qreal(1.0), a, p); } /** @@ -524,14 +518,14 @@ static qreal easeOutBack(qreal t, qreal s) */ static qreal easeInOutBack(qreal t, qreal s) { - t *= 2.0; + t *= qreal(2.0); if (t < 1) { s *= 1.525f; - return 0.5*(t*t*((s+1)*t - s)); + return qreal(0.5)*(t*t*((s+1)*t - s)); } else { t -= 2; s *= 1.525f; - return 0.5*(t*t*((s+1)*t+ s) + 2); + return qreal(0.5)*(t*t*((s+1)*t+ s) + 2); } } @@ -544,24 +538,26 @@ static qreal easeInOutBack(qreal t, qreal s) */ static qreal easeOutInBack(qreal t, qreal s) { - if (t < 0.5) return easeOutBack (2*t, s)/2; - return easeInBack(2*t - 1, s)/2 + 0.5; + if (t < qreal(0.5)) return easeOutBack (2*t, s) * qreal(0.5); + return easeInBack(2*t - 1, s) * qreal(0.5) + qreal(0.5); } static qreal easeOutBounce_helper(qreal t, qreal c, qreal a) { - if (t == 1.0) return c; - if (t < (4/11.0)) { - return c*(7.5625*t*t); - } else if (t < (8/11.0)) { - t -= (6/11.0); - return -a * (1. - (7.5625*t*t + .75)) + c; - } else if (t < (10/11.0)) { - t -= (9/11.0); - return -a * (1. - (7.5625*t*t + .9375)) + c; + const qreal inv_22 = 1 / qreal(22.0); + const qreal inv_11 = 2 * inv_22; + if (t == qreal(1.0)) return c; + if (t < (4 * inv_11)) { + return c*(qreal(7.5625)*t*t); + } else if (t < (8 * inv_11)) { + t -= (6 * inv_11); + return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.75))) + c; + } else if (t < (10 * inv_11)) { + t -= (9 * inv_11); + return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.9375))) + c; } else { - t -= (21/22.0); - return -a * (1. - (7.5625*t*t + .984375)) + c; + t -= (21 * inv_22); + return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.984375))) + c; } } @@ -586,7 +582,7 @@ static qreal easeOutBounce(qreal t, qreal a) */ static qreal easeInBounce(qreal t, qreal a) { - return 1.0 - easeOutBounce_helper(1.0-t, 1.0, a); + return qreal(1.0) - easeOutBounce_helper(qreal(1.0)-t, qreal(1.0), a); } @@ -599,8 +595,8 @@ static qreal easeInBounce(qreal t, qreal a) */ static qreal easeInOutBounce(qreal t, qreal a) { - if (t < 0.5) return easeInBounce (2*t, a)/2; - else return (t == 1.0) ? 1.0 : easeOutBounce (2*t - 1, a)/2 + 0.5; + if (t < qreal(0.5)) return easeInBounce (2*t, a) * qreal(0.5); + else return (t == qreal(1.0)) ? qreal(1.0) : easeOutBounce (2*t - 1, a) * qreal(0.5) + qreal(0.5); } /** @@ -612,13 +608,13 @@ static qreal easeInOutBounce(qreal t, qreal a) */ static qreal easeOutInBounce(qreal t, qreal a) { - if (t < 0.5) return easeOutBounce_helper(t*2, 0.5, a); - return 1.0 - easeOutBounce_helper (2.0-2*t, 0.5, a); + if (t < qreal(0.5)) return easeOutBounce_helper(t*2, qreal(0.5), a); + return qreal(1.0) - easeOutBounce_helper (qreal(2.0)-2*t, qreal(0.5), a); } static inline qreal qt_sinProgress(qreal value) { - return qSin((value * M_PI) - M_PI_2) / 2 + qreal(0.5); + return qSin((value * Q_PI) - Q_PI2) * qreal(0.5) + qreal(0.5); } static inline qreal qt_smoothBeginEndMixFactor(qreal value) @@ -656,7 +652,7 @@ static qreal easeOutCurve(qreal t) */ static qreal easeSineCurve(qreal t) { - return (qSin(((t * M_PI * 2)) - M_PI_2) + 1) / 2; + return (qSin(((t * Q_2PI)) - Q_PI2) + 1) * qreal(0.5); } /** @@ -665,6 +661,6 @@ static qreal easeSineCurve(qreal t) */ static qreal easeCosineCurve(qreal t) { - return (qCos(((t * M_PI * 2)) - M_PI_2) + 1) / 2; + return (qCos(((t * Q_2PI)) - Q_PI2) + 1) * qreal(0.5); } diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h index 9558256..6befb33 100644 --- a/src/corelib/global/qglobal.h +++ b/src/corelib/global/qglobal.h @@ -1081,14 +1081,14 @@ template inline T qAbs(const T &t) { return t >= 0 ? t : -t; } inline int qRound(qreal d) -{ return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); } +{ return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); } #if defined(QT_NO_FPU) || defined(QT_ARCH_ARM) || defined(QT_ARCH_WINDOWSCE) || defined(QT_ARCH_SYMBIAN) inline qint64 qRound64(double d) { return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); } #else inline qint64 qRound64(qreal d) -{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); } +{ return d >= 0.0 ? qint64(d + qreal(0.5)) : qint64(d - qreal(qint64(d-1)) + qreal(0.5)) + qint64(d-1); } #endif template diff --git a/src/corelib/global/qnumeric_p.h b/src/corelib/global/qnumeric_p.h index c8b5735..3f7b5b5 100644 --- a/src/corelib/global/qnumeric_p.h +++ b/src/corelib/global/qnumeric_p.h @@ -57,6 +57,12 @@ QT_BEGIN_NAMESPACE +static const qreal Q_PI = qreal(3.14159265358979323846); // pi +static const qreal Q_2PI = qreal(6.28318530717958647693); // 2*pi +static const qreal Q_PI2 = qreal(1.57079632679489661923); // pi/2 +static const qreal Q_PI180 = qreal(0.01745329251994329577); // pi/180 +static const qreal Q_180PI = qreal(57.29577951308232087685); // 180/pi + #if !defined(Q_CC_MIPS) static const union { unsigned char c[8]; double d; } qt_be_inf_bytes = { { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } }; diff --git a/src/corelib/kernel/qmath.h b/src/corelib/kernel/qmath.h index a9e4378..ef3a4b0 100644 --- a/src/corelib/kernel/qmath.h +++ b/src/corelib/kernel/qmath.h @@ -45,6 +45,7 @@ #include #include +#include QT_BEGIN_HEADER @@ -106,6 +107,16 @@ inline qreal qAcos(qreal v) return acos(v); } +inline qreal qAsin(qreal v) +{ +#ifdef QT_USE_MATH_H_FLOATS + if (sizeof(qreal) == sizeof(float)) + return asinf(float(v)); + else +#endif + return asin(v); +} + inline qreal qSqrt(qreal v) { #ifdef QT_USE_MATH_H_FLOATS @@ -136,28 +147,42 @@ inline qreal qPow(qreal x, qreal y) return pow(x, y); } -#ifndef M_PI -#define M_PI (3.14159265358979323846) -#endif - inline qreal qFastSin(qreal x) { - int si = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower. - qreal d = x - si * (2.0 * M_PI / QT_SINE_TABLE_SIZE); + int si = int(x * (qreal(0.5) * QT_SINE_TABLE_SIZE / Q_PI)); // Would be more accurate with qRound, but slower. + qreal d = x - si * (qreal(2.0) * Q_PI / QT_SINE_TABLE_SIZE); int ci = si + QT_SINE_TABLE_SIZE / 4; si &= QT_SINE_TABLE_SIZE - 1; ci &= QT_SINE_TABLE_SIZE - 1; - return qt_sine_table[si] + (qt_sine_table[ci] - 0.5 * qt_sine_table[si] * d) * d; + return qt_sine_table[si] + (qt_sine_table[ci] - qreal(0.5) * qt_sine_table[si] * d) * d; } inline qreal qFastCos(qreal x) { - int ci = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower. - qreal d = x - ci * (2.0 * M_PI / QT_SINE_TABLE_SIZE); + int ci = int(x * (qreal(0.5) * QT_SINE_TABLE_SIZE / Q_PI)); // Would be more accurate with qRound, but slower. + qreal d = x - ci * (qreal(2.0) * Q_PI / QT_SINE_TABLE_SIZE); int si = ci + QT_SINE_TABLE_SIZE / 4; si &= QT_SINE_TABLE_SIZE - 1; ci &= QT_SINE_TABLE_SIZE - 1; - return qt_sine_table[si] - (qt_sine_table[ci] + 0.5 * qt_sine_table[si] * d) * d; + return qt_sine_table[si] - (qt_sine_table[ci] + qreal(0.5) * qt_sine_table[si] * d) * d; +} + +inline qreal qFabs(qreal x) +{ +#ifdef QT_USE_MATH_H_FLOATS + if(sizeof(qreal) == sizeof(float)) + return fabsf(x); +#endif + return fabs(x); +} + +inline qreal qAtan2(qreal x, qreal y) +{ +#ifdef QT_USE_MATH_H_FLOATS + if(sizeof(qreal) == sizeof(float)) + return atan2f(x, y); +#endif + return atan2(x, y); } QT_END_NAMESPACE diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp index db6435e..5ae2dde 100644 --- a/src/corelib/tools/qdatetime.cpp +++ b/src/corelib/tools/qdatetime.cpp @@ -1915,7 +1915,7 @@ QTime QTime::fromString(const QString& s, Qt::DateFormat f) const float msec(msec_s.toFloat(&ok)); if (!ok) return QTime(); - return QTime(hour, minute, second, qMin(qRound(msec * 1000.0), 999)); + return QTime(hour, minute, second, qMin(qRound(msec * qreal(1000.0)), 999)); } } } diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp index 3e1e1ee..a629ebc 100644 --- a/src/corelib/tools/qeasingcurve.cpp +++ b/src/corelib/tools/qeasingcurve.cpp @@ -317,7 +317,7 @@ class QEasingCurveFunction public: enum Type { In, Out, InOut, OutIn }; - QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = 0.3, qreal amplitude = 1.0, + QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = qreal(0.3), qreal amplitude = qreal(1.0), qreal overshoot = 1.70158f) : _t(type), _p(period), _a(amplitude), _o(overshoot) { } @@ -667,7 +667,7 @@ bool QEasingCurve::operator==(const QEasingCurve &other) const */ qreal QEasingCurve::amplitude() const { - return d_ptr->config ? d_ptr->config->_a : 1.0; + return d_ptr->config ? d_ptr->config->_a : qreal(1.0); } /*! @@ -691,7 +691,7 @@ void QEasingCurve::setAmplitude(qreal amplitude) */ qreal QEasingCurve::period() const { - return d_ptr->config ? d_ptr->config->_p : 0.3; + return d_ptr->config ? d_ptr->config->_p : qreal(0.3); } /*! @@ -742,9 +742,9 @@ QEasingCurve::Type QEasingCurve::type() const void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType) { - qreal amp = -1.0; - qreal period = -1.0; - qreal overshoot = -1.0; + qreal amp = qreal(-1.0); + qreal period = qreal(-1.0); + qreal overshoot = qreal(-1.0); if (config) { amp = config->_a; @@ -754,13 +754,13 @@ void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType) config = 0; } - if (isConfigFunction(newType) || (amp != -1.0) || (period != -1.0) || (overshoot != -1.0)) { + if (isConfigFunction(newType) || (amp != qreal(-1.0)) || (period != qreal(-1.0)) || (overshoot != qreal(-1.0))) { config = curveToFunctionObject(newType); - if (amp != -1.0) + if (amp != qreal(-1.0)) config->_a = amp; - if (period != -1.0) + if (period != qreal(-1.0)) config->_p = period; - if (overshoot != -1.0) + if (overshoot != qreal(-1.0)) config->_o = overshoot; func = 0; } else if (newType != QEasingCurve::Custom) { diff --git a/src/corelib/tools/qline.cpp b/src/corelib/tools/qline.cpp index d0afb7a..5b30c97 100644 --- a/src/corelib/tools/qline.cpp +++ b/src/corelib/tools/qline.cpp @@ -574,7 +574,7 @@ qreal QLineF::angle() const const qreal dx = pt2.x() - pt1.x(); const qreal dy = pt2.y() - pt1.y(); - const qreal theta = atan2(-dy, dx) * 360.0 / M_2PI; + const qreal theta = qAtan2(-dy, dx) * qreal(360.0) / Q_2PI; const qreal theta_normalized = theta < 0 ? theta + 360 : theta; @@ -598,7 +598,7 @@ qreal QLineF::angle() const */ void QLineF::setAngle(qreal angle) { - const qreal angleR = angle * M_2PI / 360.0; + const qreal angleR = angle * Q_2PI / qreal(360.0); const qreal l = length(); const qreal dx = qCos(angleR) * l; @@ -620,7 +620,7 @@ void QLineF::setAngle(qreal angle) */ QLineF QLineF::fromPolar(qreal length, qreal angle) { - const qreal angleR = angle * M_2PI / 360.0; + const qreal angleR = angle * Q_2PI / qreal(360.0); return QLineF(0, 0, qCos(angleR) * length, -qSin(angleR) * length); } @@ -639,7 +639,7 @@ QLineF QLineF::unitVector() const QLineF f(p1(), QPointF(pt1.x() + x/len, pt1.y() + y/len)); #ifndef QT_NO_DEBUG - if (qAbs(f.length() - 1) >= 0.001) + if (qAbs(f.length() - 1) >= qreal(0.001)) qWarning("QLine::unitVector: New line does not have unit length"); #endif @@ -814,8 +814,8 @@ qreal QLineF::angle(const QLineF &l) const qreal cos_line = (dx()*l.dx() + dy()*l.dy()) / (length()*l.length()); qreal rad = 0; // only accept cos_line in the range [-1,1], if it is outside, use 0 (we return 0 rather than PI for those cases) - if (cos_line >= -1.0 && cos_line <= 1.0) rad = acos( cos_line ); - return rad * 360 / M_2PI; + if (cos_line >= qreal(-1.0) && cos_line <= qreal(1.0)) rad = qAcos( cos_line ); + return rad * 360 / Q_2PI; } diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp index 2fd499d..b6172ab 100644 --- a/src/gui/graphicsview/qgraphicsitem.cpp +++ b/src/gui/graphicsview/qgraphicsitem.cpp @@ -8371,8 +8371,9 @@ QPainterPath QGraphicsEllipseItem::shape() const if (d->rect.isNull()) return path; if (d->spanAngle != 360 * 16) { + const qreal inv_16 = 1 / qreal(16.0); path.moveTo(d->rect.center()); - path.arcTo(d->rect, d->startAngle / 16.0, d->spanAngle / 16.0); + path.arcTo(d->rect, d->startAngle * inv_16, d->spanAngle * inv_16); } else { path.addEllipse(d->rect); } diff --git a/src/gui/graphicsview/qgraphicsitemanimation.cpp b/src/gui/graphicsview/qgraphicsitemanimation.cpp index be2f300..1516e46 100644 --- a/src/gui/graphicsview/qgraphicsitemanimation.cpp +++ b/src/gui/graphicsview/qgraphicsitemanimation.cpp @@ -165,7 +165,7 @@ qreal QGraphicsItemAnimationPrivate::linearValueForStep(qreal step, QList void QGraphicsItemAnimationPrivate::insertUniquePair(qreal step, qreal value, QList *binList, const char* method) { - if (step < 0.0 || step > 1.0) { + if (step < qreal(0.0) || step > qreal(1.0)) { qWarning("QGraphicsItemAnimation::%s: invalid step = %f", method, step); return; } @@ -255,7 +255,7 @@ void QGraphicsItemAnimation::setTimeLine(QTimeLine *timeLine) */ QPointF QGraphicsItemAnimation::posAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::posAt: invalid step = %f", step); return QPointF(d->linearValueForStep(step, &d->xPosition, d->startPos.x()), @@ -294,7 +294,7 @@ QList > QGraphicsItemAnimation::posList() const */ QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::matrixAt: invalid step = %f", step); QMatrix matrix; @@ -316,7 +316,7 @@ QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const */ qreal QGraphicsItemAnimation::rotationAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::rotationAt: invalid step = %f", step); return d->linearValueForStep(step, &d->rotation); @@ -405,7 +405,7 @@ QList > QGraphicsItemAnimation::translationList() const */ qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::verticalScaleAt: invalid step = %f", step); return d->linearValueForStep(step, &d->verticalScale, 1); @@ -418,7 +418,7 @@ qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const */ qreal QGraphicsItemAnimation::horizontalScaleAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::horizontalScaleAt: invalid step = %f", step); return d->linearValueForStep(step, &d->horizontalScale, 1); @@ -457,7 +457,7 @@ QList > QGraphicsItemAnimation::scaleList() const */ qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::verticalShearAt: invalid step = %f", step); return d->linearValueForStep(step, &d->verticalShear, 0); @@ -470,7 +470,7 @@ qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const */ qreal QGraphicsItemAnimation::horizontalShearAt(qreal step) const { - if (step < 0.0 || step > 1.0) + if (step < qreal(0.0) || step > qreal(1.0)) qWarning("QGraphicsItemAnimation::horizontalShearAt: invalid step = %f", step); return d->linearValueForStep(step, &d->horizontalShear, 0); @@ -527,7 +527,7 @@ void QGraphicsItemAnimation::clear() */ void QGraphicsItemAnimation::setStep(qreal x) { - if (x < 0.0 || x > 1.0) { + if (x < qreal(0.0) || x > qreal(1.0)) { qWarning("QGraphicsItemAnimation::setStep: invalid step = %f", x); return; } diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp index dc036f8..8431fe9 100644 --- a/src/gui/graphicsview/qgraphicsscene.cpp +++ b/src/gui/graphicsview/qgraphicsscene.cpp @@ -4109,13 +4109,13 @@ static void _q_paintItem(QGraphicsItem *item, QPainter *painter, QGraphicsWidget *widgetItem = static_cast(item); QGraphicsProxyWidget *proxy = qobject_cast(widgetItem); const qreal windowOpacity = (proxy && proxy->widget() && useWindowOpacity) - ? proxy->widget()->windowOpacity() : 1.0; + ? proxy->widget()->windowOpacity() : qreal(1.0); const qreal oldPainterOpacity = painter->opacity(); if (qFuzzyIsNull(windowOpacity)) return; // Set new painter opacity. - if (windowOpacity < 1.0) + if (windowOpacity < qreal(1.0)) painter->setOpacity(oldPainterOpacity * windowOpacity); // set layoutdirection on the painter @@ -4209,7 +4209,7 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte QGraphicsProxyWidget *proxy = item->isWidget() ? qobject_cast(static_cast(item)) : 0; if (proxy && proxy->widget()) { const qreal windowOpacity = proxy->widget()->windowOpacity(); - if (windowOpacity < 1.0) + if (windowOpacity < qreal(1.0)) newPainterOpacity *= windowOpacity; } diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp index c88f678..7ac1a8f 100644 --- a/src/gui/graphicsview/qgraphicsview.cpp +++ b/src/gui/graphicsview/qgraphicsview.cpp @@ -297,7 +297,7 @@ inline int q_round_bound(qreal d) //### (int)(qreal) INT_MAX != INT_MAX for sing return INT_MIN; else if (d >= (qreal) INT_MAX) return INT_MAX; - return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); + return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); } void QGraphicsViewPrivate::translateTouchEvent(QGraphicsViewPrivate *d, QTouchEvent *touchEvent) diff --git a/src/gui/graphicsview/qgraphicswidget_p.cpp b/src/gui/graphicsview/qgraphicswidget_p.cpp index b747a30..7847635 100644 --- a/src/gui/graphicsview/qgraphicswidget_p.cpp +++ b/src/gui/graphicsview/qgraphicswidget_p.cpp @@ -457,13 +457,13 @@ static QSizeF closestAcceptableSize(const QSizeF &proposed, min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget); do { - if (maxw - minw < 0.1) { + if (maxw - minw < qreal(0.1)) { // we still havent found anything, cut off binary search minw = maxw; minh = maxh; } - middlew = minw + (maxw - minw)/2.0; - middleh = minh + (maxh - minh)/2.0; + middlew = minw + (maxw - minw) * qreal(0.5); + middleh = minh + (maxh - minh) * qreal(0.5); min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget); diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp index f61360a..f6fa16b 100644 --- a/src/gui/graphicsview/qgridlayoutengine.cpp +++ b/src/gui/graphicsview/qgridlayoutengine.cpp @@ -69,21 +69,22 @@ static void insertOrRemoveItems(QVector &items, int index, int delta) static qreal growthFactorBelowPreferredSize(qreal desired, qreal sumAvailable, qreal sumDesired) { - Q_ASSERT(sumDesired != 0.0); - return desired * ::pow(sumAvailable / sumDesired, desired / sumDesired); + Q_ASSERT(sumDesired != qreal(0.0)); + const qreal inv_sumDesired = 1 / sumDesired; + return desired * ::pow(sumAvailable * inv_sumDesired, desired * inv_sumDesired); } static qreal fixedDescent(qreal descent, qreal ascent, qreal targetSize) { - if (descent < 0.0) - return -1.0; + if (descent < qreal(0.0)) + return qreal(-1.0); - Q_ASSERT(descent >= 0.0); - Q_ASSERT(ascent >= 0.0); + Q_ASSERT(descent >= qreal(0.0)); + Q_ASSERT(ascent >= qreal(0.0)); Q_ASSERT(targetSize >= ascent + descent); qreal extra = targetSize - (ascent + descent); - return descent + (extra / 2.0); + return descent + (extra * qreal(0.5)); } static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int which) @@ -100,7 +101,7 @@ static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int void QGridLayoutBox::add(const QGridLayoutBox &other, int stretch, qreal spacing) { - Q_ASSERT(q_minimumDescent < 0.0); + Q_ASSERT(q_minimumDescent < qreal(0.0)); q_minimumSize += other.q_minimumSize + spacing; q_preferredSize += other.q_preferredSize + spacing; @@ -134,7 +135,7 @@ void QGridLayoutBox::normalize() q_preferredSize = qBound(q_minimumSize, q_preferredSize, q_maximumSize); q_minimumDescent = qMin(q_minimumDescent, q_minimumSize); - Q_ASSERT((q_minimumDescent < 0.0) == (q_minimumAscent < 0.0)); + Q_ASSERT((q_minimumDescent < qreal(0.0)) == (q_minimumAscent < qreal(0.0))); } #ifdef QT_DEBUG @@ -161,7 +162,7 @@ void QGridLayoutRowData::reset(int count) boxes.fill(QGridLayoutBox(), count); multiCellMap.clear(); stretches.fill(0, count); - spacings.fill(0.0, count); + spacings.fill(qreal(0.0), count); hasIgnoreFlag = false; } @@ -182,7 +183,7 @@ void QGridLayoutRowData::distributeMultiCells() for (int j = 0; j < NSizes; ++j) { qreal extra = compare(totalBox, box, j); - if (extra > 0.0) { + if (extra > qreal(0.0)) { calculateGeometries(start, end, totalBox.q_sizes(j), dummy.data(), newSizes.data(), 0, totalBox); @@ -210,7 +211,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz int n = end - start; QVarLengthArray newSizes(n); QVarLengthArray factors(n); - qreal sumFactors = 0.0; + qreal sumFactors = qreal(0.0); int sumStretches = 0; qreal sumAvailable; @@ -223,24 +224,25 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz stealBox(start, end, MinimumSize, positions, sizes); sumAvailable = targetSize - totalBox.q_minimumSize; - if (sumAvailable > 0.0) { - qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize; + if (sumAvailable > qreal(0.0)) { + const qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize; for (int i = 0; i < n; ++i) { if (ignore.testBit(start + i)) { - factors[i] = 0.0; + factors[i] = qreal(0.0); continue; } const QGridLayoutBox &box = boxes.at(start + i); - qreal desired = box.q_preferredSize - box.q_minimumSize; + const qreal desired = box.q_preferredSize - box.q_minimumSize; factors[i] = growthFactorBelowPreferredSize(desired, sumAvailable, sumDesired); sumFactors += factors[i]; } + const qreal inv_sumFactors = 1 / sumFactors; for (int i = 0; i < n; ++i) { - Q_ASSERT(sumFactors > 0.0); - qreal delta = sumAvailable * factors[i] / sumFactors; + Q_ASSERT(sumFactors > qreal(0.0)); + const qreal delta = sumAvailable * factors[i] * inv_sumFactors; newSizes[i] = sizes[i] + delta; } } @@ -248,46 +250,46 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz stealBox(start, end, PreferredSize, positions, sizes); sumAvailable = targetSize - totalBox.q_preferredSize; - if (sumAvailable > 0.0) { + if (sumAvailable > qreal(0.0)) { bool somethingHasAMaximumSize = false; - qreal sumPreferredSizes = 0.0; + qreal sumPreferredSizes = qreal(0.0); for (int i = 0; i < n; ++i) sumPreferredSizes += sizes[i]; for (int i = 0; i < n; ++i) { if (ignore.testBit(start + i)) { - newSizes[i] = 0.0; - factors[i] = 0.0; + newSizes[i] = qreal(0.0); + factors[i] = qreal(0.0); continue; } const QGridLayoutBox &box = boxes.at(start + i); - qreal desired = box.q_maximumSize - box.q_preferredSize; - if (desired == 0.0) { + const qreal desired = box.q_maximumSize - box.q_preferredSize; + if (desired == qreal(0.0)) { newSizes[i] = sizes[i]; - factors[i] = 0.0; + factors[i] = qreal(0.0); } else { - Q_ASSERT(desired > 0.0); + Q_ASSERT(desired > qreal(0.0)); int stretch = stretches[start + i]; if (sumStretches == 0) { if (hasIgnoreFlag) { - factors[i] = (stretch < 0) ? 1.0 : 0.0; + factors[i] = (stretch < 0) ? qreal(1.0) : qreal(0.0); } else { - factors[i] = (stretch < 0) ? sizes[i] : 0.0; + factors[i] = (stretch < 0) ? sizes[i] : qreal(0.0); } } else if (stretch == sumStretches) { - factors[i] = 1.0; + factors[i] = qreal(1.0); } else if (stretch <= 0) { - factors[i] = 0.0; + factors[i] = qreal(0.0); } else { qreal ultimatePreferredSize; qreal ultimateSumPreferredSizes; qreal x = ((stretch * sumPreferredSizes) - (sumStretches * box.q_preferredSize)) / (sumStretches - stretch); - if (x >= 0.0) { + if (x >= qreal(0.0)) { ultimatePreferredSize = box.q_preferredSize + x; ultimateSumPreferredSizes = sumPreferredSizes + x; } else { @@ -301,8 +303,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz (at the expense of the stretch factors, which are not fully respected during the transition). */ - ultimatePreferredSize = ultimatePreferredSize * 3 / 2; - ultimateSumPreferredSizes = ultimateSumPreferredSizes * 3 / 2; + ultimatePreferredSize = ultimatePreferredSize * qreal(1.5); + ultimateSumPreferredSizes = ultimateSumPreferredSizes * qreal(1.5); qreal ultimateFactor = (stretch * ultimateSumPreferredSizes / sumStretches) @@ -323,7 +325,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz if (desired < sumAvailable) somethingHasAMaximumSize = true; - newSizes[i] = -1.0; + newSizes[i] = qreal(-1.0); } } @@ -332,7 +334,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz keepGoing = false; for (int i = 0; i < n; ++i) { - if (newSizes[i] >= 0.0) + if (newSizes[i] >= qreal(0.0)) continue; const QGridLayoutBox &box = boxes.at(start + i); @@ -341,7 +343,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz newSizes[i] = box.q_maximumSize; sumAvailable -= box.q_maximumSize - sizes[i]; sumFactors -= factors[i]; - keepGoing = (sumAvailable > 0.0); + keepGoing = (sumAvailable > qreal(0.0)); if (!keepGoing) break; } @@ -349,8 +351,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz } for (int i = 0; i < n; ++i) { - if (newSizes[i] < 0.0) { - qreal delta = (sumFactors == 0.0) ? 0.0 + if (newSizes[i] < qreal(0.0)) { + qreal delta = (sumFactors == qreal(0.0)) ? qreal(0.0) : sumAvailable * factors[i] / sumFactors; newSizes[i] = sizes[i] + delta; } @@ -406,8 +408,8 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const { QGridLayoutBox result; if (start < end) { - result.q_maximumSize = 0.0; - qreal nextSpacing = 0.0; + result.q_maximumSize = qreal(0.0); + qreal nextSpacing = qreal(0.0); for (int i = start; i < end; ++i) { result.add(boxes.at(i), stretches.at(i), nextSpacing); nextSpacing = spacings.at(i); @@ -418,11 +420,11 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes) { - qreal offset = 0.0; - qreal nextSpacing = 0.0; + qreal offset = qreal(0.0); + qreal nextSpacing = qreal(0.0); for (int i = start; i < end; ++i) { - qreal avail = 0.0; + qreal avail = qreal(0.0); if (!ignore.testBit(i)) { const QGridLayoutBox &box = boxes.at(i); diff --git a/src/gui/graphicsview/qsimplex_p.cpp b/src/gui/graphicsview/qsimplex_p.cpp index 86b10b4..5ad329e 100644 --- a/src/gui/graphicsview/qsimplex_p.cpp +++ b/src/gui/graphicsview/qsimplex_p.cpp @@ -485,8 +485,8 @@ bool QSimplex::iterate() // Normalize Pivot Row qreal pivot = valueAt(pivotRow, pivotColumn); - if (pivot != 1.0) - combineRows(pivotRow, pivotRow, (1.0 - pivot) / pivot); + if (pivot != qreal(1.0)) + combineRows(pivotRow, pivotRow, (qreal(1.0) - pivot) / pivot); // Update other rows for (int row=0; row < rows; ++row) { diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp index 21ca1e3..2cf8597 100644 --- a/src/gui/image/qimage.cpp +++ b/src/gui/image/qimage.cpp @@ -5313,19 +5313,19 @@ int QImage::metric(PaintDeviceMetric metric) const break; case PdmDpiX: - return qRound(d->dpmx * 0.0254); + return qRound(d->dpmx * qreal(0.0254)); break; case PdmDpiY: - return qRound(d->dpmy * 0.0254); + return qRound(d->dpmy * qreal(0.0254)); break; case PdmPhysicalDpiX: - return qRound(d->dpmx * 0.0254); + return qRound(d->dpmx * qreal(0.0254)); break; case PdmPhysicalDpiY: - return qRound(d->dpmy * 0.0254); + return qRound(d->dpmy * qreal(0.0254)); break; default: @@ -5391,12 +5391,12 @@ bool qt_xForm_helper(const QTransform &trueMat, int xoffset, int type, int depth uchar *dptr, int dbpl, int p_inc, int dHeight, const uchar *sptr, int sbpl, int sWidth, int sHeight) { - int m11 = int(trueMat.m11()*4096.0); - int m12 = int(trueMat.m12()*4096.0); - int m21 = int(trueMat.m21()*4096.0); - int m22 = int(trueMat.m22()*4096.0); - int dx = qRound(trueMat.dx()*4096.0); - int dy = qRound(trueMat.dy()*4096.0); + int m11 = int(trueMat.m11()*qreal(4096.0)); + int m12 = int(trueMat.m12()*qreal(4096.0)); + int m21 = int(trueMat.m21()*qreal(4096.0)); + int m22 = int(trueMat.m22()*qreal(4096.0)); + int dx = qRound(trueMat.dx()*qreal(4096.0)); + int dy = qRound(trueMat.dy()*qreal(4096.0)); int m21ydx = dx + (xoffset<<16) + (m11 + m21) / 2; int m22ydy = dy + (m12 + m22) / 2; @@ -5980,22 +5980,22 @@ QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode if (mat.type() <= QTransform::TxScale) { if (mat.type() == QTransform::TxNone) // identity matrix return *this; - else if (mat.m11() == -1. && mat.m22() == -1.) + else if (mat.m11() == qreal(-1.) && mat.m22() == qreal(-1.)) return rotated180(*this); if (mode == Qt::FastTransformation) { hd = qRound(qAbs(mat.m22()) * hs); wd = qRound(qAbs(mat.m11()) * ws); } else { - hd = int(qAbs(mat.m22()) * hs + 0.9999); - wd = int(qAbs(mat.m11()) * ws + 0.9999); + hd = int(qAbs(mat.m22()) * hs + qreal(0.9999)); + wd = int(qAbs(mat.m11()) * ws + qreal(0.9999)); } scale_xform = true; } else { if (mat.type() <= QTransform::TxRotate && mat.m11() == 0 && mat.m22() == 0) { - if (mat.m12() == 1. && mat.m21() == -1.) + if (mat.m12() == qreal(1.) && mat.m21() == qreal(-1.)) return rotated90(*this); - else if (mat.m12() == -1. && mat.m21() == 1.) + else if (mat.m12() == qreal(-1.) && mat.m21() == qreal(1.)) return rotated270(*this); } diff --git a/src/gui/image/qpaintengine_pic.cpp b/src/gui/image/qpaintengine_pic.cpp index 80b16cf..b6fea8b 100644 --- a/src/gui/image/qpaintengine_pic.cpp +++ b/src/gui/image/qpaintengine_pic.cpp @@ -342,7 +342,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr) } d->pic_d->pictb.seek(newpos); // set to new position - if (br.width() > 0.0 || br.height() > 0.0) { + if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) { if (corr) { // widen bounding rect int w2 = painter()->pen().width() / 2; br.setCoords(br.left() - w2, br.top() - w2, @@ -354,7 +354,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr) br &= cr; } - if (br.width() > 0.0 || br.height() > 0.0) { + if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) { int minx = qFloor(br.left()); int miny = qFloor(br.top()); int maxx = qCeil(br.right()); diff --git a/src/gui/image/qpicture.cpp b/src/gui/image/qpicture.cpp index f502827..39a4fcc 100644 --- a/src/gui/image/qpicture.cpp +++ b/src/gui/image/qpicture.cpp @@ -967,10 +967,10 @@ int QPicture::metric(PaintDeviceMetric m) const val = brect.height(); break; case PdmWidthMM: - val = int(25.4/qt_defaultDpiX()*brect.width()); + val = int(qreal(25.4)/qt_defaultDpiX()*brect.width()); break; case PdmHeightMM: - val = int(25.4/qt_defaultDpiY()*brect.height()); + val = int(qreal(25.4)/qt_defaultDpiY()*brect.height()); break; case PdmDpiX: case PdmPhysicalDpiX: diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp index fc76dc3..8560e5d 100644 --- a/src/gui/image/qpixmap_raster.cpp +++ b/src/gui/image/qpixmap_raster.cpp @@ -373,9 +373,9 @@ int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const case QPaintDevice::PdmHeight: return h; case QPaintDevice::PdmWidthMM: - return qRound(d->width * 25.4 / qt_defaultDpiX()); + return qRound(d->width * qreal(25.4) / qt_defaultDpiX()); case QPaintDevice::PdmHeightMM: - return qRound(d->width * 25.4 / qt_defaultDpiY()); + return qRound(d->width * qreal(25.4) / qt_defaultDpiY()); case QPaintDevice::PdmNumColors: return d->colortable.size(); case QPaintDevice::PdmDepth: diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp index cd8a4d4..6a999b4 100644 --- a/src/gui/image/qpixmap_s60.cpp +++ b/src/gui/image/qpixmap_s60.cpp @@ -568,6 +568,7 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const if (!cfbsBitmap) return 0; + qreal div_by_KTwipsPerInch = 1 / (qreal)KTwipsPerInch; switch (metric) { case QPaintDevice::PdmWidth: return cfbsBitmap->SizeInPixels().iWidth; @@ -575,23 +576,23 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const return cfbsBitmap->SizeInPixels().iHeight; case QPaintDevice::PdmWidthMM: { TInt twips = cfbsBitmap->SizeInTwips().iWidth; - return (int)(twips * (25.4/KTwipsPerInch)); + return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch)); } case QPaintDevice::PdmHeightMM: { TInt twips = cfbsBitmap->SizeInTwips().iHeight; - return (int)(twips * (25.4/KTwipsPerInch)); + return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch)); } case QPaintDevice::PdmNumColors: return TDisplayModeUtils::NumDisplayModeColors(cfbsBitmap->DisplayMode()); case QPaintDevice::PdmDpiX: case QPaintDevice::PdmPhysicalDpiX: { - TReal inches = cfbsBitmap->SizeInTwips().iWidth / (TReal)KTwipsPerInch; + qreal inches = cfbsBitmap->SizeInTwips().iWidth * div_by_KTwipsPerInch; TInt pixels = cfbsBitmap->SizeInPixels().iWidth; return pixels / inches; } case QPaintDevice::PdmDpiY: case QPaintDevice::PdmPhysicalDpiY: { - TReal inches = cfbsBitmap->SizeInTwips().iHeight / (TReal)KTwipsPerInch; + qreal inches = cfbsBitmap->SizeInTwips().iHeight * div_by_KTwipsPerInch; TInt pixels = cfbsBitmap->SizeInPixels().iHeight; return pixels / inches; } diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp index 44d689d..e520c63 100644 --- a/src/gui/image/qpnghandler.cpp +++ b/src/gui/image/qpnghandler.cpp @@ -732,8 +732,8 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in, png_set_compression_level(png_ptr, quality); } - if (gamma != 0.0) { - png_set_gAMA(png_ptr, info_ptr, 1.0/gamma); + if (gamma != qreal(0.0)) { + png_set_gAMA(png_ptr, info_ptr, qreal(1.0)/gamma); } png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn); diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp index 2c3d616..031c5ef 100644 --- a/src/gui/math3d/qmatrix4x4.cpp +++ b/src/gui/math3d/qmatrix4x4.cpp @@ -40,6 +40,7 @@ ****************************************************************************/ #include "qmatrix4x4.h" +#include #include #include #include @@ -58,7 +59,7 @@ QT_BEGIN_NAMESPACE \sa QVector3D, QGenericMatrix */ -static const qreal inv_dist_to_plane = 1. / 1024.; +static const qreal inv_dist_to_plane = qreal(1.) / qreal(1024.); /*! \fn QMatrix4x4::QMatrix4x4() @@ -506,22 +507,23 @@ QMatrix4x4 QMatrix4x4::transposed() const */ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor) { - m[0][0] /= divisor; - m[0][1] /= divisor; - m[0][2] /= divisor; - m[0][3] /= divisor; - m[1][0] /= divisor; - m[1][1] /= divisor; - m[1][2] /= divisor; - m[1][3] /= divisor; - m[2][0] /= divisor; - m[2][1] /= divisor; - m[2][2] /= divisor; - m[2][3] /= divisor; - m[3][0] /= divisor; - m[3][1] /= divisor; - m[3][2] /= divisor; - m[3][3] /= divisor; + const qreal inv_divisor = (1 / divisor); + m[0][0] *= inv_divisor; + m[0][1] *= inv_divisor; + m[0][2] *= inv_divisor; + m[0][3] *= inv_divisor; + m[1][0] *= inv_divisor; + m[1][1] *= inv_divisor; + m[1][2] *= inv_divisor; + m[1][3] *= inv_divisor; + m[2][0] *= inv_divisor; + m[2][1] *= inv_divisor; + m[2][2] *= inv_divisor; + m[2][3] *= inv_divisor; + m[3][0] *= inv_divisor; + m[3][1] *= inv_divisor; + m[3][2] *= inv_divisor; + m[3][3] *= inv_divisor; flagBits = General; return *this; } @@ -662,23 +664,24 @@ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor) */ QMatrix4x4 operator/(const QMatrix4x4& matrix, qreal divisor) { + const qreal inv_divisor = (1 / divisor); QMatrix4x4 m(1); // The "1" says to not load the identity. - m.m[0][0] = matrix.m[0][0] / divisor; - m.m[0][1] = matrix.m[0][1] / divisor; - m.m[0][2] = matrix.m[0][2] / divisor; - m.m[0][3] = matrix.m[0][3] / divisor; - m.m[1][0] = matrix.m[1][0] / divisor; - m.m[1][1] = matrix.m[1][1] / divisor; - m.m[1][2] = matrix.m[1][2] / divisor; - m.m[1][3] = matrix.m[1][3] / divisor; - m.m[2][0] = matrix.m[2][0] / divisor; - m.m[2][1] = matrix.m[2][1] / divisor; - m.m[2][2] = matrix.m[2][2] / divisor; - m.m[2][3] = matrix.m[2][3] / divisor; - m.m[3][0] = matrix.m[3][0] / divisor; - m.m[3][1] = matrix.m[3][1] / divisor; - m.m[3][2] = matrix.m[3][2] / divisor; - m.m[3][3] = matrix.m[3][3] / divisor; + m.m[0][0] = matrix.m[0][0] * inv_divisor; + m.m[0][1] = matrix.m[0][1] * inv_divisor; + m.m[0][2] = matrix.m[0][2] * inv_divisor; + m.m[0][3] = matrix.m[0][3] * inv_divisor; + m.m[1][0] = matrix.m[1][0] * inv_divisor; + m.m[1][1] = matrix.m[1][1] * inv_divisor; + m.m[1][2] = matrix.m[1][2] * inv_divisor; + m.m[1][3] = matrix.m[1][3] * inv_divisor; + m.m[2][0] = matrix.m[2][0] * inv_divisor; + m.m[2][1] = matrix.m[2][1] * inv_divisor; + m.m[2][2] = matrix.m[2][2] * inv_divisor; + m.m[2][3] = matrix.m[2][3] * inv_divisor; + m.m[3][0] = matrix.m[3][0] * inv_divisor; + m.m[3][1] = matrix.m[3][1] * inv_divisor; + m.m[3][2] = matrix.m[3][2] * inv_divisor; + m.m[3][3] = matrix.m[3][3] * inv_divisor; return m; } @@ -1011,7 +1014,7 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z) s = 0.0f; c = -1.0f; } else { - qreal a = angle * M_PI / 180.0f; + qreal a = angle * Q_PI180; c = qCos(a); s = qSin(a); } @@ -1066,10 +1069,11 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z) if (!quick) { qreal len = x * x + y * y + z * z; if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) { + const qreal inv_len = 1 / len; len = qSqrt(len); - x /= len; - y /= len; - z /= len; + x *= inv_len; + y *= inv_len; + z *= inv_len; } ic = 1.0f - c; m.m[0][0] = x * x * ic + c; @@ -1118,7 +1122,7 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z) s = 0.0f; c = -1.0f; } else { - qreal a = angle * M_PI / 180.0f; + qreal a = angle * Q_PI180; c = qCos(a); s = qSin(a); } @@ -1169,10 +1173,11 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z) if (!quick) { qreal len = x * x + y * y + z * z; if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) { + const qreal inv_len = 1 / len; len = qSqrt(len); - x /= len; - y /= len; - z /= len; + x *= inv_len; + y *= inv_len; + z *= inv_len; } ic = 1.0f - c; m.m[0][0] = x * x * ic + c; @@ -1299,35 +1304,39 @@ void QMatrix4x4::ortho(qreal left, qreal right, qreal bottom, qreal top, qreal n qreal width = right - left; qreal invheight = top - bottom; qreal clip = farPlane - nearPlane; + qreal inv_width = 1 / width; + qreal inv_invheight = 1 / invheight; + qreal inv_clip = 1 / clip; #ifndef QT_NO_VECTOR3D if (clip == 2.0f && (nearPlane + farPlane) == 0.0f) { // We can express this projection as a translate and scale // which will be more efficient to modify with further // transformations than producing a "General" matrix. + translate(QVector3D - (-(left + right) / width, - -(top + bottom) / invheight, + (-(left + right) * inv_width, + -(top + bottom) * inv_invheight, 0.0f)); scale(QVector3D - (2.0f / width, - 2.0f / invheight, + (2.0f * inv_width, + 2.0f * inv_invheight, -1.0f)); return; } #endif QMatrix4x4 m(1); - m.m[0][0] = 2.0f / width; + m.m[0][0] = 2.0f * inv_width; m.m[1][0] = 0.0f; m.m[2][0] = 0.0f; - m.m[3][0] = -(left + right) / width; + m.m[3][0] = -(left + right) * inv_width; m.m[0][1] = 0.0f; - m.m[1][1] = 2.0f / invheight; + m.m[1][1] = 2.0f * inv_invheight; m.m[2][1] = 0.0f; - m.m[3][1] = -(top + bottom) / invheight; + m.m[3][1] = -(top + bottom) * inv_invheight; m.m[0][2] = 0.0f; m.m[1][2] = 0.0f; - m.m[2][2] = -2.0f / clip; - m.m[3][2] = -(nearPlane + farPlane) / clip; + m.m[2][2] = -2.0f * inv_clip; + m.m[3][2] = -(nearPlane + farPlane) * inv_clip; m.m[0][3] = 0.0f; m.m[1][3] = 0.0f; m.m[2][3] = 0.0f; @@ -1354,21 +1363,24 @@ void QMatrix4x4::frustum(qreal left, qreal right, qreal bottom, qreal top, qreal // Construct the projection. QMatrix4x4 m(1); - qreal width = right - left; - qreal invheight = top - bottom; - qreal clip = farPlane - nearPlane; - m.m[0][0] = 2.0f * nearPlane / width; + const qreal width = right - left; + const qreal invheight = top - bottom; + const qreal clip = farPlane - nearPlane; + const qreal inv_width = 1 / width; + const qreal inv_invheight = 1 / invheight; + const qreal inv_clip = 1 / clip; + m.m[0][0] = 2.0f * nearPlane * inv_width; m.m[1][0] = 0.0f; - m.m[2][0] = (left + right) / width; + m.m[2][0] = (left + right) * inv_width; m.m[3][0] = 0.0f; m.m[0][1] = 0.0f; - m.m[1][1] = 2.0f * nearPlane / invheight; - m.m[2][1] = (top + bottom) / invheight; + m.m[1][1] = 2.0f * nearPlane * inv_invheight; + m.m[2][1] = (top + bottom) * inv_invheight; m.m[3][1] = 0.0f; m.m[0][2] = 0.0f; m.m[1][2] = 0.0f; - m.m[2][2] = -(nearPlane + farPlane) / clip; - m.m[3][2] = -2.0f * nearPlane * farPlane / clip; + m.m[2][2] = -(nearPlane + farPlane) * inv_clip; + m.m[3][2] = -2.0f * nearPlane * farPlane * inv_clip; m.m[0][3] = 0.0f; m.m[1][3] = 0.0f; m.m[2][3] = -1.0f; @@ -1394,12 +1406,13 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f // Construct the projection. QMatrix4x4 m(1); - qreal radians = (angle / 2.0f) * M_PI / 180.0f; - qreal sine = qSin(radians); + const qreal radians = (angle * 0.5f) * Q_PI180; + const qreal sine = qSin(radians); if (sine == 0.0f) return; - qreal cotan = qCos(radians) / sine; - qreal clip = farPlane - nearPlane; + const qreal cotan = qCos(radians) / sine; + const qreal clip = farPlane - nearPlane; + const qreal inv_clip = 1 / clip; m.m[0][0] = cotan / aspect; m.m[1][0] = 0.0f; m.m[2][0] = 0.0f; @@ -1410,8 +1423,8 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f m.m[3][1] = 0.0f; m.m[0][2] = 0.0f; m.m[1][2] = 0.0f; - m.m[2][2] = -(nearPlane + farPlane) / clip; - m.m[3][2] = -(2.0f * nearPlane * farPlane) / clip; + m.m[2][2] = -(nearPlane + farPlane) * inv_clip; + m.m[3][2] = -(2.0f * nearPlane * farPlane) * inv_clip; m.m[0][3] = 0.0f; m.m[1][3] = 0.0f; m.m[2][3] = -1.0f; diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp index 626cb3c..da629e6 100644 --- a/src/gui/math3d/qquaternion.cpp +++ b/src/gui/math3d/qquaternion.cpp @@ -269,11 +269,12 @@ void QQuaternion::normalize() return; len = qSqrt(len); + const double inv_len = 1 / len; - xp /= len; - yp /= len; - zp /= len; - wp /= len; + xp *= inv_len; + yp *= inv_len; + zp *= inv_len; + wp *= inv_len; } /*! @@ -357,7 +358,7 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, qreal angle) // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56 // We normalize the result just in case the values are close // to zero, as suggested in the above FAQ. - qreal a = (angle / 2.0f) * M_PI / 180.0f; + qreal a = (angle * 0.5f) * Q_PI180; qreal s = qSin(a); qreal c = qCos(a); QVector3D ax = axis.normalized(); @@ -375,11 +376,12 @@ QQuaternion QQuaternion::fromAxisAndAngle { qreal length = qSqrt(x * x + y * y + z * z); if (!qFuzzyIsNull(length - 1.0f) && !qFuzzyIsNull(length)) { - x /= length; - y /= length; - z /= length; + const qreal inv_length = 1 / length; + x *= inv_length; + y *= inv_length; + z *= inv_length; } - qreal a = (angle / 2.0f) * M_PI / 180.0f; + qreal a = (angle * 0.5f) * Q_PI180; qreal s = qSin(a); qreal c = qCos(a); return QQuaternion(c, x * s, y * s, z * s).normalized(); @@ -516,12 +518,13 @@ QQuaternion QQuaternion::slerp // then revert to simple linear interpolation. qreal factor1 = 1.0f - t; qreal factor2 = t; - if ((1.0f - dot) > 0.0000001) { + if ((1.0f - dot) > qreal(0.0000001)) { qreal angle = qreal(qAcos(dot)); qreal sinOfAngle = qreal(qSin(angle)); - if (sinOfAngle > 0.0000001) { - factor1 = qreal(qSin((1.0f - t) * angle)) / sinOfAngle; - factor2 = qreal(qSin(t * angle)) / sinOfAngle; + if (sinOfAngle > qreal(0.0000001)) { + const qreal inv_sinOfAngle = 1 / sinOfAngle; + factor1 = qreal(qSin((1.0f - t) * angle)) * inv_sinOfAngle; + factor2 = qreal(qSin(t * angle)) * inv_sinOfAngle; } } diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp index 2555a6f..a959979 100644 --- a/src/gui/math3d/qvector2d.cpp +++ b/src/gui/math3d/qvector2d.cpp @@ -216,9 +216,9 @@ void QVector2D::normalize() return; len = qSqrt(len); - - xp /= len; - yp /= len; + const double inv_len = 1 / len; + xp *= inv_len; + yp *= inv_len; } /*! diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp index 9552e3a..a8cc807 100644 --- a/src/gui/math3d/qvector3d.cpp +++ b/src/gui/math3d/qvector3d.cpp @@ -233,10 +233,10 @@ void QVector3D::normalize() return; len = qSqrt(len); - - xp /= len; - yp /= len; - zp /= len; + const double inv_len = 1 / len; + xp *= inv_len; + yp *= inv_len; + zp *= inv_len; } /*! diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp index 1691a6d..e4b2b82 100644 --- a/src/gui/math3d/qvector4d.cpp +++ b/src/gui/math3d/qvector4d.cpp @@ -285,11 +285,11 @@ void QVector4D::normalize() return; len = qSqrt(len); - - xp /= len; - yp /= len; - zp /= len; - wp /= len; + const double inv_len = 1 / len; + xp *= inv_len; + yp *= inv_len; + zp *= inv_len; + wp *= inv_len; } /*! @@ -459,7 +459,8 @@ QVector2D QVector4D::toVector2DAffine() const { if (qIsNull(wp)) return QVector2D(); - return QVector2D(xp / wp, yp / wp, 1); + const qreal inv_wp = 1 / wp; + return QVector2D(xp * inv_wp, yp * inv_wp, 1); } #endif @@ -486,7 +487,8 @@ QVector3D QVector4D::toVector3DAffine() const { if (qIsNull(wp)) return QVector3D(); - return QVector3D(xp / wp, yp / wp, zp / wp, 1); + const qreal inv_wp = 1 / wp; + return QVector3D(xp * inv_wp, yp * inv_wp, zp * inv_wp, 1); } #endif diff --git a/src/gui/painting/qbezier.cpp b/src/gui/painting/qbezier.cpp index a6b4cef..c49086b 100644 --- a/src/gui/painting/qbezier.cpp +++ b/src/gui/painting/qbezier.cpp @@ -62,10 +62,10 @@ QT_BEGIN_NAMESPACE #endif #ifndef M_SQRT2 -#define M_SQRT2 1.41421356237309504880 +#define M_SQRT2 qreal(1.41421356237309504880) #endif -#define log2(x) (qLn(x)/qLn(2.)) +#define log2(x) (qLn(qreal(x))/qLn(qreal(2.))) static inline qreal log4(qreal x) { @@ -132,7 +132,7 @@ static inline void flattenBezierWithoutInflections(QBezier &bez, qreal d = qAbs(dx * (bez.y3 - bez.y2) - dy * (bez.x3 - bez.x2)); - qreal t = qSqrt(4. / 3. * normalized * flatness / d); + qreal t = qSqrt(qreal(4.) / qreal(3.) * normalized * flatness / d); if (t > 1 || qFuzzyIsNull(t - (qreal)1.)) break; bez.parameterSplitLeft(t, &left); @@ -267,7 +267,7 @@ void QBezier::addToPolygonMixed(QPolygonF *polygon) const qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3); l = 1.; } - if (d < .5*l || b == beziers + 31) { + if (d < qreal(.5)*l || b == beziers + 31) { // good enough, we pop it off and add the endpoint polygon->append(QPointF(b->x4, b->y4)); --b; @@ -327,8 +327,8 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse const qreal o2 = offset*offset; const qreal max_dist_line = threshold*offset*offset; const qreal max_dist_normal = threshold*offset; - const qreal spacing = 0.25; - for (qreal i = spacing; i < 0.99; i += spacing) { + const qreal spacing = qreal(0.25); + for (qreal i = spacing; i < qreal(0.99); i += spacing) { QPointF p1 = b1->pointAt(i); QPointF p2 = b2->pointAt(i); qreal d = (p1.x() - p2.x())*(p1.x() - p2.x()) + (p1.y() - p2.y())*(p1.y() - p2.y()); @@ -337,7 +337,7 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse QPointF normalPoint = b1->normalVector(i); qreal l = qAbs(normalPoint.x()) + qAbs(normalPoint.y()); - if (l != 0.) { + if (l != qreal(0.)) { d = qAbs( normalPoint.x()*(p1.y() - p2.y()) - normalPoint.y()*(p1.x() - p2.x()) ) / l; if (d > max_dist_normal) return Split; @@ -418,14 +418,14 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr } QRectF b = orig->bounds(); - if (np == 4 && b.width() < .1*offset && b.height() < .1*offset) { + if (np == 4 && b.width() < qreal(.1)*offset && b.height() < qreal(.1)*offset) { qreal l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) + (orig->y1 - orig->y2)*(orig->y1 - orig->y1) * (orig->x3 - orig->x4)*(orig->x3 - orig->x4) + (orig->y3 - orig->y4)*(orig->y3 - orig->y4); qreal dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) + (orig->y1 - orig->y2)*(orig->y3 - orig->y4); - if (dot < 0 && dot*dot < 0.8*l) + if (dot < 0 && dot*dot < qreal(0.8)*l) // the points are close and reverse dirction. Approximate the whole // thing by a semi circle return Circle; @@ -444,7 +444,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr QPointF normal_sum = prev_normal + next_normal; - qreal r = 1.0 + prev_normal.x() * next_normal.x() + qreal r = qreal(1.0) + prev_normal.x() * next_normal.x() + prev_normal.y() * next_normal.y(); if (qFuzzyIsNull(r)) { @@ -468,7 +468,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr // This value is used to determine the length of control point vectors // when approximating arc segments as curves. The factor is multiplied // with the radius of the circle. -#define KAPPA 0.5522847498 +#define KAPPA qreal(0.5522847498) static bool addCircle(const QBezier *b, qreal offset, QBezier *o) @@ -490,32 +490,32 @@ static bool addCircle(const QBezier *b, qreal offset, QBezier *o) normals[1] /= -1*qSqrt(normals[1].x()*normals[1].x() + normals[1].y()*normals[1].y()); qreal angles[2]; - qreal sign = 1.; + qreal sign = qreal(1.); for (int i = 0; i < 2; ++i) { qreal cos_a = normals[i].x()*normals[i+1].x() + normals[i].y()*normals[i+1].y(); - if (cos_a > 1.) - cos_a = 1.; - if (cos_a < -1.) + if (cos_a > qreal(1.)) + cos_a = qreal(1.); + if (cos_a < qreal(-1.)) cos_a = -1; - angles[i] = acos(cos_a)/Q_PI; + angles[i] = qAcos(cos_a)/Q_PI; } - if (angles[0] + angles[1] > 1.) { + if (angles[0] + angles[1] > qreal(1.)) { // more than 180 degrees normals[1] = -normals[1]; - angles[0] = 1. - angles[0]; - angles[1] = 1. - angles[1]; - sign = -1.; + angles[0] = qreal(1.) - angles[0]; + angles[1] = qreal(1.) - angles[1]; + sign = qreal(-1.); } QPointF circle[3]; circle[0] = QPointF(b->x1, b->y1) + normals[0]*offset; - circle[1] = QPointF(0.5*(b->x1 + b->x4), 0.5*(b->y1 + b->y4)) + normals[1]*offset; + circle[1] = QPointF(qreal(0.5)*(b->x1 + b->x4), qreal(0.5)*(b->y1 + b->y4)) + normals[1]*offset; circle[2] = QPointF(b->x4, b->y4) + normals[2]*offset; for (int i = 0; i < 2; ++i) { - qreal kappa = 2.*KAPPA * sign * offset * angles[i]; + qreal kappa = qreal(2.)*KAPPA * sign * offset * angles[i]; o->x1 = circle[i].x(); o->y1 = circle[i].y(); @@ -695,7 +695,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth if (deptha > 0) { QBezier A[2]; a.split(&A[0], &A[1]); - qreal tmid = (t0+t1)*0.5; + qreal tmid = (t0+t1)*qreal(0.5); //qDebug()<<"\t1)"< 0) { QBezier B[2]; b.split(&B[0], &B[1]); - qreal umid = (u0 + u1)*0.5; + qreal umid = (u0 + u1)*qreal(0.5); depthb--; if (IntersectBB(a, B[0])) { //fprintf(stderr, "\t 7 from %d\n", currentD); @@ -783,13 +783,13 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth qreal xmk = b.x1 - a.x1; qreal ymk = b.y1 - a.y1; qreal det = xnm * ylk - ynm * xlk; - if (1.0 + det == 1.0) { + if (qreal(1.0) + det == qreal(1.0)) { return false; } else { qreal detinv = 1.0 / det; qreal rs = (xnm * ymk - ynm *xmk) * detinv; qreal rt = (xlk * ymk - ylk * xmk) * detinv; - if ((rs < 0.0) || (rs > 1.0) || (rt < 0.0) || (rt > 1.0)) + if ((rs < qreal(0.0)) || (rs > qreal(1.0)) || (rt < qreal(0.0)) || (rt > qreal(1.0))) return false; if (t) { @@ -816,17 +816,17 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b, QVector > *t) { if (IntersectBB(a, b)) { - QPointF la1(fabs((a.x3 - a.x2) - (a.x2 - a.x1)), - fabs((a.y3 - a.y2) - (a.y2 - a.y1))); - QPointF la2(fabs((a.x4 - a.x3) - (a.x3 - a.x2)), - fabs((a.y4 - a.y3) - (a.y3 - a.y2))); + QPointF la1(qFabs((a.x3 - a.x2) - (a.x2 - a.x1)), + qFabs((a.y3 - a.y2) - (a.y2 - a.y1))); + QPointF la2(qFabs((a.x4 - a.x3) - (a.x3 - a.x2)), + qFabs((a.y4 - a.y3) - (a.y3 - a.y2))); QPointF la; if (la1.x() > la2.x()) la.setX(la1.x()); else la.setX(la2.x()); if (la1.y() > la2.y()) la.setY(la1.y()); else la.setY(la2.y()); - QPointF lb1(fabs((b.x3 - b.x2) - (b.x2 - b.x1)), - fabs((b.y3 - b.y2) - (b.y2 - b.y1))); - QPointF lb2(fabs((b.x4 - b.x3) - (b.x3 - b.x2)), - fabs((b.y4 - b.y3) - (b.y3 - b.y2))); + QPointF lb1(qFabs((b.x3 - b.x2) - (b.x2 - b.x1)), + qFabs((b.y3 - b.y2) - (b.y2 - b.y1))); + QPointF lb2(qFabs((b.x4 - b.x3) - (b.x3 - b.x2)), + qFabs((b.y4 - b.y3) - (b.y3 - b.y2))); QPointF lb; if (lb1.x() > lb2.x()) lb.setX(lb1.x()); else lb.setX(lb2.x()); if (lb1.y() > lb2.y()) lb.setY(lb1.y()); else lb.setY(lb2.y()); @@ -836,27 +836,27 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b, else l0 = la.y(); int ra; - if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0) + if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0)) ra = 0; else - ra = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0)); + ra = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0)); if (lb.x() > lb.y()) l0 = lb.x(); else l0 = lb.y(); int rb; - if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0) + if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0)) rb = 0; else - rb = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0)); + rb = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0)); // if qreal is float then halve the number of subdivisions if (sizeof(qreal) == 4) { - ra /= 2; - rb /= 2; + ra *= qreal(0.5); + rb *= qreal(0.5); } - return RecursivelyIntersect(a, 0., 1., ra, b, 0., 1., rb, t); + return RecursivelyIntersect(a, qreal(0.), qreal(1.), ra, b, qreal(0.), qreal(1.), rb, t); } //Don't sort here because it breaks the orders of corresponding @@ -934,7 +934,7 @@ QVector< QList > QBezier::splitAtIntersections(QBezier &b) qreal QBezier::length(qreal error) const { - qreal length = 0.0; + qreal length = qreal(0.0); addIfClose(&length, error); @@ -945,7 +945,7 @@ void QBezier::addIfClose(qreal *length, qreal error) const { QBezier left, right; /* bez poly splits */ - qreal len = 0.0; /* arc length */ + qreal len = qreal(0.0); /* arc length */ qreal chord; /* chord length */ len = len + QLineF(QPointF(x1, y1),QPointF(x2, y2)).length(); @@ -988,7 +988,7 @@ qreal QBezier::tForY(qreal t0, qreal t1, qreal y) const qreal lt = t0; qreal dt; do { - qreal t = 0.5 * (t0 + t1); + qreal t = qreal(0.5) * (t0 + t1); qreal a, b, c, d; QBezier::coefficients(t, a, b, c, d); @@ -1054,15 +1054,15 @@ int QBezier::stationaryYPoints(qreal &t0, qreal &t1) const qreal QBezier::tAtLength(qreal l) const { qreal len = length(); - qreal t = 1.0; - const qreal error = (qreal)0.01; + qreal t = qreal(1.0); + const qreal error = qreal(0.01); if (l > len || qFuzzyCompare(l, len)) return t; - t *= 0.5; + t *= qreal(0.5); //int iters = 0; //qDebug()<<"LEN is "<x2 = (x1 + x2)*.5; - secondHalf->x3 = (x3 + x4)*.5; + qreal c = (x2 + x3)*qreal(.5); + firstHalf->x2 = (x1 + x2)*qreal(.5); + secondHalf->x3 = (x3 + x4)*qreal(.5); firstHalf->x1 = x1; secondHalf->x4 = x4; - firstHalf->x3 = (firstHalf->x2 + c)*.5; - secondHalf->x2 = (secondHalf->x3 + c)*.5; - firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*.5; + firstHalf->x3 = (firstHalf->x2 + c)*qreal(.5); + secondHalf->x2 = (secondHalf->x3 + c)*qreal(.5); + firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*qreal(.5); - c = (y2 + y3)/2; - firstHalf->y2 = (y1 + y2)*.5; - secondHalf->y3 = (y3 + y4)*.5; + c = (y2 + y3)*qreal(.5); + firstHalf->y2 = (y1 + y2)*qreal(.5); + secondHalf->y3 = (y3 + y4)*qreal(.5); firstHalf->y1 = y1; secondHalf->y4 = y4; - firstHalf->y3 = (firstHalf->y2 + c)*.5; - secondHalf->y2 = (secondHalf->y3 + c)*.5; - firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*.5; + firstHalf->y3 = (firstHalf->y2 + c)*qreal(.5); + secondHalf->y2 = (secondHalf->y3 + c)*qreal(.5); + firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*qreal(.5); } inline void QBezier::parameterSplitLeft(qreal t, QBezier *left) diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp index f8dd424..76d50db 100644 --- a/src/gui/painting/qblendfunctions.cpp +++ b/src/gui/painting/qblendfunctions.cpp @@ -223,8 +223,8 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl, int h = ty2 - ty1; int w = tx2 - tx1; - const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1; - const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1; + const int dstx = qCeil((tx1 + qreal(0.5) - qMin(targetRect.left(), targetRect.right())) * ix) - 1; + const int dsty = qCeil((ty1 + qreal(0.5) - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1; quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx; quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty; @@ -723,8 +723,8 @@ template void qt_scale_image_32bit(uchar *destPixels, int dbpl, int h = ty2 - ty1; int w = tx2 - tx1; - const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1; - const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1; + const int dstx = qCeil((tx1 + qreal(0.5) - qMin(targetRect.left(), targetRect.right())) * ix) - 1; + const int dsty = qCeil((ty1 + qreal(0.5) - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1; quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx; quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty; @@ -818,8 +818,8 @@ void qt_transform_image_rasterize(DestT *destPixels, int dbpl, qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y); int dx_l = int(leftSlope * 0x10000); int dx_r = int(rightSlope * 0x10000); - int x_l = int((topLeft.x + (0.5 + fromY - topLeft.y) * leftSlope + 0.5) * 0x10000); - int x_r = int((topRight.x + (0.5 + fromY - topRight.y) * rightSlope + 0.5) * 0x10000); + int x_l = int((topLeft.x + (qreal(0.5) + fromY - topLeft.y) * leftSlope + qreal(0.5)) * 0x10000); + int x_r = int((topRight.x + (qreal(0.5) + fromY - topRight.y) * rightSlope + qreal(0.5)) * 0x10000); int fromX, toX, x1, x2, u, v, i, ii; DestT *line; @@ -996,7 +996,7 @@ void qt_transform_image(DestT *destPixels, int dbpl, if (det == 0) return; - qreal invDet = 1.0 / det; + qreal invDet = qreal(1.0) / det; qreal m11, m12, m21, m22, mdx, mdy; m11 = (u.u * w.y - u.y * w.u) * invDet; @@ -1010,8 +1010,8 @@ void qt_transform_image(DestT *destPixels, int dbpl, int dvdx = int(m21 * 0x10000); int dudy = int(m12 * 0x10000); int dvdy = int(m22 * 0x10000); - int u0 = qCeil((0.5 * m11 + 0.5 * m12 + mdx) * 0x10000) - 1; - int v0 = qCeil((0.5 * m21 + 0.5 * m22 + mdy) * 0x10000) - 1; + int u0 = qCeil((qreal(0.5) * m11 + qreal(0.5) * m12 + mdx) * 0x10000) - 1; + int v0 = qCeil((qreal(0.5) * m21 + qreal(0.5) * m22 + mdy) * 0x10000) - 1; int x1 = qFloor(sourceRect.left()); int y1 = qFloor(sourceRect.top()); diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp index cbfbba6..6982f22 100644 --- a/src/gui/painting/qbrush.cpp +++ b/src/gui/painting/qbrush.cpp @@ -1752,7 +1752,7 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF ¢er, // We have a one pixel buffer zone to avoid numerical instability on the // circle border //### this is hacky because technically we should adjust based on current matrix - const qreal compensated_radius = radius - radius * 0.001; + const qreal compensated_radius = radius - radius * qreal(0.001); QLineF line(center, focalPoint); if (line.length() > (compensated_radius)) line.setLength(compensated_radius); diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp index 4da993b..acbad3e 100644 --- a/src/gui/painting/qcolor.cpp +++ b/src/gui/painting/qcolor.cpp @@ -604,12 +604,13 @@ void QColor::getHsvF(qreal *h, qreal *s, qreal *v, qreal *a) const return; } - *h = ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0; - *s = ct.ahsv.saturation / qreal(USHRT_MAX); - *v = ct.ahsv.value / qreal(USHRT_MAX); + const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); + *h = ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0); + *s = ct.ahsv.saturation * inv_USHRT_MAX; + *v = ct.ahsv.value * inv_USHRT_MAX; if (a) - *a = ct.ahsv.alpha / qreal(USHRT_MAX); + *a = ct.ahsv.alpha * inv_USHRT_MAX; } /*! @@ -715,12 +716,13 @@ void QColor::getHslF(qreal *h, qreal *s, qreal *l, qreal *a) const return; } - *h = ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0; - *s = ct.ahsl.saturation / qreal(USHRT_MAX); - *l = ct.ahsl.lightness / qreal(USHRT_MAX); + const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); + *h = ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0); + *s = ct.ahsl.saturation * inv_USHRT_MAX; + *l = ct.ahsl.lightness * inv_USHRT_MAX; if (a) - *a = ct.ahsl.alpha / qreal(USHRT_MAX); + *a = ct.ahsl.alpha * inv_USHRT_MAX; } /*! @@ -1300,7 +1302,7 @@ qreal QColor::hsvHueF() const { if (cspec != Invalid && cspec != Hsv) return toHsv().hueF(); - return ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0; + return ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0); } /*! @@ -1396,7 +1398,7 @@ qreal QColor::hslHueF() const { if (cspec != Invalid && cspec != Hsl) return toHsl().hslHueF(); - return ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0; + return ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0); } /*! @@ -1547,6 +1549,8 @@ QColor QColor::toRgb() const color.ct.argb.alpha = ct.argb.alpha; color.ct.argb.pad = 0; + const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); + switch (cspec) { case Hsv: { @@ -1557,15 +1561,15 @@ QColor QColor::toRgb() const } // chromatic case - const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / 6000.; - const qreal s = ct.ahsv.saturation / qreal(USHRT_MAX); - const qreal v = ct.ahsv.value / qreal(USHRT_MAX); + const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / qreal(6000.); + const qreal s = ct.ahsv.saturation * inv_USHRT_MAX; + const qreal v = ct.ahsv.value * inv_USHRT_MAX; const int i = int(h); const qreal f = h - i; - const qreal p = v * (1.0 - s); + const qreal p = v * (qreal(1.0) - s); if (i & 1) { - const qreal q = v * (1.0 - (s * f)); + const qreal q = v * (qreal(1.0) - (s * f)); switch (i) { case 1: @@ -1585,7 +1589,7 @@ QColor QColor::toRgb() const break; } } else { - const qreal t = v * (1.0 - (s * (1.0 - f))); + const qreal t = v * (qreal(1.0) - (s * (qreal(1.0) - f))); switch (i) { case 0: @@ -1617,9 +1621,9 @@ QColor QColor::toRgb() const color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = 0; } else { // chromatic case - const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / 36000.; - const qreal s = ct.ahsl.saturation / qreal(USHRT_MAX); - const qreal l = ct.ahsl.lightness / qreal(USHRT_MAX); + const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / qreal(36000.); + const qreal s = ct.ahsl.saturation * inv_USHRT_MAX; + const qreal l = ct.ahsl.lightness * inv_USHRT_MAX; qreal temp2; if (l < qreal(0.5)) @@ -1656,14 +1660,14 @@ QColor QColor::toRgb() const } case Cmyk: { - const qreal c = ct.acmyk.cyan / qreal(USHRT_MAX); - const qreal m = ct.acmyk.magenta / qreal(USHRT_MAX); - const qreal y = ct.acmyk.yellow / qreal(USHRT_MAX); - const qreal k = ct.acmyk.black / qreal(USHRT_MAX); - - color.ct.argb.red = qRound((1.0 - (c * (1.0 - k) + k)) * USHRT_MAX); - color.ct.argb.green = qRound((1.0 - (m * (1.0 - k) + k)) * USHRT_MAX); - color.ct.argb.blue = qRound((1.0 - (y * (1.0 - k) + k)) * USHRT_MAX); + const qreal c = ct.acmyk.cyan * inv_USHRT_MAX; + const qreal m = ct.acmyk.magenta * inv_USHRT_MAX; + const qreal y = ct.acmyk.yellow * inv_USHRT_MAX; + const qreal k = ct.acmyk.black * inv_USHRT_MAX; + + color.ct.argb.red = qRound((qreal(1.0) - (c * (qreal(1.0) - k) + k)) * USHRT_MAX); + color.ct.argb.green = qRound((qreal(1.0) - (m * (qreal(1.0) - k) + k)) * USHRT_MAX); + color.ct.argb.blue = qRound((qreal(1.0) - (y * (qreal(1.0) - k) + k)) * USHRT_MAX); break; } default: @@ -1697,9 +1701,10 @@ QColor QColor::toHsv() const color.ct.ahsv.alpha = ct.argb.alpha; color.ct.ahsv.pad = 0; - const qreal r = ct.argb.red / qreal(USHRT_MAX); - const qreal g = ct.argb.green / qreal(USHRT_MAX); - const qreal b = ct.argb.blue / qreal(USHRT_MAX); + const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); + const qreal r = ct.argb.red * inv_USHRT_MAX; + const qreal g = ct.argb.green * inv_USHRT_MAX; + const qreal b = ct.argb.blue * inv_USHRT_MAX; const qreal max = Q_MAX_3(r, g, b); const qreal min = Q_MIN_3(r, g, b); const qreal delta = max - min; @@ -1715,15 +1720,15 @@ QColor QColor::toHsv() const if (qFuzzyCompare(r, max)) { hue = ((g - b) /delta); } else if (qFuzzyCompare(g, max)) { - hue = (2.0 + (b - r) / delta); + hue = (qreal(2.0) + (b - r) / delta); } else if (qFuzzyCompare(b, max)) { - hue = (4.0 + (r - g) / delta); + hue = (qreal(4.0) + (r - g) / delta); } else { Q_ASSERT_X(false, "QColor::toHsv", "internal error"); } - hue *= 60.0; - if (hue < 0.0) - hue += 360.0; + hue *= qreal(60.0); + if (hue < qreal(0.0)) + hue += qreal(360.0); color.ct.ahsv.hue = qRound(hue * 100); } @@ -1804,9 +1809,10 @@ QColor QColor::toCmyk() const color.ct.acmyk.alpha = ct.argb.alpha; // rgb -> cmy - const qreal r = ct.argb.red / qreal(USHRT_MAX); - const qreal g = ct.argb.green / qreal(USHRT_MAX); - const qreal b = ct.argb.blue / qreal(USHRT_MAX); + const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); + const qreal r = ct.argb.red * inv_USHRT_MAX; + const qreal g = ct.argb.green * inv_USHRT_MAX; + const qreal b = ct.argb.blue * inv_USHRT_MAX; qreal c = 1.0 - r; qreal m = 1.0 - g; qreal y = 1.0 - b; @@ -1815,9 +1821,10 @@ QColor QColor::toCmyk() const const qreal k = qMin(c, qMin(m, y)); if (!qFuzzyIsNull(k - 1)) { - c = (c - k) / (1.0 - k); - m = (m - k) / (1.0 - k); - y = (y - k) / (1.0 - k); + const qreal div_by_one_minus_k = 1 / (qreal(1.0) - k); + c = (c - k) * div_by_one_minus_k; + m = (m - k) * div_by_one_minus_k; + y = (y - k) * div_by_one_minus_k; } color.ct.acmyk.cyan = qRound(c * USHRT_MAX); diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp index 41602a1..b9f439e 100644 --- a/src/gui/painting/qdrawhelper.cpp +++ b/src/gui/painting/qdrawhelper.cpp @@ -565,8 +565,8 @@ const uint * QT_FASTCALL fetchTransformed(uint *buffer, const Operator *, const int image_width = data->texture.width; int image_height = data->texture.height; - const qreal cx = x + 0.5; - const qreal cy = y + 0.5; + const qreal cx = x + qreal(0.5); + const qreal cy = y + qreal(0.5); const uint *end = buffer + length; uint *b = buffer; @@ -670,8 +670,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator * int image_width = data->texture.width; int image_height = data->texture.height; - const qreal cx = x + 0.5; - const qreal cy = y + 0.5; + const qreal cx = x + qreal(0.5); + const qreal cy = y + qreal(0.5); const uint *end = buffer + length; uint *b = buffer; @@ -747,8 +747,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator * while (b < end) { const qreal iw = fw == 0 ? 1 : 1 / fw; - const qreal px = fx * iw - 0.5; - const qreal py = fy * iw - 0.5; + const qreal px = fx * iw - qreal(0.5); + const qreal py = fy * iw - qreal(0.5); int x1 = int(px) - (px < 0); int x2 = x1 + 1; @@ -927,7 +927,7 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = { static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos) { - int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + 0.5); + int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5)); // calculate the actual offset. if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) { @@ -1008,8 +1008,8 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator if (op->linear.l == 0) { t = inc = 0; } else { - rx = data->m21 * (y + 0.5) + data->m11 * (x + 0.5) + data->dx; - ry = data->m22 * (y + 0.5) + data->m12 * (x + 0.5) + data->dy; + rx = data->m21 * (y + qreal(0.5)) + data->m11 * (x + qreal(0.5)) + data->dx; + ry = data->m22 * (y + qreal(0.5)) + data->m12 * (x + qreal(0.5)) + data->dy; t = op->linear.dx*rx + op->linear.dy*ry + op->linear.off; inc = op->linear.dx * data->m11 + op->linear.dy * data->m12; affine = !data->m13 && !data->m23; @@ -1045,7 +1045,7 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator } } } else { // fall back to float math here as well - qreal rw = data->m23 * (y + 0.5) + data->m13 * (x + 0.5) + data->m33; + qreal rw = data->m23 * (y + qreal(0.5)) + data->m13 * (x + qreal(0.5)) + data->m33; while (buffer < end) { qreal x = rx/rw; qreal y = ry/rw; @@ -1092,10 +1092,10 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator int y, int x, int length) { const uint *b = buffer; - qreal rx = data->m21 * (y + 0.5) - + data->dx + data->m11 * (x + 0.5); - qreal ry = data->m22 * (y + 0.5) - + data->dy + data->m12 * (x + 0.5); + qreal rx = data->m21 * (y + qreal(0.5)) + + data->dx + data->m11 * (x + qreal(0.5)); + qreal ry = data->m22 * (y + qreal(0.5)) + + data->dy + data->m12 * (x + qreal(0.5)); bool affine = !data->m13 && !data->m23; //qreal r = data->gradient.radial.radius; @@ -1141,8 +1141,8 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator ++buffer; } } else { - qreal rw = data->m23 * (y + 0.5) - + data->m33 + data->m13 * (x + 0.5); + qreal rw = data->m23 * (y + qreal(0.5)) + + data->m33 + data->m13 * (x + qreal(0.5)); if (!rw) rw = 1; while (buffer < end) { @@ -1171,10 +1171,10 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato int y, int x, int length) { const uint *b = buffer; - qreal rx = data->m21 * (y + 0.5) - + data->dx + data->m11 * (x + 0.5); - qreal ry = data->m22 * (y + 0.5) - + data->dy + data->m12 * (x + 0.5); + qreal rx = data->m21 * (y + qreal(0.5)) + + data->dx + data->m11 * (x + qreal(0.5)); + qreal ry = data->m22 * (y + qreal(0.5)) + + data->dy + data->m12 * (x + qreal(0.5)); bool affine = !data->m13 && !data->m23; const uint *end = buffer + length; @@ -1182,25 +1182,25 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato rx -= data->gradient.conical.center.x; ry -= data->gradient.conical.center.y; while (buffer < end) { - qreal angle = atan2(ry, rx) + data->gradient.conical.angle; + qreal angle = qAtan2(ry, rx) + data->gradient.conical.angle; - *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / (2*Q_PI)); + *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / Q_2PI); rx += data->m11; ry += data->m12; ++buffer; } } else { - qreal rw = data->m23 * (y + 0.5) - + data->m33 + data->m13 * (x + 0.5); + qreal rw = data->m23 * (y + qreal(0.5)) + + data->m33 + data->m13 * (x + qreal(0.5)); if (!rw) rw = 1; while (buffer < end) { - qreal angle = atan2(ry/rw - data->gradient.conical.center.x, + qreal angle = qAtan2(ry/rw - data->gradient.conical.center.x, rx/rw - data->gradient.conical.center.y) + data->gradient.conical.angle; - *buffer = qt_gradient_pixel(&data->gradient, 1. - angle / (2*Q_PI)); + *buffer = qt_gradient_pixel(&data->gradient, qreal(1.) - angle / Q_2PI); rx += data->m11; ry += data->m12; @@ -5168,8 +5168,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale) - half_point; @@ -5243,8 +5243,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -5258,8 +5258,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const uint *b = buffer; while (b < end) { const qreal iw = w == 0 ? 1 : 1 / w; - const qreal px = x * iw - 0.5; - const qreal py = y * iw - 0.5; + const qreal px = x * iw - qreal(0.5); + const qreal py = y * iw - qreal(0.5); int x1 = int(px) - (px < 0); int x2 = x1 + 1; @@ -5670,8 +5670,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale) - half_point; @@ -5753,8 +5753,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -5768,8 +5768,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, uint *b = buffer; while (b < end) { const qreal iw = w == 0 ? 1 : 1 / w; - const qreal px = x * iw - 0.5; - const qreal py = y * iw - 0.5; + const qreal px = x * iw - qreal(0.5); + const qreal py = y * iw - qreal(0.5); int x1 = int(px) - (px < 0); int x2 = x1 + 1; @@ -5861,8 +5861,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale); @@ -5909,8 +5909,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -6261,8 +6261,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale); @@ -6313,8 +6313,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + 0.5; - const qreal cy = spans->y + 0.5; + const qreal cx = spans->x + qreal(0.5); + const qreal cy = spans->y + qreal(0.5); qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -6998,7 +6998,7 @@ static void qt_gradient_quint32(int count, const QSpan *spans, void *userData) */ const int gss = GRADIENT_STOPTABLE_SIZE - 1; int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE); - int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE)); + int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE)); while (count--) { int y = spans->y; @@ -7046,7 +7046,7 @@ static void qt_gradient_quint16(int count, const QSpan *spans, void *userData) */ const int gss = GRADIENT_STOPTABLE_SIZE - 1; int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE); - int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE)); + int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE)); uint oldColor = data->solid.color; while (count--) { @@ -7125,13 +7125,13 @@ void qt_build_pow_tables() { #ifdef Q_WS_MAC // decided by testing a few things on an iMac, should probably get this from the // system... - smoothing = 2.0; + smoothing = qreal(2.0); #endif #ifdef Q_WS_WIN int winSmooth; if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0)) - smoothing = winSmooth / 1000.0; + smoothing = winSmooth / qreal(1000.0); #endif #ifdef Q_WS_X11 @@ -7141,18 +7141,19 @@ void qt_build_pow_tables() { qt_pow_rgb_invgamma[i] = uchar(i); } #else + const qreal inv_255 = 1 / qreal(255.0); for (int i=0; i<256; ++i) { - qt_pow_rgb_gamma[i] = uchar(qRound(pow(i / qreal(255.0), smoothing) * 255)); - qt_pow_rgb_invgamma[i] = uchar(qRound(pow(i / qreal(255.), 1 / smoothing) * 255)); + qt_pow_rgb_gamma[i] = uchar(qRound(qPow(i * inv_255, smoothing) * 255)); + qt_pow_rgb_invgamma[i] = uchar(qRound(qPow(i * inv_255, 1 / smoothing) * 255)); } #endif #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) - const qreal gray_gamma = 2.31; + const qreal gray_gamma = qreal(2.31); for (int i=0; i<256; ++i) - qt_pow_gamma[i] = uint(qRound(pow(i / qreal(255.), gray_gamma) * 2047)); + qt_pow_gamma[i] = uint(qRound(qPow(i / qreal(255.), gray_gamma) * 2047)); for (int i=0; i<2048; ++i) - qt_pow_invgamma[i] = uchar(qRound(pow(i / 2047.0, 1 / gray_gamma) * 255)); + qt_pow_invgamma[i] = uchar(qRound(qPow(i / qreal(2047.0), 1 / gray_gamma) * 255)); #endif } diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp index 1182b9a..be9061f 100644 --- a/src/gui/painting/qdrawutil.cpp +++ b/src/gui/painting/qdrawutil.cpp @@ -1180,46 +1180,48 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin for (int i = 2; i < rows - 1; ++i) yTarget[i] = yTarget[i - 1] + dy; + const qreal inv_d_source_width = 1 / (qreal)d.source.width(); + const qreal inv_d_source_height = 1 / (qreal)d.source.height(); // corners if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left d.point.setX(0.5 * (xTarget[1] + xTarget[0])); d.point.setY(0.5 * (yTarget[1] + yTarget[0])); d.source = QRectF(sourceRect.left(), sourceRect.top(), sourceMargins.left(), sourceMargins.top()); - d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width(); - d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height(); + d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width; + d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height; if (hints & QDrawBorderPixmap::OpaqueTopLeft) opaqueData.append(d); else translucentData.append(d); } if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right - d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1])); - d.point.setY(0.5 * (yTarget[1] + yTarget[0])); + d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1])); + d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0])); d.source = QRectF(sourceCenterRight, sourceRect.top(), sourceMargins.right(), sourceMargins.top()); - d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width(); - d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height(); + d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width; + d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height; if (hints & QDrawBorderPixmap::OpaqueTopRight) opaqueData.append(d); else translucentData.append(d); } if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left - d.point.setX(0.5 * (xTarget[1] + xTarget[0])); - d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1])); + d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0])); + d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1])); d.source = QRectF(sourceRect.left(), sourceCenterBottom, sourceMargins.left(), sourceMargins.bottom()); - d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width(); - d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height(); + d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width; + d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height; if (hints & QDrawBorderPixmap::OpaqueBottomLeft) opaqueData.append(d); else translucentData.append(d); } if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right - d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1])); - d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1])); + d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1])); + d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1])); d.source = QRectF(sourceCenterRight, sourceCenterBottom, sourceMargins.right(), sourceMargins.bottom()); - d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width(); - d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height(); + d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width; + d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height; if (hints & QDrawBorderPixmap::OpaqueBottomRight) opaqueData.append(d); else @@ -1231,11 +1233,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData; d.source = QRectF(sourceCenterLeft, sourceRect.top(), sourceCenterWidth, sourceMargins.top()); - d.point.setY(0.5 * (yTarget[1] + yTarget[0])); - d.scaleX = dx / d.source.width(); - d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height(); + d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0])); + d.scaleX = dx * inv_d_source_width; + d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height; for (int i = 1; i < columns - 1; ++i) { - d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i])); + d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i])); data.append(d); } if (rules.horizontal == Qt::RepeatTile) @@ -1244,11 +1246,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData; d.source = QRectF(sourceCenterLeft, sourceCenterBottom, sourceCenterWidth, sourceMargins.bottom());; - d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1])); - d.scaleX = dx / d.source.width(); - d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height(); + d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1])); + d.scaleX = dx * inv_d_source_width; + d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height; for (int i = 1; i < columns - 1; ++i) { - d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i])); + d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i])); data.append(d); } if (rules.horizontal == Qt::RepeatTile) @@ -1261,11 +1263,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData; d.source = QRectF(sourceRect.left(), sourceCenterTop, sourceMargins.left(), sourceCenterHeight); - d.point.setX(0.5 * (xTarget[1] + xTarget[0])); - d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width(); - d.scaleY = dy / d.source.height(); + d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0])); + d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width; + d.scaleY = dy * inv_d_source_height; for (int i = 1; i < rows - 1; ++i) { - d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i])); + d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i])); data.append(d); } if (rules.vertical == Qt::RepeatTile) @@ -1274,11 +1276,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData; d.source = QRectF(sourceCenterRight, sourceCenterTop, sourceMargins.right(), sourceCenterHeight); - d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1])); - d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width(); - d.scaleY = dy / d.source.height(); + d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1])); + d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width; + d.scaleY = dy * inv_d_source_height; for (int i = 1; i < rows - 1; ++i) { - d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i])); + d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i])); data.append(d); } if (rules.vertical == Qt::RepeatTile) @@ -1290,16 +1292,16 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) { QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData; d.source = QRectF(sourceCenterLeft, sourceCenterTop, sourceCenterWidth, sourceCenterHeight); - d.scaleX = dx / d.source.width(); - d.scaleY = dy / d.source.height(); + d.scaleX = dx * inv_d_source_width; + d.scaleY = dy * inv_d_source_height; qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX; qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY; for (int j = 1; j < rows - 1; ++j) { - d.point.setY(0.5 * (yTarget[j + 1] + yTarget[j])); + d.point.setY(qreal(0.5) * (yTarget[j + 1] + yTarget[j])); for (int i = 1; i < columns - 1; ++i) { - d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i])); + d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i])); data.append(d); } if (rules.horizontal == Qt::RepeatTile) diff --git a/src/gui/painting/qmath_p.h b/src/gui/painting/qmath_p.h index f4a3982..53ed8ab 100644 --- a/src/gui/painting/qmath_p.h +++ b/src/gui/painting/qmath_p.h @@ -54,13 +54,10 @@ // #include +#include QT_BEGIN_NAMESPACE -static const qreal Q_PI = qreal(3.14159265358979323846); // pi -static const qreal Q_2PI = qreal(6.28318530717958647693); // 2*pi -static const qreal Q_PI2 = qreal(1.57079632679489661923); // pi/2 - QT_END_NAMESPACE #endif // QMATH_P_H diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp index 6b9d77c..a323a43 100644 --- a/src/gui/painting/qpaintbuffer.cpp +++ b/src/gui/painting/qpaintbuffer.cpp @@ -424,7 +424,7 @@ void QPaintBufferEngine::penChanged() QPointF transformedWidth(penWidth, penWidth); if (!pen.isCosmetic()) transformedWidth = painter()->transform().map(transformedWidth); - buffer->penWidthAdjustment = transformedWidth.x() / 2.0; + buffer->penWidthAdjustment = transformedWidth.x() * qreal(0.5); } } buffer->addCommand(QPaintBufferPrivate::Cmd_SetPen, pen); diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp index 8d0b961..e3c4fe5 100644 --- a/src/gui/painting/qpaintengine_raster.cpp +++ b/src/gui/painting/qpaintengine_raster.cpp @@ -126,7 +126,7 @@ void dumpClip(int width, int height, const QClipData *clip); #define int_dim(pos, dim) (int(pos+dim) - int(pos)) // use the same rounding as in qrasterizer.cpp (6 bit fixed point) -static const qreal aliasedCoordinateDelta = 0.5 - 0.015625; +static const qreal aliasedCoordinateDelta = qreal(0.5) - qreal(0.015625); #ifdef Q_WS_WIN extern bool qt_cleartype_enabled; @@ -1743,8 +1743,8 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen) if (lines[i].p1() == lines[i].p2()) { if (s->lastPen.capStyle() != Qt::FlatCap) { QPointF p = lines[i].p1(); - QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()), - QPointF(p.x() + width*0.5, p.y()))); + QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*qreal(0.5), p.y()), + QPointF(p.x() + width*qreal(0.5), p.y()))); d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1); } continue; @@ -1958,8 +1958,9 @@ static bool splitPolygon(const QPointF *points, int pointCount, QVector QVector sorted; sorted.reserve(pointCount); - upper->reserve(pointCount * 3 / 4); - lower->reserve(pointCount * 3 / 4); + const qreal three_quarters = qreal(3) / qreal(4); + upper->reserve(pointCount * three_quarters); + lower->reserve(pointCount * three_quarters); for (int i = 0; i < pointCount; ++i) sorted << points + i; @@ -2336,13 +2337,13 @@ void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCo int x1 = points[pointCount-1].x() * m11 + dx; int y1 = points[pointCount-1].y() * m22 + dy; - qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + 1.; + qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + qreal(1.); w = 1/w; x1 = int(x1*w); y1 = int(y1*w); int x2 = points[0].x() * m11 + dx; int y2 = points[0].y() * m22 + dy; - w = m13*points[0].x() + m23*points[0].y() + 1.; + w = m13*points[0].x() + m23*points[0].y() + qreal(1.); w = 1/w; x2 = int(x2 * w); y2 = int(y2 * w); @@ -4867,7 +4868,7 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint uint next_color; qreal incr = 1 / qreal(size); // the double increment. - qreal dpos = 1.5 * incr; // current position in gradient stop list (0 to 1) + qreal dpos = qreal(1.5) * incr; // current position in gradient stop list (0 to 1) // Up to first point colorTable[pos++] = PREMUL(current_color); @@ -5041,7 +5042,7 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode QPointF center = g->center(); conicalData.center.x = center.x(); conicalData.center.y = center.y(); - conicalData.angle = g->angle() * 2 * Q_PI / 360.0; + conicalData.angle = g->angle() * Q_2PI / qreal(360.0); } break; @@ -5140,7 +5141,8 @@ void QSpanData::setupMatrix(const QTransform &matrix, int bilin) { QTransform delta; // make sure we round off correctly in qdrawhelper.cpp - delta.translate(1.0 / 65536, 1.0 / 65536); + const qreal inv_65536 = qreal(1.0) / 65536; + delta.translate(inv_65536, inv_65536); QTransform inv = (delta * matrix).inverted(); m11 = inv.m11(); @@ -6049,9 +6051,9 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip, const QFixed b = QFixed(rect.height()) >> 1; QFixed d = b*b - (a*a*b) + ((a*a) >> 2); #else - const qreal a = qreal(rect.width()) / 2; - const qreal b = qreal(rect.height()) / 2; - qreal d = b*b - (a*a*b) + 0.25*a*a; + const qreal a = qreal(rect.width()) * qreal(0.5); + const qreal b = qreal(rect.height()) * qreal(0.5); + qreal d = b*b - (a*a*b) + qreal(0.25)*a*a; #endif int x = 0; @@ -6079,7 +6081,7 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip, d = b*b*(x + (QFixed(1) >> 1))*(x + (QFixed(1) >> 1)) + a*a*((y - 1)*(y - 1) - b*b); #else - d = b*b*(x + 0.5)*(x + 0.5) + a*a*((y - 1)*(y - 1) - b*b); + d = b*b*(x + qreal(0.5))*(x + qreal(0.5)) + a*a*(qreal(y - 1)*qreal(y - 1) - b*b); #endif const int miny = rect.height() & 0x1; while (y > miny) { @@ -6150,4 +6152,4 @@ void dumpClip(int width, int height, const QClipData *clip) #endif -QT_END_NAMESPACE +QT_END_NAMESPACE \ No newline at end of file diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp index 9e21182..b3d7f08 100644 --- a/src/gui/painting/qpaintengineex.cpp +++ b/src/gui/painting/qpaintengineex.cpp @@ -727,8 +727,9 @@ void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yR qreal y2 = rect.bottom(); if (mode == Qt::RelativeSize) { - xRadius = xRadius * rect.width() / 200.; - yRadius = yRadius * rect.height() / 200.; + const qreal inv_200 = 1 / qreal(200.); + xRadius = xRadius * rect.width() * inv_200; + yRadius = yRadius * rect.height() * inv_200; } xRadius = qMin(xRadius, rect.width() / 2); @@ -842,7 +843,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount) for (int i=0; imatrix).boundingRect(); } else { - strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0); - strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0); + strokeOffsetX = qAbs(penWidth * state->matrix.m11() * qreal(0.5)); + strokeOffsetY = qAbs(penWidth * state->matrix.m22() * qreal(0.5)); } } } @@ -467,7 +467,7 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio pt.end(); p.resetTransform(); p.setCompositionMode(QPainter::CompositionMode_SourceAtop); - p.setOpacity(0.5); + p.setOpacity(qreal(0.5)); p.fillRect(0, 0, image.width(), image.height(), QBrush(block)); } #endif @@ -3565,7 +3565,7 @@ void QPainter::drawPoints(const QPointF *points, int pointCount) QPainterPath path; for (int i=0; idraw_helper(path, QPainterPrivate::StrokeDraw); if (flat_pen) @@ -3627,7 +3627,7 @@ void QPainter::drawPoints(const QPoint *points, int pointCount) QPainterPath path; for (int i=0; idraw_helper(path, QPainterPrivate::StrokeDraw); if (flat_pen) @@ -4291,8 +4291,9 @@ void QPainter::drawArc(const QRectF &r, int a, int alen) QRectF rect = r.normalized(); QPainterPath path; - path.arcMoveTo(rect, a/16.0); - path.arcTo(rect, a/16.0, alen/16.0); + const qreal inv_16 = 1 / qreal(16.0); + path.arcMoveTo(rect, a * inv_16); + path.arcTo(rect, a * inv_16, alen * inv_16); strokePath(path, d->state->pen); } @@ -4361,8 +4362,9 @@ void QPainter::drawPie(const QRectF &r, int a, int alen) QRectF rect = r.normalized(); QPainterPath path; + const qreal inv_16 = 1 / qreal(16.0); path.moveTo(rect.center()); - path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a/16.0, alen/16.0); + path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a * inv_16, alen * inv_16); path.closeSubpath(); drawPath(path); @@ -4423,8 +4425,9 @@ void QPainter::drawChord(const QRectF &r, int a, int alen) QRectF rect = r.normalized(); QPainterPath path; - path.arcMoveTo(rect, a/16.0); - path.arcTo(rect, a/16.0, alen/16.0); + const qreal inv_16 = 1 / qreal(16.0); + path.arcMoveTo(rect, a * inv_16); + path.arcTo(rect, a * inv_16, alen * inv_16); path.closeSubpath(); drawPath(path); } @@ -5926,7 +5929,7 @@ static QPainterPath generateWavyPath(qreal minWidth, qreal maxRadius, QPaintDevi QPainterPath path; bool up = true; - const qreal radius = qMax(qreal(.5), qMin(qreal(1.25 * device->logicalDpiY() / qt_defaultDpi()), maxRadius)); + const qreal radius = qMax(qreal(.5), qMin(qreal(1.25) * device->logicalDpiY() / qt_defaultDpi(), maxRadius)); qreal xs, ys; int i = 0; path.moveTo(0, radius); @@ -6006,7 +6009,7 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const if (ti.flags & QTextItem::StrikeOut) { QLineF strikeOutLine = line; - strikeOutLine.translate(0., - fe->ascent().toReal() / 3.); + strikeOutLine.translate(qreal(0.), - fe->ascent().toReal() / qreal(3.)); painter->setPen(pen); painter->drawLine(strikeOutLine); } diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp index 8133793..0f31cca 100644 --- a/src/gui/painting/qpainterpath.cpp +++ b/src/gui/painting/qpainterpath.cpp @@ -799,8 +799,9 @@ void QPainterPath::quadTo(const QPointF &c, const QPointF &e) if (prev == c && c == e) return; - QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3); - QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3); + const qreal inv_3 = 1 / qreal(3); + QPointF c1((prev.x() + 2*c.x()) * inv_3, (prev.y() + 2*c.y()) * inv_3); + QPointF c2((e.x() + 2*c.x()) * inv_3, (e.y() + 2*c.y()) * inv_3); cubicTo(c1, c2, e); } @@ -1804,22 +1805,24 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y return false; if (p1 | p2) { - qreal dx = x2 - x1; - qreal dy = y2 - y1; + const qreal dx = x2 - x1; + const qreal dy = y2 - y1; + const qreal dx_dy_ratio = dx / dy; + const qreal dy_dx_ratio = dy / dx; // clip x coordinates if (x1 < left) { - y1 += dy/dx * (left - x1); + y1 += dy_dx_ratio * (left - x1); x1 = left; } else if (x1 > right) { - y1 -= dy/dx * (x1 - right); + y1 -= dy_dx_ratio * (x1 - right); x1 = right; } if (x2 < left) { - y2 += dy/dx * (left - x2); + y2 += dy_dx_ratio * (left - x2); x2 = left; } else if (x2 > right) { - y2 -= dy/dx * (x2 - right); + y2 -= dy_dx_ratio * (x2 - right); x2 = right; } @@ -1833,17 +1836,17 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y // clip y coordinates if (y1 < top) { - x1 += dx/dy * (top - y1); + x1 += dx_dy_ratio * (top - y1); y1 = top; } else if (y1 > bottom) { - x1 -= dx/dy * (y1 - bottom); + x1 -= dx_dy_ratio * (y1 - bottom); y1 = bottom; } if (y2 < top) { - x2 += dx/dy * (top - y2); + x2 += dx_dy_ratio * (top - y2); y2 = top; } else if (y2 > bottom) { - x2 -= dx/dy * (y2 - bottom); + x2 -= dx_dy_ratio * (y2 - bottom); y2 = bottom; } diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h index 54b9392..a2bc905 100644 --- a/src/gui/painting/qpainterpath_p.h +++ b/src/gui/painting/qpainterpath_p.h @@ -258,7 +258,7 @@ inline void QPainterPathData::maybeMoveTo() } } -#define KAPPA 0.5522847498 +#define KAPPA qreal(0.5522847498) QT_END_NAMESPACE diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp index ab2dc33..1568ad8 100644 --- a/src/gui/painting/qpathclipper.cpp +++ b/src/gui/painting/qpathclipper.cpp @@ -321,11 +321,11 @@ void QIntersectionFinder::intersectLines(const QLineF &a, const QLineF &b, QData if (p1_equals_q1 || p1_equals_q2 || p2_equals_q1 || p2_equals_q2) return; - + const qreal inv_par = 1 / qreal(par); const qreal tp = (qDelta.y() * (q1.x() - p1.x()) - - qDelta.x() * (q1.y() - p1.y())) / par; + qDelta.x() * (q1.y() - p1.y())) * inv_par; const qreal tq = (pDelta.y() * (q1.x() - p1.x()) - - pDelta.x() * (q1.y() - p1.y())) / par; + pDelta.x() * (q1.y() - p1.y())) * inv_par; if (tp<0 || tp>1 || tq<0 || tq>1) return; @@ -1192,24 +1192,24 @@ static qreal computeAngle(const QPointF &v) { #if 1 if (v.x() == 0) { - return v.y() <= 0 ? 0 : 64.; + return v.y() <= 0 ? 0 : qreal(64.); } else if (v.y() == 0) { - return v.x() <= 0 ? 32. : 96.; + return v.x() <= 0 ? qreal(32.) : qreal(96.); } QPointF nv = normalize(v); if (nv.y() < 0) { if (nv.x() < 0) { // 0 - 32 - return -32. * nv.x(); + return qreal(-32.) * nv.x(); } else { // 96 - 128 - return 128. - 32. * nv.x(); + return qreal(128.) - qreal(32.) * nv.x(); } } else { // 32 - 96 - return 64. + 32 * nv.x(); + return qreal(64.) + 32 * nv.x(); } #else // doesn't seem to be robust enough - return atan2(v.x(), v.y()) + Q_PI; + return qAtan2(v.x(), v.y()) + Q_PI; #endif } diff --git a/src/gui/painting/qrasterizer.cpp b/src/gui/painting/qrasterizer.cpp index b602690..ba5eda6 100644 --- a/src/gui/painting/qrasterizer.cpp +++ b/src/gui/painting/qrasterizer.cpp @@ -44,6 +44,7 @@ #include #include +#include #include #include #include @@ -51,8 +52,8 @@ QT_BEGIN_NAMESPACE typedef int Q16Dot16; -#define Q16Dot16ToFloat(i) ((i)/65536.) -#define FloatToQ16Dot16(i) (int)((i) * 65536.) +#define Q16Dot16ToFloat(i) ((i)/qreal(65536.)) +#define FloatToQ16Dot16(i) (int)((i) * qreal(65536.)) #define IntToQ16Dot16(i) ((i) << 16) #define Q16Dot16ToInt(i) ((i) >> 16) #define Q16Dot16Factor 65536 @@ -707,12 +708,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, if (a == b || width == 0 || d->clipRect.isEmpty()) return; - Q_ASSERT(width > 0.0); + Q_ASSERT(width > qreal(0.0)); QPointF pa = a; QPointF pb = b; - QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * 0.5; + QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * qreal(0.5); if (squareCap) offs += QPointF(offs.y(), offs.x()); const QRectF clip(d->clipRect.topLeft() - offs, d->clipRect.bottomRight() + QPoint(1, 1) + offs); @@ -750,10 +751,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, } if (!d->antialiased) { - pa.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.; - pa.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.; - pb.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.; - pb.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.; + const qreal inv_64 = 1 / qreal(64.); + const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64; + pa.rx() += delta; + pa.ry() += delta; + pb.rx() += delta; + pb.ry() += delta; } { @@ -778,7 +781,7 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, return; // adjust width which is given relative to |b - a| - width *= sqrt(w0 / w); + width *= qSqrt(w0 / w); } QSpanBuffer buffer(d->blend, d->data, d->clipRect); @@ -793,10 +796,11 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, pa = QPointF(x, y - dy); pb = QPointF(x, y + dy); + const qreal inv_width = 1 / width; if (squareCap) - width = 1 / width + 1.0f; + width = inv_width + 1.0f; else - width = 1 / width; + width = inv_width; squareCap = false; } @@ -1192,8 +1196,10 @@ void QRasterizer::rasterize(const QPainterPath &path, Qt::FillRule fillRule) QRectF bounds = path.controlPointRect(); - int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.)); - int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.)); + const qreal inv_64 = 1 / qreal(64.); + const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64 ; + int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + qreal(0.5) + delta)); + int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - qreal(0.5) + delta)); if (iTopBound > iBottomBound) return; diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp index 228a6b1..b33d86b 100644 --- a/src/gui/painting/qstroker.cpp +++ b/src/gui/painting/qstroker.cpp @@ -788,12 +788,12 @@ qreal qt_t_for_arc_angle(qreal angle) if (qFuzzyCompare(angle, qreal(90))) return 1; - qreal radians = Q_PI * angle / 180; + qreal radians = Q_PI180 * angle; qreal cosAngle = qCos(radians); qreal sinAngle = qSin(radians); // initial guess - qreal tc = angle / 90; + qreal tc = angle / qreal(90); // do some iterations of newton's method to approximate cosAngle // finds the zero of the function b.pointAt(tc).x() - cosAngle tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value @@ -812,7 +812,7 @@ qreal qt_t_for_arc_angle(qreal angle) // use the average of the t that best approximates cosAngle // and the t that best approximates sinAngle - qreal t = 0.5 * (tc + ts); + qreal t = qreal(0.5) * (tc + ts); #if 0 printf("angle: %f, t: %f\n", angle, t); @@ -861,11 +861,11 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt qreal y = rect.y(); qreal w = rect.width(); - qreal w2 = rect.width() / 2; + qreal w2 = rect.width() * qreal(0.5); qreal w2k = w2 * QT_PATH_KAPPA; qreal h = rect.height(); - qreal h2 = rect.height() / 2; + qreal h2 = rect.height() * qreal(0.5); qreal h2k = h2 * QT_PATH_KAPPA; QPointF points[16] = @@ -898,23 +898,24 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt else if (sweepLength < -360) sweepLength = -360; // Special case fast paths - if (startAngle == 0.0) { - if (sweepLength == 360.0) { + if (startAngle == qreal(0.0)) { + if (sweepLength == qreal(360.0)) { for (int i = 11; i >= 0; --i) curves[(*point_count)++] = points[i]; return points[12]; - } else if (sweepLength == -360.0) { + } else if (sweepLength == qreal(-360.0)) { for (int i = 1; i <= 12; ++i) curves[(*point_count)++] = points[i]; return points[0]; } } - int startSegment = int(floor(startAngle / 90)); - int endSegment = int(floor((startAngle + sweepLength) / 90)); + qreal inv_90 = qreal(1) / qreal(90); + int startSegment = int(floor(startAngle * inv_90)); + int endSegment = int(floor((startAngle + sweepLength) * inv_90)); - qreal startT = (startAngle - startSegment * 90) / 90; - qreal endT = (startAngle + sweepLength - endSegment * 90) / 90; + qreal startT = (startAngle - startSegment * 90) * inv_90; + qreal endT = (startAngle + sweepLength - endSegment * 90) * inv_90; int delta = sweepLength > 0 ? 1 : -1; if (delta < 0) { diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h index a10ebd9..5ff9d87 100644 --- a/src/gui/painting/qstroker_p.h +++ b/src/gui/painting/qstroker_p.h @@ -110,7 +110,7 @@ struct qfixed2d }; #endif -#define QT_PATH_KAPPA 0.5522847498 +#define QT_PATH_KAPPA qreal(0.5522847498) QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength, QPointF *controlPoints, int *point_count); diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp index 8118450..4732278 100644 --- a/src/gui/painting/qtransform.cpp +++ b/src/gui/painting/qtransform.cpp @@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE -#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001) +#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? qreal(0.000001) : qreal(0.0001)) #ifdef MAP # undef MAP @@ -82,7 +82,7 @@ QT_BEGIN_NAMESPACE if (t == TxProject) { \ qreal w = (m_13 * FX_ + m_23 * FY_ + m_33); \ if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP); \ - w = 1./w; \ + w = qreal(1.)/w; \ nx *= w; \ ny *= w; \ } \ @@ -369,8 +369,8 @@ QTransform QTransform::inverted(bool *invertible) const inv = !qFuzzyIsNull(affine._m11); inv &= !qFuzzyIsNull(affine._m22); if (inv) { - invert.affine._m11 = 1. / affine._m11; - invert.affine._m22 = 1. / affine._m22; + invert.affine._m11 = qreal(1.) / affine._m11; + invert.affine._m22 = qreal(1.) / affine._m22; invert.affine._dx = -affine._dx * invert.affine._m11; invert.affine._dy = -affine._dy * invert.affine._m22; } @@ -1087,7 +1087,7 @@ QPoint QTransform::map(const QPoint &p) const x = affine._m11 * fx + affine._m21 * fy + affine._dx; y = affine._m12 * fx + affine._m22 * fy + affine._dy; if (t == TxProject) { - qreal w = 1./(m_13 * fx + m_23 * fy + m_33); + qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33); x *= w; y *= w; } @@ -1138,7 +1138,7 @@ QPointF QTransform::map(const QPointF &p) const x = affine._m11 * fx + affine._m21 * fy + affine._dx; y = affine._m12 * fx + affine._m22 * fy + affine._dy; if (t == TxProject) { - qreal w = 1./(m_13 * fx + m_23 * fy + m_33); + qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33); x *= w; y *= w; } @@ -1217,10 +1217,10 @@ QLine QTransform::map(const QLine &l) const x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx; y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy; if (t == TxProject) { - qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33); + qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33); x1 *= w; y1 *= w; - w = 1./(m_13 * fx2 + m_23 * fy2 + m_33); + w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33); x2 *= w; y2 *= w; } @@ -1276,10 +1276,10 @@ QLineF QTransform::map(const QLineF &l) const x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx; y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy; if (t == TxProject) { - qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33); + qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33); x1 *= w; y1 *= w; - w = 1./(m_13 * fx2 + m_23 * fy2 + m_33); + w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33); x2 *= w; y2 *= w; } @@ -1438,7 +1438,7 @@ struct QHomogeneousCoordinate QHomogeneousCoordinate(qreal x_, qreal y_, qreal w_) : x(x_), y(y_), w(w_) {} const QPointF toPoint() const { - qreal iw = 1. / w; + qreal iw = qreal(1.) / w; return QPointF(x * iw, y * iw); } }; @@ -1695,8 +1695,9 @@ bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans) if (!bottom) return false; - g = gtop/bottom; - h = htop/bottom; + double inv_bottom = 1 / bottom; + g = gtop * inv_bottom; + h = htop * inv_bottom; a = dx1 - dx0 + g * dx1; b = dx3 - dx0 + h * dx3; diff --git a/src/gui/styles/qcommonstyle.cpp b/src/gui/styles/qcommonstyle.cpp index 4c9541b..4d3272c 100644 --- a/src/gui/styles/qcommonstyle.cpp +++ b/src/gui/styles/qcommonstyle.cpp @@ -3070,9 +3070,9 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a) int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition); if (dial->maximum == dial->minimum) - a = Q_PI / 2; + a = Q_PI2; else if (dial->dialWrapping) - a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI + a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI / (dial->maximum - dial->minimum); else a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI @@ -3087,12 +3087,13 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a) int back = len / 2; QPolygonF arrow(3); - arrow[0] = QPointF(0.5 + xc + len * qCos(a), - 0.5 + yc - len * qSin(a)); - arrow[1] = QPointF(0.5 + xc + back * qCos(a + Q_PI * 5 / 6), - 0.5 + yc - back * qSin(a + Q_PI * 5 / 6)); - arrow[2] = QPointF(0.5 + xc + back * qCos(a - Q_PI * 5 / 6), - 0.5 + yc - back * qSin(a - Q_PI * 5 / 6)); + const qreal five_div_by_six = 5 / 6; + arrow[0] = QPointF(qreal(0.5) + xc + len * qCos(a), + qreal(0.5) + yc - len * qSin(a)); + arrow[1] = QPointF(qreal(0.5) + xc + back * qCos(a + Q_PI * five_div_by_six), + qreal(0.5) + yc - back * qSin(a + Q_PI * five_div_by_six)); + arrow[2] = QPointF(qreal(0.5) + xc + back * qCos(a - Q_PI * five_div_by_six), + qreal(0.5) + yc - back * qSin(a - Q_PI * five_div_by_six)); return arrow; } diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index e0fcb92..016b6a7 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -579,7 +579,7 @@ void QS60StylePrivate::drawRow(QS60StyleEnums::SkinParts start, #if 0 painter->save(); - painter->setOpacity(.3); + painter->setOpacity(qreal(.3)); painter->fillRect(startRect, Qt::red); painter->fillRect(middleRect, Qt::green); painter->fillRect(endRect, Qt::blue); @@ -1624,7 +1624,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, QS60StylePrivate::SF_PointNorth : QS60StylePrivate::SF_PointWest; QS60StylePrivate::drawSkinPart(QS60StyleEnums::SP_QgnGrafBarWait, painter, progressRect, flags | orientationFlag); } else { - const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? 1.0 + const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? qreal(1.0) : (qreal)optionProgressBar->progress / optionProgressBar->maximum; if (optionProgressBar->orientation == Qt::Horizontal) { progressRect.setWidth(int(progressRect.width() * progressFactor)); @@ -1912,12 +1912,12 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, if (focusFrame->widget() && focusFrame->widget()->hasEditFocus()) editFocus = true; } - const qreal opacity = editFocus ? 0.65 : 0.45; // Trial and error factors. Feel free to improve. + const qreal opacity = editFocus ? qreal(0.65) : qreal(0.45); // Trial and error factors. Feel free to improve. #else - const qreal opacity = 0.5; + const qreal opacity = qreal(0.5); #endif // Because of Qts coordinate system, we need to tweak the rect by .5 pixels, otherwise it gets blurred. - const qreal rectAdjustment = (penWidth % 2) ? -.5 : 0; + const qreal rectAdjustment = (penWidth % 2) ? qreal(-.5) : 0; // Make sure that the pen stroke is inside the rect const QRectF adjustedRect = @@ -1941,7 +1941,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, case CE_Splitter: if (option->state & State_Sunken && option->state & State_Enabled) { painter->save(); - painter->setOpacity(0.5); + painter->setOpacity(qreal(0.5)); painter->setBrush(d->themePalette()->light()); painter->setRenderHint(QPainter::Antialiasing); const qreal roundRectRadius = 4 * goldenRatio; @@ -2019,8 +2019,8 @@ void QS60Style::drawPrimitive(PrimitiveElement element, const QStyleOption *opti case PE_IndicatorRadioButton: { QRect buttonRect = option->rect; //there is empty (a. 33%) space in svg graphics for radiobutton - const qreal reduceWidth = (qreal)buttonRect.width()/3.0; - const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : 1.0; + const qreal reduceWidth = (qreal)buttonRect.width()/qreal(3.0); + const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : qreal(1.0); // Try to occupy the full area const qreal scaler = 1 + (reduceWidth/rectWidth); buttonRect.setWidth((int)((buttonRect.width()-reduceWidth) * scaler)); diff --git a/src/gui/styles/qstyle.cpp b/src/gui/styles/qstyle.cpp index ec238a9..6733209 100644 --- a/src/gui/styles/qstyle.cpp +++ b/src/gui/styles/qstyle.cpp @@ -2132,7 +2132,7 @@ int QStyle::sliderPositionFromValue(int min, int max, int logicalValue, int span uint p = upsideDown ? max - logicalValue : logicalValue - min; if (range > (uint)INT_MAX/4096) { - double dpos = (double(p))/(double(range)/span); + qreal dpos = (qreal(p))/(qreal(range)/span); return int(dpos); } else if (range > (uint)span) { return (2 * p * span + range) / (2*range); diff --git a/src/gui/styles/qstylehelper.cpp b/src/gui/styles/qstylehelper.cpp index af30f15..5b6f72f 100644 --- a/src/gui/styles/qstylehelper.cpp +++ b/src/gui/styles/qstylehelper.cpp @@ -117,15 +117,15 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset) const int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition); qreal a = 0; if (dial->maximum == dial->minimum) - a = Q_PI / 2; + a = Q_PI2; else if (dial->dialWrapping) - a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI + a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI / (dial->maximum - dial->minimum); else a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI / (dial->maximum - dial->minimum)) / 6; - qreal xc = width / 2.0; - qreal yc = height / 2.0; + const qreal xc = width * qreal(0.5); + const qreal yc = height * qreal(0.5); qreal len = r - QStyleHelper::calcBigLineSize(r) - 3; qreal back = offset * len; QPointF pos(QPointF(xc + back * qCos(a), yc - back * qSin(a))); @@ -134,7 +134,7 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset) qreal angle(const QPointF &p1, const QPointF &p2) { - static const qreal rad_factor = 180 / Q_PI; + static const qreal rad_factor = Q_PI180; qreal _angle = 0; if (p1.x() == p2.x()) { @@ -186,7 +186,7 @@ QPolygonF calcLines(const QStyleOptionSlider *dial) poly.resize(2 + 2 * notches); int smallLineSize = bigLineSize / 2; for (int i = 0; i <= notches; ++i) { - qreal angle = dial->dialWrapping ? Q_PI * 3 / 2 - i * 2 * Q_PI / notches + qreal angle = dial->dialWrapping ? Q_PI2 * 3 - i * Q_2PI / notches : (Q_PI * 8 - i * 10 * Q_PI / notches) / 6; qreal s = qSin(angle); qreal c = qCos(angle); @@ -215,7 +215,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) const bool enabled = option->state & QStyle::State_Enabled; qreal r = qMin(width, height) / 2; r -= r/50; - const qreal penSize = r/20.0; + const qreal penSize = r/qreal(20.0); painter->save(); painter->setRenderHint(QPainter::Antialiasing); @@ -234,7 +234,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) const qreal dx = option->rect.x() + d_ + (width - 2 * r) / 2 + 1; const qreal dy = option->rect.y() + d_ + (height - 2 * r) / 2 + 1; - QRectF br = QRectF(dx + 0.5, dy + 0.5, + QRectF br = QRectF(dx + qreal(0.5), dy + qreal(0.5), int(r * 2 - 2 * d_ - 2), int(r * 2 - 2 * d_ - 2)); buttonColor.setHsv(buttonColor .hue(), @@ -244,11 +244,11 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) if (enabled) { // Drop shadow - qreal shadowSize = qMax(1.0, penSize/2.0); + const qreal shadowSize = qMax(qreal(1.0), penSize * qreal(0.5)); QRectF shadowRect= br.adjusted(-2*shadowSize, -2*shadowSize, 2*shadowSize, 2*shadowSize); QRadialGradient shadowGradient(shadowRect.center().x(), - shadowRect.center().y(), shadowRect.width()/2.0, + shadowRect.center().y(), shadowRect.width() * qreal(0.5), shadowRect.center().x(), shadowRect.center().y()); shadowGradient.setColorAt(qreal(0.91), QColor(0, 0, 0, 40)); shadowGradient.setColorAt(qreal(1.0), Qt::transparent); @@ -260,7 +260,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) // Main gradient QRadialGradient gradient(br.center().x() - br.width()/3, dy, - br.width()*1.3, br.center().x(), + br.width()*qreal(1.3), br.center().x(), br.center().y() - br.height()/2); gradient.setColorAt(0, buttonColor.lighter(110)); gradient.setColorAt(qreal(0.5), buttonColor); @@ -283,7 +283,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) qMin(160, highlight.saturation()), qMax(230, highlight.value())); highlight.setAlpha(127); - p->setPen(QPen(highlight, 2.0)); + p->setPen(QPen(highlight, qreal(2.0))); p->setBrush(Qt::NoBrush); p->drawEllipse(br.adjusted(-1, -1, 1, 1)); } @@ -302,7 +302,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) dialGradient.setColorAt(1, buttonColor.darker(140)); dialGradient.setColorAt(qreal(0.4), buttonColor.darker(120)); dialGradient.setColorAt(0, buttonColor.darker(110)); - if (penSize > 3.0) { + if (penSize > qreal(3.0)) { painter->setPen(QPen(QColor(0, 0, 0, 25), penSize)); painter->drawLine(calcRadialPos(option, qreal(0.90)), calcRadialPos(option, qreal(0.96))); } diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp index ae1d33a..ae84442 100644 --- a/src/gui/styles/qstylesheetstyle.cpp +++ b/src/gui/styles/qstylesheetstyle.cpp @@ -1252,20 +1252,20 @@ QPainterPath QRenderRule::borderClip(QRect r) const QRectF rect(r); const int *borders = border()->borders; QPainterPath path; - qreal curY = rect.y() + borders[TopEdge]/2.0; + qreal curY = rect.y() + borders[TopEdge]*qreal(0.5); path.moveTo(rect.x() + tlr.width(), curY); path.lineTo(rect.right() - trr.width(), curY); - qreal curX = rect.right() - borders[RightEdge]/2.0; + qreal curX = rect.right() - borders[RightEdge]*qreal(0.5); path.arcTo(curX - 2*trr.width() + borders[RightEdge], curY, trr.width()*2 - borders[RightEdge], trr.height()*2 - borders[TopEdge], 90, -90); path.lineTo(curX, rect.bottom() - brr.height()); - curY = rect.bottom() - borders[BottomEdge]/2.0; + curY = rect.bottom() - borders[BottomEdge]*qreal(0.5); path.arcTo(curX - 2*brr.width() + borders[RightEdge], curY - 2*brr.height() + borders[BottomEdge], brr.width()*2 - borders[RightEdge], brr.height()*2 - borders[BottomEdge], 0, -90); path.lineTo(rect.x() + blr.width(), curY); - curX = rect.left() + borders[LeftEdge]/2.0; + curX = rect.left() + borders[LeftEdge]*qreal(0.5); path.arcTo(curX, rect.bottom() - 2*blr.height() + borders[BottomEdge]/2, blr.width()*2 - borders[LeftEdge], blr.height()*2 - borders[BottomEdge], 270, -90); diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp index 447087c..4511709 100644 --- a/src/gui/text/qfont.cpp +++ b/src/gui/text/qfont.cpp @@ -309,7 +309,7 @@ QFontPrivate *QFontPrivate::smallCapsFontPrivate() const QFont font(const_cast(this)); qreal pointSize = font.pointSizeF(); if (pointSize > 0) - font.setPointSizeF(pointSize * .7); + font.setPointSizeF(pointSize * qreal(.7)); else font.setPixelSize((font.pixelSize() * 7 + 5) / 10); scFont = font.d.data(); @@ -2143,7 +2143,7 @@ QDataStream &operator<<(QDataStream &s, const QFont &font) if (s.version() >= QDataStream::Qt_4_0) { // 4.0 - double pointSize = font.d->request.pointSize; + qreal pointSize = font.d->request.pointSize; qint32 pixelSize = font.d->request.pixelSize; s << pointSize; s << pixelSize; @@ -2205,7 +2205,7 @@ QDataStream &operator>>(QDataStream &s, QFont &font) if (s.version() >= QDataStream::Qt_4_0) { // 4.0 - double pointSize; + qreal pointSize; qint32 pixelSize; s >> pointSize; s >> pixelSize; diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp index fb8444e..1ceb28b 100644 --- a/src/gui/text/qfontdatabase.cpp +++ b/src/gui/text/qfontdatabase.cpp @@ -1877,11 +1877,12 @@ QList QFontDatabase::pointSizes(const QString &family, smoothScalable = true; goto end; } + const qreal pointsize_factor = qreal(72.0) / dpi; for (int l = 0; l < style->count; l++) { const QtFontSize *size = style->pixelSizes + l; if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) { - const uint pointSize = qRound(size->pixelSize * 72.0 / dpi); + const uint pointSize = qRound(size->pixelSize * pointsize_factor); if (! sizes.contains(pointSize)) sizes.append(pointSize); } @@ -1984,11 +1985,12 @@ QList QFontDatabase::smoothSizes(const QString &family, smoothScalable = true; goto end; } + const qreal pointsize_factor = qreal(72.0) / dpi; for (int l = 0; l < style->count; l++) { const QtFontSize *size = style->pixelSizes + l; if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) { - const uint pointSize = qRound(size->pixelSize * 72.0 / dpi); + const uint pointSize = qRound(size->pixelSize * pointsize_factor); if (! sizes.contains(pointSize)) sizes.append(pointSize); } diff --git a/src/svg/qsvggenerator.cpp b/src/svg/qsvggenerator.cpp index 2f80a92..248bf55 100644 --- a/src/svg/qsvggenerator.cpp +++ b/src/svg/qsvggenerator.cpp @@ -796,9 +796,9 @@ int QSvgGenerator::metric(QPaintDevice::PaintDeviceMetric metric) const case QPaintDevice::PdmDpiY: return d->engine->resolution(); case QPaintDevice::PdmHeightMM: - return qRound(d->engine->size().height() * 25.4 / d->engine->resolution()); + return qRound(d->engine->size().height() * (d->engine->resolution() / qreal(25.4))); case QPaintDevice::PdmWidthMM: - return qRound(d->engine->size().width() * 25.4 / d->engine->resolution()); + return qRound(d->engine->size().width() * (d->engine->resolution() / qreal(25.4))); case QPaintDevice::PdmNumColors: return 0xffffffff; case QPaintDevice::PdmPhysicalDpiX: @@ -842,8 +842,9 @@ bool QSvgPaintEngine::begin(QPaintDevice *) *d->stream << "" << endl << "size.isValid()) { - qreal wmm = d->size.width() * 25.4 / d->resolution; - qreal hmm = d->size.height() * 25.4 / d->resolution; + const qreal mm_factor = d->resolution / qreal(25.4); + const qreal wmm = d->size.width() * mm_factor; + const qreal hmm = d->size.height() * mm_factor; *d->stream << " width=\"" << wmm << "mm\" height=\"" << hmm << "mm\"" << endl; } diff --git a/src/svg/qsvggraphics.cpp b/src/svg/qsvggraphics.cpp index 6552b69..cc3c170 100644 --- a/src/svg/qsvggraphics.cpp +++ b/src/svg/qsvggraphics.cpp @@ -332,11 +332,12 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) // Force the font to have a size of 100 pixels to avoid truncation problems // when the font is very small. - qreal scale = 100.0 / p->font().pointSizeF(); + const qreal scale = qreal(100.0) / p->font().pointSizeF(); + const qreal inv_scale = p->font().pointSizeF() / qreal(100.0); // like '1/scale' but with less rounding errors Qt::Alignment alignment = states.textAnchor; QTransform oldTransform = p->worldTransform(); - p->scale(1 / scale, 1 / scale); + p->scale(inv_scale, inv_scale); qreal y = 0; bool initial = true; @@ -346,7 +347,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) if (m_type == TEXTAREA) { if (alignment == Qt::AlignHCenter) - px += scaledSize.width() / 2; + px += scaledSize.width() * qreal(0.5); else if (alignment == Qt::AlignRight) px += scaledSize.width(); } @@ -459,7 +460,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) qreal x = 0; if (alignment == Qt::AlignHCenter) - x -= 0.5 * line.naturalTextWidth(); + x -= qreal(0.5) * line.naturalTextWidth(); else if (alignment == Qt::AlignRight) x -= line.naturalTextWidth(); @@ -479,7 +480,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) break; } - y += 1.1 * line.height(); + y += qreal(1.1) * line.height(); } tl.draw(p, QPointF(px, py), QVector(), bounds); diff --git a/src/svg/qsvghandler.cpp b/src/svg/qsvghandler.cpp index 3ed918e..a340c05 100644 --- a/src/svg/qsvghandler.cpp +++ b/src/svg/qsvghandler.cpp @@ -66,6 +66,7 @@ #include "qnumeric.h" #include "qvarlengtharray.h" #include "private/qmath_p.h" +#include "private/qnumeric_p.h" #include "float.h" @@ -908,7 +909,7 @@ static inline qreal convertToNumber(const QString &str, QSvgHandler *handler, bo QSvgHandler::LengthType type; qreal num = parseLength(str, type, handler, ok); if (type == QSvgHandler::LT_PERCENT) { - num = num/100.0; + num = num * qreal(0.01); } return num; } @@ -943,13 +944,13 @@ static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type) case QSvgHandler::LT_PC: break; case QSvgHandler::LT_PT: - return len * 1.25; + return len * qreal(1.25); break; case QSvgHandler::LT_MM: - return len * 3.543307; + return len * qreal(3.543307); break; case QSvgHandler::LT_CM: - return len * 35.43307; + return len * qreal(35.43307); break; case QSvgHandler::LT_IN: return len * 90; @@ -1372,16 +1373,16 @@ static void pathArcSegment(QPainterPath &path, qreal t; qreal thHalf; - sinTh = qSin(xAxisRotation * (Q_PI / 180.0)); - cosTh = qCos(xAxisRotation * (Q_PI / 180.0)); + sinTh = qSin(xAxisRotation * Q_PI180); + cosTh = qCos(xAxisRotation * Q_PI180); a00 = cosTh * rx; a01 = -sinTh * ry; a10 = sinTh * rx; a11 = cosTh * ry; - thHalf = 0.5 * (th1 - th0); - t = (8.0 / 3.0) * qSin(thHalf * 0.5) * qSin(thHalf * 0.5) / qSin(thHalf); + thHalf = qreal(0.5) * (th1 - th0); + t = (qreal(8.0) / qreal(3.0)) * qSin(thHalf * qreal(0.5)) * qSin(thHalf * qreal(0.5)) / qSin(thHalf); x1 = xc + qCos(th0) - t * qSin(th0); y1 = yc + qSin(th0) + t * qCos(th0); x3 = xc + qCos(th1); @@ -1441,11 +1442,11 @@ static void pathArc(QPainterPath &path, rx = qAbs(rx); ry = qAbs(ry); - sin_th = qSin(x_axis_rotation * (Q_PI / 180.0)); - cos_th = qCos(x_axis_rotation * (Q_PI / 180.0)); + sin_th = qSin(x_axis_rotation * Q_PI180); + cos_th = qCos(x_axis_rotation * Q_PI180); - dx = (curx - x) / 2.0; - dy = (cury - y) / 2.0; + dx = (curx - x) * qreal(0.5); + dy = (cury - y) * qreal(0.5); dx1 = cos_th * dx + sin_th * dy; dy1 = -sin_th * dx + cos_th * dy; Pr1 = rx * rx; @@ -1459,10 +1460,12 @@ static void pathArc(QPainterPath &path, ry = ry * qSqrt(check); } - a00 = cos_th / rx; - a01 = sin_th / rx; - a10 = -sin_th / ry; - a11 = cos_th / ry; + const qreal inv_rx = 1 / rx; + const qreal inv_ry = 1 / ry; + a00 = cos_th * inv_rx; + a01 = sin_th * inv_rx; + a10 = -sin_th * inv_ry; + a11 = cos_th * inv_ry; x0 = a00 * curx + a01 * cury; y0 = a10 * curx + a11 * cury; x1 = a00 * x + a01 * y; @@ -1473,12 +1476,12 @@ static void pathArc(QPainterPath &path, The arc fits a unit-radius circle in this space. */ d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0); - sfactor_sq = 1.0 / d - 0.25; + sfactor_sq = qreal(1.0) / d - qreal(0.25); if (sfactor_sq < 0) sfactor_sq = 0; sfactor = qSqrt(sfactor_sq); if (sweep_flag == large_arc_flag) sfactor = -sfactor; - xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0); - yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0); + xc = qreal(0.5) * (x0 + x1) - sfactor * (y1 - y0); + yc = qreal(0.5) * (y0 + y1) + sfactor * (x1 - x0); /* (xc, yc) is center of the circle. */ th0 = atan2(y0 - yc, x0 - xc); @@ -1486,16 +1489,18 @@ static void pathArc(QPainterPath &path, th_arc = th1 - th0; if (th_arc < 0 && sweep_flag) - th_arc += 2 * Q_PI; + th_arc += Q_2PI; else if (th_arc > 0 && !sweep_flag) - th_arc -= 2 * Q_PI; + th_arc -= Q_2PI; - n_segs = qCeil(qAbs(th_arc / (Q_PI * 0.5 + 0.001))); + n_segs = qCeil(qAbs(th_arc / (Q_PI2 + qreal(0.001)))); + const qreal th_arc_div_n_segs = th_arc / n_segs; for (i = 0; i < n_segs; i++) { + const qreal i_mul_th_arc_div_n_segs = i * th_arc_div_n_segs; pathArcSegment(path, xc, yc, - th0 + i * th_arc / n_segs, - th0 + (i + 1) * th_arc / n_segs, + th0 + i_mul_th_arc_div_n_segs, + th0 + i_mul_th_arc_div_n_segs + th_arc_div_n_segs, rx, ry, x_axis_rotation); } } @@ -2969,10 +2974,10 @@ static QSvgNode *createRectNode(QSvgNode *parent, //9.2 The 'rect' element clearly specifies it // but the case might in fact be handled because // we draw rounded rectangles differently - if (nrx > bounds.width()/2) - nrx = bounds.width()/2; - if (nry > bounds.height()/2) - nry = bounds.height()/2; + if (nrx > bounds.width()*qreal(0.5)) + nrx = bounds.width()*qreal(0.5); + if (nry > bounds.height()*qreal(0.5)) + nry = bounds.height()*qreal(0.5); if (nrx && !nry) nry = nrx; @@ -2982,8 +2987,8 @@ static QSvgNode *createRectNode(QSvgNode *parent, //we draw rounded rect from 0...99 //svg from 0...bounds.width()/2 so we're adjusting the //coordinates - nrx *= (100/(bounds.width()/2)); - nry *= (100/(bounds.height()/2)); + nrx *= (200/bounds.width()); + nry *= (200/bounds.height()); QSvgNode *rect = new QSvgRect(parent, bounds, int(nrx), @@ -3073,7 +3078,7 @@ static bool parseStopNode(QSvgStyleProperty *parent, bool ok = true; qreal offset = convertToNumber(offsetStr, handler, &ok); if (!ok) - offset = 0.0; + offset = qreal(0.0); QString black = QString::fromLatin1("#000000"); if (colorStr.isEmpty()) { colorStr = QStringRef(&black); @@ -3093,9 +3098,9 @@ static bool parseStopNode(QSvgStyleProperty *parent, } // If offset is greater than one, it must be clamped to one. - if (offset > 1.0) { - if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < 1.0 - FLT_EPSILON)) { - stops.back().first = 1.0 - FLT_EPSILON; + if (offset > qreal(1.0)) { + if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < qreal(1.0) - FLT_EPSILON)) { + stops.back().first = qreal(1.0) - FLT_EPSILON; grad->setStops(stops); } offset = 1.0; diff --git a/src/svg/qsvgtinydocument.cpp b/src/svg/qsvgtinydocument.cpp index e2cefeb..21e9e9f 100644 --- a/src/svg/qsvgtinydocument.cpp +++ b/src/svg/qsvgtinydocument.cpp @@ -466,20 +466,19 @@ QMatrix QSvgTinyDocument::matrixForElement(const QString &id) const int QSvgTinyDocument::currentFrame() const { - double runningPercentage = qMin(m_time.elapsed()/double(m_animationDuration), 1.); + const qreal runningPercentage = qMin(qreal(m_time.elapsed()) / qreal(m_animationDuration), qreal(1.)); - int totalFrames = m_fps * m_animationDuration; + const int totalFrames = m_fps * m_animationDuration; return int(runningPercentage * totalFrames); } void QSvgTinyDocument::setCurrentFrame(int frame) { - int totalFrames = m_fps * m_animationDuration; - double framePercentage = frame/double(totalFrames); - double timeForFrame = m_animationDuration * framePercentage; //in S - timeForFrame *= 1000; //in ms - int timeToAdd = int(timeForFrame - m_time.elapsed()); + const int totalFrames = m_fps * m_animationDuration; + const qreal framePercentage = frame / totalFrames; + const qreal timeForFrame = m_animationDuration * framePercentage * 1000; //in ms + const int timeToAdd = int(timeForFrame - m_time.elapsed()); m_time = m_time.addMSecs(timeToAdd); } -- cgit v0.12 From 7ea04bf5c065a037b2db667572e1947f1a1b8b2e Mon Sep 17 00:00:00 2001 From: Alessandro Portale Date: Fri, 6 Nov 2009 20:10:12 +0100 Subject: Simplify NavigationModeKeypad cases Basically, QFileDialog on Desktop performs heavy event handling tweaks on the lineedit and listview to make them ultra keyboard friendly. We added many "anti"-hacks for Keypadnavigation to restore the native behavior of the widgets. The result is pure unmaintainability. (I admit that most of these "anti"-hacks were my fault, since I participated in some and reviewed all of them) This commit has results in the same native behavior for Keypad navigation but without having the #ifdefs inside the event handling switches. Only one of these switch-#ifdefs was there before and still is. embeddedlinux and wince should still be fine and without unintended behavioural changes compared to Qt 4.5, since the Qt::NavigationModeKeypadTabOrder case stays unchanged. Reviewed-by: axis Reviewed-by: Sami Merila modified: src/gui/dialogs/qfiledialog.cpp --- src/gui/dialogs/qfiledialog.cpp | 55 +++++++++++++++++------------------------ 1 file changed, 22 insertions(+), 33 deletions(-) diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp index 6bc6b76..3b1befd 100644 --- a/src/gui/dialogs/qfiledialog.cpp +++ b/src/gui/dialogs/qfiledialog.cpp @@ -3022,12 +3022,6 @@ bool QFileDialogPrivate::itemViewKeyboardEvent(QKeyEvent *event) { case Qt::Key_Escape: q->hide(); return true; -#ifdef QT_KEYPAD_NAVIGATION - case Qt::Key_Down: - case Qt::Key_Up: - return (QApplication::navigationMode() != Qt::NavigationModeKeypadTabOrder - && QApplication::navigationMode() != Qt::NavigationModeKeypadDirectional); -#endif default: break; } @@ -3145,20 +3139,16 @@ QSize QFileDialogListView::sizeHint() const void QFileDialogListView::keyPressEvent(QKeyEvent *e) { - if (!d_ptr->itemViewKeyboardEvent(e)) { - QListView::keyPressEvent(e); - } #ifdef QT_KEYPAD_NAVIGATION - else if ((QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder - || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) - && !hasEditFocus()) { - e->ignore(); - } else { - e->accept(); + if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) { + QListView::keyPressEvent(e); + return; } -#else +#endif // QT_KEYPAD_NAVIGATION + + if (!d_ptr->itemViewKeyboardEvent(e)) + QListView::keyPressEvent(e); e->accept(); -#endif } QFileDialogTreeView::QFileDialogTreeView(QWidget *parent) : QTreeView(parent) @@ -3184,20 +3174,16 @@ void QFileDialogTreeView::init(QFileDialogPrivate *d_pointer) void QFileDialogTreeView::keyPressEvent(QKeyEvent *e) { - if (!d_ptr->itemViewKeyboardEvent(e)) { - QTreeView::keyPressEvent(e); - } #ifdef QT_KEYPAD_NAVIGATION - else if ((QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder - || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) - && !hasEditFocus()) { - e->ignore(); - } else { - e->accept(); + if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) { + QTreeView::keyPressEvent(e); + return; } -#else +#endif // QT_KEYPAD_NAVIGATION + + if (!d_ptr->itemViewKeyboardEvent(e)) + QTreeView::keyPressEvent(e); e->accept(); -#endif } QSize QFileDialogTreeView::sizeHint() const @@ -3213,13 +3199,16 @@ QSize QFileDialogTreeView::sizeHint() const */ void QFileDialogLineEdit::keyPressEvent(QKeyEvent *e) { +#ifdef QT_KEYPAD_NAVIGATION + if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) { + QLineEdit::keyPressEvent(e); + return; + } +#endif // QT_KEYPAD_NAVIGATION + int key = e->key(); QLineEdit::keyPressEvent(e); - if (key != Qt::Key_Escape -#ifdef QT_KEYPAD_NAVIGATION - && QApplication::navigationMode() == Qt::NavigationModeNone -#endif - ) + if (key != Qt::Key_Escape) e->accept(); if (hideOnEsc && (key == Qt::Key_Escape || key == Qt::Key_Return || key == Qt::Key_Enter)) { e->accept(); -- cgit v0.12 From b48ae5932131b6d0934a50846cad441f6e9f5ccd Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Mon, 9 Nov 2009 10:18:35 +1000 Subject: Set frameless window hints on QGL test windows under QWS QWS combines the window title bar and the top-level widget into one window surface, which causes problems when the top-level widget is a QGLWidget: the raw GL surface contents are not the same as on other platforms where only the top-level widget contents are included in the window surface. This change sets Qt::FramelessWindowHint on QWS systems on widgets where we need to read back the top-level widget for comparison against a reference image. Reviewed-by: Sarah Smith --- tests/auto/qgl/tst_qgl.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp index 2c60eb2..6703d4e 100644 --- a/tests/auto/qgl/tst_qgl.cpp +++ b/tests/auto/qgl/tst_qgl.cpp @@ -805,6 +805,9 @@ void tst_QGL::graphicsViewClipping() scene.addWidget(widget)->setPos(0, 0); QGraphicsView view(&scene); +#ifdef Q_WS_QWS + view.setWindowFlags(Qt::FramelessWindowHint); +#endif view.resize(2*size, 2*size); QGLWidget *viewport = new QGLWidget; @@ -949,6 +952,9 @@ public: void tst_QGL::glWidgetRendering() { GLWidget w; +#ifdef Q_WS_QWS + w.setWindowFlags(Qt::FramelessWindowHint); +#endif w.setGeometry(100, 100, 200, 200); w.show(); @@ -1176,6 +1182,9 @@ void tst_QGL::glFBOUseInGLWidget() QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle); FBOUseInGLWidget w; +#ifdef Q_WS_QWS + w.setWindowFlags(Qt::FramelessWindowHint); +#endif w.resize(128, 128); w.show(); @@ -1562,6 +1571,9 @@ protected: void tst_QGL::replaceClipping() { ReplaceClippingGLWidget glw; +#ifdef Q_WS_QWS + glw.setWindowFlags(Qt::FramelessWindowHint); +#endif glw.resize(300, 300); glw.show(); @@ -1693,6 +1705,9 @@ protected: void tst_QGL::clipTest() { ClipTestGLWidget glw; +#ifdef Q_WS_QWS + glw.setWindowFlags(Qt::FramelessWindowHint); +#endif glw.resize(220, 220); glw.show(); -- cgit v0.12 From f89fc92d1da06964a890e7800caeab62579a0fb4 Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Mon, 9 Nov 2009 12:17:42 +1000 Subject: Detect context sharing on EGL systems Context sharing was enabled on EGL systems, but QGLContext::isSharing() was still returning false because the flag in QGLContextPrivate was not updated. Reviewed-by: Sarah Smith --- src/gui/egl/qegl.cpp | 4 ++++ src/gui/egl/qegl_p.h | 2 ++ src/opengl/qgl_qws.cpp | 1 + src/opengl/qgl_wince.cpp | 1 + src/opengl/qgl_x11egl.cpp | 1 + 5 files changed, 9 insertions(+) diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp index 39291d3..c0e4890 100644 --- a/src/gui/egl/qegl.cpp +++ b/src/gui/egl/qegl.cpp @@ -62,6 +62,7 @@ QEglContext::QEglContext() , currentSurface(EGL_NO_SURFACE) , current(false) , ownsContext(true) + , sharing(false) { } @@ -174,6 +175,7 @@ bool QEglContext::createContext(QEglContext *shareContext, const QEglProperties if (apiType == QEgl::OpenGL) contextProps.setValue(EGL_CONTEXT_CLIENT_VERSION, 2); #endif + sharing = false; if (shareContext && shareContext->ctx == EGL_NO_CONTEXT) shareContext = 0; if (shareContext) { @@ -181,6 +183,8 @@ bool QEglContext::createContext(QEglContext *shareContext, const QEglProperties if (ctx == EGL_NO_CONTEXT) { qWarning() << "QEglContext::createContext(): Could not share context:" << errorString(eglGetError()); shareContext = 0; + } else { + sharing = true; } } if (ctx == EGL_NO_CONTEXT) { diff --git a/src/gui/egl/qegl_p.h b/src/gui/egl/qegl_p.h index 16b5b16..51bdbbe 100644 --- a/src/gui/egl/qegl_p.h +++ b/src/gui/egl/qegl_p.h @@ -81,6 +81,7 @@ public: bool isValid() const; bool isCurrent() const; + bool isSharing() const { return sharing; } QEgl::API api() const { return apiType; } void setApi(QEgl::API api) { apiType = api; } @@ -132,6 +133,7 @@ private: EGLSurface currentSurface; bool current; bool ownsContext; + bool sharing; static EGLDisplay getDisplay(QPaintDevice *device); diff --git a/src/opengl/qgl_qws.cpp b/src/opengl/qgl_qws.cpp index 5e59975..de9c6ae 100644 --- a/src/opengl/qgl_qws.cpp +++ b/src/opengl/qgl_qws.cpp @@ -206,6 +206,7 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) d->eglContext = 0; return false; } + d->sharing = d->eglContext->isSharing(); #if defined(EGL_VERSION_1_1) if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp index fea2d3a..86fe3ba 100644 --- a/src/opengl/qgl_wince.cpp +++ b/src/opengl/qgl_wince.cpp @@ -166,6 +166,7 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) d->eglContext = 0; return false; } + d->sharing = d->eglContext->isSharing(); #if defined(EGL_VERSION_1_1) if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp index 9b20297..5325451 100644 --- a/src/opengl/qgl_x11egl.cpp +++ b/src/opengl/qgl_x11egl.cpp @@ -115,6 +115,7 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) d->eglContext = 0; return false; } + d->sharing = d->eglContext->isSharing(); #if defined(EGL_VERSION_1_1) if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) -- cgit v0.12 From 09a123c7f9df37f82a4baab0e7ec70ebfe5444d3 Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Mon, 9 Nov 2009 12:58:48 +1000 Subject: Mark both the new and original EGL contexts as sharing If we succeed in creating a shared context, then mark the original as shared as well. Reviewed-by: Sarah Smith --- src/opengl/qgl_qws.cpp | 2 ++ src/opengl/qgl_wince.cpp | 2 ++ src/opengl/qgl_x11egl.cpp | 2 ++ tests/auto/qgl/tst_qgl.cpp | 1 + 4 files changed, 7 insertions(+) diff --git a/src/opengl/qgl_qws.cpp b/src/opengl/qgl_qws.cpp index de9c6ae..a189c20 100644 --- a/src/opengl/qgl_qws.cpp +++ b/src/opengl/qgl_qws.cpp @@ -207,6 +207,8 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) return false; } d->sharing = d->eglContext->isSharing(); + if (d->sharing && shareContext) + const_cast(shareContext)->d_func()->sharing = true; #if defined(EGL_VERSION_1_1) if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp index 86fe3ba..2553110 100644 --- a/src/opengl/qgl_wince.cpp +++ b/src/opengl/qgl_wince.cpp @@ -167,6 +167,8 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) return false; } d->sharing = d->eglContext->isSharing(); + if (d->sharing && shareContext) + const_cast(shareContext)->d_func()->sharing = true; #if defined(EGL_VERSION_1_1) if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp index 5325451..b51c239 100644 --- a/src/opengl/qgl_x11egl.cpp +++ b/src/opengl/qgl_x11egl.cpp @@ -116,6 +116,8 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) return false; } d->sharing = d->eglContext->isSharing(); + if (d->sharing && shareContext) + const_cast(shareContext)->d_func()->sharing = true; #if defined(EGL_VERSION_1_1) if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp index 6703d4e..373cc45 100644 --- a/tests/auto/qgl/tst_qgl.cpp +++ b/tests/auto/qgl/tst_qgl.cpp @@ -1817,6 +1817,7 @@ void tst_QGL::shareRegister() delete glw1; QSKIP("Context sharing is not supported", SkipSingle); } + QVERIFY(glw1->isSharing()); QVERIFY(glw1->context() != glw2->context()); // Check that the first context's resource is also on the second. -- cgit v0.12 From 3143014a80d1dfdfe3bb0f6175a3f7f7f41b2aaf Mon Sep 17 00:00:00 2001 From: Tom Cooksey Date: Mon, 9 Nov 2009 08:32:40 +0100 Subject: Add a simpler FBO autotest which just uses glClear() If this autotest doesn't pass, FBOs are really broken. --- tests/auto/qgl/tst_qgl.cpp | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp index 373cc45..ccb08c3 100644 --- a/tests/auto/qgl/tst_qgl.cpp +++ b/tests/auto/qgl/tst_qgl.cpp @@ -76,6 +76,7 @@ private slots: void partialGLWidgetUpdates_data(); void partialGLWidgetUpdates(); void glWidgetRendering(); + void glFBOSimpleRendering(); void glFBORendering(); void multipleFBOInterleavedRendering(); void glFBOUseInGLWidget(); @@ -973,6 +974,36 @@ void tst_QGL::glWidgetRendering() QFUZZY_COMPARE_IMAGES(fb, reference); } +void tst_QGL::glFBOSimpleRendering() +{ + if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()) + QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle); + + QGLWidget glw; + glw.makeCurrent(); + + // No multisample with combined depth/stencil attachment: + QGLFramebufferObjectFormat fboFormat; + fboFormat.setAttachment(QGLFramebufferObject::NoAttachment); + + // Don't complicate things by using NPOT: + QGLFramebufferObject *fbo = new QGLFramebufferObject(256, 128, fboFormat); + + fbo->bind(); + + glClearColor(1.0, 0.0, 0.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + glFinish(); + + QImage fb = fbo->toImage().convertToFormat(QImage::Format_RGB32); + QImage reference(fb.size(), QImage::Format_RGB32); + reference.fill(0xffff0000); + + QFUZZY_COMPARE_IMAGES(fb, reference); + + delete fbo; +} + // NOTE: This tests that CombinedDepthStencil attachment works by assuming the // GL2 engine is being used and is implemented the same way as it was when // this autotest was written. If this is not the case, there may be some -- cgit v0.12 From 434a75313ea30a5fb2d45ecd857b19919b5e7547 Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Mon, 9 Nov 2009 10:09:33 +0100 Subject: Fixed inconsistent coloring of bullets, circles and square lists Also removed a redundant setBrush(), as it will be followed by painter->restore() a few lines below. Reviewed-by: Eskil --- src/gui/text/qtextdocumentlayout.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp index 73434b1..03eb723 100644 --- a/src/gui/text/qtextdocumentlayout.cpp +++ b/src/gui/text/qtextdocumentlayout.cpp @@ -1448,13 +1448,13 @@ void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *p painter->fillRect(r, brush); break; case QTextListFormat::ListCircle: + painter->setPen(QPen(brush)); painter->drawEllipse(r); break; case QTextListFormat::ListDisc: painter->setBrush(brush); painter->setPen(Qt::NoPen); painter->drawEllipse(r); - painter->setBrush(Qt::NoBrush); break; case QTextListFormat::ListStyleUndefined: break; -- cgit v0.12 From abe04b845ea19110dbbc06ba443fe1bf6a29ee92 Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Mon, 9 Nov 2009 10:13:22 +0100 Subject: Pixelalign circles in HTML bullet lists Reviewed-by: Eskil --- src/gui/text/qtextdocumentlayout.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp index 03eb723..85265af 100644 --- a/src/gui/text/qtextdocumentlayout.cpp +++ b/src/gui/text/qtextdocumentlayout.cpp @@ -1449,7 +1449,7 @@ void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *p break; case QTextListFormat::ListCircle: painter->setPen(QPen(brush)); - painter->drawEllipse(r); + painter->drawEllipse(r.translated(0.5, 0.5)); // pixel align for sharper rendering break; case QTextListFormat::ListDisc: painter->setBrush(brush); -- cgit v0.12 From 9c6e3590da6c49d055d452b08de0e51b0b77f1c4 Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Mon, 9 Nov 2009 07:58:56 +0100 Subject: Fixed up qttracereplay and trace graphicsystem a bit. - Added "qttrace" to binary file, making it possible to do a sanity verification of the input file in qttracereplay - Sanity check input binary file, both for existance and for content in qttracereplay - Console app on windows and mac - Added helpful output for -h and --help command line options Reviewed-by: Samuel --- .../trace/qgraphicssystem_trace.cpp | 1 + tools/qttracereplay/main.cpp | 38 ++++++++++++++++------ tools/qttracereplay/qttracereplay.pro | 2 ++ 3 files changed, 31 insertions(+), 10 deletions(-) diff --git a/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp b/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp index 8756ecb..fb6f5ea 100644 --- a/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp +++ b/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp @@ -82,6 +82,7 @@ QTraceWindowSurface::~QTraceWindowSurface() QFile outputFile(QString(QLatin1String("qtgraphics-%0.trace")).arg(winId)); if (outputFile.open(QIODevice::WriteOnly)) { QDataStream out(&outputFile); + out.writeBytes("qttrace", 7); out << *buffer << updates; } delete buffer; diff --git a/tools/qttracereplay/main.cpp b/tools/qttracereplay/main.cpp index 1d21a21..7261082 100644 --- a/tools/qttracereplay/main.cpp +++ b/tools/qttracereplay/main.cpp @@ -56,7 +56,7 @@ public: public slots: void updateRect(); -private: +public: QList updates; QPaintBuffer buffer; @@ -70,7 +70,8 @@ private: void ReplayWidget::updateRect() { - update(updates.at(currentFrame)); + if (!updates.isEmpty()) + update(updates.at(currentFrame)); } void ReplayWidget::paintEvent(QPaintEvent *) @@ -138,12 +139,25 @@ ReplayWidget::ReplayWidget(const QString &filename_) QFile file(filename); QRect bounds; - if (file.open(QIODevice::ReadOnly)) { - QDataStream in(&file); - in >> buffer >> updates; + if (!file.open(QIODevice::ReadOnly)) { + printf("Failed to load input file '%s'\n", qPrintable(filename_)); + return; + } + + QDataStream in(&file); + + char *data; + uint size; + in.readBytes(data, size); + bool isTraceFile = size == 7 && qstrncmp(data, "qttrace", 7) == 0; + delete [] data; + if (!isTraceFile) { + printf("File '%s' is not a trace file\n", qPrintable(filename_)); + return; } - qDebug() << "Read paint buffer with" << buffer.numFrames() << "frames"; + in >> buffer >> updates; + printf("Read paint buffer with %d frames\n", buffer.numFrames()); resize(buffer.boundingRect().size().toSize()); @@ -157,14 +171,18 @@ int main(int argc, char **argv) { QApplication app(argc, argv); - if (argc <= 1) { - printf("Usage: %s filename\n", argv[0]); + if (argc <= 1 || qstrcmp(argv[1], "-h") == 0 || qstrcmp(argv[1], "--help") == 0) { + printf("Replays a tracefile generated with '-graphicssystem trace'\n"); + printf("Usage:\n > %s [traceFile]\n", argv[0]); return 1; } ReplayWidget *widget = new ReplayWidget(argv[1]); - widget->show(); - return app.exec(); + if (!widget->updates.isEmpty()) { + widget->show(); + return app.exec(); + } + } #include "main.moc" diff --git a/tools/qttracereplay/qttracereplay.pro b/tools/qttracereplay/qttracereplay.pro index 766ed04..cc5b98d 100644 --- a/tools/qttracereplay/qttracereplay.pro +++ b/tools/qttracereplay/qttracereplay.pro @@ -11,3 +11,5 @@ SOURCES += main.cpp target.path=$$[QT_INSTALL_BINS] INSTALLS += target + +CONFIG += console -- cgit v0.12 From 845c69b2e780e1646f68ee99beda10768a1971e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Samuel=20R=C3=B8dal?= Date: Fri, 6 Nov 2009 16:09:16 +0100 Subject: Fixed loading of 8-bit grayscale TIFF files. The PHOTOMETRIC_MINISBLACK and PHOTOMETRIC_MINISWHITE settings also apply to 8-bit grayscale, so we need to check the bit depth of the image as well. For convenience we also try to write the images using PHOTOMETRIC_MINISBLACK and PHOTOMETRIC_MINISWHITE as opposed to PHOTOMETRIC_PALETTE when we detect that the color table is grayscale. Task-number: QTBUG-5459 Reviewed-by: Benjamin Poulain --- src/plugins/imageformats/tiff/qtiffhandler.cpp | 155 ++++++++++++++--------- tests/auto/qimagereader/images/grayscale-ref.tif | Bin 0 -> 256182 bytes tests/auto/qimagereader/images/grayscale.tif | Bin 0 -> 64162 bytes tests/auto/qimagereader/tst_qimagereader.cpp | 9 ++ tests/auto/qimagewriter/tst_qimagewriter.cpp | 17 ++- 5 files changed, 118 insertions(+), 63 deletions(-) create mode 100644 tests/auto/qimagereader/images/grayscale-ref.tif create mode 100644 tests/auto/qimagereader/images/grayscale.tif diff --git a/src/plugins/imageformats/tiff/qtiffhandler.cpp b/src/plugins/imageformats/tiff/qtiffhandler.cpp index 3669be7..9538745 100644 --- a/src/plugins/imageformats/tiff/qtiffhandler.cpp +++ b/src/plugins/imageformats/tiff/qtiffhandler.cpp @@ -192,7 +192,14 @@ bool QTiffHandler::read(QImage *image) return false; } - if (photometric == PHOTOMETRIC_MINISBLACK || photometric == PHOTOMETRIC_MINISWHITE) { + uint16 bitPerSample; + if (!TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitPerSample)) { + TIFFClose(tiff); + return false; + } + + bool grayscale = photometric == PHOTOMETRIC_MINISBLACK || photometric == PHOTOMETRIC_MINISWHITE; + if (grayscale && bitPerSample == 1) { if (image->size() != QSize(width, height) || image->format() != QImage::Format_Mono) *image = QImage(width, height, QImage::Format_Mono); QVector colortable(2); @@ -208,42 +215,43 @@ bool QTiffHandler::read(QImage *image) if (!image->isNull()) { for (uint32 y=0; yscanLine(y), y, 0) < 0) { - TIFFClose(tiff); - return false; + TIFFClose(tiff); + return false; } } } } else { - uint16 bitPerSample; - if (!TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitPerSample)) { - TIFFClose(tiff); - return false; - } - if (photometric == PHOTOMETRIC_PALETTE && bitPerSample == 8) { + if ((grayscale || photometric == PHOTOMETRIC_PALETTE) && bitPerSample == 8) { if (image->size() != QSize(width, height) || image->format() != QImage::Format_Indexed8) *image = QImage(width, height, QImage::Format_Indexed8); if (!image->isNull()) { - // create the color table const uint16 tableSize = 256; - uint16 *redTable = static_cast(qMalloc(tableSize * sizeof(uint16))); - uint16 *greenTable = static_cast(qMalloc(tableSize * sizeof(uint16))); - uint16 *blueTable = static_cast(qMalloc(tableSize * sizeof(uint16))); - if (!redTable || !greenTable || !blueTable) { - TIFFClose(tiff); - return false; - } - if (!TIFFGetField(tiff, TIFFTAG_COLORMAP, &redTable, &greenTable, &blueTable)) { - TIFFClose(tiff); - return false; - } - QVector qtColorTable(tableSize); - for (int i = 0; i(qMalloc(tableSize * sizeof(uint16))); + uint16 *greenTable = static_cast(qMalloc(tableSize * sizeof(uint16))); + uint16 *blueTable = static_cast(qMalloc(tableSize * sizeof(uint16))); + if (!redTable || !greenTable || !blueTable) { + TIFFClose(tiff); + return false; + } + if (!TIFFGetField(tiff, TIFFTAG_COLORMAP, &redTable, &greenTable, &blueTable)) { + TIFFClose(tiff); + return false; + } + for (int i = 0; isetColorTable(qtColorTable); @@ -371,6 +379,20 @@ bool QTiffHandler::read(QImage *image) return true; } +static bool checkGrayscale(const QVector &colorTable) +{ + if (colorTable.size() != 256) + return false; + + const bool increasing = (colorTable.at(0) == 0xff000000); + for (int i = 0; i < 256; ++i) { + if (increasing && colorTable.at(i) != qRgb(i, i, i) + || !increasing && colorTable.at(i) != qRgb(255 - i, 255 - i, 255 - i)) + return false; + } + return true; +} + bool QTiffHandler::write(const QImage &image) { if (!device()->isWritable()) @@ -425,7 +447,8 @@ bool QTiffHandler::write(const QImage &image) if (image.colorTable().at(0) == 0xffffffff) photometric = PHOTOMETRIC_MINISWHITE; if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, photometric) - || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_CCITTRLE)) { + || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_CCITTRLE) + || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 1)) { TIFFClose(tiff); return false; } @@ -450,43 +473,55 @@ bool QTiffHandler::write(const QImage &image) } TIFFClose(tiff); } else if (format == QImage::Format_Indexed8) { - if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE) - || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS) - || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) { - TIFFClose(tiff); - return false; - } - //// write the color table - // allocate the color tables - uint16 *redTable = static_cast(qMalloc(256 * sizeof(uint16))); - uint16 *greenTable = static_cast(qMalloc(256 * sizeof(uint16))); - uint16 *blueTable = static_cast(qMalloc(256 * sizeof(uint16))); - if (!redTable || !greenTable || !blueTable) { - TIFFClose(tiff); - return false; - } - - // set the color table const QVector colorTable = image.colorTable(); + bool isGrayscale = checkGrayscale(colorTable); + if (isGrayscale) { + uint16 photometric = PHOTOMETRIC_MINISBLACK; + if (image.colorTable().at(0) == 0xffffffff) + photometric = PHOTOMETRIC_MINISWHITE; + if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, photometric) + || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS) + || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) { + TIFFClose(tiff); + return false; + } + } else { + if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE) + || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS) + || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) { + TIFFClose(tiff); + return false; + } + //// write the color table + // allocate the color tables + uint16 *redTable = static_cast(qMalloc(256 * sizeof(uint16))); + uint16 *greenTable = static_cast(qMalloc(256 * sizeof(uint16))); + uint16 *blueTable = static_cast(qMalloc(256 * sizeof(uint16))); + if (!redTable || !greenTable || !blueTable) { + TIFFClose(tiff); + return false; + } - const int tableSize = colorTable.size(); - Q_ASSERT(tableSize <= 256); - for (int i = 0; i("format"); QTest::addColumn("expectedFormat"); - QTest::newRow("tiff mono") << QImage::Format_Mono << QImage::Format_Mono; - QTest::newRow("tiff indexed") << QImage::Format_Indexed8 << QImage::Format_Indexed8; - QTest::newRow("tiff rgb32") << QImage::Format_ARGB32 << QImage::Format_ARGB32; + QTest::addColumn("grayscale"); + QTest::newRow("tiff mono") << QImage::Format_Mono << QImage::Format_Mono << false; + QTest::newRow("tiff indexed") << QImage::Format_Indexed8 << QImage::Format_Indexed8 << false; + QTest::newRow("tiff rgb32") << QImage::Format_ARGB32 << QImage::Format_ARGB32 << false; + QTest::newRow("tiff grayscale") << QImage::Format_Indexed8 << QImage::Format_Indexed8 << true; } void tst_QImageWriter::readWriteNonDestructive() { QFETCH(QImage::Format, format); QFETCH(QImage::Format, expectedFormat); + QFETCH(bool, grayscale); QImage image = QImage(prefix + "colorful.bmp").convertToFormat(format); + + if (grayscale) { + QVector colors; + for (int i = 0; i < 256; ++i) + colors << qRgb(i, i, i); + image.setColorTable(colors); + } + QVERIFY(image.save(prefix + "gen-readWriteNonDestructive.tiff")); QImage image2 = QImage(prefix + "gen-readWriteNonDestructive.tiff"); -- cgit v0.12 From d9a275b3cc4a248da1f392fb5649b9fe7a93b12c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sami=20Meril=C3=A4?= Date: Mon, 9 Nov 2009 12:54:33 +0200 Subject: Check that we're not using double where qreal should be used Added two missing qreal conversion from QS60Style. Task-number: QTBUG-4894 Reviewed-by: Aleksandar Babic --- src/gui/styles/qs60style.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index 016b6a7..5204743 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -1749,7 +1749,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, optionMenuItem.palette.setColor(QPalette::Disabled, QPalette::Text, QS60StylePrivate::lighterColor( optionMenuItem.palette.color(QPalette::Disabled, QPalette::Text))); painter->save(); - painter->setOpacity(0.5); + painter->setOpacity(qreal(0.75)); } QCommonStyle::drawItemText(painter, textRect, text_flags, optionMenuItem.palette, enabled, @@ -1855,7 +1855,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, painter->save(); if (widget) painter->setBrush(widget->palette().button()); - painter->setOpacity(0.3); + painter->setOpacity(qreal(0.3)); painter->fillRect(toolBar->rect, painter->brush()); painter->restore(); } -- cgit v0.12 From 97c275332f4560183b4fc0384013e3757d23b32c Mon Sep 17 00:00:00 2001 From: axis Date: Mon, 9 Nov 2009 10:34:23 +0100 Subject: Made it possible to bring up the FEP symbols menu using star key. Task: QT-1141 RevBy: mread --- src/gui/inputmethod/qcoefepinputcontext_s60.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp index 25b2313..ea5e29b 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp +++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp @@ -79,7 +79,7 @@ QCoeFepInputContext::QCoeFepInputContext(QObject *parent) m_fepState->SetPermittedInputModes( EAknEditorAllInputModes ); m_fepState->SetDefaultCase( EAknEditorLowerCase ); m_fepState->SetPermittedCases( EAknEditorLowerCase|EAknEditorUpperCase ); - m_fepState->SetSpecialCharacterTableResourceId( 0 ); + m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG); m_fepState->SetNumericKeymap( EAknEditorStandardNumberModeKeymap ); } @@ -407,6 +407,14 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints) } m_fepState->SetNumericKeymap(static_cast(flags)); + if (hints & ImhEmailCharactersOnly) { + m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_EMAIL_ADDR_SPECIAL_CHARACTER_TABLE_DIALOG); + } else if (hints & ImhUrlCharactersOnly) { + m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_URL_SPECIAL_CHARACTER_TABLE_DIALOG); + } else { + m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG); + } + if (hints & ImhHiddenText) { m_textCapabilities = TCoeInputCapabilities::EAllText | TCoeInputCapabilities::ESecretText; } else { -- cgit v0.12 From c56b52a83ee5546c53d1e9e18216f91d097e1213 Mon Sep 17 00:00:00 2001 From: axis Date: Mon, 9 Nov 2009 10:36:29 +0100 Subject: Prevented compiler warning. RevBy: Trust me --- src/gui/kernel/qt_s60_p.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h index 3405bcf..a1e760c 100644 --- a/src/gui/kernel/qt_s60_p.h +++ b/src/gui/kernel/qt_s60_p.h @@ -175,7 +175,7 @@ public: protected: // from MAknFadedComponent TInt CountFadedComponents() {return 1;} - CCoeControl* FadedComponent(TInt aIndex) {return this;} + CCoeControl* FadedComponent(TInt /*aIndex*/) {return this;} #else #warning No fallback implementation for QSymbianControl::FadeBehindPopup void FadeBehindPopup(bool /*fade*/){ } -- cgit v0.12 From 290f9182bb975061f68628008acd592e262a3f45 Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Fri, 6 Nov 2009 15:59:58 +0100 Subject: Replaced tabs with spaces in scale() in qjpeghandler.cpp. Replaced tabs with spaces and Qt-ified code formatting in QImageSmoothScaler::scale(). Reviewed-by: Trond --- src/plugins/imageformats/jpeg/qjpeghandler.cpp | 467 +++++++++++++------------ 1 file changed, 238 insertions(+), 229 deletions(-) diff --git a/src/plugins/imageformats/jpeg/qjpeghandler.cpp b/src/plugins/imageformats/jpeg/qjpeghandler.cpp index 3b23e56..d51668a 100644 --- a/src/plugins/imageformats/jpeg/qjpeghandler.cpp +++ b/src/plugins/imageformats/jpeg/qjpeghandler.cpp @@ -196,52 +196,52 @@ inline QRgb *QImageSmoothScaler::scanLine(const int line, const QImage *src) QImage QImageSmoothScaler::scale() { - long SCALE; - long HALFSCALE; - QRgb *xelrow = 0; - QRgb *tempxelrow = 0; - QRgb *xP; - QRgb *nxP; - int row, rowsread; - int col, needtoreadrow; - uchar maxval = 255; - qreal xscale, yscale; - long sxscale, syscale; - long fracrowtofill, fracrowleft; - long *as; - long *rs; - long *gs; - long *bs; - int rowswritten = 0; - QImage dst; + long SCALE; + long HALFSCALE; + QRgb *xelrow = 0; + QRgb *tempxelrow = 0; + QRgb *xP; + QRgb *nxP; + int row, rowsread; + int col, needtoreadrow; + uchar maxval = 255; + qreal xscale, yscale; + long sxscale, syscale; + long fracrowtofill, fracrowleft; + long *as; + long *rs; + long *gs; + long *bs; + int rowswritten = 0; + QImage dst; if (d->cols > 4096) { - SCALE = 4096; - HALFSCALE = 2048; + SCALE = 4096; + HALFSCALE = 2048; } else { - int fac = 4096; - while (d->cols * fac > 4096) { - fac /= 2; - } + int fac = 4096; + while (d->cols * fac > 4096) + fac /= 2; - SCALE = fac * d->cols; - HALFSCALE = fac * d->cols / 2; + SCALE = fac * d->cols; + HALFSCALE = fac * d->cols / 2; } - xscale = (qreal) d->newcols / (qreal) d->cols; - yscale = (qreal) d->newrows / (qreal) d->rows; + xscale = (qreal)d->newcols / (qreal)d->cols; + yscale = (qreal)d->newrows / (qreal)d->rows; sxscale = (long)(xscale * SCALE); syscale = (long)(yscale * SCALE); - if ( d->newrows != d->rows ) /* shortcut Y scaling if possible */ - tempxelrow = new QRgb[d->cols]; + // shortcut Y scaling if possible + if (d->newrows != d->rows) + tempxelrow = new QRgb[d->cols]; - if ( d->hasAlpha ) { - as = new long[d->cols]; - for ( col = 0; col < d->cols; ++col ) - as[col] = HALFSCALE; + if (d->hasAlpha) { + as = new long[d->cols]; + for (col = 0; col < d->cols; ++col) + as[col] = HALFSCALE; } else { - as = 0; + as = 0; } rs = new long[d->cols]; gs = new long[d->cols]; @@ -249,205 +249,214 @@ QImage QImageSmoothScaler::scale() rowsread = 0; fracrowleft = syscale; needtoreadrow = 1; - for ( col = 0; col < d->cols; ++col ) - rs[col] = gs[col] = bs[col] = HALFSCALE; + for (col = 0; col < d->cols; ++col) + rs[col] = gs[col] = bs[col] = HALFSCALE; fracrowtofill = SCALE; - dst = QImage( d->newcols, d->newrows, d->hasAlpha ? QImage::Format_ARGB32 : QImage::Format_RGB32 ); - - for ( row = 0; row < d->newrows; ++row ) { - /* First scale Y from xelrow into tempxelrow. */ - if ( d->newrows == d->rows ) { - /* shortcut Y scaling if possible */ - tempxelrow = xelrow = scanLine(rowsread++, d->src); - } else { - while ( fracrowleft < fracrowtofill ) { - if ( needtoreadrow && rowsread < d->rows ) { - xelrow = scanLine(rowsread++, d->src); - } - for ( col = 0, xP = xelrow; col < d->cols; ++col, ++xP ) { - if (as) { - as[col] += fracrowleft * qAlpha( *xP ); - rs[col] += fracrowleft * qRed( *xP ) * qAlpha( *xP ) / 255; - gs[col] += fracrowleft * qGreen( *xP ) * qAlpha( *xP ) / 255; - bs[col] += fracrowleft * qBlue( *xP ) * qAlpha( *xP ) / 255; - } else { - rs[col] += fracrowleft * qRed( *xP ); - gs[col] += fracrowleft * qGreen( *xP ); - bs[col] += fracrowleft * qBlue( *xP ); - } - } - fracrowtofill -= fracrowleft; - fracrowleft = syscale; - needtoreadrow = 1; - } - /* Now fracrowleft is >= fracrowtofill, so we can produce a row. */ - if ( needtoreadrow && rowsread < d->rows) { - xelrow = scanLine(rowsread++, d->src); - needtoreadrow = 0; - } - for ( col = 0, xP = xelrow, nxP = tempxelrow; - col < d->cols; ++col, ++xP, ++nxP ) - { - register long a, r, g, b; - - if ( as ) { - r = rs[col] + fracrowtofill * qRed( *xP ) * qAlpha( *xP ) / 255; - g = gs[col] + fracrowtofill * qGreen( *xP ) * qAlpha( *xP ) / 255; - b = bs[col] + fracrowtofill * qBlue( *xP ) * qAlpha( *xP ) / 255; - a = as[col] + fracrowtofill * qAlpha( *xP ); - if ( a ) { - r = r * 255 / a * SCALE; - g = g * 255 / a * SCALE; - b = b * 255 / a * SCALE; - } - } else { - r = rs[col] + fracrowtofill * qRed( *xP ); - g = gs[col] + fracrowtofill * qGreen( *xP ); - b = bs[col] + fracrowtofill * qBlue( *xP ); - a = 0; // unwarn - } - r /= SCALE; - if ( r > maxval ) r = maxval; - g /= SCALE; - if ( g > maxval ) g = maxval; - b /= SCALE; - if ( b > maxval ) b = maxval; - if ( as ) { - a /= SCALE; - if ( a > maxval ) a = maxval; - *nxP = qRgba( (int)r, (int)g, (int)b, (int)a ); - as[col] = HALFSCALE; - } else { - *nxP = qRgb( (int)r, (int)g, (int)b ); - } - rs[col] = gs[col] = bs[col] = HALFSCALE; - } - fracrowleft -= fracrowtofill; - if ( fracrowleft == 0 ) { - fracrowleft = syscale; - needtoreadrow = 1; - } - fracrowtofill = SCALE; - } + dst = QImage(d->newcols, d->newrows, d->hasAlpha ? QImage::Format_ARGB32 : QImage::Format_RGB32); - /* Now scale X from tempxelrow into dst and write it out. */ - if ( d->newcols == d->cols ) { - /* shortcut X scaling if possible */ - memcpy(dst.scanLine(rowswritten++), tempxelrow, d->newcols*4); - } else { - register long a, r, g, b; - register long fraccoltofill, fraccolleft = 0; - register int needcol; - - nxP = (QRgb*)dst.scanLine(rowswritten++); - fraccoltofill = SCALE; - a = r = g = b = HALFSCALE; - needcol = 0; - for ( col = 0, xP = tempxelrow; col < d->cols; ++col, ++xP ) { - fraccolleft = sxscale; - while ( fraccolleft >= fraccoltofill ) { - if ( needcol ) { - ++nxP; - a = r = g = b = HALFSCALE; - } - if ( as ) { - r += fraccoltofill * qRed( *xP ) * qAlpha( *xP ) / 255; - g += fraccoltofill * qGreen( *xP ) * qAlpha( *xP ) / 255; - b += fraccoltofill * qBlue( *xP ) * qAlpha( *xP ) / 255; - a += fraccoltofill * qAlpha( *xP ); - if ( a ) { - r = r * 255 / a * SCALE; - g = g * 255 / a * SCALE; - b = b * 255 / a * SCALE; - } - } else { - r += fraccoltofill * qRed( *xP ); - g += fraccoltofill * qGreen( *xP ); - b += fraccoltofill * qBlue( *xP ); - } - r /= SCALE; - if ( r > maxval ) r = maxval; - g /= SCALE; - if ( g > maxval ) g = maxval; - b /= SCALE; - if ( b > maxval ) b = maxval; - if (as) { - a /= SCALE; - if ( a > maxval ) a = maxval; - *nxP = qRgba( (int)r, (int)g, (int)b, (int)a ); - } else { - *nxP = qRgb( (int)r, (int)g, (int)b ); - } - fraccolleft -= fraccoltofill; - fraccoltofill = SCALE; - needcol = 1; - } - if ( fraccolleft > 0 ) { - if ( needcol ) { - ++nxP; - a = r = g = b = HALFSCALE; - needcol = 0; - } - if (as) { - a += fraccolleft * qAlpha( *xP ); - r += fraccolleft * qRed( *xP ) * qAlpha( *xP ) / 255; - g += fraccolleft * qGreen( *xP ) * qAlpha( *xP ) / 255; - b += fraccolleft * qBlue( *xP ) * qAlpha( *xP ) / 255; - } else { - r += fraccolleft * qRed( *xP ); - g += fraccolleft * qGreen( *xP ); - b += fraccolleft * qBlue( *xP ); - } - fraccoltofill -= fraccolleft; - } - } - if ( fraccoltofill > 0 ) { - --xP; - if (as) { - a += fraccolleft * qAlpha( *xP ); - r += fraccoltofill * qRed( *xP ) * qAlpha( *xP ) / 255; - g += fraccoltofill * qGreen( *xP ) * qAlpha( *xP ) / 255; - b += fraccoltofill * qBlue( *xP ) * qAlpha( *xP ) / 255; - if ( a ) { - r = r * 255 / a * SCALE; - g = g * 255 / a * SCALE; - b = b * 255 / a * SCALE; - } - } else { - r += fraccoltofill * qRed( *xP ); - g += fraccoltofill * qGreen( *xP ); - b += fraccoltofill * qBlue( *xP ); - } - } - if ( ! needcol ) { - r /= SCALE; - if ( r > maxval ) r = maxval; - g /= SCALE; - if ( g > maxval ) g = maxval; - b /= SCALE; - if ( b > maxval ) b = maxval; - if (as) { - a /= SCALE; - if ( a > maxval ) a = maxval; - *nxP = qRgba( (int)r, (int)g, (int)b, (int)a ); - } else { - *nxP = qRgb( (int)r, (int)g, (int)b ); - } - } - } + for (row = 0; row < d->newrows; ++row) { + // First scale Y from xelrow into tempxelrow. + if (d->newrows == d->rows) { + // shortcut Y scaling if possible + tempxelrow = xelrow = scanLine(rowsread++, d->src); + } else { + while (fracrowleft < fracrowtofill) { + if (needtoreadrow && rowsread < d->rows) + xelrow = scanLine(rowsread++, d->src); + for (col = 0, xP = xelrow; col < d->cols; ++col, ++xP) { + if (as) { + as[col] += fracrowleft * qAlpha(*xP); + rs[col] += fracrowleft * qRed(*xP) * qAlpha(*xP) / 255; + gs[col] += fracrowleft * qGreen(*xP) * qAlpha(*xP) / 255; + bs[col] += fracrowleft * qBlue(*xP) * qAlpha(*xP) / 255; + } else { + rs[col] += fracrowleft * qRed(*xP); + gs[col] += fracrowleft * qGreen(*xP); + bs[col] += fracrowleft * qBlue(*xP); + } + } + fracrowtofill -= fracrowleft; + fracrowleft = syscale; + needtoreadrow = 1; + } + // Now fracrowleft is >= fracrowtofill, so we can produce a row. + if (needtoreadrow && rowsread < d->rows) { + xelrow = scanLine(rowsread++, d->src); + needtoreadrow = 0; + } + for (col = 0, xP = xelrow, nxP = tempxelrow; col < d->cols; ++col, ++xP, ++nxP) { + register long a, r, g, b; + + if (as) { + r = rs[col] + fracrowtofill * qRed(*xP) * qAlpha(*xP) / 255; + g = gs[col] + fracrowtofill * qGreen(*xP) * qAlpha(*xP) / 255; + b = bs[col] + fracrowtofill * qBlue(*xP) * qAlpha(*xP) / 255; + a = as[col] + fracrowtofill * qAlpha(*xP); + if (a) { + r = r * 255 / a * SCALE; + g = g * 255 / a * SCALE; + b = b * 255 / a * SCALE; + } + } else { + r = rs[col] + fracrowtofill * qRed(*xP); + g = gs[col] + fracrowtofill * qGreen(*xP); + b = bs[col] + fracrowtofill * qBlue(*xP); + a = 0; // unwarn + } + r /= SCALE; + if (r > maxval) + r = maxval; + g /= SCALE; + if (g > maxval) + g = maxval; + b /= SCALE; + if (b > maxval) + b = maxval; + if (as) { + a /= SCALE; + if (a > maxval) + a = maxval; + *nxP = qRgba((int)r, (int)g, (int)b, (int)a); + as[col] = HALFSCALE; + } else { + *nxP = qRgb((int)r, (int)g, (int)b); + } + rs[col] = gs[col] = bs[col] = HALFSCALE; + } + fracrowleft -= fracrowtofill; + if (fracrowleft == 0) { + fracrowleft = syscale; + needtoreadrow = 1; + } + fracrowtofill = SCALE; + } + + // Now scale X from tempxelrow into dst and write it out. + if (d->newcols == d->cols) { + // shortcut X scaling if possible + memcpy(dst.scanLine(rowswritten++), tempxelrow, d->newcols * 4); + } else { + register long a, r, g, b; + register long fraccoltofill, fraccolleft = 0; + register int needcol; + + nxP = (QRgb *)dst.scanLine(rowswritten++); + fraccoltofill = SCALE; + a = r = g = b = HALFSCALE; + needcol = 0; + for (col = 0, xP = tempxelrow; col < d->cols; ++col, ++xP) { + fraccolleft = sxscale; + while (fraccolleft >= fraccoltofill) { + if (needcol) { + ++nxP; + a = r = g = b = HALFSCALE; + } + if (as) { + r += fraccoltofill * qRed(*xP) * qAlpha(*xP) / 255; + g += fraccoltofill * qGreen(*xP) * qAlpha(*xP) / 255; + b += fraccoltofill * qBlue(*xP) * qAlpha(*xP) / 255; + a += fraccoltofill * qAlpha(*xP); + if (a) { + r = r * 255 / a * SCALE; + g = g * 255 / a * SCALE; + b = b * 255 / a * SCALE; + } + } else { + r += fraccoltofill * qRed(*xP); + g += fraccoltofill * qGreen(*xP); + b += fraccoltofill * qBlue(*xP); + } + r /= SCALE; + if (r > maxval) + r = maxval; + g /= SCALE; + if (g > maxval) + g = maxval; + b /= SCALE; + if (b > maxval) + b = maxval; + if (as) { + a /= SCALE; + if (a > maxval) + a = maxval; + *nxP = qRgba((int)r, (int)g, (int)b, (int)a); + } else { + *nxP = qRgb((int)r, (int)g, (int)b); + } + fraccolleft -= fraccoltofill; + fraccoltofill = SCALE; + needcol = 1; + } + if (fraccolleft > 0) { + if (needcol) { + ++nxP; + a = r = g = b = HALFSCALE; + needcol = 0; + } + if (as) { + a += fraccolleft * qAlpha(*xP); + r += fraccolleft * qRed(*xP) * qAlpha(*xP) / 255; + g += fraccolleft * qGreen(*xP) * qAlpha(*xP) / 255; + b += fraccolleft * qBlue(*xP) * qAlpha(*xP) / 255; + } else { + r += fraccolleft * qRed(*xP); + g += fraccolleft * qGreen(*xP); + b += fraccolleft * qBlue(*xP); + } + fraccoltofill -= fraccolleft; + } + } + if (fraccoltofill > 0) { + --xP; + if (as) { + a += fraccolleft * qAlpha(*xP); + r += fraccoltofill * qRed(*xP) * qAlpha(*xP) / 255; + g += fraccoltofill * qGreen(*xP) * qAlpha(*xP) / 255; + b += fraccoltofill * qBlue(*xP) * qAlpha(*xP) / 255; + if (a) { + r = r * 255 / a * SCALE; + g = g * 255 / a * SCALE; + b = b * 255 / a * SCALE; + } + } else { + r += fraccoltofill * qRed(*xP); + g += fraccoltofill * qGreen(*xP); + b += fraccoltofill * qBlue(*xP); + } + } + if (!needcol) { + r /= SCALE; + if (r > maxval) + r = maxval; + g /= SCALE; + if (g > maxval) + g = maxval; + b /= SCALE; + if (b > maxval) + b = maxval; + if (as) { + a /= SCALE; + if (a > maxval) + a = maxval; + *nxP = qRgba((int)r, (int)g, (int)b, (int)a); + } else { + *nxP = qRgb((int)r, (int)g, (int)b); + } + } + } } - if ( d->newrows != d->rows && tempxelrow )// Robust, tempxelrow might be 0 1 day - delete [] tempxelrow; - if ( as ) // Avoid purify complaint - delete [] as; - if ( rs ) // Robust, rs might be 0 one day - delete [] rs; - if ( gs ) // Robust, gs might be 0 one day - delete [] gs; - if ( bs ) // Robust, bs might be 0 one day - delete [] bs; + if (d->newrows != d->rows && tempxelrow)// Robust, tempxelrow might be 0 1 day + delete [] tempxelrow; + if (as) // Avoid purify complaint + delete [] as; + if (rs) // Robust, rs might be 0 one day + delete [] rs; + if (gs) // Robust, gs might be 0 one day + delete [] gs; + if (bs) // Robust, bs might be 0 one day + delete [] bs; return dst; } -- cgit v0.12 From cbfef77bb7bd370f7373edb78c2646328461d259 Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Fri, 6 Nov 2009 16:22:28 +0100 Subject: Fixed bug where JPEG scaling resulted in an uninitialised pixel column. Loading a JPEG image after calling QImageReader::setScaledSize() could cause a 1 pixel wide column of uninitialised pixels at the far right of the image. The bug was caused by rounding in the scaling algorithm. Fixed by copying the last calculated pixel all the way to the end of the row. Task-number: QTBUG-3282 Reviewed-by: Trond --- src/plugins/imageformats/jpeg/qjpeghandler.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/plugins/imageformats/jpeg/qjpeghandler.cpp b/src/plugins/imageformats/jpeg/qjpeghandler.cpp index d51668a..e5e5e80 100644 --- a/src/plugins/imageformats/jpeg/qjpeghandler.cpp +++ b/src/plugins/imageformats/jpeg/qjpeghandler.cpp @@ -342,6 +342,7 @@ QImage QImageSmoothScaler::scale() register int needcol; nxP = (QRgb *)dst.scanLine(rowswritten++); + QRgb *nxPEnd = nxP + d->newcols; fraccoltofill = SCALE; a = r = g = b = HALFSCALE; needcol = 0; @@ -425,7 +426,7 @@ QImage QImageSmoothScaler::scale() b += fraccoltofill * qBlue(*xP); } } - if (!needcol) { + if (nxP < nxPEnd) { r /= SCALE; if (r > maxval) r = maxval; @@ -443,6 +444,8 @@ QImage QImageSmoothScaler::scale() } else { *nxP = qRgb((int)r, (int)g, (int)b); } + while (++nxP != nxPEnd) + nxP[0] = nxP[-1]; } } } -- cgit v0.12 From e55d77afa7f53562d4b9f0aebd30725e5f4fde86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sami=20Meril=C3=A4?= Date: Mon, 9 Nov 2009 15:00:42 +0200 Subject: Focus changes cause softkey area to flicker Current implementation of softkeys causes flicker, since it re-draws the softkeys for each event handled. First re-draw initializes the softkeys to empty ones, and second one draws the new updated softkeys onscreen. Due to initialization to empty softkey command set, AVKON cannot deduce if the needed redraw is necessary (AVKON does not redraw softkeys if the softkey commands and/or texts won't change). The fixed behaviour is that softkeys are set to -1 for each command when initializing, but no call to SetCommandSetL is done. Now, AVKON won't even try to draw the softkeys until we set the real command set later. Task-number: QTBUG-5436 Reviewed-by: Janne Anttila --- src/gui/kernel/qsoftkeymanager.cpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/gui/kernel/qsoftkeymanager.cpp b/src/gui/kernel/qsoftkeymanager.cpp index ecad72f..6d148fe 100644 --- a/src/gui/kernel/qsoftkeymanager.cpp +++ b/src/gui/kernel/qsoftkeymanager.cpp @@ -213,11 +213,14 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList &softkeys) CEikButtonGroupContainer* nativeContainer = S60->buttonGroupContainer(); nativeContainer->DrawableWindow()->SetOrdinalPosition(0); nativeContainer->DrawableWindow()->SetPointerCapturePriority(1); //keep softkeys available in modal dialog - QT_TRAP_THROWING(nativeContainer->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY_WITH_IDS)); int position = -1; - int command; bool needsExitButton = true; + QT_TRAP_THROWING( + //Using -1 instead of EAknSoftkeyEmpty to avoid flickering. + nativeContainer->SetCommandL(0, -1, KNullDesC); + nativeContainer->SetCommandL(2, -1, KNullDesC); + ); for (int index = 0; index < softkeys.count(); index++) { const QAction* softKeyAction = softkeys.at(index); @@ -238,7 +241,7 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList &softkeys) break; } - command = (softKeyAction->objectName().contains("_q_menuSoftKeyAction")) + int command = (softKeyAction->objectName().contains("_q_menuSoftKeyAction")) ? EAknSoftkeyOptions : s60CommandStart + index; @@ -255,7 +258,8 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList &softkeys) : Qt::Widget; if (needsExitButton && sourceWindowType != Qt::Dialog && sourceWindowType != Qt::Popup) - QT_TRAP_THROWING(nativeContainer->SetCommandL(2, EAknSoftkeyExit, qt_QString2TPtrC(QSoftKeyManager::tr("Exit")))); + QT_TRAP_THROWING( + nativeContainer->SetCommandL(2, EAknSoftkeyExit, qt_QString2TPtrC(QSoftKeyManager::tr("Exit")))); nativeContainer->DrawDeferred(); // 3.1 needs an extra invitation } -- cgit v0.12 From e441fa33a1068e198bf2c7bc54f54f1ff13410c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Trond=20Kjern=C3=A5sen?= Date: Mon, 9 Nov 2009 14:45:41 +0100 Subject: Fixed handling of the "..." button in QPrintDialog for X11. Task-number: QTBUG-5547 Reviewed-by: Kim --- src/gui/dialogs/qprintdialog_unix.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/gui/dialogs/qprintdialog_unix.cpp b/src/gui/dialogs/qprintdialog_unix.cpp index 6fc270d..9d6cd55 100644 --- a/src/gui/dialogs/qprintdialog_unix.cpp +++ b/src/gui/dialogs/qprintdialog_unix.cpp @@ -835,9 +835,6 @@ void QUnixPrintWidgetPrivate::setOptionsPane(QPrintDialogPrivate *pane) void QUnixPrintWidgetPrivate::_q_btnBrowseClicked() { - const int prevPrinter = widget.printers->currentIndex(); - widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one - QString filename = widget.filename->text(); #ifndef QT_NO_FILEDIALOG filename = QFileDialog::getSaveFileName(parent, QPrintDialog::tr("Print To File ..."), filename, @@ -849,9 +846,11 @@ void QUnixPrintWidgetPrivate::_q_btnBrowseClicked() widget.filename->setText(filename); if (filename.endsWith(QString::fromLatin1(".ps"), Qt::CaseInsensitive)) widget.printers->setCurrentIndex(widget.printers->count() - 1); // the postscript one + else if (filename.endsWith(QString::fromLatin1(".pdf"), Qt::CaseInsensitive)) + widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one + else if (widget.printers->currentIndex() != widget.printers->count() - 1) // if ps is not selected, pdf is default + widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one } - else - widget.printers->setCurrentIndex(prevPrinter); } void QUnixPrintWidgetPrivate::applyPrinterProperties(QPrinter *p) -- cgit v0.12 From caaf77c971ea96b021bb6efe0bd1796ce8ebec6a Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Mon, 9 Nov 2009 14:52:45 +0100 Subject: Fixed dropshadow raster implementation since rewrite Reviewed-by: Samuel --- src/gui/image/qpixmapfilter.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp index d83ef2c..de8f4e0 100644 --- a/src/gui/image/qpixmapfilter.cpp +++ b/src/gui/image/qpixmapfilter.cpp @@ -1089,19 +1089,24 @@ void QPixmapDropShadowFilter::draw(QPainter *p, return; } - QImage tmp = src.isNull() ? px.toImage() : px.copy(src.toAlignedRect()).toImage(); + QImage tmp(px.size(), QImage::Format_ARGB32_Premultiplied); + tmp.fill(0); + QPainter tmpPainter(&tmp); + tmpPainter.setCompositionMode(QPainter::CompositionMode_Source); + tmpPainter.drawPixmap(d->offset, px); + tmpPainter.end(); // blur the alpha channel tmp = blurred(tmp, tmp.rect(), qRound(d->radius), true); // blacken the image... - QPainter tmpPainter(&tmp); + tmpPainter.begin(&tmp); tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn); - tmpPainter.fillRect(0, 0, tmp.width(), tmp.height(), d->color); + tmpPainter.fillRect(tmp.rect(), d->color); tmpPainter.end(); // draw the blurred drop shadow... - p->drawImage(pos + d->offset, tmp); + p->drawImage(pos, tmp); // Draw the actual pixmap... p->drawPixmap(pos, px, src); -- cgit v0.12 From a674879a8e070a8fbb85110c0bba3eed212c16b4 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Mon, 9 Nov 2009 14:22:17 +0100 Subject: Remove temp dirs workaround for raptor builds only Webkit cannot build because of too long command lines in the sbsv2 config. There is an alternative workaround in raptor for the relative include paths problem, i.e. "sbs -c winscw_udeb.mwccinc" Removing the temp dirs from being created and added to systeminclude makes the command line short enough again that webkit can be compiled. Reviewed-By: Miikka Heikkinen Based on following commit from the no-tmp-dirs branch: commit 33e8c420bb40ca6194d29f96ef2fbd0f18340e6b Author: Iain Date: Wed Oct 7 13:45:48 2009 +0200 First attempt at removing the tmp dirs workaround on Symbian OS I may not have caught all the places where it is used, but MMP files look OK afterwards. TODO: Slightly concerned that I've trimmed too much from the abld generator as I think that the bit I cut was also used for other temp dirs --- .../flm/qt/qmake_generate_temp_dirs.flm | 22 ------------ mkspecs/symbian-sbsv2/flm/qt/qt.xml | 5 --- qmake/generators/symbian/symmake.cpp | 11 +----- qmake/generators/symbian/symmake.h | 1 + qmake/generators/symbian/symmake_abld.cpp | 14 ++++++++ qmake/generators/symbian/symmake_abld.h | 1 + qmake/generators/symbian/symmake_sbsv2.cpp | 40 +++++++++------------- qmake/generators/symbian/symmake_sbsv2.h | 1 + 8 files changed, 34 insertions(+), 61 deletions(-) delete mode 100644 mkspecs/symbian-sbsv2/flm/qt/qmake_generate_temp_dirs.flm diff --git a/mkspecs/symbian-sbsv2/flm/qt/qmake_generate_temp_dirs.flm b/mkspecs/symbian-sbsv2/flm/qt/qmake_generate_temp_dirs.flm deleted file mode 100644 index ca6cca9..0000000 --- a/mkspecs/symbian-sbsv2/flm/qt/qmake_generate_temp_dirs.flm +++ /dev/null @@ -1,22 +0,0 @@ -# /**************************************************************************** -# ** -# ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). -# ** Contact: Nokia Corporation (qt-info@nokia.com) -# ** -# ** This file is part of symbian-sbsv2 mkspec. -# ** -# ****************************************************************************/ - -include $(FLMHOME)/metaflm.mk - -SINGLETON:=$(call sanitise,TEMP_DIRS_$(EXTENSION_ROOT)) - -ifeq ($($(SINGLETON)),) -$(SINGLETON):=1 -$(call makepath,$(DIRS)) -$(eval $(call GenerateStandardCleanTarget,'',$(DIRS))) -endif - - - - diff --git a/mkspecs/symbian-sbsv2/flm/qt/qt.xml b/mkspecs/symbian-sbsv2/flm/qt/qt.xml index 5074e47..c99b5e2 100644 --- a/mkspecs/symbian-sbsv2/flm/qt/qt.xml +++ b/mkspecs/symbian-sbsv2/flm/qt/qt.xml @@ -35,11 +35,6 @@ - - - - diff --git a/qmake/generators/symbian/symmake.cpp b/qmake/generators/symbian/symmake.cpp index 8ec4b3f..1326a49 100644 --- a/qmake/generators/symbian/symmake.cpp +++ b/qmake/generators/symbian/symmake.cpp @@ -610,19 +610,10 @@ void SymbianMakefileGenerator::initMmpVariables() incpaths << project->values("UI_HEADERS_DIR"); incpaths << project->values("UI_DIR"); - QString epocPath("epoc32"); for (int j = 0; j < incpaths.size(); ++j) { QString includepath = canonizePath(incpaths.at(j)); appendIfnotExist(sysincspaths, includepath); - // As a workaround for Symbian toolchain insistence to treat include - // statements as relative to source file rather than the file they appear in, - // we generate extra temporary include directories to make - // relative include paths used in various headers to work properly. - // Note that this is not a fix-all solution; it's just a stop-gap measure - // to make Qt itself build until toolchain can support relative includes in - // a way that Qt expects. - if (!includepath.contains(epocPath)) // No temp dirs for epoc includes - appendIfnotExist(sysincspaths, includepath + QString("/" QT_EXTRA_INCLUDE_DIR)); + appendAbldTempDirs(sysincspaths, includepath); } // Remove duplicate include path entries diff --git a/qmake/generators/symbian/symmake.h b/qmake/generators/symbian/symmake.h index 36f6e05..a3e2c17 100644 --- a/qmake/generators/symbian/symmake.h +++ b/qmake/generators/symbian/symmake.h @@ -147,6 +147,7 @@ protected: virtual void writeBldInfMkFilePart(QTextStream& t, bool addDeploymentExtension) = 0; virtual void writeMkFile(const QString& wrapperFileName, bool deploymentOnly) = 0; virtual void writeWrapperMakefile(QFile& wrapperFile, bool isPrimaryMakefile) = 0; + virtual void appendAbldTempDirs(QStringList& sysincspaths, QString includepath) = 0; public: diff --git a/qmake/generators/symbian/symmake_abld.cpp b/qmake/generators/symbian/symmake_abld.cpp index 4d1673b..1b5464f 100644 --- a/qmake/generators/symbian/symmake_abld.cpp +++ b/qmake/generators/symbian/symmake_abld.cpp @@ -450,3 +450,17 @@ void SymbianAbldMakefileGenerator::writeBldInfMkFilePart(QTextStream& t, bool ad t << "gnumakefile " << gnuMakefileName << endl; } } + +void SymbianAbldMakefileGenerator::appendAbldTempDirs(QStringList& sysincspaths, QString includepath) +{ + // As a workaround for Symbian toolchain insistence to treat include + // statements as relative to source file rather than the file they appear in, + // we generate extra temporary include directories to make + // relative include paths used in various headers to work properly. + // Note that this is not a fix-all solution; it's just a stop-gap measure + // to make Qt itself build until toolchain can support relative includes in + // a way that Qt expects. + QString epocPath("epoc32"); + if (!includepath.contains(epocPath)) // No temp dirs for epoc includes + appendIfnotExist(sysincspaths, includepath + QString("/" QT_EXTRA_INCLUDE_DIR)); +} diff --git a/qmake/generators/symbian/symmake_abld.h b/qmake/generators/symbian/symmake_abld.h index f844096..11b9cd1 100644 --- a/qmake/generators/symbian/symmake_abld.h +++ b/qmake/generators/symbian/symmake_abld.h @@ -55,6 +55,7 @@ protected: virtual void writeBldInfMkFilePart(QTextStream& t, bool addDeploymentExtension); virtual void writeMkFile(const QString& wrapperFileName, bool deploymentOnly); virtual void writeWrapperMakefile(QFile& wrapperFile, bool isPrimaryMakefile); + virtual void appendAbldTempDirs(QStringList& sysincspaths, QString includepath); void writeStoreBuildTarget(QTextStream &t); bool writeDeploymentTargets(QTextStream &t); diff --git a/qmake/generators/symbian/symmake_sbsv2.cpp b/qmake/generators/symbian/symmake_sbsv2.cpp index cad2736..5e624de 100644 --- a/qmake/generators/symbian/symmake_sbsv2.cpp +++ b/qmake/generators/symbian/symmake_sbsv2.cpp @@ -182,15 +182,22 @@ void SymbianSbsv2MakefileGenerator::writeWrapperMakefile(QFile& wrapperFile, boo } t << endl; + QString winscw("winscw"); // For more specific builds, targets are in this form: build-platform, e.g. release-armv5 foreach(QString item, debugPlatforms) { t << "debug-" << item << ": " << BLD_INF_FILENAME << endl; - t << "\t$(SBS) -c " << item << "_udeb" << testClause << endl; + if(QString::compare(item, winscw) == 0) + t << "\t$(SBS) -c " << item << "_udeb.mwccinc" << testClause << endl; + else + t << "\t$(SBS) -c " << item << "_udeb" << testClause << endl; } foreach(QString item, releasePlatforms) { t << "release-" << item << ": " << BLD_INF_FILENAME << endl; - t << "\t$(SBS) -c " << item << "_urel" << testClause << endl; + if(QString::compare(item, winscw) == 0) + t << "\t$(SBS) -c " << item << "_urel.mwccinc" << testClause << endl; + else + t << "\t$(SBS) -c " << item << "_urel" << testClause << endl; } t << endl; @@ -379,28 +386,6 @@ void SymbianSbsv2MakefileGenerator::writeBldInfExtensionRulesPart(QTextStream& t t << "END" << endl; } - // Generate temp dirs - QString tempDirs; - for (QMap::iterator it = systeminclude.begin(); it != systeminclude.end(); ++it) { - QStringList values = it.value(); - for (int i = 0; i < values.size(); ++i) { - QString value = values.at(i); - if (value.endsWith("/" QT_EXTRA_INCLUDE_DIR)) { - value = fileInfo(value).absoluteFilePath(); - tempDirs.append(value); - tempDirs.append(" "); - } - } - } - - if (tempDirs.size()) - tempDirs.chop(1); // Remove final space - - t << "START EXTENSION qt/qmake_generate_temp_dirs" << endl; - t << "OPTION DIRS " << tempDirs << endl; - t << "END" << endl; - t << endl; - t << "START EXTENSION qt/qmake_store_build" << endl; t << "END" << endl; t << endl; @@ -414,3 +399,10 @@ void SymbianSbsv2MakefileGenerator::writeBldInfMkFilePart(QTextStream& t, bool a Q_UNUSED(t); Q_UNUSED(addDeploymentExtension); } + +void SymbianSbsv2MakefileGenerator::appendAbldTempDirs(QStringList& sysincspaths, QString includepath) +{ + //Do nothing + Q_UNUSED(sysincspaths); + Q_UNUSED(includepath); +} diff --git a/qmake/generators/symbian/symmake_sbsv2.h b/qmake/generators/symbian/symmake_sbsv2.h index 1cbddb3..9472b68 100644 --- a/qmake/generators/symbian/symmake_sbsv2.h +++ b/qmake/generators/symbian/symmake_sbsv2.h @@ -55,6 +55,7 @@ protected: virtual void writeBldInfMkFilePart(QTextStream& t, bool addDeploymentExtension); virtual void writeMkFile(const QString& wrapperFileName, bool deploymentOnly); virtual void writeWrapperMakefile(QFile& wrapperFile, bool isPrimaryMakefile); + virtual void appendAbldTempDirs(QStringList& sysincspaths, QString includepath); public: -- cgit v0.12 From 0ce94a763cfa9ec0829e096795a52446c74e4557 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Mon, 9 Nov 2009 14:27:59 +0100 Subject: Add def files for webkit Reviewed-by: Trust Me --- src/s60installs/bwins/QtWebKitu.def | 619 ++++++++++++++++++++++++++++++++++++ src/s60installs/eabi/QtWebKitu.def | 57 +++- 2 files changed, 662 insertions(+), 14 deletions(-) create mode 100644 src/s60installs/bwins/QtWebKitu.def diff --git a/src/s60installs/bwins/QtWebKitu.def b/src/s60installs/bwins/QtWebKitu.def new file mode 100644 index 0000000..14f3707 --- /dev/null +++ b/src/s60installs/bwins/QtWebKitu.def @@ -0,0 +1,619 @@ +EXPORTS + ??0MimeType@QWebPluginFactory@@QAE@ABU01@@Z @ 1 NONAME ; QWebPluginFactory::MimeType::MimeType(struct QWebPluginFactory::MimeType const &) + ??0QGraphicsWebView@@QAE@PAVQGraphicsItem@@@Z @ 2 NONAME ; QGraphicsWebView::QGraphicsWebView(class QGraphicsItem *) + ??0QWebDatabase@@AAE@PAVQWebDatabasePrivate@@@Z @ 3 NONAME ; QWebDatabase::QWebDatabase(class QWebDatabasePrivate *) + ??0QWebDatabase@@QAE@ABV0@@Z @ 4 NONAME ; QWebDatabase::QWebDatabase(class QWebDatabase const &) + ??0QWebElement@@AAE@PAVElement@WebCore@@@Z @ 5 NONAME ; QWebElement::QWebElement(class WebCore::Element *) + ??0QWebElement@@AAE@PAVNode@WebCore@@@Z @ 6 NONAME ; QWebElement::QWebElement(class WebCore::Node *) + ??0QWebElement@@QAE@ABV0@@Z @ 7 NONAME ; QWebElement::QWebElement(class QWebElement const &) + ??0QWebElement@@QAE@XZ @ 8 NONAME ; QWebElement::QWebElement(void) + ??0QWebElementCollection@@QAE@ABV0@@Z @ 9 NONAME ; QWebElementCollection::QWebElementCollection(class QWebElementCollection const &) + ??0QWebElementCollection@@QAE@ABVQWebElement@@ABVQString@@@Z @ 10 NONAME ; QWebElementCollection::QWebElementCollection(class QWebElement const &, class QString const &) + ??0QWebElementCollection@@QAE@XZ @ 11 NONAME ; QWebElementCollection::QWebElementCollection(void) + ??0QWebFrame@@AAE@PAV0@PAVQWebFrameData@@@Z @ 12 NONAME ; QWebFrame::QWebFrame(class QWebFrame *, class QWebFrameData *) + ??0QWebFrame@@AAE@PAVQWebPage@@PAVQWebFrameData@@@Z @ 13 NONAME ; QWebFrame::QWebFrame(class QWebPage *, class QWebFrameData *) + ??0QWebHistory@@AAE@XZ @ 14 NONAME ; QWebHistory::QWebHistory(void) + ??0QWebHistoryInterface@@QAE@PAVQObject@@@Z @ 15 NONAME ; QWebHistoryInterface::QWebHistoryInterface(class QObject *) + ??0QWebHistoryItem@@AAE@PAVQWebHistoryItemPrivate@@@Z @ 16 NONAME ; QWebHistoryItem::QWebHistoryItem(class QWebHistoryItemPrivate *) + ??0QWebHistoryItem@@QAE@ABV0@@Z @ 17 NONAME ; QWebHistoryItem::QWebHistoryItem(class QWebHistoryItem const &) + ??0QWebHitTestResult@@AAE@PAVQWebHitTestResultPrivate@@@Z @ 18 NONAME ; QWebHitTestResult::QWebHitTestResult(class QWebHitTestResultPrivate *) + ??0QWebHitTestResult@@QAE@ABV0@@Z @ 19 NONAME ; QWebHitTestResult::QWebHitTestResult(class QWebHitTestResult const &) + ??0QWebHitTestResult@@QAE@XZ @ 20 NONAME ; QWebHitTestResult::QWebHitTestResult(void) + ??0QWebInspector@@QAE@PAVQWidget@@@Z @ 21 NONAME ; QWebInspector::QWebInspector(class QWidget *) + ??0QWebPage@@QAE@PAVQObject@@@Z @ 22 NONAME ; QWebPage::QWebPage(class QObject *) + ??0QWebPluginDatabase@@AAE@PAVQObject@@@Z @ 23 NONAME ; QWebPluginDatabase::QWebPluginDatabase(class QObject *) + ??0QWebPluginFactory@@QAE@PAVQObject@@@Z @ 24 NONAME ; QWebPluginFactory::QWebPluginFactory(class QObject *) + ??0QWebPluginInfo@@AAE@PAVPluginPackage@WebCore@@@Z @ 25 NONAME ; QWebPluginInfo::QWebPluginInfo(class WebCore::PluginPackage *) + ??0QWebPluginInfo@@QAE@ABV0@@Z @ 26 NONAME ; QWebPluginInfo::QWebPluginInfo(class QWebPluginInfo const &) + ??0QWebPluginInfo@@QAE@XZ @ 27 NONAME ; QWebPluginInfo::QWebPluginInfo(void) + ??0QWebSecurityOrigin@@AAE@PAVQWebSecurityOriginPrivate@@@Z @ 28 NONAME ; QWebSecurityOrigin::QWebSecurityOrigin(class QWebSecurityOriginPrivate *) + ??0QWebSecurityOrigin@@QAE@ABV0@@Z @ 29 NONAME ; QWebSecurityOrigin::QWebSecurityOrigin(class QWebSecurityOrigin const &) + ??0QWebSettings@@AAE@PAVSettings@WebCore@@@Z @ 30 NONAME ; QWebSettings::QWebSettings(class WebCore::Settings *) + ??0QWebSettings@@AAE@XZ @ 31 NONAME ; QWebSettings::QWebSettings(void) + ??0QWebView@@QAE@PAVQWidget@@@Z @ 32 NONAME ; QWebView::QWebView(class QWidget *) + ??1MimeType@QWebPluginFactory@@QAE@XZ @ 33 NONAME ; QWebPluginFactory::MimeType::~MimeType(void) + ??1QGraphicsWebView@@UAE@XZ @ 34 NONAME ; QGraphicsWebView::~QGraphicsWebView(void) + ??1QWebDatabase@@QAE@XZ @ 35 NONAME ; QWebDatabase::~QWebDatabase(void) + ??1QWebElement@@QAE@XZ @ 36 NONAME ; QWebElement::~QWebElement(void) + ??1QWebElementCollection@@QAE@XZ @ 37 NONAME ; QWebElementCollection::~QWebElementCollection(void) + ??1QWebFrame@@EAE@XZ @ 38 NONAME ; QWebFrame::~QWebFrame(void) + ??1QWebHistory@@AAE@XZ @ 39 NONAME ; QWebHistory::~QWebHistory(void) + ??1QWebHistoryInterface@@UAE@XZ @ 40 NONAME ; QWebHistoryInterface::~QWebHistoryInterface(void) + ??1QWebHistoryItem@@QAE@XZ @ 41 NONAME ; QWebHistoryItem::~QWebHistoryItem(void) + ??1QWebHitTestResult@@QAE@XZ @ 42 NONAME ; QWebHitTestResult::~QWebHitTestResult(void) + ??1QWebInspector@@UAE@XZ @ 43 NONAME ; QWebInspector::~QWebInspector(void) + ??1QWebPage@@UAE@XZ @ 44 NONAME ; QWebPage::~QWebPage(void) + ??1QWebPluginDatabase@@EAE@XZ @ 45 NONAME ; QWebPluginDatabase::~QWebPluginDatabase(void) + ??1QWebPluginFactory@@UAE@XZ @ 46 NONAME ; QWebPluginFactory::~QWebPluginFactory(void) + ??1QWebPluginInfo@@QAE@XZ @ 47 NONAME ; QWebPluginInfo::~QWebPluginInfo(void) + ??1QWebSecurityOrigin@@QAE@XZ @ 48 NONAME ; QWebSecurityOrigin::~QWebSecurityOrigin(void) + ??1QWebSettings@@AAE@XZ @ 49 NONAME ; QWebSettings::~QWebSettings(void) + ??1QWebView@@UAE@XZ @ 50 NONAME ; QWebView::~QWebView(void) + ??4QWebDatabase@@QAEAAV0@ABV0@@Z @ 51 NONAME ; class QWebDatabase & QWebDatabase::operator=(class QWebDatabase const &) + ??4QWebElement@@QAEAAV0@ABV0@@Z @ 52 NONAME ; class QWebElement & QWebElement::operator=(class QWebElement const &) + ??4QWebElementCollection@@QAEAAV0@ABV0@@Z @ 53 NONAME ; class QWebElementCollection & QWebElementCollection::operator=(class QWebElementCollection const &) + ??4QWebHistoryItem@@QAEAAV0@ABV0@@Z @ 54 NONAME ; class QWebHistoryItem & QWebHistoryItem::operator=(class QWebHistoryItem const &) + ??4QWebHitTestResult@@QAEAAV0@ABV0@@Z @ 55 NONAME ; class QWebHitTestResult & QWebHitTestResult::operator=(class QWebHitTestResult const &) + ??4QWebPluginInfo@@QAEAAV0@ABV0@@Z @ 56 NONAME ; class QWebPluginInfo & QWebPluginInfo::operator=(class QWebPluginInfo const &) + ??4QWebSecurityOrigin@@QAEAAV0@ABV0@@Z @ 57 NONAME ; class QWebSecurityOrigin & QWebSecurityOrigin::operator=(class QWebSecurityOrigin const &) + ??5@YAAAVQDataStream@@AAV0@AAVQWebHistory@@@Z @ 58 NONAME ; class QDataStream & operator>>(class QDataStream &, class QWebHistory &) + ??6@YAAAVQDataStream@@AAV0@ABVQWebHistory@@@Z @ 59 NONAME ; class QDataStream & operator<<(class QDataStream &, class QWebHistory const &) + ??8MimeType@QWebPluginFactory@@QBE_NABU01@@Z @ 60 NONAME ; bool QWebPluginFactory::MimeType::operator==(struct QWebPluginFactory::MimeType const &) const + ??8QWebElement@@QBE_NABV0@@Z @ 61 NONAME ; bool QWebElement::operator==(class QWebElement const &) const + ??8QWebPluginInfo@@QBE_NABV0@@Z @ 62 NONAME ; bool QWebPluginInfo::operator==(class QWebPluginInfo const &) const + ??9MimeType@QWebPluginFactory@@QBE_NABU01@@Z @ 63 NONAME ; bool QWebPluginFactory::MimeType::operator!=(struct QWebPluginFactory::MimeType const &) const + ??9QWebElement@@QBE_NABV0@@Z @ 64 NONAME ; bool QWebElement::operator!=(class QWebElement const &) const + ??9QWebPluginInfo@@QBE_NABV0@@Z @ 65 NONAME ; bool QWebPluginInfo::operator!=(class QWebPluginInfo const &) const + ??AQWebElementCollection@@QBE?AVQWebElement@@H@Z @ 66 NONAME ; class QWebElement QWebElementCollection::operator[](int) const + ??HQWebElementCollection@@QBE?AV0@ABV0@@Z @ 67 NONAME ; class QWebElementCollection QWebElementCollection::operator+(class QWebElementCollection const &) const + ??YQWebElementCollection@@QAEAAV0@ABV0@@Z @ 68 NONAME ; class QWebElementCollection & QWebElementCollection::operator+=(class QWebElementCollection const &) + ??_EMimeType@QWebPluginFactory@@QAE@I@Z @ 69 NONAME ; QWebPluginFactory::MimeType::~MimeType(unsigned int) + ??_EQGraphicsWebView@@UAE@I@Z @ 70 NONAME ; QGraphicsWebView::~QGraphicsWebView(unsigned int) + ??_EQWebFrame@@UAE@I@Z @ 71 NONAME ; QWebFrame::~QWebFrame(unsigned int) + ??_EQWebHistoryInterface@@UAE@I@Z @ 72 NONAME ; QWebHistoryInterface::~QWebHistoryInterface(unsigned int) + ??_EQWebInspector@@UAE@I@Z @ 73 NONAME ; QWebInspector::~QWebInspector(unsigned int) + ??_EQWebPage@@UAE@I@Z @ 74 NONAME ; QWebPage::~QWebPage(unsigned int) + ??_EQWebPluginDatabase@@UAE@I@Z @ 75 NONAME ; QWebPluginDatabase::~QWebPluginDatabase(unsigned int) + ??_EQWebPluginFactory@@UAE@I@Z @ 76 NONAME ; QWebPluginFactory::~QWebPluginFactory(unsigned int) + ??_EQWebView@@UAE@I@Z @ 77 NONAME ; QWebView::~QWebView(unsigned int) + ?acceptNavigationRequest@QWebPage@@MAE_NPAVQWebFrame@@ABVQNetworkRequest@@W4NavigationType@1@@Z @ 78 NONAME ; bool QWebPage::acceptNavigationRequest(class QWebFrame *, class QNetworkRequest const &, enum QWebPage::NavigationType) + ?action@QWebPage@@QBEPAVQAction@@W4WebAction@1@@Z @ 79 NONAME ; class QAction * QWebPage::action(enum QWebPage::WebAction) const + ?addClass@QWebElement@@QAEXABVQString@@@Z @ 80 NONAME ; void QWebElement::addClass(class QString const &) + ?addLocalScheme@QWebSecurityOrigin@@SAXABVQString@@@Z @ 81 NONAME ; void QWebSecurityOrigin::addLocalScheme(class QString const &) + ?addSearchPath@QWebPluginDatabase@@QAEXABVQString@@@Z @ 82 NONAME ; void QWebPluginDatabase::addSearchPath(class QString const &) + ?addToJavaScriptWindowObject@QWebFrame@@QAEXABVQString@@PAVQObject@@@Z @ 83 NONAME ; void QWebFrame::addToJavaScriptWindowObject(class QString const &, class QObject *) + ?addToJavaScriptWindowObject@QWebFrame@@QAEXABVQString@@PAVQObject@@W4ValueOwnership@QScriptEngine@@@Z @ 84 NONAME ; void QWebFrame::addToJavaScriptWindowObject(class QString const &, class QObject *, enum QScriptEngine::ValueOwnership) + ?allOrigins@QWebSecurityOrigin@@SA?AV?$QList@VQWebSecurityOrigin@@@@XZ @ 85 NONAME ; class QList QWebSecurityOrigin::allOrigins(void) + ?alternateText@QWebHitTestResult@@QBE?AVQString@@XZ @ 86 NONAME ; class QString QWebHitTestResult::alternateText(void) const + ?append@QWebElementCollection@@QAEXABV1@@Z @ 87 NONAME ; void QWebElementCollection::append(class QWebElementCollection const &) + ?appendInside@QWebElement@@QAEXABV1@@Z @ 88 NONAME ; void QWebElement::appendInside(class QWebElement const &) + ?appendInside@QWebElement@@QAEXABVQString@@@Z @ 89 NONAME ; void QWebElement::appendInside(class QString const &) + ?appendOutside@QWebElement@@QAEXABV1@@Z @ 90 NONAME ; void QWebElement::appendOutside(class QWebElement const &) + ?appendOutside@QWebElement@@QAEXABVQString@@@Z @ 91 NONAME ; void QWebElement::appendOutside(class QString const &) + ?at@QWebElementCollection@@QBE?AVQWebElement@@H@Z @ 92 NONAME ; class QWebElement QWebElementCollection::at(int) const + ?attribute@QWebElement@@QBE?AVQString@@ABV2@0@Z @ 93 NONAME ; class QString QWebElement::attribute(class QString const &, class QString const &) const + ?attributeNS@QWebElement@@QBE?AVQString@@ABV2@00@Z @ 94 NONAME ; class QString QWebElement::attributeNS(class QString const &, class QString const &, class QString const &) const + ?back@QGraphicsWebView@@QAEXXZ @ 95 NONAME ; void QGraphicsWebView::back(void) + ?back@QWebHistory@@QAEXXZ @ 96 NONAME ; void QWebHistory::back(void) + ?back@QWebView@@QAEXXZ @ 97 NONAME ; void QWebView::back(void) + ?backItem@QWebHistory@@QBE?AVQWebHistoryItem@@XZ @ 98 NONAME ; class QWebHistoryItem QWebHistory::backItem(void) const + ?backItems@QWebHistory@@QBE?AV?$QList@VQWebHistoryItem@@@@H@Z @ 99 NONAME ; class QList QWebHistory::backItems(int) const + ?baseUrl@QWebFrame@@QBE?AVQUrl@@XZ @ 100 NONAME ; class QUrl QWebFrame::baseUrl(void) const + ?begin@QWebElementCollection@@QBE?AVconst_iterator@1@XZ @ 101 NONAME ; class QWebElementCollection::const_iterator QWebElementCollection::begin(void) const + ?boundingRect@QWebHitTestResult@@QBE?AVQRect@@XZ @ 102 NONAME ; class QRect QWebHitTestResult::boundingRect(void) const + ?bytesReceived@QWebPage@@QBE_KXZ @ 103 NONAME ; unsigned long long QWebPage::bytesReceived(void) const + ?canGoBack@QWebHistory@@QBE_NXZ @ 104 NONAME ; bool QWebHistory::canGoBack(void) const + ?canGoForward@QWebHistory@@QBE_NXZ @ 105 NONAME ; bool QWebHistory::canGoForward(void) const + ?changeEvent@QWebView@@MAEXPAVQEvent@@@Z @ 106 NONAME ; void QWebView::changeEvent(class QEvent *) + ?childFrames@QWebFrame@@QBE?AV?$QList@PAVQWebFrame@@@@XZ @ 107 NONAME ; class QList QWebFrame::childFrames(void) const + ?chooseFile@QWebPage@@MAE?AVQString@@PAVQWebFrame@@ABV2@@Z @ 108 NONAME ; class QString QWebPage::chooseFile(class QWebFrame *, class QString const &) + ?classes@QWebElement@@QBE?AVQStringList@@XZ @ 109 NONAME ; class QStringList QWebElement::classes(void) const + ?clear@QWebHistory@@QAEXXZ @ 110 NONAME ; void QWebHistory::clear(void) + ?clearIconDatabase@QWebSettings@@SAXXZ @ 111 NONAME ; void QWebSettings::clearIconDatabase(void) + ?clearMemoryCaches@QWebSettings@@SAXXZ @ 112 NONAME ; void QWebSettings::clearMemoryCaches(void) + ?clone@QWebElement@@QBE?AV1@XZ @ 113 NONAME ; class QWebElement QWebElement::clone(void) const + ?contentsChanged@QWebPage@@IAEXXZ @ 114 NONAME ; void QWebPage::contentsChanged(void) + ?contentsSize@QWebFrame@@QBE?AVQSize@@XZ @ 115 NONAME ; class QSize QWebFrame::contentsSize(void) const + ?contentsSizeChanged@QWebFrame@@IAEXABVQSize@@@Z @ 116 NONAME ; void QWebFrame::contentsSizeChanged(class QSize const &) + ?contextMenuEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneContextMenuEvent@@@Z @ 117 NONAME ; void QGraphicsWebView::contextMenuEvent(class QGraphicsSceneContextMenuEvent *) + ?contextMenuEvent@QWebView@@MAEXPAVQContextMenuEvent@@@Z @ 118 NONAME ; void QWebView::contextMenuEvent(class QContextMenuEvent *) + ?count@QWebElementCollection@@QBEHXZ @ 119 NONAME ; int QWebElementCollection::count(void) const + ?count@QWebHistory@@QBEHXZ @ 120 NONAME ; int QWebHistory::count(void) const + ?createPlugin@QWebPage@@MAEPAVQObject@@ABVQString@@ABVQUrl@@ABVQStringList@@2@Z @ 121 NONAME ; class QObject * QWebPage::createPlugin(class QString const &, class QUrl const &, class QStringList const &, class QStringList const &) + ?createStandardContextMenu@QWebPage@@QAEPAVQMenu@@XZ @ 122 NONAME ; class QMenu * QWebPage::createStandardContextMenu(void) + ?createWindow@QWebPage@@MAEPAV1@W4WebWindowType@1@@Z @ 123 NONAME ; class QWebPage * QWebPage::createWindow(enum QWebPage::WebWindowType) + ?createWindow@QWebView@@MAEPAV1@W4WebWindowType@QWebPage@@@Z @ 124 NONAME ; class QWebView * QWebView::createWindow(enum QWebPage::WebWindowType) + ?currentFrame@QWebPage@@QBEPAVQWebFrame@@XZ @ 125 NONAME ; class QWebFrame * QWebPage::currentFrame(void) const + ?currentItem@QWebHistory@@QBE?AVQWebHistoryItem@@XZ @ 126 NONAME ; class QWebHistoryItem QWebHistory::currentItem(void) const + ?currentItemIndex@QWebHistory@@QBEHXZ @ 127 NONAME ; int QWebHistory::currentItemIndex(void) const + ?databaseQuota@QWebSecurityOrigin@@QBE_JXZ @ 128 NONAME ; long long QWebSecurityOrigin::databaseQuota(void) const + ?databaseQuotaExceeded@QWebPage@@IAEXPAVQWebFrame@@VQString@@@Z @ 129 NONAME ; void QWebPage::databaseQuotaExceeded(class QWebFrame *, class QString) + ?databaseUsage@QWebSecurityOrigin@@QBE_JXZ @ 130 NONAME ; long long QWebSecurityOrigin::databaseUsage(void) const + ?databases@QWebSecurityOrigin@@QBE?AV?$QList@VQWebDatabase@@@@XZ @ 131 NONAME ; class QList QWebSecurityOrigin::databases(void) const + ?defaultInterface@QWebHistoryInterface@@SAPAV1@XZ @ 132 NONAME ; class QWebHistoryInterface * QWebHistoryInterface::defaultInterface(void) + ?defaultSearchPaths@QWebPluginDatabase@@SA?AVQStringList@@XZ @ 133 NONAME ; class QStringList QWebPluginDatabase::defaultSearchPaths(void) + ?defaultTextEncoding@QWebSettings@@QBE?AVQString@@XZ @ 134 NONAME ; class QString QWebSettings::defaultTextEncoding(void) const + ?description@QWebPluginInfo@@QBE?AVQString@@XZ @ 135 NONAME ; class QString QWebPluginInfo::description(void) const + ?displayName@QWebDatabase@@QBE?AVQString@@XZ @ 136 NONAME ; class QString QWebDatabase::displayName(void) const + ?document@QWebElement@@QBE?AV1@XZ @ 137 NONAME ; class QWebElement QWebElement::document(void) const + ?documentElement@QWebFrame@@QBE?AVQWebElement@@XZ @ 138 NONAME ; class QWebElement QWebFrame::documentElement(void) const + ?downloadRequested@QWebPage@@IAEXABVQNetworkRequest@@@Z @ 139 NONAME ; void QWebPage::downloadRequested(class QNetworkRequest const &) + ?dragEnterEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneDragDropEvent@@@Z @ 140 NONAME ; void QGraphicsWebView::dragEnterEvent(class QGraphicsSceneDragDropEvent *) + ?dragEnterEvent@QWebView@@MAEXPAVQDragEnterEvent@@@Z @ 141 NONAME ; void QWebView::dragEnterEvent(class QDragEnterEvent *) + ?dragLeaveEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneDragDropEvent@@@Z @ 142 NONAME ; void QGraphicsWebView::dragLeaveEvent(class QGraphicsSceneDragDropEvent *) + ?dragLeaveEvent@QWebView@@MAEXPAVQDragLeaveEvent@@@Z @ 143 NONAME ; void QWebView::dragLeaveEvent(class QDragLeaveEvent *) + ?dragMoveEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneDragDropEvent@@@Z @ 144 NONAME ; void QGraphicsWebView::dragMoveEvent(class QGraphicsSceneDragDropEvent *) + ?dragMoveEvent@QWebView@@MAEXPAVQDragMoveEvent@@@Z @ 145 NONAME ; void QWebView::dragMoveEvent(class QDragMoveEvent *) + ?dropEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneDragDropEvent@@@Z @ 146 NONAME ; void QGraphicsWebView::dropEvent(class QGraphicsSceneDragDropEvent *) + ?dropEvent@QWebView@@MAEXPAVQDropEvent@@@Z @ 147 NONAME ; void QWebView::dropEvent(class QDropEvent *) + ?element@QWebHitTestResult@@QBE?AVQWebElement@@XZ @ 148 NONAME ; class QWebElement QWebHitTestResult::element(void) const + ?enablePersistentStorage@QWebSettings@@SAXABVQString@@@Z @ 149 NONAME ; void QWebSettings::enablePersistentStorage(class QString const &) + ?encloseContentsWith@QWebElement@@QAEXABV1@@Z @ 150 NONAME ; void QWebElement::encloseContentsWith(class QWebElement const &) + ?encloseContentsWith@QWebElement@@QAEXABVQString@@@Z @ 151 NONAME ; void QWebElement::encloseContentsWith(class QString const &) + ?encloseWith@QWebElement@@QAEXABV1@@Z @ 152 NONAME ; void QWebElement::encloseWith(class QWebElement const &) + ?encloseWith@QWebElement@@QAEXABVQString@@@Z @ 153 NONAME ; void QWebElement::encloseWith(class QString const &) + ?enclosingBlockElement@QWebHitTestResult@@QBE?AVQWebElement@@XZ @ 154 NONAME ; class QWebElement QWebHitTestResult::enclosingBlockElement(void) const + ?enclosingElement@QWebElement@@CA?AV1@PAVNode@WebCore@@@Z @ 155 NONAME ; class QWebElement QWebElement::enclosingElement(class WebCore::Node *) + ?end@QWebElementCollection@@QBE?AVconst_iterator@1@XZ @ 156 NONAME ; class QWebElementCollection::const_iterator QWebElementCollection::end(void) const + ?evaluateJavaScript@QWebElement@@QAE?AVQVariant@@ABVQString@@@Z @ 157 NONAME ; class QVariant QWebElement::evaluateJavaScript(class QString const &) + ?evaluateJavaScript@QWebFrame@@QAE?AVQVariant@@ABVQString@@@Z @ 158 NONAME ; class QVariant QWebFrame::evaluateJavaScript(class QString const &) + ?event@QGraphicsWebView@@UAE_NPAVQEvent@@@Z @ 159 NONAME ; bool QGraphicsWebView::event(class QEvent *) + ?event@QWebFrame@@UAE_NPAVQEvent@@@Z @ 160 NONAME ; bool QWebFrame::event(class QEvent *) + ?event@QWebInspector@@UAE_NPAVQEvent@@@Z @ 161 NONAME ; bool QWebInspector::event(class QEvent *) + ?event@QWebPage@@UAE_NPAVQEvent@@@Z @ 162 NONAME ; bool QWebPage::event(class QEvent *) + ?event@QWebView@@UAE_NPAVQEvent@@@Z @ 163 NONAME ; bool QWebView::event(class QEvent *) + ?expectedSize@QWebDatabase@@QBE_JXZ @ 164 NONAME ; long long QWebDatabase::expectedSize(void) const + ?extension@QWebPage@@UAE_NW4Extension@1@PBVExtensionOption@1@PAVExtensionReturn@1@@Z @ 165 NONAME ; bool QWebPage::extension(enum QWebPage::Extension, class QWebPage::ExtensionOption const *, class QWebPage::ExtensionReturn *) + ?extension@QWebPluginFactory@@UAE_NW4Extension@1@PBVExtensionOption@1@PAVExtensionReturn@1@@Z @ 166 NONAME ; bool QWebPluginFactory::extension(enum QWebPluginFactory::Extension, class QWebPluginFactory::ExtensionOption const *, class QWebPluginFactory::ExtensionReturn *) + ?fileName@QWebDatabase@@QBE?AVQString@@XZ @ 167 NONAME ; class QString QWebDatabase::fileName(void) const + ?findAll@QWebElement@@QBE?AVQWebElementCollection@@ABVQString@@@Z @ 168 NONAME ; class QWebElementCollection QWebElement::findAll(class QString const &) const + ?findAllElements@QWebFrame@@QBE?AVQWebElementCollection@@ABVQString@@@Z @ 169 NONAME ; class QWebElementCollection QWebFrame::findAllElements(class QString const &) const + ?findFirst@QWebElement@@QBE?AV1@ABVQString@@@Z @ 170 NONAME ; class QWebElement QWebElement::findFirst(class QString const &) const + ?findFirstElement@QWebFrame@@QBE?AVQWebElement@@ABVQString@@@Z @ 171 NONAME ; class QWebElement QWebFrame::findFirstElement(class QString const &) const + ?findText@QWebPage@@QAE_NABVQString@@V?$QFlags@W4FindFlag@QWebPage@@@@@Z @ 172 NONAME ; bool QWebPage::findText(class QString const &, class QFlags) + ?findText@QWebView@@QAE_NABVQString@@V?$QFlags@W4FindFlag@QWebPage@@@@@Z @ 173 NONAME ; bool QWebView::findText(class QString const &, class QFlags) + ?first@QWebElementCollection@@QBE?AVQWebElement@@XZ @ 174 NONAME ; class QWebElement QWebElementCollection::first(void) const + ?firstChild@QWebElement@@QBE?AV1@XZ @ 175 NONAME ; class QWebElement QWebElement::firstChild(void) const + ?focusInEvent@QGraphicsWebView@@MAEXPAVQFocusEvent@@@Z @ 176 NONAME ; void QGraphicsWebView::focusInEvent(class QFocusEvent *) + ?focusInEvent@QWebView@@MAEXPAVQFocusEvent@@@Z @ 177 NONAME ; void QWebView::focusInEvent(class QFocusEvent *) + ?focusNextPrevChild@QGraphicsWebView@@MAE_N_N@Z @ 178 NONAME ; bool QGraphicsWebView::focusNextPrevChild(bool) + ?focusNextPrevChild@QWebPage@@QAE_N_N@Z @ 179 NONAME ; bool QWebPage::focusNextPrevChild(bool) + ?focusNextPrevChild@QWebView@@MAE_N_N@Z @ 180 NONAME ; bool QWebView::focusNextPrevChild(bool) + ?focusOutEvent@QGraphicsWebView@@MAEXPAVQFocusEvent@@@Z @ 181 NONAME ; void QGraphicsWebView::focusOutEvent(class QFocusEvent *) + ?focusOutEvent@QWebView@@MAEXPAVQFocusEvent@@@Z @ 182 NONAME ; void QWebView::focusOutEvent(class QFocusEvent *) + ?fontFamily@QWebSettings@@QBE?AVQString@@W4FontFamily@1@@Z @ 183 NONAME ; class QString QWebSettings::fontFamily(enum QWebSettings::FontFamily) const + ?fontSize@QWebSettings@@QBEHW4FontSize@1@@Z @ 184 NONAME ; int QWebSettings::fontSize(enum QWebSettings::FontSize) const + ?forward@QGraphicsWebView@@QAEXXZ @ 185 NONAME ; void QGraphicsWebView::forward(void) + ?forward@QWebHistory@@QAEXXZ @ 186 NONAME ; void QWebHistory::forward(void) + ?forward@QWebView@@QAEXXZ @ 187 NONAME ; void QWebView::forward(void) + ?forwardItem@QWebHistory@@QBE?AVQWebHistoryItem@@XZ @ 188 NONAME ; class QWebHistoryItem QWebHistory::forwardItem(void) const + ?forwardItems@QWebHistory@@QBE?AV?$QList@VQWebHistoryItem@@@@H@Z @ 189 NONAME ; class QList QWebHistory::forwardItems(int) const + ?forwardUnsupportedContent@QWebPage@@QBE_NXZ @ 190 NONAME ; bool QWebPage::forwardUnsupportedContent(void) const + ?frame@QWebHitTestResult@@QBEPAVQWebFrame@@XZ @ 191 NONAME ; class QWebFrame * QWebHitTestResult::frame(void) const + ?frameAt@QWebPage@@QBEPAVQWebFrame@@ABVQPoint@@@Z @ 192 NONAME ; class QWebFrame * QWebPage::frameAt(class QPoint const &) const + ?frameCreated@QWebPage@@IAEXPAVQWebFrame@@@Z @ 193 NONAME ; void QWebPage::frameCreated(class QWebFrame *) + ?frameName@QWebFrame@@QBE?AVQString@@XZ @ 194 NONAME ; class QString QWebFrame::frameName(void) const + ?geometry@QWebElement@@QBE?AVQRect@@XZ @ 195 NONAME ; class QRect QWebElement::geometry(void) const + ?geometry@QWebFrame@@QBE?AVQRect@@XZ @ 196 NONAME ; class QRect QWebFrame::geometry(void) const + ?geometryChangeRequested@QWebPage@@IAEXABVQRect@@@Z @ 197 NONAME ; void QWebPage::geometryChangeRequested(class QRect const &) + ?getStaticMetaObject@QGraphicsWebView@@SAABUQMetaObject@@XZ @ 198 NONAME ; struct QMetaObject const & QGraphicsWebView::getStaticMetaObject(void) + ?getStaticMetaObject@QWebFrame@@SAABUQMetaObject@@XZ @ 199 NONAME ; struct QMetaObject const & QWebFrame::getStaticMetaObject(void) + ?getStaticMetaObject@QWebHistoryInterface@@SAABUQMetaObject@@XZ @ 200 NONAME ; struct QMetaObject const & QWebHistoryInterface::getStaticMetaObject(void) + ?getStaticMetaObject@QWebInspector@@SAABUQMetaObject@@XZ @ 201 NONAME ; struct QMetaObject const & QWebInspector::getStaticMetaObject(void) + ?getStaticMetaObject@QWebPage@@SAABUQMetaObject@@XZ @ 202 NONAME ; struct QMetaObject const & QWebPage::getStaticMetaObject(void) + ?getStaticMetaObject@QWebPluginDatabase@@SAABUQMetaObject@@XZ @ 203 NONAME ; struct QMetaObject const & QWebPluginDatabase::getStaticMetaObject(void) + ?getStaticMetaObject@QWebPluginFactory@@SAABUQMetaObject@@XZ @ 204 NONAME ; struct QMetaObject const & QWebPluginFactory::getStaticMetaObject(void) + ?getStaticMetaObject@QWebView@@SAABUQMetaObject@@XZ @ 205 NONAME ; struct QMetaObject const & QWebView::getStaticMetaObject(void) + ?globalSettings@QWebSettings@@SAPAV1@XZ @ 206 NONAME ; class QWebSettings * QWebSettings::globalSettings(void) + ?goToItem@QWebHistory@@QAEXABVQWebHistoryItem@@@Z @ 207 NONAME ; void QWebHistory::goToItem(class QWebHistoryItem const &) + ?handle@QWebPage@@QBEPAVQWebPagePrivate@@XZ @ 208 NONAME ; class QWebPagePrivate * QWebPage::handle(void) const + ?handle@QWebSettings@@QBEPAVQWebSettingsPrivate@@XZ @ 209 NONAME ; class QWebSettingsPrivate * QWebSettings::handle(void) const + ?hasAttribute@QWebElement@@QBE_NABVQString@@@Z @ 210 NONAME ; bool QWebElement::hasAttribute(class QString const &) const + ?hasAttributeNS@QWebElement@@QBE_NABVQString@@0@Z @ 211 NONAME ; bool QWebElement::hasAttributeNS(class QString const &, class QString const &) const + ?hasAttributes@QWebElement@@QBE_NXZ @ 212 NONAME ; bool QWebElement::hasAttributes(void) const + ?hasClass@QWebElement@@QBE_NABVQString@@@Z @ 213 NONAME ; bool QWebElement::hasClass(class QString const &) const + ?hasFocus@QWebElement@@QBE_NXZ @ 214 NONAME ; bool QWebElement::hasFocus(void) const + ?hasFocus@QWebFrame@@QBE_NXZ @ 215 NONAME ; bool QWebFrame::hasFocus(void) const + ?hideEvent@QWebInspector@@MAEXPAVQHideEvent@@@Z @ 216 NONAME ; void QWebInspector::hideEvent(class QHideEvent *) + ?history@QGraphicsWebView@@QBEPAVQWebHistory@@XZ @ 217 NONAME ; class QWebHistory * QGraphicsWebView::history(void) const + ?history@QWebPage@@QBEPAVQWebHistory@@XZ @ 218 NONAME ; class QWebHistory * QWebPage::history(void) const + ?history@QWebView@@QBEPAVQWebHistory@@XZ @ 219 NONAME ; class QWebHistory * QWebView::history(void) const + ?hitTestContent@QWebFrame@@QBE?AVQWebHitTestResult@@ABVQPoint@@@Z @ 220 NONAME ; class QWebHitTestResult QWebFrame::hitTestContent(class QPoint const &) const + ?host@QWebSecurityOrigin@@QBE?AVQString@@XZ @ 221 NONAME ; class QString QWebSecurityOrigin::host(void) const + ?hoverLeaveEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneHoverEvent@@@Z @ 222 NONAME ; void QGraphicsWebView::hoverLeaveEvent(class QGraphicsSceneHoverEvent *) + ?hoverMoveEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneHoverEvent@@@Z @ 223 NONAME ; void QGraphicsWebView::hoverMoveEvent(class QGraphicsSceneHoverEvent *) + ?icon@QGraphicsWebView@@QBE?AVQIcon@@XZ @ 224 NONAME ; class QIcon QGraphicsWebView::icon(void) const + ?icon@QWebFrame@@QBE?AVQIcon@@XZ @ 225 NONAME ; class QIcon QWebFrame::icon(void) const + ?icon@QWebHistoryItem@@QBE?AVQIcon@@XZ @ 226 NONAME ; class QIcon QWebHistoryItem::icon(void) const + ?icon@QWebView@@QBE?AVQIcon@@XZ @ 227 NONAME ; class QIcon QWebView::icon(void) const + ?iconChanged@QGraphicsWebView@@IAEXXZ @ 228 NONAME ; void QGraphicsWebView::iconChanged(void) + ?iconChanged@QWebFrame@@IAEXXZ @ 229 NONAME ; void QWebFrame::iconChanged(void) + ?iconChanged@QWebView@@IAEXXZ @ 230 NONAME ; void QWebView::iconChanged(void) + ?iconDatabasePath@QWebSettings@@SA?AVQString@@XZ @ 231 NONAME ; class QString QWebSettings::iconDatabasePath(void) + ?iconForUrl@QWebSettings@@SA?AVQIcon@@ABVQUrl@@@Z @ 232 NONAME ; class QIcon QWebSettings::iconForUrl(class QUrl const &) + ?imageUrl@QWebHitTestResult@@QBE?AVQUrl@@XZ @ 233 NONAME ; class QUrl QWebHitTestResult::imageUrl(void) const + ?initialLayoutCompleted@QWebFrame@@IAEXXZ @ 234 NONAME ; void QWebFrame::initialLayoutCompleted(void) + ?inputMethodEvent@QGraphicsWebView@@MAEXPAVQInputMethodEvent@@@Z @ 235 NONAME ; void QGraphicsWebView::inputMethodEvent(class QInputMethodEvent *) + ?inputMethodEvent@QWebView@@MAEXPAVQInputMethodEvent@@@Z @ 236 NONAME ; void QWebView::inputMethodEvent(class QInputMethodEvent *) + ?inputMethodQuery@QWebPage@@QBE?AVQVariant@@W4InputMethodQuery@Qt@@@Z @ 237 NONAME ; class QVariant QWebPage::inputMethodQuery(enum Qt::InputMethodQuery) const + ?inputMethodQuery@QWebView@@UBE?AVQVariant@@W4InputMethodQuery@Qt@@@Z @ 238 NONAME ; class QVariant QWebView::inputMethodQuery(enum Qt::InputMethodQuery) const + ?interactivityChanged@QGraphicsWebView@@IAEXXZ @ 239 NONAME ; void QGraphicsWebView::interactivityChanged(void) + ?isContentEditable@QWebHitTestResult@@QBE_NXZ @ 240 NONAME ; bool QWebHitTestResult::isContentEditable(void) const + ?isContentEditable@QWebPage@@QBE_NXZ @ 241 NONAME ; bool QWebPage::isContentEditable(void) const + ?isContentSelected@QWebHitTestResult@@QBE_NXZ @ 242 NONAME ; bool QWebHitTestResult::isContentSelected(void) const + ?isEnabled@QWebPluginInfo@@QBE_NXZ @ 243 NONAME ; bool QWebPluginInfo::isEnabled(void) const + ?isInteractive@QGraphicsWebView@@QBE_NXZ @ 244 NONAME ; bool QGraphicsWebView::isInteractive(void) const + ?isModified@QWebPage@@QBE_NXZ @ 245 NONAME ; bool QWebPage::isModified(void) const + ?isModified@QWebView@@QBE_NXZ @ 246 NONAME ; bool QWebView::isModified(void) const + ?isNull@QWebElement@@QBE_NXZ @ 247 NONAME ; bool QWebElement::isNull(void) const + ?isNull@QWebHitTestResult@@QBE_NXZ @ 248 NONAME ; bool QWebHitTestResult::isNull(void) const + ?isNull@QWebPluginInfo@@QBE_NXZ @ 249 NONAME ; bool QWebPluginInfo::isNull(void) const + ?isValid@QWebHistoryItem@@QBE_NXZ @ 250 NONAME ; bool QWebHistoryItem::isValid(void) const + ?itemAt@QWebHistory@@QBE?AVQWebHistoryItem@@H@Z @ 251 NONAME ; class QWebHistoryItem QWebHistory::itemAt(int) const + ?itemChange@QGraphicsWebView@@UAE?AVQVariant@@W4GraphicsItemChange@QGraphicsItem@@ABV2@@Z @ 252 NONAME ; class QVariant QGraphicsWebView::itemChange(enum QGraphicsItem::GraphicsItemChange, class QVariant const &) + ?items@QWebHistory@@QBE?AV?$QList@VQWebHistoryItem@@@@XZ @ 253 NONAME ; class QList QWebHistory::items(void) const + ?javaScriptAlert@QWebPage@@MAEXPAVQWebFrame@@ABVQString@@@Z @ 254 NONAME ; void QWebPage::javaScriptAlert(class QWebFrame *, class QString const &) + ?javaScriptConfirm@QWebPage@@MAE_NPAVQWebFrame@@ABVQString@@@Z @ 255 NONAME ; bool QWebPage::javaScriptConfirm(class QWebFrame *, class QString const &) + ?javaScriptConsoleMessage@QWebPage@@MAEXABVQString@@H0@Z @ 256 NONAME ; void QWebPage::javaScriptConsoleMessage(class QString const &, int, class QString const &) + ?javaScriptPrompt@QWebPage@@MAE_NPAVQWebFrame@@ABVQString@@1PAV3@@Z @ 257 NONAME ; bool QWebPage::javaScriptPrompt(class QWebFrame *, class QString const &, class QString const &, class QString *) + ?javaScriptWindowObjectCleared@QWebFrame@@IAEXXZ @ 258 NONAME ; void QWebFrame::javaScriptWindowObjectCleared(void) + ?keyPressEvent@QGraphicsWebView@@MAEXPAVQKeyEvent@@@Z @ 259 NONAME ; void QGraphicsWebView::keyPressEvent(class QKeyEvent *) + ?keyPressEvent@QWebView@@MAEXPAVQKeyEvent@@@Z @ 260 NONAME ; void QWebView::keyPressEvent(class QKeyEvent *) + ?keyReleaseEvent@QGraphicsWebView@@MAEXPAVQKeyEvent@@@Z @ 261 NONAME ; void QGraphicsWebView::keyReleaseEvent(class QKeyEvent *) + ?keyReleaseEvent@QWebView@@MAEXPAVQKeyEvent@@@Z @ 262 NONAME ; void QWebView::keyReleaseEvent(class QKeyEvent *) + ?last@QWebElementCollection@@QBE?AVQWebElement@@XZ @ 263 NONAME ; class QWebElement QWebElementCollection::last(void) const + ?lastChild@QWebElement@@QBE?AV1@XZ @ 264 NONAME ; class QWebElement QWebElement::lastChild(void) const + ?lastVisited@QWebHistoryItem@@QBE?AVQDateTime@@XZ @ 265 NONAME ; class QDateTime QWebHistoryItem::lastVisited(void) const + ?linkClicked@QWebPage@@IAEXABVQUrl@@@Z @ 266 NONAME ; void QWebPage::linkClicked(class QUrl const &) + ?linkClicked@QWebView@@IAEXABVQUrl@@@Z @ 267 NONAME ; void QWebView::linkClicked(class QUrl const &) + ?linkDelegationPolicy@QWebPage@@QBE?AW4LinkDelegationPolicy@1@XZ @ 268 NONAME ; enum QWebPage::LinkDelegationPolicy QWebPage::linkDelegationPolicy(void) const + ?linkElement@QWebHitTestResult@@QBE?AVQWebElement@@XZ @ 269 NONAME ; class QWebElement QWebHitTestResult::linkElement(void) const + ?linkHovered@QWebPage@@IAEXABVQString@@00@Z @ 270 NONAME ; void QWebPage::linkHovered(class QString const &, class QString const &, class QString const &) + ?linkTargetFrame@QWebHitTestResult@@QBEPAVQWebFrame@@XZ @ 271 NONAME ; class QWebFrame * QWebHitTestResult::linkTargetFrame(void) const + ?linkText@QWebHitTestResult@@QBE?AVQString@@XZ @ 272 NONAME ; class QString QWebHitTestResult::linkText(void) const + ?linkTitle@QWebHitTestResult@@QBE?AVQUrl@@XZ @ 273 NONAME ; class QUrl QWebHitTestResult::linkTitle(void) const + ?linkUrl@QWebHitTestResult@@QBE?AVQUrl@@XZ @ 274 NONAME ; class QUrl QWebHitTestResult::linkUrl(void) const + ?load@QGraphicsWebView@@QAEXABVQNetworkRequest@@W4Operation@QNetworkAccessManager@@ABVQByteArray@@@Z @ 275 NONAME ; void QGraphicsWebView::load(class QNetworkRequest const &, enum QNetworkAccessManager::Operation, class QByteArray const &) + ?load@QGraphicsWebView@@QAEXABVQUrl@@@Z @ 276 NONAME ; void QGraphicsWebView::load(class QUrl const &) + ?load@QWebFrame@@QAEXABVQNetworkRequest@@W4Operation@QNetworkAccessManager@@ABVQByteArray@@@Z @ 277 NONAME ; void QWebFrame::load(class QNetworkRequest const &, enum QNetworkAccessManager::Operation, class QByteArray const &) + ?load@QWebFrame@@QAEXABVQUrl@@@Z @ 278 NONAME ; void QWebFrame::load(class QUrl const &) + ?load@QWebView@@QAEXABVQNetworkRequest@@W4Operation@QNetworkAccessManager@@ABVQByteArray@@@Z @ 279 NONAME ; void QWebView::load(class QNetworkRequest const &, enum QNetworkAccessManager::Operation, class QByteArray const &) + ?load@QWebView@@QAEXABVQUrl@@@Z @ 280 NONAME ; void QWebView::load(class QUrl const &) + ?loadFinished@QGraphicsWebView@@IAEX_N@Z @ 281 NONAME ; void QGraphicsWebView::loadFinished(bool) + ?loadFinished@QWebFrame@@IAEX_N@Z @ 282 NONAME ; void QWebFrame::loadFinished(bool) + ?loadFinished@QWebPage@@IAEX_N@Z @ 283 NONAME ; void QWebPage::loadFinished(bool) + ?loadFinished@QWebView@@IAEX_N@Z @ 284 NONAME ; void QWebView::loadFinished(bool) + ?loadProgress@QWebPage@@IAEXH@Z @ 285 NONAME ; void QWebPage::loadProgress(int) + ?loadProgress@QWebView@@IAEXH@Z @ 286 NONAME ; void QWebView::loadProgress(int) + ?loadStarted@QGraphicsWebView@@IAEXXZ @ 287 NONAME ; void QGraphicsWebView::loadStarted(void) + ?loadStarted@QWebFrame@@IAEXXZ @ 288 NONAME ; void QWebFrame::loadStarted(void) + ?loadStarted@QWebPage@@IAEXXZ @ 289 NONAME ; void QWebPage::loadStarted(void) + ?loadStarted@QWebView@@IAEXXZ @ 290 NONAME ; void QWebView::loadStarted(void) + ?localName@QWebElement@@QBE?AVQString@@XZ @ 291 NONAME ; class QString QWebElement::localName(void) const + ?localSchemes@QWebSecurityOrigin@@SA?AVQStringList@@XZ @ 292 NONAME ; class QStringList QWebSecurityOrigin::localSchemes(void) + ?localStoragePath@QWebSettings@@QBE?AVQString@@XZ @ 293 NONAME ; class QString QWebSettings::localStoragePath(void) const + ?mainFrame@QWebPage@@QBEPAVQWebFrame@@XZ @ 294 NONAME ; class QWebFrame * QWebPage::mainFrame(void) const + ?maximumItemCount@QWebHistory@@QBEHXZ @ 295 NONAME ; int QWebHistory::maximumItemCount(void) const + ?maximumPagesInCache@QWebSettings@@SAHXZ @ 296 NONAME ; int QWebSettings::maximumPagesInCache(void) + ?menuBarVisibilityChangeRequested@QWebPage@@IAEX_N@Z @ 297 NONAME ; void QWebPage::menuBarVisibilityChangeRequested(bool) + ?metaData@QWebFrame@@QBE?AV?$QMultiMap@VQString@@V1@@@XZ @ 298 NONAME ; class QMultiMap QWebFrame::metaData(void) const + ?metaObject@QGraphicsWebView@@UBEPBUQMetaObject@@XZ @ 299 NONAME ; struct QMetaObject const * QGraphicsWebView::metaObject(void) const + ?metaObject@QWebFrame@@UBEPBUQMetaObject@@XZ @ 300 NONAME ; struct QMetaObject const * QWebFrame::metaObject(void) const + ?metaObject@QWebHistoryInterface@@UBEPBUQMetaObject@@XZ @ 301 NONAME ; struct QMetaObject const * QWebHistoryInterface::metaObject(void) const + ?metaObject@QWebInspector@@UBEPBUQMetaObject@@XZ @ 302 NONAME ; struct QMetaObject const * QWebInspector::metaObject(void) const + ?metaObject@QWebPage@@UBEPBUQMetaObject@@XZ @ 303 NONAME ; struct QMetaObject const * QWebPage::metaObject(void) const + ?metaObject@QWebPluginDatabase@@UBEPBUQMetaObject@@XZ @ 304 NONAME ; struct QMetaObject const * QWebPluginDatabase::metaObject(void) const + ?metaObject@QWebPluginFactory@@UBEPBUQMetaObject@@XZ @ 305 NONAME ; struct QMetaObject const * QWebPluginFactory::metaObject(void) const + ?metaObject@QWebView@@UBEPBUQMetaObject@@XZ @ 306 NONAME ; struct QMetaObject const * QWebView::metaObject(void) const + ?microFocusChanged@QWebPage@@IAEXXZ @ 307 NONAME ; void QWebPage::microFocusChanged(void) + ?mimeTypes@QWebPluginInfo@@QBE?AV?$QList@UMimeType@QWebPluginFactory@@@@XZ @ 308 NONAME ; class QList QWebPluginInfo::mimeTypes(void) const + ?mouseDoubleClickEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneMouseEvent@@@Z @ 309 NONAME ; void QGraphicsWebView::mouseDoubleClickEvent(class QGraphicsSceneMouseEvent *) + ?mouseDoubleClickEvent@QWebView@@MAEXPAVQMouseEvent@@@Z @ 310 NONAME ; void QWebView::mouseDoubleClickEvent(class QMouseEvent *) + ?mouseMoveEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneMouseEvent@@@Z @ 311 NONAME ; void QGraphicsWebView::mouseMoveEvent(class QGraphicsSceneMouseEvent *) + ?mouseMoveEvent@QWebView@@MAEXPAVQMouseEvent@@@Z @ 312 NONAME ; void QWebView::mouseMoveEvent(class QMouseEvent *) + ?mousePressEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneMouseEvent@@@Z @ 313 NONAME ; void QGraphicsWebView::mousePressEvent(class QGraphicsSceneMouseEvent *) + ?mousePressEvent@QWebView@@MAEXPAVQMouseEvent@@@Z @ 314 NONAME ; void QWebView::mousePressEvent(class QMouseEvent *) + ?mouseReleaseEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneMouseEvent@@@Z @ 315 NONAME ; void QGraphicsWebView::mouseReleaseEvent(class QGraphicsSceneMouseEvent *) + ?mouseReleaseEvent@QWebView@@MAEXPAVQMouseEvent@@@Z @ 316 NONAME ; void QWebView::mouseReleaseEvent(class QMouseEvent *) + ?name@QWebDatabase@@QBE?AVQString@@XZ @ 317 NONAME ; class QString QWebDatabase::name(void) const + ?name@QWebPluginInfo@@QBE?AVQString@@XZ @ 318 NONAME ; class QString QWebPluginInfo::name(void) const + ?namespaceUri@QWebElement@@QBE?AVQString@@XZ @ 319 NONAME ; class QString QWebElement::namespaceUri(void) const + ?networkAccessManager@QWebPage@@QBEPAVQNetworkAccessManager@@XZ @ 320 NONAME ; class QNetworkAccessManager * QWebPage::networkAccessManager(void) const + ?nextSibling@QWebElement@@QBE?AV1@XZ @ 321 NONAME ; class QWebElement QWebElement::nextSibling(void) const + ?offlineStorageDefaultQuota@QWebSettings@@SA_JXZ @ 322 NONAME ; long long QWebSettings::offlineStorageDefaultQuota(void) + ?offlineStoragePath@QWebSettings@@SA?AVQString@@XZ @ 323 NONAME ; class QString QWebSettings::offlineStoragePath(void) + ?offlineWebApplicationCachePath@QWebSettings@@SA?AVQString@@XZ @ 324 NONAME ; class QString QWebSettings::offlineWebApplicationCachePath(void) + ?offlineWebApplicationCacheQuota@QWebSettings@@SA_JXZ @ 325 NONAME ; long long QWebSettings::offlineWebApplicationCacheQuota(void) + ?origin@QWebDatabase@@QBE?AVQWebSecurityOrigin@@XZ @ 326 NONAME ; class QWebSecurityOrigin QWebDatabase::origin(void) const + ?originalUrl@QWebHistoryItem@@QBE?AVQUrl@@XZ @ 327 NONAME ; class QUrl QWebHistoryItem::originalUrl(void) const + ?page@QGraphicsWebView@@QBEPAVQWebPage@@XZ @ 328 NONAME ; class QWebPage * QGraphicsWebView::page(void) const + ?page@QWebFrame@@QBEPAVQWebPage@@XZ @ 329 NONAME ; class QWebPage * QWebFrame::page(void) const + ?page@QWebInspector@@QBEPAVQWebPage@@XZ @ 330 NONAME ; class QWebPage * QWebInspector::page(void) const + ?page@QWebView@@QBEPAVQWebPage@@XZ @ 331 NONAME ; class QWebPage * QWebView::page(void) const + ?pageAction@QWebView@@QBEPAVQAction@@W4WebAction@QWebPage@@@Z @ 332 NONAME ; class QAction * QWebView::pageAction(enum QWebPage::WebAction) const + ?paint@QGraphicsWebView@@UAEXPAVQPainter@@PBVQStyleOptionGraphicsItem@@PAVQWidget@@@Z @ 333 NONAME ; void QGraphicsWebView::paint(class QPainter *, class QStyleOptionGraphicsItem const *, class QWidget *) + ?paintEvent@QWebView@@MAEXPAVQPaintEvent@@@Z @ 334 NONAME ; void QWebView::paintEvent(class QPaintEvent *) + ?palette@QWebPage@@QBE?AVQPalette@@XZ @ 335 NONAME ; class QPalette QWebPage::palette(void) const + ?parent@QWebElement@@QBE?AV1@XZ @ 336 NONAME ; class QWebElement QWebElement::parent(void) const + ?parentFrame@QWebFrame@@QBEPAV1@XZ @ 337 NONAME ; class QWebFrame * QWebFrame::parentFrame(void) const + ?path@QWebPluginInfo@@QBE?AVQString@@XZ @ 338 NONAME ; class QString QWebPluginInfo::path(void) const + ?pixmap@QWebHitTestResult@@QBE?AVQPixmap@@XZ @ 339 NONAME ; class QPixmap QWebHitTestResult::pixmap(void) const + ?pluginFactory@QWebPage@@QBEPAVQWebPluginFactory@@XZ @ 340 NONAME ; class QWebPluginFactory * QWebPage::pluginFactory(void) const + ?pluginForMimeType@QWebPluginDatabase@@QAE?AVQWebPluginInfo@@ABVQString@@@Z @ 341 NONAME ; class QWebPluginInfo QWebPluginDatabase::pluginForMimeType(class QString const &) + ?plugins@QWebPluginDatabase@@QBE?AV?$QList@VQWebPluginInfo@@@@XZ @ 342 NONAME ; class QList QWebPluginDatabase::plugins(void) const + ?port@QWebSecurityOrigin@@QBEHXZ @ 343 NONAME ; int QWebSecurityOrigin::port(void) const + ?pos@QWebFrame@@QBE?AVQPoint@@XZ @ 344 NONAME ; class QPoint QWebFrame::pos(void) const + ?pos@QWebHitTestResult@@QBE?AVQPoint@@XZ @ 345 NONAME ; class QPoint QWebHitTestResult::pos(void) const + ?preferredContentsSize@QWebPage@@QBE?AVQSize@@XZ @ 346 NONAME ; class QSize QWebPage::preferredContentsSize(void) const + ?prefix@QWebElement@@QBE?AVQString@@XZ @ 347 NONAME ; class QString QWebElement::prefix(void) const + ?prependInside@QWebElement@@QAEXABV1@@Z @ 348 NONAME ; void QWebElement::prependInside(class QWebElement const &) + ?prependInside@QWebElement@@QAEXABVQString@@@Z @ 349 NONAME ; void QWebElement::prependInside(class QString const &) + ?prependOutside@QWebElement@@QAEXABV1@@Z @ 350 NONAME ; void QWebElement::prependOutside(class QWebElement const &) + ?prependOutside@QWebElement@@QAEXABVQString@@@Z @ 351 NONAME ; void QWebElement::prependOutside(class QString const &) + ?previousSibling@QWebElement@@QBE?AV1@XZ @ 352 NONAME ; class QWebElement QWebElement::previousSibling(void) const + ?print@QWebView@@QBEXPAVQPrinter@@@Z @ 353 NONAME ; void QWebView::print(class QPrinter *) const + ?printRequested@QWebPage@@IAEXPAVQWebFrame@@@Z @ 354 NONAME ; void QWebPage::printRequested(class QWebFrame *) + ?printingMaximumShrinkFactor@QWebSettings@@QBEMXZ @ 355 NONAME ; float QWebSettings::printingMaximumShrinkFactor(void) const + ?printingMinimumShrinkFactor@QWebSettings@@QBEMXZ @ 356 NONAME ; float QWebSettings::printingMinimumShrinkFactor(void) const + ?progress@QGraphicsWebView@@QBEMXZ @ 357 NONAME ; float QGraphicsWebView::progress(void) const + ?progressChanged@QGraphicsWebView@@IAEXM@Z @ 358 NONAME ; void QGraphicsWebView::progressChanged(float) + ?provisionalLoad@QWebFrame@@IAEXXZ @ 359 NONAME ; void QWebFrame::provisionalLoad(void) + ?qWebKitMajorVersion@@YAHXZ @ 360 NONAME ; int qWebKitMajorVersion(void) + ?qWebKitMinorVersion@@YAHXZ @ 361 NONAME ; int qWebKitMinorVersion(void) + ?qWebKitVersion@@YA?AVQString@@XZ @ 362 NONAME ; class QString qWebKitVersion(void) + ?qt_drt_clearFrameName@@YAXPAVQWebFrame@@@Z @ 363 NONAME ; void qt_drt_clearFrameName(class QWebFrame *) + ?qt_drt_counterValueForElementById@@YA?AVQString@@PAVQWebFrame@@ABV1@@Z @ 364 NONAME ; class QString qt_drt_counterValueForElementById(class QWebFrame *, class QString const &) + ?qt_drt_garbageCollector_collect@@YAXXZ @ 365 NONAME ; void qt_drt_garbageCollector_collect(void) + ?qt_drt_garbageCollector_collectOnAlternateThread@@YAX_N@Z @ 366 NONAME ; void qt_drt_garbageCollector_collectOnAlternateThread(bool) + ?qt_drt_javaScriptObjectsCount@@YAHXZ @ 367 NONAME ; int qt_drt_javaScriptObjectsCount(void) + ?qt_drt_numberOfActiveAnimations@@YAHPAVQWebFrame@@@Z @ 368 NONAME ; int qt_drt_numberOfActiveAnimations(class QWebFrame *) + ?qt_drt_overwritePluginDirectories@@YAXXZ @ 369 NONAME ; void qt_drt_overwritePluginDirectories(void) + ?qt_drt_pauseAnimation@@YA_NPAVQWebFrame@@ABVQString@@N1@Z @ 370 NONAME ; bool qt_drt_pauseAnimation(class QWebFrame *, class QString const &, double, class QString const &) + ?qt_drt_pauseTransitionOfProperty@@YA_NPAVQWebFrame@@ABVQString@@N1@Z @ 371 NONAME ; bool qt_drt_pauseTransitionOfProperty(class QWebFrame *, class QString const &, double, class QString const &) + ?qt_drt_resetOriginAccessWhiteLists@@YAXXZ @ 372 NONAME ; void qt_drt_resetOriginAccessWhiteLists(void) + ?qt_drt_run@@YAX_N@Z @ 373 NONAME ; void qt_drt_run(bool) + ?qt_drt_setJavaScriptProfilingEnabled@@YAXPAVQWebFrame@@_N@Z @ 374 NONAME ; void qt_drt_setJavaScriptProfilingEnabled(class QWebFrame *, bool) + ?qt_drt_whiteListAccessFromOrigin@@YAXABVQString@@00_N@Z @ 375 NONAME ; void qt_drt_whiteListAccessFromOrigin(class QString const &, class QString const &, class QString const &, bool) + ?qt_dump_editing_callbacks@@YAX_N@Z @ 376 NONAME ; void qt_dump_editing_callbacks(bool) + ?qt_dump_frame_loader@@YAX_N@Z @ 377 NONAME ; void qt_dump_frame_loader(bool) + ?qt_dump_resource_load_callbacks@@YAX_N@Z @ 378 NONAME ; void qt_dump_resource_load_callbacks(bool) + ?qt_dump_set_accepts_editing@@YAX_N@Z @ 379 NONAME ; void qt_dump_set_accepts_editing(bool) + ?qt_metacall@QGraphicsWebView@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 380 NONAME ; int QGraphicsWebView::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebFrame@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 381 NONAME ; int QWebFrame::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebHistoryInterface@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 382 NONAME ; int QWebHistoryInterface::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebInspector@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 383 NONAME ; int QWebInspector::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebPage@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 384 NONAME ; int QWebPage::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebPluginDatabase@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 385 NONAME ; int QWebPluginDatabase::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebPluginFactory@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 386 NONAME ; int QWebPluginFactory::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QWebView@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 387 NONAME ; int QWebView::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacast@QGraphicsWebView@@UAEPAXPBD@Z @ 388 NONAME ; void * QGraphicsWebView::qt_metacast(char const *) + ?qt_metacast@QWebFrame@@UAEPAXPBD@Z @ 389 NONAME ; void * QWebFrame::qt_metacast(char const *) + ?qt_metacast@QWebHistoryInterface@@UAEPAXPBD@Z @ 390 NONAME ; void * QWebHistoryInterface::qt_metacast(char const *) + ?qt_metacast@QWebInspector@@UAEPAXPBD@Z @ 391 NONAME ; void * QWebInspector::qt_metacast(char const *) + ?qt_metacast@QWebPage@@UAEPAXPBD@Z @ 392 NONAME ; void * QWebPage::qt_metacast(char const *) + ?qt_metacast@QWebPluginDatabase@@UAEPAXPBD@Z @ 393 NONAME ; void * QWebPluginDatabase::qt_metacast(char const *) + ?qt_metacast@QWebPluginFactory@@UAEPAXPBD@Z @ 394 NONAME ; void * QWebPluginFactory::qt_metacast(char const *) + ?qt_metacast@QWebView@@UAEPAXPBD@Z @ 395 NONAME ; void * QWebView::qt_metacast(char const *) + ?qt_webpage_groupName@@YA?AVQString@@PAVQWebPage@@@Z @ 396 NONAME ; class QString qt_webpage_groupName(class QWebPage *) + ?qt_webpage_setGroupName@@YAXPAVQWebPage@@ABVQString@@@Z @ 397 NONAME ; void qt_webpage_setGroupName(class QWebPage *, class QString const &) + ?refresh@QWebPluginDatabase@@QAEXXZ @ 398 NONAME ; void QWebPluginDatabase::refresh(void) + ?refreshPlugins@QWebPluginFactory@@UAEXXZ @ 399 NONAME ; void QWebPluginFactory::refreshPlugins(void) + ?reload@QGraphicsWebView@@QAEXXZ @ 400 NONAME ; void QGraphicsWebView::reload(void) + ?reload@QWebView@@QAEXXZ @ 401 NONAME ; void QWebView::reload(void) + ?removeAllChildren@QWebElement@@QAEXXZ @ 402 NONAME ; void QWebElement::removeAllChildren(void) + ?removeAllDatabases@QWebDatabase@@SAXXZ @ 403 NONAME ; void QWebDatabase::removeAllDatabases(void) + ?removeAttribute@QWebElement@@QAEXABVQString@@@Z @ 404 NONAME ; void QWebElement::removeAttribute(class QString const &) + ?removeAttributeNS@QWebElement@@QAEXABVQString@@0@Z @ 405 NONAME ; void QWebElement::removeAttributeNS(class QString const &, class QString const &) + ?removeClass@QWebElement@@QAEXABVQString@@@Z @ 406 NONAME ; void QWebElement::removeClass(class QString const &) + ?removeDatabase@QWebDatabase@@SAXABV1@@Z @ 407 NONAME ; void QWebDatabase::removeDatabase(class QWebDatabase const &) + ?removeFromDocument@QWebElement@@QAEXXZ @ 408 NONAME ; void QWebElement::removeFromDocument(void) + ?removeLocalScheme@QWebSecurityOrigin@@SAXABVQString@@@Z @ 409 NONAME ; void QWebSecurityOrigin::removeLocalScheme(class QString const &) + ?render@QWebElement@@QAEXPAVQPainter@@@Z @ 410 NONAME ; void QWebElement::render(class QPainter *) + ?render@QWebFrame@@QAEXPAVQPainter@@@Z @ 411 NONAME ; void QWebFrame::render(class QPainter *) + ?render@QWebFrame@@QAEXPAVQPainter@@ABVQRegion@@@Z @ 412 NONAME ; void QWebFrame::render(class QPainter *, class QRegion const &) + ?render@QWebFrame@@QAEXPAVQPainter@@W4RenderLayer@1@ABVQRegion@@@Z @ 413 NONAME ; void QWebFrame::render(class QPainter *, enum QWebFrame::RenderLayer, class QRegion const &) + ?renderHints@QWebView@@QBE?AV?$QFlags@W4RenderHint@QPainter@@@@XZ @ 414 NONAME ; class QFlags QWebView::renderHints(void) const + ?renderTreeDump@QWebFrame@@QBE?AVQString@@XZ @ 415 NONAME ; class QString QWebFrame::renderTreeDump(void) const + ?repaintRequested@QWebPage@@IAEXABVQRect@@@Z @ 416 NONAME ; void QWebPage::repaintRequested(class QRect const &) + ?replace@QWebElement@@QAEXABV1@@Z @ 417 NONAME ; void QWebElement::replace(class QWebElement const &) + ?replace@QWebElement@@QAEXABVQString@@@Z @ 418 NONAME ; void QWebElement::replace(class QString const &) + ?requestedUrl@QWebFrame@@QBE?AVQUrl@@XZ @ 419 NONAME ; class QUrl QWebFrame::requestedUrl(void) const + ?resetAttribute@QWebSettings@@QAEXW4WebAttribute@1@@Z @ 420 NONAME ; void QWebSettings::resetAttribute(enum QWebSettings::WebAttribute) + ?resetFontFamily@QWebSettings@@QAEXW4FontFamily@1@@Z @ 421 NONAME ; void QWebSettings::resetFontFamily(enum QWebSettings::FontFamily) + ?resetFontSize@QWebSettings@@QAEXW4FontSize@1@@Z @ 422 NONAME ; void QWebSettings::resetFontSize(enum QWebSettings::FontSize) + ?resizeEvent@QWebInspector@@MAEXPAVQResizeEvent@@@Z @ 423 NONAME ; void QWebInspector::resizeEvent(class QResizeEvent *) + ?resizeEvent@QWebView@@MAEXPAVQResizeEvent@@@Z @ 424 NONAME ; void QWebView::resizeEvent(class QResizeEvent *) + ?restoreFrameStateRequested@QWebPage@@IAEXPAVQWebFrame@@@Z @ 425 NONAME ; void QWebPage::restoreFrameStateRequested(class QWebFrame *) + ?saveFrameStateRequested@QWebPage@@IAEXPAVQWebFrame@@PAVQWebHistoryItem@@@Z @ 426 NONAME ; void QWebPage::saveFrameStateRequested(class QWebFrame *, class QWebHistoryItem *) + ?sceneEvent@QGraphicsWebView@@MAE_NPAVQEvent@@@Z @ 427 NONAME ; bool QGraphicsWebView::sceneEvent(class QEvent *) + ?scheme@QWebSecurityOrigin@@QBE?AVQString@@XZ @ 428 NONAME ; class QString QWebSecurityOrigin::scheme(void) const + ?scroll@QWebFrame@@QAEXHH@Z @ 429 NONAME ; void QWebFrame::scroll(int, int) + ?scrollBarGeometry@QWebFrame@@QBE?AVQRect@@W4Orientation@Qt@@@Z @ 430 NONAME ; class QRect QWebFrame::scrollBarGeometry(enum Qt::Orientation) const + ?scrollBarMaximum@QWebFrame@@QBEHW4Orientation@Qt@@@Z @ 431 NONAME ; int QWebFrame::scrollBarMaximum(enum Qt::Orientation) const + ?scrollBarMinimum@QWebFrame@@QBEHW4Orientation@Qt@@@Z @ 432 NONAME ; int QWebFrame::scrollBarMinimum(enum Qt::Orientation) const + ?scrollBarPolicy@QWebFrame@@QBE?AW4ScrollBarPolicy@Qt@@W4Orientation@3@@Z @ 433 NONAME ; enum Qt::ScrollBarPolicy QWebFrame::scrollBarPolicy(enum Qt::Orientation) const + ?scrollBarValue@QWebFrame@@QBEHW4Orientation@Qt@@@Z @ 434 NONAME ; int QWebFrame::scrollBarValue(enum Qt::Orientation) const + ?scrollPosition@QWebFrame@@QBE?AVQPoint@@XZ @ 435 NONAME ; class QPoint QWebFrame::scrollPosition(void) const + ?scrollRequested@QWebPage@@IAEXHHABVQRect@@@Z @ 436 NONAME ; void QWebPage::scrollRequested(int, int, class QRect const &) + ?searchPaths@QWebPluginDatabase@@QBE?AVQStringList@@XZ @ 437 NONAME ; class QStringList QWebPluginDatabase::searchPaths(void) const + ?securityOrigin@QWebFrame@@QBE?AVQWebSecurityOrigin@@XZ @ 438 NONAME ; class QWebSecurityOrigin QWebFrame::securityOrigin(void) const + ?selectedText@QWebPage@@QBE?AVQString@@XZ @ 439 NONAME ; class QString QWebPage::selectedText(void) const + ?selectedText@QWebView@@QBE?AVQString@@XZ @ 440 NONAME ; class QString QWebView::selectedText(void) const + ?selectionChanged@QWebPage@@IAEXXZ @ 441 NONAME ; void QWebPage::selectionChanged(void) + ?selectionChanged@QWebView@@IAEXXZ @ 442 NONAME ; void QWebView::selectionChanged(void) + ?setAttribute@QWebElement@@QAEXABVQString@@0@Z @ 443 NONAME ; void QWebElement::setAttribute(class QString const &, class QString const &) + ?setAttribute@QWebSettings@@QAEXW4WebAttribute@1@_N@Z @ 444 NONAME ; void QWebSettings::setAttribute(enum QWebSettings::WebAttribute, bool) + ?setAttributeNS@QWebElement@@QAEXABVQString@@00@Z @ 445 NONAME ; void QWebElement::setAttributeNS(class QString const &, class QString const &, class QString const &) + ?setContent@QGraphicsWebView@@QAEXABVQByteArray@@ABVQString@@ABVQUrl@@@Z @ 446 NONAME ; void QGraphicsWebView::setContent(class QByteArray const &, class QString const &, class QUrl const &) + ?setContent@QWebFrame@@QAEXABVQByteArray@@ABVQString@@ABVQUrl@@@Z @ 447 NONAME ; void QWebFrame::setContent(class QByteArray const &, class QString const &, class QUrl const &) + ?setContent@QWebView@@QAEXABVQByteArray@@ABVQString@@ABVQUrl@@@Z @ 448 NONAME ; void QWebView::setContent(class QByteArray const &, class QString const &, class QUrl const &) + ?setContentEditable@QWebPage@@QAEX_N@Z @ 449 NONAME ; void QWebPage::setContentEditable(bool) + ?setDatabaseQuota@QWebSecurityOrigin@@QAEX_J@Z @ 450 NONAME ; void QWebSecurityOrigin::setDatabaseQuota(long long) + ?setDefaultInterface@QWebHistoryInterface@@SAXPAV1@@Z @ 451 NONAME ; void QWebHistoryInterface::setDefaultInterface(class QWebHistoryInterface *) + ?setDefaultTextEncoding@QWebSettings@@QAEXABVQString@@@Z @ 452 NONAME ; void QWebSettings::setDefaultTextEncoding(class QString const &) + ?setEnabled@QWebPluginInfo@@QAEX_N@Z @ 453 NONAME ; void QWebPluginInfo::setEnabled(bool) + ?setFocus@QWebElement@@QAEXXZ @ 454 NONAME ; void QWebElement::setFocus(void) + ?setFocus@QWebFrame@@QAEXXZ @ 455 NONAME ; void QWebFrame::setFocus(void) + ?setFontFamily@QWebSettings@@QAEXW4FontFamily@1@ABVQString@@@Z @ 456 NONAME ; void QWebSettings::setFontFamily(enum QWebSettings::FontFamily, class QString const &) + ?setFontSize@QWebSettings@@QAEXW4FontSize@1@H@Z @ 457 NONAME ; void QWebSettings::setFontSize(enum QWebSettings::FontSize, int) + ?setForwardUnsupportedContent@QWebPage@@QAEX_N@Z @ 458 NONAME ; void QWebPage::setForwardUnsupportedContent(bool) + ?setGeometry@QGraphicsWebView@@UAEXABVQRectF@@@Z @ 459 NONAME ; void QGraphicsWebView::setGeometry(class QRectF const &) + ?setHtml@QGraphicsWebView@@QAEXABVQString@@ABVQUrl@@@Z @ 460 NONAME ; void QGraphicsWebView::setHtml(class QString const &, class QUrl const &) + ?setHtml@QWebFrame@@QAEXABVQString@@ABVQUrl@@@Z @ 461 NONAME ; void QWebFrame::setHtml(class QString const &, class QUrl const &) + ?setHtml@QWebView@@QAEXABVQString@@ABVQUrl@@@Z @ 462 NONAME ; void QWebView::setHtml(class QString const &, class QUrl const &) + ?setIconDatabasePath@QWebSettings@@SAXABVQString@@@Z @ 463 NONAME ; void QWebSettings::setIconDatabasePath(class QString const &) + ?setInnerXml@QWebElement@@QAEXABVQString@@@Z @ 464 NONAME ; void QWebElement::setInnerXml(class QString const &) + ?setInteractive@QGraphicsWebView@@QAEX_N@Z @ 465 NONAME ; void QGraphicsWebView::setInteractive(bool) + ?setLinkDelegationPolicy@QWebPage@@QAEXW4LinkDelegationPolicy@1@@Z @ 466 NONAME ; void QWebPage::setLinkDelegationPolicy(enum QWebPage::LinkDelegationPolicy) + ?setLocalStoragePath@QWebSettings@@QAEXABVQString@@@Z @ 467 NONAME ; void QWebSettings::setLocalStoragePath(class QString const &) + ?setMaximumItemCount@QWebHistory@@QAEXH@Z @ 468 NONAME ; void QWebHistory::setMaximumItemCount(int) + ?setMaximumPagesInCache@QWebSettings@@SAXH@Z @ 469 NONAME ; void QWebSettings::setMaximumPagesInCache(int) + ?setNetworkAccessManager@QWebPage@@QAEXPAVQNetworkAccessManager@@@Z @ 470 NONAME ; void QWebPage::setNetworkAccessManager(class QNetworkAccessManager *) + ?setObjectCacheCapacities@QWebSettings@@SAXHHH@Z @ 471 NONAME ; void QWebSettings::setObjectCacheCapacities(int, int, int) + ?setOfflineStorageDefaultQuota@QWebSettings@@SAX_J@Z @ 472 NONAME ; void QWebSettings::setOfflineStorageDefaultQuota(long long) + ?setOfflineStoragePath@QWebSettings@@SAXABVQString@@@Z @ 473 NONAME ; void QWebSettings::setOfflineStoragePath(class QString const &) + ?setOfflineWebApplicationCachePath@QWebSettings@@SAXABVQString@@@Z @ 474 NONAME ; void QWebSettings::setOfflineWebApplicationCachePath(class QString const &) + ?setOfflineWebApplicationCacheQuota@QWebSettings@@SAX_J@Z @ 475 NONAME ; void QWebSettings::setOfflineWebApplicationCacheQuota(long long) + ?setOuterXml@QWebElement@@QAEXABVQString@@@Z @ 476 NONAME ; void QWebElement::setOuterXml(class QString const &) + ?setPage@QGraphicsWebView@@QAEXPAVQWebPage@@@Z @ 477 NONAME ; void QGraphicsWebView::setPage(class QWebPage *) + ?setPage@QWebInspector@@QAEXPAVQWebPage@@@Z @ 478 NONAME ; void QWebInspector::setPage(class QWebPage *) + ?setPage@QWebView@@QAEXPAVQWebPage@@@Z @ 479 NONAME ; void QWebView::setPage(class QWebPage *) + ?setPalette@QWebPage@@QAEXABVQPalette@@@Z @ 480 NONAME ; void QWebPage::setPalette(class QPalette const &) + ?setPlainText@QWebElement@@QAEXABVQString@@@Z @ 481 NONAME ; void QWebElement::setPlainText(class QString const &) + ?setPluginFactory@QWebPage@@QAEXPAVQWebPluginFactory@@@Z @ 482 NONAME ; void QWebPage::setPluginFactory(class QWebPluginFactory *) + ?setPreferredContentsSize@QWebPage@@QBEXABVQSize@@@Z @ 483 NONAME ; void QWebPage::setPreferredContentsSize(class QSize const &) const + ?setPreferredPluginForMimeType@QWebPluginDatabase@@QAEXABVQString@@ABVQWebPluginInfo@@@Z @ 484 NONAME ; void QWebPluginDatabase::setPreferredPluginForMimeType(class QString const &, class QWebPluginInfo const &) + ?setPrintingMaximumShrinkFactor@QWebSettings@@QAEXM@Z @ 485 NONAME ; void QWebSettings::setPrintingMaximumShrinkFactor(float) + ?setPrintingMinimumShrinkFactor@QWebSettings@@QAEXM@Z @ 486 NONAME ; void QWebSettings::setPrintingMinimumShrinkFactor(float) + ?setRenderHint@QWebView@@QAEXW4RenderHint@QPainter@@_N@Z @ 487 NONAME ; void QWebView::setRenderHint(enum QPainter::RenderHint, bool) + ?setRenderHints@QWebView@@QAEXV?$QFlags@W4RenderHint@QPainter@@@@@Z @ 488 NONAME ; void QWebView::setRenderHints(class QFlags) + ?setScrollBarPolicy@QWebFrame@@QAEXW4Orientation@Qt@@W4ScrollBarPolicy@3@@Z @ 489 NONAME ; void QWebFrame::setScrollBarPolicy(enum Qt::Orientation, enum Qt::ScrollBarPolicy) + ?setScrollBarValue@QWebFrame@@QAEXW4Orientation@Qt@@H@Z @ 490 NONAME ; void QWebFrame::setScrollBarValue(enum Qt::Orientation, int) + ?setScrollPosition@QWebFrame@@QAEXABVQPoint@@@Z @ 491 NONAME ; void QWebFrame::setScrollPosition(class QPoint const &) + ?setSearchPaths@QWebPluginDatabase@@QAEXABVQStringList@@@Z @ 492 NONAME ; void QWebPluginDatabase::setSearchPaths(class QStringList const &) + ?setStyleProperty@QWebElement@@QAEXABVQString@@0@Z @ 493 NONAME ; void QWebElement::setStyleProperty(class QString const &, class QString const &) + ?setTextSizeMultiplier@QWebFrame@@QAEXM@Z @ 494 NONAME ; void QWebFrame::setTextSizeMultiplier(float) + ?setTextSizeMultiplier@QWebView@@QAEXM@Z @ 495 NONAME ; void QWebView::setTextSizeMultiplier(float) + ?setUrl@QGraphicsWebView@@QAEXABVQUrl@@@Z @ 496 NONAME ; void QGraphicsWebView::setUrl(class QUrl const &) + ?setUrl@QWebFrame@@QAEXABVQUrl@@@Z @ 497 NONAME ; void QWebFrame::setUrl(class QUrl const &) + ?setUrl@QWebView@@QAEXABVQUrl@@@Z @ 498 NONAME ; void QWebView::setUrl(class QUrl const &) + ?setUserData@QWebHistoryItem@@QAEXABVQVariant@@@Z @ 499 NONAME ; void QWebHistoryItem::setUserData(class QVariant const &) + ?setUserStyleSheetUrl@QWebSettings@@QAEXABVQUrl@@@Z @ 500 NONAME ; void QWebSettings::setUserStyleSheetUrl(class QUrl const &) + ?setView@QWebPage@@QAEXPAVQWidget@@@Z @ 501 NONAME ; void QWebPage::setView(class QWidget *) + ?setViewportSize@QWebPage@@QBEXABVQSize@@@Z @ 502 NONAME ; void QWebPage::setViewportSize(class QSize const &) const + ?setWebGraphic@QWebSettings@@SAXW4WebGraphic@1@ABVQPixmap@@@Z @ 503 NONAME ; void QWebSettings::setWebGraphic(enum QWebSettings::WebGraphic, class QPixmap const &) + ?setZoomFactor@QGraphicsWebView@@QAEXM@Z @ 504 NONAME ; void QGraphicsWebView::setZoomFactor(float) + ?setZoomFactor@QWebFrame@@QAEXM@Z @ 505 NONAME ; void QWebFrame::setZoomFactor(float) + ?setZoomFactor@QWebView@@QAEXM@Z @ 506 NONAME ; void QWebView::setZoomFactor(float) + ?settings@QGraphicsWebView@@QBEPAVQWebSettings@@XZ @ 507 NONAME ; class QWebSettings * QGraphicsWebView::settings(void) const + ?settings@QWebPage@@QBEPAVQWebSettings@@XZ @ 508 NONAME ; class QWebSettings * QWebPage::settings(void) const + ?settings@QWebView@@QBEPAVQWebSettings@@XZ @ 509 NONAME ; class QWebSettings * QWebView::settings(void) const + ?shouldInterruptJavaScript@QWebPage@@QAE_NXZ @ 510 NONAME ; bool QWebPage::shouldInterruptJavaScript(void) + ?showEvent@QWebInspector@@MAEXPAVQShowEvent@@@Z @ 511 NONAME ; void QWebInspector::showEvent(class QShowEvent *) + ?size@QWebDatabase@@QBE_JXZ @ 512 NONAME ; long long QWebDatabase::size(void) const + ?sizeHint@QWebInspector@@UBE?AVQSize@@XZ @ 513 NONAME ; class QSize QWebInspector::sizeHint(void) const + ?sizeHint@QWebView@@UBE?AVQSize@@XZ @ 514 NONAME ; class QSize QWebView::sizeHint(void) const + ?status@QGraphicsWebView@@QBE?AVQString@@XZ @ 515 NONAME ; class QString QGraphicsWebView::status(void) const + ?statusBarMessage@QWebPage@@IAEXABVQString@@@Z @ 516 NONAME ; void QWebPage::statusBarMessage(class QString const &) + ?statusBarMessage@QWebView@@IAEXABVQString@@@Z @ 517 NONAME ; void QWebView::statusBarMessage(class QString const &) + ?statusBarVisibilityChangeRequested@QWebPage@@IAEX_N@Z @ 518 NONAME ; void QWebPage::statusBarVisibilityChangeRequested(bool) + ?statusChanged@QGraphicsWebView@@IAEXXZ @ 519 NONAME ; void QGraphicsWebView::statusChanged(void) + ?stop@QGraphicsWebView@@QAEXXZ @ 520 NONAME ; void QGraphicsWebView::stop(void) + ?stop@QWebView@@QAEXXZ @ 521 NONAME ; void QWebView::stop(void) + ?styleProperty@QWebElement@@QBE?AVQString@@ABV2@W4StyleResolveStrategy@1@@Z @ 522 NONAME ; class QString QWebElement::styleProperty(class QString const &, enum QWebElement::StyleResolveStrategy) const + ?supportsExtension@QWebPage@@UBE_NW4Extension@1@@Z @ 523 NONAME ; bool QWebPage::supportsExtension(enum QWebPage::Extension) const + ?supportsExtension@QWebPluginFactory@@UBE_NW4Extension@1@@Z @ 524 NONAME ; bool QWebPluginFactory::supportsExtension(enum QWebPluginFactory::Extension) const + ?supportsMimeType@QWebPluginInfo@@QBE_NABVQString@@@Z @ 525 NONAME ; bool QWebPluginInfo::supportsMimeType(class QString const &) const + ?swallowContextMenuEvent@QWebPage@@QAE_NPAVQContextMenuEvent@@@Z @ 526 NONAME ; bool QWebPage::swallowContextMenuEvent(class QContextMenuEvent *) + ?tagName@QWebElement@@QBE?AVQString@@XZ @ 527 NONAME ; class QString QWebElement::tagName(void) const + ?takeFromDocument@QWebElement@@QAEAAV1@XZ @ 528 NONAME ; class QWebElement & QWebElement::takeFromDocument(void) + ?testAttribute@QWebSettings@@QBE_NW4WebAttribute@1@@Z @ 529 NONAME ; bool QWebSettings::testAttribute(enum QWebSettings::WebAttribute) const + ?textSizeMultiplier@QWebFrame@@QBEMXZ @ 530 NONAME ; float QWebFrame::textSizeMultiplier(void) const + ?textSizeMultiplier@QWebView@@QBEMXZ @ 531 NONAME ; float QWebView::textSizeMultiplier(void) const + ?title@QGraphicsWebView@@QBE?AVQString@@XZ @ 532 NONAME ; class QString QGraphicsWebView::title(void) const + ?title@QWebFrame@@QBE?AVQString@@XZ @ 533 NONAME ; class QString QWebFrame::title(void) const + ?title@QWebHistoryItem@@QBE?AVQString@@XZ @ 534 NONAME ; class QString QWebHistoryItem::title(void) const + ?title@QWebHitTestResult@@QBE?AVQString@@XZ @ 535 NONAME ; class QString QWebHitTestResult::title(void) const + ?title@QWebView@@QBE?AVQString@@XZ @ 536 NONAME ; class QString QWebView::title(void) const + ?titleChanged@QGraphicsWebView@@IAEXABVQString@@@Z @ 537 NONAME ; void QGraphicsWebView::titleChanged(class QString const &) + ?titleChanged@QWebFrame@@IAEXABVQString@@@Z @ 538 NONAME ; void QWebFrame::titleChanged(class QString const &) + ?titleChanged@QWebView@@IAEXABVQString@@@Z @ 539 NONAME ; void QWebView::titleChanged(class QString const &) + ?toHtml@QGraphicsWebView@@QBE?AVQString@@XZ @ 540 NONAME ; class QString QGraphicsWebView::toHtml(void) const + ?toHtml@QWebFrame@@QBE?AVQString@@XZ @ 541 NONAME ; class QString QWebFrame::toHtml(void) const + ?toInnerXml@QWebElement@@QBE?AVQString@@XZ @ 542 NONAME ; class QString QWebElement::toInnerXml(void) const + ?toList@QWebElementCollection@@QBE?AV?$QList@VQWebElement@@@@XZ @ 543 NONAME ; class QList QWebElementCollection::toList(void) const + ?toOuterXml@QWebElement@@QBE?AVQString@@XZ @ 544 NONAME ; class QString QWebElement::toOuterXml(void) const + ?toPlainText@QWebElement@@QBE?AVQString@@XZ @ 545 NONAME ; class QString QWebElement::toPlainText(void) const + ?toPlainText@QWebFrame@@QBE?AVQString@@XZ @ 546 NONAME ; class QString QWebFrame::toPlainText(void) const + ?toggleClass@QWebElement@@QAEXABVQString@@@Z @ 547 NONAME ; void QWebElement::toggleClass(class QString const &) + ?toolBarVisibilityChangeRequested@QWebPage@@IAEX_N@Z @ 548 NONAME ; void QWebPage::toolBarVisibilityChangeRequested(bool) + ?totalBytes@QWebPage@@QBE_KXZ @ 549 NONAME ; unsigned long long QWebPage::totalBytes(void) const + ?tr@QGraphicsWebView@@SA?AVQString@@PBD0@Z @ 550 NONAME ; class QString QGraphicsWebView::tr(char const *, char const *) + ?tr@QGraphicsWebView@@SA?AVQString@@PBD0H@Z @ 551 NONAME ; class QString QGraphicsWebView::tr(char const *, char const *, int) + ?tr@QWebFrame@@SA?AVQString@@PBD0@Z @ 552 NONAME ; class QString QWebFrame::tr(char const *, char const *) + ?tr@QWebFrame@@SA?AVQString@@PBD0H@Z @ 553 NONAME ; class QString QWebFrame::tr(char const *, char const *, int) + ?tr@QWebHistoryInterface@@SA?AVQString@@PBD0@Z @ 554 NONAME ; class QString QWebHistoryInterface::tr(char const *, char const *) + ?tr@QWebHistoryInterface@@SA?AVQString@@PBD0H@Z @ 555 NONAME ; class QString QWebHistoryInterface::tr(char const *, char const *, int) + ?tr@QWebInspector@@SA?AVQString@@PBD0@Z @ 556 NONAME ; class QString QWebInspector::tr(char const *, char const *) + ?tr@QWebInspector@@SA?AVQString@@PBD0H@Z @ 557 NONAME ; class QString QWebInspector::tr(char const *, char const *, int) + ?tr@QWebPage@@SA?AVQString@@PBD0@Z @ 558 NONAME ; class QString QWebPage::tr(char const *, char const *) + ?tr@QWebPage@@SA?AVQString@@PBD0H@Z @ 559 NONAME ; class QString QWebPage::tr(char const *, char const *, int) + ?tr@QWebPluginDatabase@@SA?AVQString@@PBD0@Z @ 560 NONAME ; class QString QWebPluginDatabase::tr(char const *, char const *) + ?tr@QWebPluginDatabase@@SA?AVQString@@PBD0H@Z @ 561 NONAME ; class QString QWebPluginDatabase::tr(char const *, char const *, int) + ?tr@QWebPluginFactory@@SA?AVQString@@PBD0@Z @ 562 NONAME ; class QString QWebPluginFactory::tr(char const *, char const *) + ?tr@QWebPluginFactory@@SA?AVQString@@PBD0H@Z @ 563 NONAME ; class QString QWebPluginFactory::tr(char const *, char const *, int) + ?tr@QWebView@@SA?AVQString@@PBD0@Z @ 564 NONAME ; class QString QWebView::tr(char const *, char const *) + ?tr@QWebView@@SA?AVQString@@PBD0H@Z @ 565 NONAME ; class QString QWebView::tr(char const *, char const *, int) + ?trUtf8@QGraphicsWebView@@SA?AVQString@@PBD0@Z @ 566 NONAME ; class QString QGraphicsWebView::trUtf8(char const *, char const *) + ?trUtf8@QGraphicsWebView@@SA?AVQString@@PBD0H@Z @ 567 NONAME ; class QString QGraphicsWebView::trUtf8(char const *, char const *, int) + ?trUtf8@QWebFrame@@SA?AVQString@@PBD0@Z @ 568 NONAME ; class QString QWebFrame::trUtf8(char const *, char const *) + ?trUtf8@QWebFrame@@SA?AVQString@@PBD0H@Z @ 569 NONAME ; class QString QWebFrame::trUtf8(char const *, char const *, int) + ?trUtf8@QWebHistoryInterface@@SA?AVQString@@PBD0@Z @ 570 NONAME ; class QString QWebHistoryInterface::trUtf8(char const *, char const *) + ?trUtf8@QWebHistoryInterface@@SA?AVQString@@PBD0H@Z @ 571 NONAME ; class QString QWebHistoryInterface::trUtf8(char const *, char const *, int) + ?trUtf8@QWebInspector@@SA?AVQString@@PBD0@Z @ 572 NONAME ; class QString QWebInspector::trUtf8(char const *, char const *) + ?trUtf8@QWebInspector@@SA?AVQString@@PBD0H@Z @ 573 NONAME ; class QString QWebInspector::trUtf8(char const *, char const *, int) + ?trUtf8@QWebPage@@SA?AVQString@@PBD0@Z @ 574 NONAME ; class QString QWebPage::trUtf8(char const *, char const *) + ?trUtf8@QWebPage@@SA?AVQString@@PBD0H@Z @ 575 NONAME ; class QString QWebPage::trUtf8(char const *, char const *, int) + ?trUtf8@QWebPluginDatabase@@SA?AVQString@@PBD0@Z @ 576 NONAME ; class QString QWebPluginDatabase::trUtf8(char const *, char const *) + ?trUtf8@QWebPluginDatabase@@SA?AVQString@@PBD0H@Z @ 577 NONAME ; class QString QWebPluginDatabase::trUtf8(char const *, char const *, int) + ?trUtf8@QWebPluginFactory@@SA?AVQString@@PBD0@Z @ 578 NONAME ; class QString QWebPluginFactory::trUtf8(char const *, char const *) + ?trUtf8@QWebPluginFactory@@SA?AVQString@@PBD0H@Z @ 579 NONAME ; class QString QWebPluginFactory::trUtf8(char const *, char const *, int) + ?trUtf8@QWebView@@SA?AVQString@@PBD0@Z @ 580 NONAME ; class QString QWebView::trUtf8(char const *, char const *) + ?trUtf8@QWebView@@SA?AVQString@@PBD0H@Z @ 581 NONAME ; class QString QWebView::trUtf8(char const *, char const *, int) + ?triggerAction@QWebPage@@UAEXW4WebAction@1@_N@Z @ 582 NONAME ; void QWebPage::triggerAction(enum QWebPage::WebAction, bool) + ?triggerPageAction@QWebView@@QAEXW4WebAction@QWebPage@@_N@Z @ 583 NONAME ; void QWebView::triggerPageAction(enum QWebPage::WebAction, bool) + ?undoStack@QWebPage@@QBEPAVQUndoStack@@XZ @ 584 NONAME ; class QUndoStack * QWebPage::undoStack(void) const + ?unsupportedContent@QWebPage@@IAEXPAVQNetworkReply@@@Z @ 585 NONAME ; void QWebPage::unsupportedContent(class QNetworkReply *) + ?updateGeometry@QGraphicsWebView@@UAEXXZ @ 586 NONAME ; void QGraphicsWebView::updateGeometry(void) + ?updatePositionDependentActions@QWebPage@@QAEXABVQPoint@@@Z @ 587 NONAME ; void QWebPage::updatePositionDependentActions(class QPoint const &) + ?url@QGraphicsWebView@@QBE?AVQUrl@@XZ @ 588 NONAME ; class QUrl QGraphicsWebView::url(void) const + ?url@QWebFrame@@QBE?AVQUrl@@XZ @ 589 NONAME ; class QUrl QWebFrame::url(void) const + ?url@QWebHistoryItem@@QBE?AVQUrl@@XZ @ 590 NONAME ; class QUrl QWebHistoryItem::url(void) const + ?url@QWebView@@QBE?AVQUrl@@XZ @ 591 NONAME ; class QUrl QWebView::url(void) const + ?urlChanged@QGraphicsWebView@@IAEXABVQUrl@@@Z @ 592 NONAME ; void QGraphicsWebView::urlChanged(class QUrl const &) + ?urlChanged@QWebFrame@@IAEXABVQUrl@@@Z @ 593 NONAME ; void QWebFrame::urlChanged(class QUrl const &) + ?urlChanged@QWebView@@IAEXABVQUrl@@@Z @ 594 NONAME ; void QWebView::urlChanged(class QUrl const &) + ?userAgentForUrl@QWebPage@@MBE?AVQString@@ABVQUrl@@@Z @ 595 NONAME ; class QString QWebPage::userAgentForUrl(class QUrl const &) const + ?userData@QWebHistoryItem@@QBE?AVQVariant@@XZ @ 596 NONAME ; class QVariant QWebHistoryItem::userData(void) const + ?userStyleSheetUrl@QWebSettings@@QBE?AVQUrl@@XZ @ 597 NONAME ; class QUrl QWebSettings::userStyleSheetUrl(void) const + ?view@QWebPage@@QBEPAVQWidget@@XZ @ 598 NONAME ; class QWidget * QWebPage::view(void) const + ?viewportSize@QWebPage@@QBE?AVQSize@@XZ @ 599 NONAME ; class QSize QWebPage::viewportSize(void) const + ?webFrame@QWebElement@@QBEPAVQWebFrame@@XZ @ 600 NONAME ; class QWebFrame * QWebElement::webFrame(void) const + ?webGraphic@QWebSettings@@SA?AVQPixmap@@W4WebGraphic@1@@Z @ 601 NONAME ; class QPixmap QWebSettings::webGraphic(enum QWebSettings::WebGraphic) + ?webInspectorTriggered@QWebPage@@IAEXABVQWebElement@@@Z @ 602 NONAME ; void QWebPage::webInspectorTriggered(class QWebElement const &) + ?wheelEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneWheelEvent@@@Z @ 603 NONAME ; void QGraphicsWebView::wheelEvent(class QGraphicsSceneWheelEvent *) + ?wheelEvent@QWebView@@MAEXPAVQWheelEvent@@@Z @ 604 NONAME ; void QWebView::wheelEvent(class QWheelEvent *) + ?windowCloseRequested@QWebPage@@IAEXXZ @ 605 NONAME ; void QWebPage::windowCloseRequested(void) + ?zoomFactor@QGraphicsWebView@@QBEMXZ @ 606 NONAME ; float QGraphicsWebView::zoomFactor(void) const + ?zoomFactor@QWebFrame@@QBEMXZ @ 607 NONAME ; float QWebFrame::zoomFactor(void) const + ?zoomFactor@QWebView@@QBEMXZ @ 608 NONAME ; float QWebView::zoomFactor(void) const + ?zoomFactorChanged@QGraphicsWebView@@IAEXXZ @ 609 NONAME ; void QGraphicsWebView::zoomFactorChanged(void) + ?staticMetaObject@QWebPluginDatabase@@2UQMetaObject@@B @ 610 NONAME ; struct QMetaObject const QWebPluginDatabase::staticMetaObject + ?staticMetaObject@QWebFrame@@2UQMetaObject@@B @ 611 NONAME ; struct QMetaObject const QWebFrame::staticMetaObject + ?staticMetaObject@QWebHistoryInterface@@2UQMetaObject@@B @ 612 NONAME ; struct QMetaObject const QWebHistoryInterface::staticMetaObject + ?staticMetaObject@QWebInspector@@2UQMetaObject@@B @ 613 NONAME ; struct QMetaObject const QWebInspector::staticMetaObject + ?staticMetaObject@QWebPluginFactory@@2UQMetaObject@@B @ 614 NONAME ; struct QMetaObject const QWebPluginFactory::staticMetaObject + ?staticMetaObject@QGraphicsWebView@@2UQMetaObject@@B @ 615 NONAME ; struct QMetaObject const QGraphicsWebView::staticMetaObject + ?staticMetaObject@QWebPage@@2UQMetaObject@@B @ 616 NONAME ; struct QMetaObject const QWebPage::staticMetaObject + ?staticMetaObject@QWebView@@2UQMetaObject@@B @ 617 NONAME ; struct QMetaObject const QWebView::staticMetaObject + diff --git a/src/s60installs/eabi/QtWebKitu.def b/src/s60installs/eabi/QtWebKitu.def index 31a82bc..2ca393c 100644 --- a/src/s60installs/eabi/QtWebKitu.def +++ b/src/s60installs/eabi/QtWebKitu.def @@ -34,7 +34,7 @@ EXPORTS _ZN11QWebElement13prependInsideERKS_ @ 33 NONAME _ZN11QWebElement14prependOutsideERK7QString @ 34 NONAME _ZN11QWebElement14prependOutsideERKS_ @ 35 NONAME - _ZN11QWebElement14removeChildrenEv @ 36 NONAME + _ZN11QWebElement14removeChildrenEv @ 36 NONAME ABSENT _ZN11QWebElement14setAttributeNSERK7QStringS2_S2_ @ 37 NONAME _ZN11QWebElement15removeAttributeERK7QString @ 38 NONAME _ZN11QWebElement16enclosingElementEPN7WebCore4NodeE @ 39 NONAME @@ -60,7 +60,7 @@ EXPORTS _ZN11QWebElementD1Ev @ 59 NONAME _ZN11QWebElementD2Ev @ 60 NONAME _ZN11QWebElementaSERKS_ @ 61 NONAME - _ZN11QWebHistory12restoreStateERK10QByteArray @ 62 NONAME + _ZN11QWebHistory12restoreStateERK10QByteArray @ 62 NONAME ABSENT _ZN11QWebHistory19setMaximumItemCountEi @ 63 NONAME _ZN11QWebHistory4backEv @ 64 NONAME _ZN11QWebHistory5clearEv @ 65 NONAME @@ -87,7 +87,7 @@ EXPORTS _ZN12QWebSettings13setFontFamilyENS_10FontFamilyERK7QString @ 86 NONAME _ZN12QWebSettings13setWebGraphicENS_10WebGraphicERK7QPixmap @ 87 NONAME _ZN12QWebSettings14globalSettingsEv @ 88 NONAME - _ZN12QWebSettings14pluginDatabaseEv @ 89 NONAME + _ZN12QWebSettings14pluginDatabaseEv @ 89 NONAME ABSENT _ZN12QWebSettings14resetAttributeENS_12WebAttributeE @ 90 NONAME _ZN12QWebSettings15resetFontFamilyENS_10FontFamilyE @ 91 NONAME _ZN12QWebSettings16iconDatabasePathEv @ 92 NONAME @@ -119,7 +119,7 @@ EXPORTS _ZN13QWebInspector11qt_metacastEPKc @ 118 NONAME _ZN13QWebInspector11resizeEventEP12QResizeEvent @ 119 NONAME _ZN13QWebInspector16staticMetaObjectE @ 120 NONAME DATA 16 - _ZN13QWebInspector18windowTitleChangedERK7QString @ 121 NONAME + _ZN13QWebInspector18windowTitleChangedERK7QString @ 121 NONAME ABSENT _ZN13QWebInspector19getStaticMetaObjectEv @ 122 NONAME _ZN13QWebInspector5eventEP6QEvent @ 123 NONAME _ZN13QWebInspector7setPageEP8QWebPage @ 124 NONAME @@ -148,7 +148,7 @@ EXPORTS _ZN15QWebHistoryItemD1Ev @ 147 NONAME _ZN15QWebHistoryItemD2Ev @ 148 NONAME _ZN15QWebHistoryItemaSERKS_ @ 149 NONAME - _ZN16QGraphicsWebView10loadFailedEv @ 150 NONAME + _ZN16QGraphicsWebView10loadFailedEv @ 150 NONAME ABSENT _ZN16QGraphicsWebView10sceneEventEP6QEvent @ 151 NONAME _ZN16QGraphicsWebView10setContentERK10QByteArrayRK7QStringRK4QUrl @ 152 NONAME _ZN16QGraphicsWebView10urlChangedERK4QUrl @ 153 NONAME @@ -159,7 +159,7 @@ EXPORTS _ZN16QGraphicsWebView11qt_metacastEPKc @ 158 NONAME _ZN16QGraphicsWebView11setGeometryERK6QRectF @ 159 NONAME _ZN16QGraphicsWebView12focusInEventEP11QFocusEvent @ 160 NONAME - _ZN16QGraphicsWebView12loadFinishedEv @ 161 NONAME + _ZN16QGraphicsWebView12loadFinishedEv @ 161 NONAME ABSENT _ZN16QGraphicsWebView12titleChangedERK7QString @ 162 NONAME _ZN16QGraphicsWebView13dragMoveEventEP27QGraphicsSceneDragDropEvent @ 163 NONAME _ZN16QGraphicsWebView13focusOutEventEP11QFocusEvent @ 164 NONAME @@ -241,8 +241,8 @@ EXPORTS _ZN18QWebSecurityOrigin14addLocalSchemeERK7QString @ 240 NONAME _ZN18QWebSecurityOrigin16setDatabaseQuotaEx @ 241 NONAME _ZN18QWebSecurityOrigin17removeLocalSchemeERK7QString @ 242 NONAME - _ZN18QWebSecurityOrigin25whiteListAccessFromOriginERK7QStringS2_S2_b @ 243 NONAME - _ZN18QWebSecurityOrigin27resetOriginAccessWhiteListsEv @ 244 NONAME + _ZN18QWebSecurityOrigin25whiteListAccessFromOriginERK7QStringS2_S2_b @ 243 NONAME ABSENT + _ZN18QWebSecurityOrigin27resetOriginAccessWhiteListsEv @ 244 NONAME ABSENT _ZN18QWebSecurityOriginC1EP25QWebSecurityOriginPrivate @ 245 NONAME _ZN18QWebSecurityOriginC1ERKS_ @ 246 NONAME _ZN18QWebSecurityOriginC2EP25QWebSecurityOriginPrivate @ 247 NONAME @@ -352,7 +352,7 @@ EXPORTS _ZN8QWebView17mouseReleaseEventEP11QMouseEvent @ 351 NONAME _ZN8QWebView17triggerPageActionEN8QWebPage9WebActionEb @ 352 NONAME _ZN8QWebView18focusNextPrevChildEb @ 353 NONAME - _ZN8QWebView18guessUrlFromStringERK7QString @ 354 NONAME + _ZN8QWebView18guessUrlFromStringERK7QString @ 354 NONAME ABSENT _ZN8QWebView19getStaticMetaObjectEv @ 355 NONAME _ZN8QWebView21mouseDoubleClickEventEP11QMouseEvent @ 356 NONAME _ZN8QWebView21setTextSizeMultiplierEf @ 357 NONAME @@ -392,7 +392,7 @@ EXPORTS _ZN9QWebFrame19getStaticMetaObjectEv @ 391 NONAME _ZN9QWebFrame21setTextSizeMultiplierEf @ 392 NONAME _ZN9QWebFrame22initialLayoutCompletedEv @ 393 NONAME - _ZN9QWebFrame23setClipRenderToViewportEb @ 394 NONAME + _ZN9QWebFrame23setClipRenderToViewportEb @ 394 NONAME ABSENT _ZN9QWebFrame27addToJavaScriptWindowObjectERK7QStringP7QObject @ 395 NONAME _ZN9QWebFrame27addToJavaScriptWindowObjectERK7QStringP7QObjectN13QScriptEngine14ValueOwnershipE @ 396 NONAME _ZN9QWebFrame29javaScriptWindowObjectClearedEv @ 397 NONAME @@ -454,7 +454,7 @@ EXPORTS _ZNK11QWebHistory8backItemEv @ 453 NONAME _ZNK11QWebHistory9backItemsEi @ 454 NONAME _ZNK11QWebHistory9canGoBackEv @ 455 NONAME - _ZNK11QWebHistory9saveStateENS_19HistoryStateVersionE @ 456 NONAME + _ZNK11QWebHistory9saveStateENS_19HistoryStateVersionE @ 456 NONAME ABSENT _ZNK12QWebDatabase11displayNameEv @ 457 NONAME _ZNK12QWebDatabase12expectedSizeEv @ 458 NONAME _ZNK12QWebDatabase4nameEv @ 459 NONAME @@ -539,12 +539,12 @@ EXPORTS _ZNK8QWebPage15setViewportSizeERK5QSize @ 538 NONAME _ZNK8QWebPage15userAgentForUrlERK4QUrl @ 539 NONAME _ZNK8QWebPage16inputMethodQueryEN2Qt16InputMethodQueryE @ 540 NONAME - _ZNK8QWebPage17fixedContentsSizeEv @ 541 NONAME + _ZNK8QWebPage17fixedContentsSizeEv @ 541 NONAME ABSENT _ZNK8QWebPage17isContentEditableEv @ 542 NONAME _ZNK8QWebPage17supportsExtensionENS_9ExtensionE @ 543 NONAME _ZNK8QWebPage20linkDelegationPolicyEv @ 544 NONAME _ZNK8QWebPage20networkAccessManagerEv @ 545 NONAME - _ZNK8QWebPage20setFixedContentsSizeERK5QSize @ 546 NONAME + _ZNK8QWebPage20setFixedContentsSizeERK5QSize @ 546 NONAME ABSENT _ZNK8QWebPage25forwardUnsupportedContentEv @ 547 NONAME _ZNK8QWebPage4viewEv @ 548 NONAME _ZNK8QWebPage6actionENS_9WebActionE @ 549 NONAME @@ -590,7 +590,7 @@ EXPORTS _ZNK9QWebFrame16scrollBarMinimumEN2Qt11OrientationE @ 589 NONAME _ZNK9QWebFrame17scrollBarGeometryEN2Qt11OrientationE @ 590 NONAME _ZNK9QWebFrame18textSizeMultiplierEv @ 591 NONAME - _ZNK9QWebFrame20clipRenderToViewportEv @ 592 NONAME + _ZNK9QWebFrame20clipRenderToViewportEv @ 592 NONAME ABSENT _ZNK9QWebFrame3posEv @ 593 NONAME _ZNK9QWebFrame3urlEv @ 594 NONAME _ZNK9QWebFrame4iconEv @ 595 NONAME @@ -649,4 +649,33 @@ EXPORTS _ZThn8_N8QWebViewD1Ev @ 648 NONAME _ZlsR11QDataStreamRK11QWebHistory @ 649 NONAME _ZrsR11QDataStreamR11QWebHistory @ 650 NONAME + _Z32qt_drt_whiteListAccessFromOriginRK7QStringS1_S1_b @ 651 NONAME + _Z33qt_drt_counterValueForElementByIdP9QWebFrameRK7QString @ 652 NONAME + _Z34qt_drt_resetOriginAccessWhiteListsv @ 653 NONAME + _ZN11QWebElement17removeAllChildrenEv @ 654 NONAME + _ZN11QWebElement6renderEP8QPainter @ 655 NONAME + _ZN12QWebSettings30setPrintingMaximumShrinkFactorEf @ 656 NONAME + _ZN12QWebSettings30setPrintingMinimumShrinkFactorEf @ 657 NONAME + _ZN16QGraphicsWebView10itemChangeEN13QGraphicsItem18GraphicsItemChangeERK8QVariant @ 658 NONAME + _ZN16QGraphicsWebView12loadFinishedEb @ 659 NONAME + _ZN21QWebElementCollection6appendERKS_ @ 660 NONAME + _ZN21QWebElementCollectionC1ERK11QWebElementRK7QString @ 661 NONAME + _ZN21QWebElementCollectionC1ERKS_ @ 662 NONAME + _ZN21QWebElementCollectionC1Ev @ 663 NONAME + _ZN21QWebElementCollectionC2ERK11QWebElementRK7QString @ 664 NONAME + _ZN21QWebElementCollectionC2ERKS_ @ 665 NONAME + _ZN21QWebElementCollectionC2Ev @ 666 NONAME + _ZN21QWebElementCollectionD1Ev @ 667 NONAME + _ZN21QWebElementCollectionD2Ev @ 668 NONAME + _ZN21QWebElementCollectionaSERKS_ @ 669 NONAME + _ZN9QWebFrame6renderEP8QPainterNS_11RenderLayerERK7QRegion @ 670 NONAME + _ZNK12QWebSettings27printingMaximumShrinkFactorEv @ 671 NONAME + _ZNK12QWebSettings27printingMinimumShrinkFactorEv @ 672 NONAME + _ZNK21QWebElementCollection2atEi @ 673 NONAME + _ZNK21QWebElementCollection5countEv @ 674 NONAME + _ZNK21QWebElementCollection6toListEv @ 675 NONAME + _ZNK21QWebElementCollectionplERKS_ @ 676 NONAME + _ZNK8QWebPage21preferredContentsSizeEv @ 677 NONAME + _ZNK8QWebPage24setPreferredContentsSizeERK5QSize @ 678 NONAME + _ZThn8_N16QGraphicsWebView10itemChangeEN13QGraphicsItem18GraphicsItemChangeERK8QVariant @ 679 NONAME -- cgit v0.12 From dd34feda9c0ec23f3aef6863ce71b15b57aeba7d Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Mon, 9 Nov 2009 16:32:01 +0100 Subject: Fixed handling of stroke-dashoffset in the SVG module. When stroke-dashoffset was set on a solid stroke (stroke-dasharray="none"), the path was not painted. QPen::setDashOffset() automatically sets the pen's style to CustomDashLine, so if there is no dash array, nothing is drawn. The fix is to avoid calling QPen::setDashOffset() when the pen is solid. Task-number: QTBUG-5609 Reviewed-by: Tor Arne --- src/svg/qsvgstyle.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/svg/qsvgstyle.cpp b/src/svg/qsvgstyle.cpp index f834016..57927fd 100644 --- a/src/svg/qsvgstyle.cpp +++ b/src/svg/qsvgstyle.cpp @@ -363,7 +363,10 @@ void QSvgStrokeStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraSt if (m_strokeMiterLimitSet) pen.setMiterLimit(m_stroke.miterLimit()); - if (setDashOffsetNeeded) { + // You can have dash offset on solid strokes in SVG files, but not in Qt. + // QPen::setDashOffset() will set the pen style to Qt::CustomDashLine, + // so don't call the method if the pen is solid. + if (setDashOffsetNeeded && pen.style() != Qt::SolidLine) { qreal currentWidth = pen.widthF(); if (currentWidth == 0) currentWidth = 1; -- cgit v0.12 From 6125645db9ddb8bc614f79961138d5371b8717d6 Mon Sep 17 00:00:00 2001 From: Eskil Abrahamsen Blomfeldt Date: Mon, 9 Nov 2009 18:10:15 +0100 Subject: Add some of my changes to changes-4.6.0 Update changes-4.6.0 with relevant changes. Reviewed-by: Trond --- dist/changes-4.6.0 | 43 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/dist/changes-4.6.0 b/dist/changes-4.6.0 index a42b213..182191b 100644 --- a/dist/changes-4.6.0 +++ b/dist/changes-4.6.0 @@ -191,6 +191,40 @@ QtGui - QWidget * [201649] Added QWidget::previousInFocusChain + - QPlainTextEdit + * Fixed crash when clicking on a text edit which was smaller than the + height of the font used. + + - QPrinter + * [QTBUG-4497] Removed redundant SetPen command in the postscript code + when reusing a QPrinter object. + + - QTextLayout + * [QTBUG-4468] Count tabs as multiple characters when applying a fixed + column width. + * [176401] Take into account the negative right bearing of the last + character in an item of text if the glyph extends beyond its ascent. + + - QTextDocument + * [207189] Support setting font size using short hand syntax in the + CSS "font" property. + * [201228] Remove implicit margin on bullet lists when exporting to + HTML. + * [240086] Fixed bug which caused floating objects which span several + pages to float into the second page of the document even when it's + the only existing object, causing the document to contain a blank + first page. + * [240325] Even when wrap mode is set to Qt::TextWordWrap, the layout + would sometimes break outside word boundaries when floating objects + affected the width available to the text. This has been fixed. + + - QFontEngine + * [QTBUG-2354] Support certain 'Microsoft' platform symbol fonts which + also contain a regular unicode table for exactly the symbol range of + code points. + + - QFontMetrics + * [176401] Account for right bearing in bounding rect. **************************************************************************** * Platform Specific Changes * @@ -231,7 +265,14 @@ QtGui * If Video Mixing Renderer 9 is not available, falls back to software rendering. * Fixed a flicker issue when switching source with a transition time of 0 - + + - [QTBUG-3620] Fixed bug on X11 that caused bitmap fonts to become so small + it was unreadable when printed or presented in a print preview widget. + + - [QTBUG-4445] Fixed bug on Windows that caused problems when printing + text where several characters were represented by a single glyph, e.g. + a double 't' with the Calibri font. + **************************************************************************** * Tools * **************************************************************************** -- cgit v0.12 From 829265b98a6c7c3856f3504e29209bff38c95ce9 Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Tue, 10 Nov 2009 15:23:04 +1000 Subject: Match drop shadow bounding rectangle unit test to the new implementation Reviewed-by: Sarah Smith --- tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp b/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp index a80c787..3f5c3d3 100644 --- a/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp +++ b/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp @@ -390,24 +390,24 @@ void tst_QPixmapFilter::dropShadowBoundingRectFor() const QRectF rect3(2.2, 6.3, 11.4, 47.5); filter.setOffset(QPointF(0,0)); - QCOMPARE(filter.boundingRectFor(rect1), rect1); - QCOMPARE(filter.boundingRectFor(rect2), rect2); - QCOMPARE(filter.boundingRectFor(rect3), rect3); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-2, -2, 2, 2)); filter.setOffset(QPointF(1,1)); QCOMPARE(filter.offset(), QPointF(1, 1)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(0, 0, 1, 1)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(0, 0, 1, 1)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(0, 0, 1, 1)); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-2, -2, 2, 2)); filter.setOffset(QPointF(-1,-1)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-1, -1, 0, 0)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-1, -1, 0, 0)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-1, -1, 0, 0)); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-2, -2, 2, 2)); filter.setBlurRadius(2); filter.setOffset(QPointF(0,0)); - int delta = 2 * 2; + int delta = 2 + 1; QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-delta, -delta, delta, delta)); QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-delta, -delta, delta, delta)); QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta, -delta, delta, delta)); @@ -418,9 +418,9 @@ void tst_QPixmapFilter::dropShadowBoundingRectFor() QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta + 1, -delta + 1, delta + 1, delta + 1)); filter.setOffset(QPointF(-10,-10)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-delta - 10, -delta - 10, 0, 0)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-delta - 10, -delta - 10, 0, 0)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta - 10, -delta - 10, 0, 0)); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-delta - 10, -delta - 10, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-delta - 10, -delta - 10, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta - 10, -delta - 10, 2, 2)); } -- cgit v0.12 From d7c4165a8e3c0a8000b3239e8790cdae7c814637 Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Mon, 9 Nov 2009 17:07:39 +0100 Subject: Removed redundant line of code. Reviewed-by: Simon Hausmann --- src/gui/text/qfontengine_ft.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp index 4041717..293eac7 100644 --- a/src/gui/text/qfontengine_ft.cpp +++ b/src/gui/text/qfontengine_ft.cpp @@ -755,9 +755,8 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyphMetrics(QGlyphSet *set, uint glyph load_flags = FT_LOAD_NO_BITMAP; // apply our matrix to this, but note that the metrics will not be affected by this. - FT_Matrix matrix = freetype->matrix; FT_Face face = lockFace(); - matrix = this->matrix; + FT_Matrix matrix = this->matrix; FT_Matrix_Multiply(&set->transformationMatrix, &matrix); FT_Set_Transform(face, &matrix, 0); freetype->matrix = matrix; -- cgit v0.12 From c05fc777cac9a585567c83508b0e39cc3f86e7f6 Mon Sep 17 00:00:00 2001 From: Eskil Abrahamsen Blomfeldt Date: Tue, 10 Nov 2009 10:59:15 +0100 Subject: Compile QPen does not have a constructor which only takes a single QBrush. Reviewed-by: Gunnar --- src/gui/text/qtextdocumentlayout.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp index 85265af..2604879 100644 --- a/src/gui/text/qtextdocumentlayout.cpp +++ b/src/gui/text/qtextdocumentlayout.cpp @@ -1448,7 +1448,7 @@ void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *p painter->fillRect(r, brush); break; case QTextListFormat::ListCircle: - painter->setPen(QPen(brush)); + painter->setPen(QPen(brush, 0)); painter->drawEllipse(r.translated(0.5, 0.5)); // pixel align for sharper rendering break; case QTextListFormat::ListDisc: -- cgit v0.12 From f42dd78db71c29d288b4a76a2fcfe720335afe1a Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Tue, 10 Nov 2009 11:22:09 +0100 Subject: update def files Reviewed-by: Trust Me --- src/s60installs/bwins/QtCoreu.def | 16 ++++++++++---- src/s60installs/bwins/QtGuiu.def | 44 +++++++++++++++++++++++++++++++++++++-- src/s60installs/eabi/QtCoreu.def | 15 +++++++++---- src/s60installs/eabi/QtGuiu.def | 26 +++++++++++++++++++++++ 4 files changed, 91 insertions(+), 10 deletions(-) diff --git a/src/s60installs/bwins/QtCoreu.def b/src/s60installs/bwins/QtCoreu.def index a787be9..a0d0564 100644 --- a/src/s60installs/bwins/QtCoreu.def +++ b/src/s60installs/bwins/QtCoreu.def @@ -417,7 +417,7 @@ EXPORTS ?setReadChannelMode@QProcess@@QAEXW4ProcessChannelMode@1@@Z @ 416 NONAME ; void QProcess::setReadChannelMode(enum QProcess::ProcessChannelMode) ?d_func@QFactoryLoader@@ABEPBVQFactoryLoaderPrivate@@XZ @ 417 NONAME ; class QFactoryLoaderPrivate const * QFactoryLoader::d_func(void) const ?setEncodedUrl@QUrl@@QAEXABVQByteArray@@W4ParsingMode@1@@Z @ 418 NONAME ; void QUrl::setEncodedUrl(class QByteArray const &, enum QUrl::ParsingMode) - ?insertPauseAt@QSequentialAnimationGroup@@QAEPAVQPauseAnimation@@HH@Z @ 419 NONAME ; class QPauseAnimation * QSequentialAnimationGroup::insertPauseAt(int, int) + ?insertPauseAt@QSequentialAnimationGroup@@QAEPAVQPauseAnimation@@HH@Z @ 419 NONAME ABSENT ; class QPauseAnimation * QSequentialAnimationGroup::insertPauseAt(int, int) ?qt_metacast@QVariantAnimation@@UAEPAXPBD@Z @ 420 NONAME ; void * QVariantAnimation::qt_metacast(char const *) ?insert@QString@@QAEAAV1@HVQChar@@@Z @ 421 NONAME ; class QString & QString::insert(int, class QChar) ??0QTextStreamManipulator@@QAE@P8QTextStream@@AEXH@ZH@Z @ 422 NONAME ; QTextStreamManipulator::QTextStreamManipulator(void (*)(int), int) @@ -1055,7 +1055,7 @@ EXPORTS ?isValid@QRegExp@@QBE_NXZ @ 1054 NONAME ; bool QRegExp::isValid(void) const ?d_func@QState@@ABEPBVQStatePrivate@@XZ @ 1055 NONAME ; class QStatePrivate const * QState::d_func(void) const ??5@YAAAVQDataStream@@AAV0@AAVQLocale@@@Z @ 1056 NONAME ; class QDataStream & operator>>(class QDataStream &, class QLocale &) - ?clearAnimations@QAnimationGroup@@QAEXXZ @ 1057 NONAME ; void QAnimationGroup::clearAnimations(void) + ?clearAnimations@QAnimationGroup@@QAEXXZ @ 1057 NONAME ABSENT ; void QAnimationGroup::clearAnimations(void) ?toFloat@QString@@QBEMPA_N@Z @ 1058 NONAME ; float QString::toFloat(bool *) const ?kill@QProcess@@QAEXXZ @ 1059 NONAME ; void QProcess::kill(void) ?d_func@QResource@@ABEPBVQResourcePrivate@@XZ @ 1060 NONAME ; class QResourcePrivate const * QResource::d_func(void) const @@ -1841,7 +1841,7 @@ EXPORTS ??0QLibrary@@QAE@PAVQObject@@@Z @ 1840 NONAME ; QLibrary::QLibrary(class QObject *) ??0QRect@@QAE@XZ @ 1841 NONAME ; QRect::QRect(void) ?begin@QListData@@QBEPAPAXXZ @ 1842 NONAME ; void * * QListData::begin(void) const - ?takeAnimationAt@QAnimationGroup@@QAEPAVQAbstractAnimation@@H@Z @ 1843 NONAME ; class QAbstractAnimation * QAnimationGroup::takeAnimationAt(int) + ?takeAnimationAt@QAnimationGroup@@QAEPAVQAbstractAnimation@@H@Z @ 1843 NONAME ABSENT ; class QAbstractAnimation * QAnimationGroup::takeAnimationAt(int) ?machine@QAbstractTransitionPrivate@@QBEPAVQStateMachine@@XZ @ 1844 NONAME ; class QStateMachine * QAbstractTransitionPrivate::machine(void) const ?sendPostedEvents@QEventDispatcherSymbian@@AAE_NXZ @ 1845 NONAME ; bool QEventDispatcherSymbian::sendPostedEvents(void) ?eventType@QEventTransition@@QBE?AW4Type@QEvent@@XZ @ 1846 NONAME ; enum QEvent::Type QEventTransition::eventType(void) const @@ -2509,7 +2509,7 @@ EXPORTS ?q_func@QCoreApplicationPrivate@@AAEPAVQCoreApplication@@XZ @ 2508 NONAME ; class QCoreApplication * QCoreApplicationPrivate::q_func(void) ?readyReadStandardError@QProcess@@IAEXXZ @ 2509 NONAME ; void QProcess::readyReadStandardError(void) ?isDetached@QUrl@@QBE_NXZ @ 2510 NONAME ; bool QUrl::isDetached(void) const - ?insertAnimationAt@QAnimationGroup@@QAEXHPAVQAbstractAnimation@@@Z @ 2511 NONAME ; void QAnimationGroup::insertAnimationAt(int, class QAbstractAnimation *) + ?insertAnimationAt@QAnimationGroup@@QAEXHPAVQAbstractAnimation@@@Z @ 2511 NONAME ABSENT ; void QAnimationGroup::insertAnimationAt(int, class QAbstractAnimation *) ??0QFile@@QAE@ABVQString@@PAVQObject@@@Z @ 2512 NONAME ; QFile::QFile(class QString const &, class QObject *) ??6QDebug@@QAEAAV0@ABVQStringRef@@@Z @ 2513 NONAME ; class QDebug & QDebug::operator<<(class QStringRef const &) ?setLoadHints@QLibrary@@QAEXV?$QFlags@W4LoadHint@QLibrary@@@@@Z @ 2514 NONAME ; void QLibrary::setLoadHints(class QFlags) @@ -4388,4 +4388,12 @@ EXPORTS ?propertiesAssigned@QState@@IAEXXZ @ 4387 NONAME ; void QState::propertiesAssigned(void) ?qShapeItem@@YAEPAUHB_ShaperItem_@@@Z @ 4388 NONAME ; unsigned char qShapeItem(struct HB_ShaperItem_ *) ?setAnimated@QStateMachine@@QAEX_N@Z @ 4389 NONAME ; void QStateMachine::setAnimated(bool) + ?clear@QAnimationGroup@@QAEXXZ @ 4390 NONAME ; void QAnimationGroup::clear(void) + ?convertFromAscii@QAbstractConcatenable@@KAXDAAPAVQChar@@@Z @ 4391 NONAME ; void QAbstractConcatenable::convertFromAscii(char, class QChar * &) + ?convertFromAscii@QAbstractConcatenable@@KAXPBDHAAPAVQChar@@@Z @ 4392 NONAME ; void QAbstractConcatenable::convertFromAscii(char const *, int, class QChar * &) + ?currentLoopTime@QAbstractAnimation@@QBEHXZ @ 4393 NONAME ; int QAbstractAnimation::currentLoopTime(void) const + ?insertAnimation@QAnimationGroup@@QAEXHPAVQAbstractAnimation@@@Z @ 4394 NONAME ; void QAnimationGroup::insertAnimation(int, class QAbstractAnimation *) + ?insertPause@QSequentialAnimationGroup@@QAEPAVQPauseAnimation@@HH@Z @ 4395 NONAME ; class QPauseAnimation * QSequentialAnimationGroup::insertPause(int, int) + ?setPaused@QAbstractAnimation@@QAEX_N@Z @ 4396 NONAME ; void QAbstractAnimation::setPaused(bool) + ?takeAnimation@QAnimationGroup@@QAEPAVQAbstractAnimation@@H@Z @ 4397 NONAME ; class QAbstractAnimation * QAnimationGroup::takeAnimation(int) diff --git a/src/s60installs/bwins/QtGuiu.def b/src/s60installs/bwins/QtGuiu.def index 2728210..445018a 100644 --- a/src/s60installs/bwins/QtGuiu.def +++ b/src/s60installs/bwins/QtGuiu.def @@ -11870,7 +11870,7 @@ EXPORTS ?setCornerWidget@QMenuBar@@QAEXPAVQWidget@@W4Corner@Qt@@@Z @ 11869 NONAME ; void QMenuBar::setCornerWidget(class QWidget *, enum Qt::Corner) ?background@QTreeWidgetItem@@QBE?AVQBrush@@H@Z @ 11870 NONAME ; class QBrush QTreeWidgetItem::background(int) const ?getStaticMetaObject@QLabel@@SAABUQMetaObject@@XZ @ 11871 NONAME ; struct QMetaObject const & QLabel::getStaticMetaObject(void) - ?process@QPaintEngineExReplayer@@QAEXABUQPaintBufferCommand@@@Z @ 11872 NONAME ; void QPaintEngineExReplayer::process(struct QPaintBufferCommand const &) + ?process@QPaintEngineExReplayer@@QAEXABUQPaintBufferCommand@@@Z @ 11872 NONAME ABSENT ; void QPaintEngineExReplayer::process(struct QPaintBufferCommand const &) ?trUtf8@QWizard@@SA?AVQString@@PBD0H@Z @ 11873 NONAME ; class QString QWizard::trUtf8(char const *, char const *, int) ?mousePressEvent@QMenuBar@@MAEXPAVQMouseEvent@@@Z @ 11874 NONAME ; void QMenuBar::mousePressEvent(class QMouseEvent *) ?resolveSymlinks@QFileSystemModel@@QBE_NXZ @ 11875 NONAME ; bool QFileSystemModel::resolveSymlinks(void) const @@ -12231,7 +12231,7 @@ EXPORTS ?setPicture@QPictureIO@@QAEXABVQPicture@@@Z @ 12230 NONAME ; void QPictureIO::setPicture(class QPicture const &) ?metaObject@QAbstractProxyModel@@UBEPBUQMetaObject@@XZ @ 12231 NONAME ; struct QMetaObject const * QAbstractProxyModel::metaObject(void) const ?brush@QPainter@@QBEABVQBrush@@XZ @ 12232 NONAME ; class QBrush const & QPainter::brush(void) const - ?process@QPainterReplayer@@QAEXABUQPaintBufferCommand@@@Z @ 12233 NONAME ; void QPainterReplayer::process(struct QPaintBufferCommand const &) + ?process@QPainterReplayer@@QAEXABUQPaintBufferCommand@@@Z @ 12233 NONAME ABSENT ; void QPainterReplayer::process(struct QPaintBufferCommand const &) ?staticMetaObject@QAbstractItemView@@2UQMetaObject@@B @ 12234 NONAME ; struct QMetaObject const QAbstractItemView::staticMetaObject ?createRecursively@QWidgetPrivate@@QAEXXZ @ 12235 NONAME ; void QWidgetPrivate::createRecursively(void) ?drawLines@QPaintEngineEx@@UAEXPBVQLine@@H@Z @ 12236 NONAME ; void QPaintEngineEx::drawLines(class QLine const *, int) @@ -12631,4 +12631,44 @@ EXPORTS ?translate@QMatrix4x4@@QAEXMMM@Z @ 12630 NONAME ; void QMatrix4x4::translate(float, float, float) ?ungrabGesture@QGraphicsObject@@QAEXW4GestureType@Qt@@@Z @ 12631 NONAME ; void QGraphicsObject::ungrabGesture(enum Qt::GestureType) ?unregisterRecognizer@QGestureRecognizer@@SAXW4GestureType@Qt@@@Z @ 12632 NONAME ; void QGestureRecognizer::unregisterRecognizer(enum Qt::GestureType) + ??0QFileOpenEvent@@QAE@ABVQUrl@@@Z @ 12633 NONAME ; QFileOpenEvent::QFileOpenEvent(class QUrl const &) + ??0QTapAndHoldGesture@@QAE@PAVQObject@@@Z @ 12634 NONAME ; QTapAndHoldGesture::QTapAndHoldGesture(class QObject *) + ??0QTapGesture@@QAE@PAVQObject@@@Z @ 12635 NONAME ; QTapGesture::QTapGesture(class QObject *) + ??1QTapAndHoldGesture@@UAE@XZ @ 12636 NONAME ; QTapAndHoldGesture::~QTapAndHoldGesture(void) + ??1QTapGesture@@UAE@XZ @ 12637 NONAME ; QTapGesture::~QTapGesture(void) + ??_EQTapAndHoldGesture@@UAE@I@Z @ 12638 NONAME ; QTapAndHoldGesture::~QTapAndHoldGesture(unsigned int) + ??_EQTapGesture@@UAE@I@Z @ 12639 NONAME ; QTapGesture::~QTapGesture(unsigned int) + ?d_func@QPaintBuffer@@AAEPAVQPaintBufferPrivate@@XZ @ 12640 NONAME ; class QPaintBufferPrivate * QPaintBuffer::d_func(void) + ?d_func@QPaintBuffer@@ABEPBVQPaintBufferPrivate@@XZ @ 12641 NONAME ; class QPaintBufferPrivate const * QPaintBuffer::d_func(void) const + ?d_func@QTapAndHoldGesture@@AAEPAVQTapAndHoldGesturePrivate@@XZ @ 12642 NONAME ; class QTapAndHoldGesturePrivate * QTapAndHoldGesture::d_func(void) + ?d_func@QTapAndHoldGesture@@ABEPBVQTapAndHoldGesturePrivate@@XZ @ 12643 NONAME ; class QTapAndHoldGesturePrivate const * QTapAndHoldGesture::d_func(void) const + ?d_func@QTapGesture@@AAEPAVQTapGesturePrivate@@XZ @ 12644 NONAME ; class QTapGesturePrivate * QTapGesture::d_func(void) + ?d_func@QTapGesture@@ABEPBVQTapGesturePrivate@@XZ @ 12645 NONAME ; class QTapGesturePrivate const * QTapGesture::d_func(void) const + ?getStaticMetaObject@QTapAndHoldGesture@@SAABUQMetaObject@@XZ @ 12646 NONAME ; struct QMetaObject const & QTapAndHoldGesture::getStaticMetaObject(void) + ?getStaticMetaObject@QTapGesture@@SAABUQMetaObject@@XZ @ 12647 NONAME ; struct QMetaObject const & QTapGesture::getStaticMetaObject(void) + ?metaObject@QTapAndHoldGesture@@UBEPBUQMetaObject@@XZ @ 12648 NONAME ; struct QMetaObject const * QTapAndHoldGesture::metaObject(void) const + ?metaObject@QTapGesture@@UBEPBUQMetaObject@@XZ @ 12649 NONAME ; struct QMetaObject const * QTapGesture::metaObject(void) const + ?position@QTapAndHoldGesture@@QBE?AVQPointF@@XZ @ 12650 NONAME ; class QPointF QTapAndHoldGesture::position(void) const + ?position@QTapGesture@@QBE?AVQPointF@@XZ @ 12651 NONAME ; class QPointF QTapGesture::position(void) const + ?process@QPaintEngineExReplayer@@UAEXABUQPaintBufferCommand@@@Z @ 12652 NONAME ; void QPaintEngineExReplayer::process(struct QPaintBufferCommand const &) + ?process@QPainterReplayer@@UAEXABUQPaintBufferCommand@@@Z @ 12653 NONAME ; void QPainterReplayer::process(struct QPaintBufferCommand const &) + ?qt_metacall@QTapAndHoldGesture@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 12654 NONAME ; int QTapAndHoldGesture::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacall@QTapGesture@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 12655 NONAME ; int QTapGesture::qt_metacall(enum QMetaObject::Call, int, void * *) + ?qt_metacast@QTapAndHoldGesture@@UAEPAXPBD@Z @ 12656 NONAME ; void * QTapAndHoldGesture::qt_metacast(char const *) + ?qt_metacast@QTapGesture@@UAEPAXPBD@Z @ 12657 NONAME ; void * QTapGesture::qt_metacast(char const *) + ?sendScenePosChange@QGraphicsItemPrivate@@QAEXXZ @ 12658 NONAME ; void QGraphicsItemPrivate::sendScenePosChange(void) + ?setPosition@QTapAndHoldGesture@@QAEXABVQPointF@@@Z @ 12659 NONAME ; void QTapAndHoldGesture::setPosition(class QPointF const &) + ?setPosition@QTapGesture@@QAEXABVQPointF@@@Z @ 12660 NONAME ; void QTapGesture::setPosition(class QPointF const &) + ?siblingOrderChange@QGraphicsItemPrivate@@UAEXXZ @ 12661 NONAME ; void QGraphicsItemPrivate::siblingOrderChange(void) + ?tr@QTapAndHoldGesture@@SA?AVQString@@PBD0@Z @ 12662 NONAME ; class QString QTapAndHoldGesture::tr(char const *, char const *) + ?tr@QTapAndHoldGesture@@SA?AVQString@@PBD0H@Z @ 12663 NONAME ; class QString QTapAndHoldGesture::tr(char const *, char const *, int) + ?tr@QTapGesture@@SA?AVQString@@PBD0@Z @ 12664 NONAME ; class QString QTapGesture::tr(char const *, char const *) + ?tr@QTapGesture@@SA?AVQString@@PBD0H@Z @ 12665 NONAME ; class QString QTapGesture::tr(char const *, char const *, int) + ?trUtf8@QTapAndHoldGesture@@SA?AVQString@@PBD0@Z @ 12666 NONAME ; class QString QTapAndHoldGesture::trUtf8(char const *, char const *) + ?trUtf8@QTapAndHoldGesture@@SA?AVQString@@PBD0H@Z @ 12667 NONAME ; class QString QTapAndHoldGesture::trUtf8(char const *, char const *, int) + ?trUtf8@QTapGesture@@SA?AVQString@@PBD0@Z @ 12668 NONAME ; class QString QTapGesture::trUtf8(char const *, char const *) + ?trUtf8@QTapGesture@@SA?AVQString@@PBD0H@Z @ 12669 NONAME ; class QString QTapGesture::trUtf8(char const *, char const *, int) + ?url@QFileOpenEvent@@QBE?AVQUrl@@XZ @ 12670 NONAME ; class QUrl QFileOpenEvent::url(void) const + ?staticMetaObject@QTapGesture@@2UQMetaObject@@B @ 12671 NONAME ; struct QMetaObject const QTapGesture::staticMetaObject + ?staticMetaObject@QTapAndHoldGesture@@2UQMetaObject@@B @ 12672 NONAME ; struct QMetaObject const QTapAndHoldGesture::staticMetaObject diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index 2fd8d0c..a8149bb 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -694,11 +694,11 @@ EXPORTS _ZN15QAnimationGroup11qt_metacallEN11QMetaObject4CallEiPPv @ 693 NONAME _ZN15QAnimationGroup11qt_metacastEPKc @ 694 NONAME _ZN15QAnimationGroup12addAnimationEP18QAbstractAnimation @ 695 NONAME - _ZN15QAnimationGroup15clearAnimationsEv @ 696 NONAME + _ZN15QAnimationGroup15clearAnimationsEv @ 696 NONAME ABSENT _ZN15QAnimationGroup15removeAnimationEP18QAbstractAnimation @ 697 NONAME - _ZN15QAnimationGroup15takeAnimationAtEi @ 698 NONAME + _ZN15QAnimationGroup15takeAnimationAtEi @ 698 NONAME ABSENT _ZN15QAnimationGroup16staticMetaObjectE @ 699 NONAME DATA 16 - _ZN15QAnimationGroup17insertAnimationAtEiP18QAbstractAnimation @ 700 NONAME + _ZN15QAnimationGroup17insertAnimationAtEiP18QAbstractAnimation @ 700 NONAME ABSENT _ZN15QAnimationGroup19getStaticMetaObjectEv @ 701 NONAME _ZN15QAnimationGroup5eventEP6QEvent @ 702 NONAME _ZN15QAnimationGroupC2EP7QObject @ 703 NONAME @@ -1376,7 +1376,7 @@ EXPORTS _ZN25QSequentialAnimationGroup11qt_metacallEN11QMetaObject4CallEiPPv @ 1375 NONAME _ZN25QSequentialAnimationGroup11qt_metacastEPKc @ 1376 NONAME _ZN25QSequentialAnimationGroup11updateStateEN18QAbstractAnimation5StateES1_ @ 1377 NONAME - _ZN25QSequentialAnimationGroup13insertPauseAtEii @ 1378 NONAME + _ZN25QSequentialAnimationGroup13insertPauseAtEii @ 1378 NONAME ABSENT _ZN25QSequentialAnimationGroup15updateDirectionEN18QAbstractAnimation9DirectionE @ 1379 NONAME _ZN25QSequentialAnimationGroup16staticMetaObjectE @ 1380 NONAME DATA 16 _ZN25QSequentialAnimationGroup17updateCurrentTimeEi @ 1381 NONAME @@ -3611,4 +3611,11 @@ EXPORTS _ZN15QBasicAtomicInt25isReferenceCountingNativeEv @ 3610 NONAME _ZN6QState18propertiesAssignedEv @ 3611 NONAME _ZNK13QStateMachine10isAnimatedEv @ 3612 NONAME + _ZN15QAnimationGroup13takeAnimationEi @ 3613 NONAME + _ZN15QAnimationGroup15insertAnimationEiP18QAbstractAnimation @ 3614 NONAME + _ZN15QAnimationGroup5clearEv @ 3615 NONAME + _ZN18QAbstractAnimation9setPausedEb @ 3616 NONAME + _ZN21QAbstractConcatenable16convertFromAsciiEPKciRP5QChar @ 3617 NONAME + _ZN25QSequentialAnimationGroup11insertPauseEii @ 3618 NONAME + _ZNK18QAbstractAnimation15currentLoopTimeEv @ 3619 NONAME diff --git a/src/s60installs/eabi/QtGuiu.def b/src/s60installs/eabi/QtGuiu.def index 9ea9361..d5f1c7e 100644 --- a/src/s60installs/eabi/QtGuiu.def +++ b/src/s60installs/eabi/QtGuiu.def @@ -11689,4 +11689,30 @@ EXPORTS _ZNK19QKeyEventTransition12modifierMaskEv @ 11688 NONAME _ZNK21QMouseEventTransition11hitTestPathEv @ 11689 NONAME _ZNK21QMouseEventTransition12modifierMaskEv @ 11690 NONAME + _ZN11QTapGesture11qt_metacallEN11QMetaObject4CallEiPPv @ 11691 NONAME + _ZN11QTapGesture11qt_metacastEPKc @ 11692 NONAME + _ZN11QTapGesture11setPositionERK7QPointF @ 11693 NONAME + _ZN11QTapGesture16staticMetaObjectE @ 11694 NONAME DATA 16 + _ZN11QTapGesture19getStaticMetaObjectEv @ 11695 NONAME + _ZN11QTapGestureC1EP7QObject @ 11696 NONAME + _ZN11QTapGestureC2EP7QObject @ 11697 NONAME + _ZN14QFileOpenEventC1ERK4QUrl @ 11698 NONAME + _ZN14QFileOpenEventC2ERK4QUrl @ 11699 NONAME + _ZN18QTapAndHoldGesture11qt_metacallEN11QMetaObject4CallEiPPv @ 11700 NONAME + _ZN18QTapAndHoldGesture11qt_metacastEPKc @ 11701 NONAME + _ZN18QTapAndHoldGesture11setPositionERK7QPointF @ 11702 NONAME + _ZN18QTapAndHoldGesture16staticMetaObjectE @ 11703 NONAME DATA 16 + _ZN18QTapAndHoldGesture19getStaticMetaObjectEv @ 11704 NONAME + _ZN18QTapAndHoldGestureC1EP7QObject @ 11705 NONAME + _ZN18QTapAndHoldGestureC2EP7QObject @ 11706 NONAME + _ZN20QGraphicsItemPrivate18siblingOrderChangeEv @ 11707 NONAME + _ZNK11QTapGesture10metaObjectEv @ 11708 NONAME + _ZNK11QTapGesture8positionEv @ 11709 NONAME + _ZNK14QFileOpenEvent3urlEv @ 11710 NONAME + _ZNK18QTapAndHoldGesture10metaObjectEv @ 11711 NONAME + _ZNK18QTapAndHoldGesture8positionEv @ 11712 NONAME + _ZTI11QTapGesture @ 11713 NONAME + _ZTI18QTapAndHoldGesture @ 11714 NONAME + _ZTV11QTapGesture @ 11715 NONAME + _ZTV18QTapAndHoldGesture @ 11716 NONAME -- cgit v0.12 From 82e78e6797a99ffba279247731d43915d69890a4 Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Mon, 9 Nov 2009 10:41:30 +0100 Subject: Fixed QPixmapDropShadowFilter and updated its testcase Reivewed-by: Samuel --- src/gui/image/qpixmapfilter.cpp | 4 +--- tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp index de8f4e0..650aeaa 100644 --- a/src/gui/image/qpixmapfilter.cpp +++ b/src/gui/image/qpixmapfilter.cpp @@ -1064,9 +1064,7 @@ void QPixmapDropShadowFilter::setOffset(const QPointF &offset) QRectF QPixmapDropShadowFilter::boundingRectFor(const QRectF &rect) const { Q_D(const QPixmapDropShadowFilter); - qreal delta = d->radius + 1; - return rect.adjusted(-2, -2, 2, 2).united( - rect.translated(d->offset).adjusted(-delta, -delta, delta, delta)); + return rect.united(rect.translated(d->offset).adjusted(-d->radius, -d->radius, d->radius, d->radius)); } /*! diff --git a/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp b/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp index 3f5c3d3..b9c6b01 100644 --- a/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp +++ b/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp @@ -407,7 +407,7 @@ void tst_QPixmapFilter::dropShadowBoundingRectFor() filter.setBlurRadius(2); filter.setOffset(QPointF(0,0)); - int delta = 2 + 1; + qreal delta = 2; QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-delta, -delta, delta, delta)); QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-delta, -delta, delta, delta)); QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta, -delta, delta, delta)); -- cgit v0.12 From e35d08343032ca366541de2a892f36dfc266b0da Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Tue, 10 Nov 2009 09:38:40 +0100 Subject: Use a non-cosmetic 1-width pen in example to match graphicsview specs Reviewed-by: Samuel --- examples/effects/lighting/lighting.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/effects/lighting/lighting.cpp b/examples/effects/lighting/lighting.cpp index 7026b66..51fa9f8 100644 --- a/examples/effects/lighting/lighting.cpp +++ b/examples/effects/lighting/lighting.cpp @@ -94,7 +94,7 @@ void Lighting::setupScene() else item = new QGraphicsRectItem(0, 0, 50, 50); - item->setPen(QPen(Qt::black)); + item->setPen(QPen(Qt::black, 1)); item->setBrush(QBrush(Qt::white)); QGraphicsDropShadowEffect *effect = new QGraphicsDropShadowEffect; effect->setBlurRadius(8); -- cgit v0.12 From 1340c2ff7d395b0da0749506eee70510ef1e0a15 Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Tue, 10 Nov 2009 12:08:31 +0100 Subject: Fixed drop shadows for opengl graphics system Reviewed-by: Samuel --- src/opengl/qglpixmapfilter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/opengl/qglpixmapfilter.cpp b/src/opengl/qglpixmapfilter.cpp index 0eaab28..e171a21 100644 --- a/src/opengl/qglpixmapfilter.cpp +++ b/src/opengl/qglpixmapfilter.cpp @@ -989,7 +989,7 @@ bool QGLPixmapDropShadowFilter::processGL(QPainter *painter, const QPointF &pos, // ensure GL_LINEAR filtering is used painter->setRenderHint(QPainter::SmoothPixmapTransform); filter->setOnPainter(painter); - engine->drawTexture(targetRect, fbo->texture(), fbo->size(), src.rect().translated(0, fbo->height() - src.height())); + engine->drawTexture(targetRect, fbo->texture(), fbo->size(), QRectF(0, fbo->height() - targetRect.height(), targetRect.width(), targetRect.height())); filter->removeFromPainter(painter); painter->restore(); -- cgit v0.12 From e2e8104c03608ef753f84740bdf6ac1bff18be84 Mon Sep 17 00:00:00 2001 From: Gunnar Sletta Date: Tue, 10 Nov 2009 13:13:24 +0100 Subject: Fixed tst_qpixmapfilter testcase Reviewed-by: Samuel --- tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp b/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp index b9c6b01..751c7dc 100644 --- a/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp +++ b/tests/auto/qpixmapfilter/tst_qpixmapfilter.cpp @@ -390,20 +390,20 @@ void tst_QPixmapFilter::dropShadowBoundingRectFor() const QRectF rect3(2.2, 6.3, 11.4, 47.5); filter.setOffset(QPointF(0,0)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-2, -2, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-2, -2, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect1), rect1); + QCOMPARE(filter.boundingRectFor(rect2), rect2); + QCOMPARE(filter.boundingRectFor(rect3), rect3); filter.setOffset(QPointF(1,1)); QCOMPARE(filter.offset(), QPointF(1, 1)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-2, -2, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-2, -2, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(0, 0, 1, 1)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(0, 0, 1, 1)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(0, 0, 1, 1)); filter.setOffset(QPointF(-1,-1)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-2, -2, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-2, -2, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-2, -2, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-1, -1, 0, 0)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-1, -1, 0, 0)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-1, -1, 0, 0)); filter.setBlurRadius(2); filter.setOffset(QPointF(0,0)); @@ -418,9 +418,9 @@ void tst_QPixmapFilter::dropShadowBoundingRectFor() QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta + 1, -delta + 1, delta + 1, delta + 1)); filter.setOffset(QPointF(-10,-10)); - QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-delta - 10, -delta - 10, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-delta - 10, -delta - 10, 2, 2)); - QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta - 10, -delta - 10, 2, 2)); + QCOMPARE(filter.boundingRectFor(rect1), rect1.adjusted(-delta - 10, -delta - 10, 0, 0)); + QCOMPARE(filter.boundingRectFor(rect2), rect2.adjusted(-delta - 10, -delta - 10, 0, 0)); + QCOMPARE(filter.boundingRectFor(rect3), rect3.adjusted(-delta - 10, -delta - 10, 0, 0)); } -- cgit v0.12 From 9a7140a6788effee2737b593f8cd3edc807beac3 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Tue, 10 Nov 2009 13:39:48 +0100 Subject: Merge 4.6 from main repo and freeze def files Reviewed-by: Trust Me --- src/s60installs/bwins/QtCoreu.def | 1 + src/s60installs/bwins/QtGuiu.def | 14 ++++++++++++++ src/s60installs/bwins/QtMultimediau.def | 26 +++++++++++++++++-------- src/s60installs/bwins/QtScriptu.def | 28 +++++++++++++++++++++++++++ src/s60installs/bwins/QtWebKitu.def | 33 ++++++++++++++++++++++---------- src/s60installs/eabi/QtCoreu.def | 1 + src/s60installs/eabi/QtGuiu.def | 11 +++++++++++ src/s60installs/eabi/QtMultimediau.def | 20 +++++++++++++------ src/s60installs/eabi/QtScriptu.def | 34 +++++++++++++++++++++++++++++++++ src/s60installs/eabi/QtWebKitu.def | 31 ++++++++++++++++++++---------- 10 files changed, 165 insertions(+), 34 deletions(-) diff --git a/src/s60installs/bwins/QtCoreu.def b/src/s60installs/bwins/QtCoreu.def index a0d0564..8495ff1 100644 --- a/src/s60installs/bwins/QtCoreu.def +++ b/src/s60installs/bwins/QtCoreu.def @@ -4396,4 +4396,5 @@ EXPORTS ?insertPause@QSequentialAnimationGroup@@QAEPAVQPauseAnimation@@HH@Z @ 4395 NONAME ; class QPauseAnimation * QSequentialAnimationGroup::insertPause(int, int) ?setPaused@QAbstractAnimation@@QAEX_N@Z @ 4396 NONAME ; void QAbstractAnimation::setPaused(bool) ?takeAnimation@QAnimationGroup@@QAEPAVQAbstractAnimation@@H@Z @ 4397 NONAME ; class QAbstractAnimation * QAnimationGroup::takeAnimation(int) + ?captureCount@QRegExp@@QBEHXZ @ 4398 NONAME ; int QRegExp::captureCount(void) const diff --git a/src/s60installs/bwins/QtGuiu.def b/src/s60installs/bwins/QtGuiu.def index 445018a..3fd4940 100644 --- a/src/s60installs/bwins/QtGuiu.def +++ b/src/s60installs/bwins/QtGuiu.def @@ -12671,4 +12671,18 @@ EXPORTS ?url@QFileOpenEvent@@QBE?AVQUrl@@XZ @ 12670 NONAME ; class QUrl QFileOpenEvent::url(void) const ?staticMetaObject@QTapGesture@@2UQMetaObject@@B @ 12671 NONAME ; struct QMetaObject const QTapGesture::staticMetaObject ?staticMetaObject@QTapAndHoldGesture@@2UQMetaObject@@B @ 12672 NONAME ; struct QMetaObject const QTapAndHoldGesture::staticMetaObject + ?byteCount@QImage@@QBEHXZ @ 12673 NONAME ; int QImage::byteCount(void) const + ?colorCount@QImage@@QBEHXZ @ 12674 NONAME ; int QImage::colorCount(void) const + ?colorCount@QPaintDevice@@QBEHXZ @ 12675 NONAME ; int QPaintDevice::colorCount(void) const + ?colorCount@QPixmapData@@QBEHXZ @ 12676 NONAME ; int QPixmapData::colorCount(void) const + ?contentsMargins@QLayout@@QBE?AVQMargins@@XZ @ 12677 NONAME ; class QMargins QLayout::contentsMargins(void) const + ?determinant@QMatrix@@QBEMXZ @ 12678 NONAME ; float QMatrix::determinant(void) const + ?digitCount@QLCDNumber@@QBEHXZ @ 12679 NONAME ; int QLCDNumber::digitCount(void) const + ?rectCount@QRegion@@QBEHXZ @ 12680 NONAME ; int QRegion::rectCount(void) const + ?setColorCount@QImage@@QAEXH@Z @ 12681 NONAME ; void QImage::setColorCount(int) + ?setContentsMargins@QLayout@@QAEXABVQMargins@@@Z @ 12682 NONAME ; void QLayout::setContentsMargins(class QMargins const &) + ?setDigitCount@QLCDNumber@@QAEXH@Z @ 12683 NONAME ; void QLCDNumber::setDigitCount(int) + ?setTextMargins@QLineEdit@@QAEXABVQMargins@@@Z @ 12684 NONAME ; void QLineEdit::setTextMargins(class QMargins const &) + ?setViewportMargins@QAbstractScrollArea@@IAEXABVQMargins@@@Z @ 12685 NONAME ; void QAbstractScrollArea::setViewportMargins(class QMargins const &) + ?textMargins@QLineEdit@@QBE?AVQMargins@@XZ @ 12686 NONAME ; class QMargins QLineEdit::textMargins(void) const diff --git a/src/s60installs/bwins/QtMultimediau.def b/src/s60installs/bwins/QtMultimediau.def index 98913c7..5d0beb7 100644 --- a/src/s60installs/bwins/QtMultimediau.def +++ b/src/s60installs/bwins/QtMultimediau.def @@ -1,7 +1,7 @@ EXPORTS ?format@QAudioInput@@QBE?AVQAudioFormat@@XZ @ 1 NONAME ; class QAudioFormat QAudioInput::format(void) const ??9QAudioFormat@@QBE_NABV0@@Z @ 2 NONAME ; bool QAudioFormat::operator!=(class QAudioFormat const &) const - ?totalTime@QAudioInput@@QBE_JXZ @ 3 NONAME ; long long QAudioInput::totalTime(void) const + ?totalTime@QAudioInput@@QBE_JXZ @ 3 NONAME ABSENT ; long long QAudioInput::totalTime(void) const ?tr@QAudioEnginePlugin@@SA?AVQString@@PBD0@Z @ 4 NONAME ; class QString QAudioEnginePlugin::tr(char const *, char const *) ?isMapped@QVideoFrame@@QBE_NXZ @ 5 NONAME ; bool QVideoFrame::isMapped(void) const ?staticMetaObject@QAudioInput@@2UQMetaObject@@B @ 6 NONAME ; struct QMetaObject const QAudioInput::staticMetaObject @@ -21,8 +21,8 @@ EXPORTS ?state@QAudioOutput@@QBE?AW4State@QAudio@@XZ @ 20 NONAME ; enum QAudio::State QAudioOutput::state(void) const ?qt_metacall@QAbstractAudioDeviceInfo@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 21 NONAME ; int QAbstractAudioDeviceInfo::qt_metacall(enum QMetaObject::Call, int, void * *) ?deviceName@QAudioDeviceInfo@@QBE?AVQString@@XZ @ 22 NONAME ; class QString QAudioDeviceInfo::deviceName(void) const - ?start@QAudioOutput@@QAEPAVQIODevice@@PAV2@@Z @ 23 NONAME ; class QIODevice * QAudioOutput::start(class QIODevice *) - ?start@QAudioInput@@QAEPAVQIODevice@@PAV2@@Z @ 24 NONAME ; class QIODevice * QAudioInput::start(class QIODevice *) + ?start@QAudioOutput@@QAEPAVQIODevice@@PAV2@@Z @ 23 NONAME ABSENT ; class QIODevice * QAudioOutput::start(class QIODevice *) + ?start@QAudioInput@@QAEPAVQIODevice@@PAV2@@Z @ 24 NONAME ABSENT ; class QIODevice * QAudioInput::start(class QIODevice *) ?setBufferSize@QAudioOutput@@QAEXH@Z @ 25 NONAME ; void QAudioOutput::setBufferSize(int) ??6@YA?AVQDebug@@V0@ABVQVideoSurfaceFormat@@@Z @ 26 NONAME ; class QDebug operator<<(class QDebug, class QVideoSurfaceFormat const &) ??_EQAbstractVideoSurface@@UAE@I@Z @ 27 NONAME ; QAbstractVideoSurface::~QAbstractVideoSurface(unsigned int) @@ -70,9 +70,9 @@ EXPORTS ?qt_metacast@QAbstractAudioDeviceInfo@@UAEPAXPBD@Z @ 69 NONAME ; void * QAbstractAudioDeviceInfo::qt_metacast(char const *) ?staticMetaObject@QAudioEnginePlugin@@2UQMetaObject@@B @ 70 NONAME ; struct QMetaObject const QAudioEnginePlugin::staticMetaObject ??_EQAudioInput@@UAE@I@Z @ 71 NONAME ; QAudioInput::~QAudioInput(unsigned int) - ?clock@QAudioInput@@QBE_JXZ @ 72 NONAME ; long long QAudioInput::clock(void) const + ?clock@QAudioInput@@QBE_JXZ @ 72 NONAME ABSENT ; long long QAudioInput::clock(void) const ?setPixelAspectRatio@QVideoSurfaceFormat@@QAEXABVQSize@@@Z @ 73 NONAME ; void QVideoSurfaceFormat::setPixelAspectRatio(class QSize const &) - ?isNull@QAudioFormat@@QBE_NXZ @ 74 NONAME ; bool QAudioFormat::isNull(void) const + ?isNull@QAudioFormat@@QBE_NXZ @ 74 NONAME ABSENT ; bool QAudioFormat::isNull(void) const ?supportedChannels@QAudioDeviceInfo@@QBE?AV?$QList@H@@XZ @ 75 NONAME ; class QList QAudioDeviceInfo::supportedChannels(void) const ?getStaticMetaObject@QAudioOutput@@SAABUQMetaObject@@XZ @ 76 NONAME ; struct QMetaObject const & QAudioOutput::getStaticMetaObject(void) ?stateChanged@QAbstractAudioOutput@@IAEXW4State@QAudio@@@Z @ 77 NONAME ; void QAbstractAudioOutput::stateChanged(enum QAudio::State) @@ -126,7 +126,7 @@ EXPORTS ?isValid@QVideoFrame@@QBE_NXZ @ 125 NONAME ; bool QVideoFrame::isValid(void) const ??4QAudioFormat@@QAEAAV0@ABV0@@Z @ 126 NONAME ; class QAudioFormat & QAudioFormat::operator=(class QAudioFormat const &) ?isReadable@QVideoFrame@@QBE_NXZ @ 127 NONAME ; bool QVideoFrame::isReadable(void) const - ?totalTime@QAudioOutput@@QBE_JXZ @ 128 NONAME ; long long QAudioOutput::totalTime(void) const + ?totalTime@QAudioOutput@@QBE_JXZ @ 128 NONAME ABSENT ; long long QAudioOutput::totalTime(void) const ?qt_metacall@QAbstractAudioOutput@@UAEHW4Call@QMetaObject@@HPAPAX@Z @ 129 NONAME ; int QAbstractAudioOutput::qt_metacall(enum QMetaObject::Call, int, void * *) ??0QAudioOutput@@QAE@ABVQAudioDeviceInfo@@ABVQAudioFormat@@PAVQObject@@@Z @ 130 NONAME ; QAudioOutput::QAudioOutput(class QAudioDeviceInfo const &, class QAudioFormat const &, class QObject *) ??0QAudioInput@@QAE@ABVQAudioDeviceInfo@@ABVQAudioFormat@@PAVQObject@@@Z @ 131 NONAME ; QAudioInput::QAudioInput(class QAudioDeviceInfo const &, class QAudioFormat const &, class QObject *) @@ -136,10 +136,10 @@ EXPORTS ??0QAudioDeviceInfo@@QAE@XZ @ 135 NONAME ; QAudioDeviceInfo::QAudioDeviceInfo(void) ?setCodec@QAudioFormat@@QAEXABVQString@@@Z @ 136 NONAME ; void QAudioFormat::setCodec(class QString const &) ?tr@QAudioEnginePlugin@@SA?AVQString@@PBD0H@Z @ 137 NONAME ; class QString QAudioEnginePlugin::tr(char const *, char const *, int) - ?deviceList@QAudioDeviceInfo@@SA?AV?$QList@VQAudioDeviceInfo@@@@W4Mode@QAudio@@@Z @ 138 NONAME ; class QList QAudioDeviceInfo::deviceList(enum QAudio::Mode) + ?deviceList@QAudioDeviceInfo@@SA?AV?$QList@VQAudioDeviceInfo@@@@W4Mode@QAudio@@@Z @ 138 NONAME ABSENT ; class QList QAudioDeviceInfo::deviceList(enum QAudio::Mode) ?pixelFormat@QVideoSurfaceFormat@@QBE?AW4PixelFormat@QVideoFrame@@XZ @ 139 NONAME ; enum QVideoFrame::PixelFormat QVideoSurfaceFormat::pixelFormat(void) const ?handleType@QVideoSurfaceFormat@@QBE?AW4HandleType@QAbstractVideoBuffer@@XZ @ 140 NONAME ; enum QAbstractVideoBuffer::HandleType QVideoSurfaceFormat::handleType(void) const - ?clock@QAudioOutput@@QBE_JXZ @ 141 NONAME ; long long QAudioOutput::clock(void) const + ?clock@QAudioOutput@@QBE_JXZ @ 141 NONAME ABSENT ; long long QAudioOutput::clock(void) const ?map@QMemoryVideoBuffer@@UAEPAEW4MapMode@QAbstractVideoBuffer@@PAH1@Z @ 142 NONAME ; unsigned char * QMemoryVideoBuffer::map(enum QAbstractVideoBuffer::MapMode, int *, int *) ?setNotifyInterval@QAudioOutput@@QAEXH@Z @ 143 NONAME ; void QAudioOutput::setNotifyInterval(int) ?start@QAbstractVideoSurface@@UAE_NABVQVideoSurfaceFormat@@@Z @ 144 NONAME ; bool QAbstractVideoSurface::start(class QVideoSurfaceFormat const &) @@ -281,4 +281,14 @@ EXPORTS ?setFrameSize@QVideoSurfaceFormat@@QAEXHH@Z @ 280 NONAME ; void QVideoSurfaceFormat::setFrameSize(int, int) ?setYCbCrColorSpace@QVideoSurfaceFormat@@QAEXW4YCbCrColorSpace@1@@Z @ 281 NONAME ; void QVideoSurfaceFormat::setYCbCrColorSpace(enum QVideoSurfaceFormat::YCbCrColorSpace) ?yCbCrColorSpace@QVideoSurfaceFormat@@QBE?AW4YCbCrColorSpace@1@XZ @ 282 NONAME ; enum QVideoSurfaceFormat::YCbCrColorSpace QVideoSurfaceFormat::yCbCrColorSpace(void) const + ?availableDevices@QAudioDeviceInfo@@SA?AV?$QList@VQAudioDeviceInfo@@@@W4Mode@QAudio@@@Z @ 283 NONAME ; class QList QAudioDeviceInfo::availableDevices(enum QAudio::Mode) + ?elapsedUSecs@QAudioInput@@QBE_JXZ @ 284 NONAME ; long long QAudioInput::elapsedUSecs(void) const + ?elapsedUSecs@QAudioOutput@@QBE_JXZ @ 285 NONAME ; long long QAudioOutput::elapsedUSecs(void) const + ?isValid@QAudioFormat@@QBE_NXZ @ 286 NONAME ; bool QAudioFormat::isValid(void) const + ?processedUSecs@QAudioInput@@QBE_JXZ @ 287 NONAME ; long long QAudioInput::processedUSecs(void) const + ?processedUSecs@QAudioOutput@@QBE_JXZ @ 288 NONAME ; long long QAudioOutput::processedUSecs(void) const + ?start@QAudioInput@@QAEPAVQIODevice@@XZ @ 289 NONAME ; class QIODevice * QAudioInput::start(void) + ?start@QAudioInput@@QAEXPAVQIODevice@@@Z @ 290 NONAME ; void QAudioInput::start(class QIODevice *) + ?start@QAudioOutput@@QAEPAVQIODevice@@XZ @ 291 NONAME ; class QIODevice * QAudioOutput::start(void) + ?start@QAudioOutput@@QAEXPAVQIODevice@@@Z @ 292 NONAME ; void QAudioOutput::start(class QIODevice *) diff --git a/src/s60installs/bwins/QtScriptu.def b/src/s60installs/bwins/QtScriptu.def index b3efd69..05b2a40 100644 --- a/src/s60installs/bwins/QtScriptu.def +++ b/src/s60installs/bwins/QtScriptu.def @@ -343,4 +343,32 @@ EXPORTS ?isNull@QScriptProgram@@QBE_NXZ @ 342 NONAME ; bool QScriptProgram::isNull(void) const ?sourceCode@QScriptProgram@@QBE?AVQString@@XZ @ 343 NONAME ; class QString QScriptProgram::sourceCode(void) const ?toArrayIndex@QScriptString@@QBEIPA_N@Z @ 344 NONAME ; unsigned int QScriptString::toArrayIndex(bool *) const + ??0PersistentIdentifier@QScriptDeclarativeClass@@AAE@_N@Z @ 345 NONAME ; QScriptDeclarativeClass::PersistentIdentifier::PersistentIdentifier(bool) + ??0PersistentIdentifier@QScriptDeclarativeClass@@QAE@ABV01@@Z @ 346 NONAME ; QScriptDeclarativeClass::PersistentIdentifier::PersistentIdentifier(class QScriptDeclarativeClass::PersistentIdentifier const &) + ??0PersistentIdentifier@QScriptDeclarativeClass@@QAE@XZ @ 347 NONAME ; QScriptDeclarativeClass::PersistentIdentifier::PersistentIdentifier(void) + ??0QScriptDeclarativeClass@@QAE@PAVQScriptEngine@@@Z @ 348 NONAME ; QScriptDeclarativeClass::QScriptDeclarativeClass(class QScriptEngine *) + ??1PersistentIdentifier@QScriptDeclarativeClass@@QAE@XZ @ 349 NONAME ; QScriptDeclarativeClass::PersistentIdentifier::~PersistentIdentifier(void) + ??1QScriptDeclarativeClass@@UAE@XZ @ 350 NONAME ; QScriptDeclarativeClass::~QScriptDeclarativeClass(void) + ??4PersistentIdentifier@QScriptDeclarativeClass@@QAEAAV01@ABV01@@Z @ 351 NONAME ; class QScriptDeclarativeClass::PersistentIdentifier & QScriptDeclarativeClass::PersistentIdentifier::operator=(class QScriptDeclarativeClass::PersistentIdentifier const &) + ??_EQScriptDeclarativeClass@@UAE@I@Z @ 352 NONAME ; QScriptDeclarativeClass::~QScriptDeclarativeClass(unsigned int) + ?context@QScriptDeclarativeClass@@QBEPAVQScriptContext@@XZ @ 353 NONAME ; class QScriptContext * QScriptDeclarativeClass::context(void) const + ?createPersistentIdentifier@QScriptDeclarativeClass@@QAE?AVPersistentIdentifier@1@ABQAX@Z @ 354 NONAME ; class QScriptDeclarativeClass::PersistentIdentifier QScriptDeclarativeClass::createPersistentIdentifier(void * const const &) + ?createPersistentIdentifier@QScriptDeclarativeClass@@QAE?AVPersistentIdentifier@1@ABVQString@@@Z @ 355 NONAME ; class QScriptDeclarativeClass::PersistentIdentifier QScriptDeclarativeClass::createPersistentIdentifier(class QString const &) + ?engine@QScriptDeclarativeClass@@QBEPAVQScriptEngine@@XZ @ 356 NONAME ; class QScriptEngine * QScriptDeclarativeClass::engine(void) const + ?function@QScriptDeclarativeClass@@SA?AVQScriptValue@@ABV2@ABQAX@Z @ 357 NONAME ; class QScriptValue QScriptDeclarativeClass::function(class QScriptValue const &, void * const const &) + ?newObject@QScriptDeclarativeClass@@SA?AVQScriptValue@@PAVQScriptEngine@@PAV1@PAUObject@1@@Z @ 358 NONAME ; class QScriptValue QScriptDeclarativeClass::newObject(class QScriptEngine *, class QScriptDeclarativeClass *, struct QScriptDeclarativeClass::Object *) + ?object@QScriptDeclarativeClass@@SAPAUObject@1@ABVQScriptValue@@@Z @ 359 NONAME ; struct QScriptDeclarativeClass::Object * QScriptDeclarativeClass::object(class QScriptValue const &) + ?property@QScriptDeclarativeClass@@SA?AVQScriptValue@@ABV2@ABQAX@Z @ 360 NONAME ; class QScriptValue QScriptDeclarativeClass::property(class QScriptValue const &, void * const const &) + ?property@QScriptDeclarativeClass@@UAE?AVQScriptValue@@PAUObject@1@ABQAX@Z @ 361 NONAME ; class QScriptValue QScriptDeclarativeClass::property(struct QScriptDeclarativeClass::Object *, void * const const &) + ?propertyFlags@QScriptDeclarativeClass@@UAE?AV?$QFlags@W4PropertyFlag@QScriptValue@@@@PAUObject@1@ABQAX@Z @ 362 NONAME ; class QFlags QScriptDeclarativeClass::propertyFlags(struct QScriptDeclarativeClass::Object *, void * const const &) + ?propertyNames@QScriptDeclarativeClass@@UAE?AVQStringList@@PAUObject@1@@Z @ 363 NONAME ; class QStringList QScriptDeclarativeClass::propertyNames(struct QScriptDeclarativeClass::Object *) + ?pushCleanContext@QScriptDeclarativeClass@@SAPAVQScriptContext@@PAVQScriptEngine@@@Z @ 364 NONAME ; class QScriptContext * QScriptDeclarativeClass::pushCleanContext(class QScriptEngine *) + ?queryProperty@QScriptDeclarativeClass@@UAE?AV?$QFlags@W4QueryFlag@QScriptClass@@@@PAUObject@1@ABQAXV2@@Z @ 365 NONAME ; class QFlags QScriptDeclarativeClass::queryProperty(struct QScriptDeclarativeClass::Object *, void * const const &, class QFlags) + ?scopeChainValue@QScriptDeclarativeClass@@SA?AVQScriptValue@@PAVQScriptContext@@H@Z @ 366 NONAME ; class QScriptValue QScriptDeclarativeClass::scopeChainValue(class QScriptContext *, int) + ?scriptClass@QScriptDeclarativeClass@@SAPAV1@ABVQScriptValue@@@Z @ 367 NONAME ; class QScriptDeclarativeClass * QScriptDeclarativeClass::scriptClass(class QScriptValue const &) + ?setProperty@QScriptDeclarativeClass@@UAEXPAUObject@1@ABQAXABVQScriptValue@@@Z @ 368 NONAME ; void QScriptDeclarativeClass::setProperty(struct QScriptDeclarativeClass::Object *, void * const const &, class QScriptValue const &) + ?toArrayIndex@QScriptDeclarativeClass@@QAEIABQAXPA_N@Z @ 369 NONAME ; unsigned int QScriptDeclarativeClass::toArrayIndex(void * const const &, bool *) + ?toQObject@QScriptDeclarativeClass@@UAEPAVQObject@@PAUObject@1@PA_N@Z @ 370 NONAME ; class QObject * QScriptDeclarativeClass::toQObject(struct QScriptDeclarativeClass::Object *, bool *) + ?toString@QScriptDeclarativeClass@@QAE?AVQString@@ABQAX@Z @ 371 NONAME ; class QString QScriptDeclarativeClass::toString(void * const const &) + ?toVariant@QScriptDeclarativeClass@@UAE?AVQVariant@@PAUObject@1@PA_N@Z @ 372 NONAME ; class QVariant QScriptDeclarativeClass::toVariant(struct QScriptDeclarativeClass::Object *, bool *) diff --git a/src/s60installs/bwins/QtWebKitu.def b/src/s60installs/bwins/QtWebKitu.def index 14f3707..8341bfa 100644 --- a/src/s60installs/bwins/QtWebKitu.def +++ b/src/s60installs/bwins/QtWebKitu.def @@ -237,12 +237,12 @@ EXPORTS ?inputMethodEvent@QWebView@@MAEXPAVQInputMethodEvent@@@Z @ 236 NONAME ; void QWebView::inputMethodEvent(class QInputMethodEvent *) ?inputMethodQuery@QWebPage@@QBE?AVQVariant@@W4InputMethodQuery@Qt@@@Z @ 237 NONAME ; class QVariant QWebPage::inputMethodQuery(enum Qt::InputMethodQuery) const ?inputMethodQuery@QWebView@@UBE?AVQVariant@@W4InputMethodQuery@Qt@@@Z @ 238 NONAME ; class QVariant QWebView::inputMethodQuery(enum Qt::InputMethodQuery) const - ?interactivityChanged@QGraphicsWebView@@IAEXXZ @ 239 NONAME ; void QGraphicsWebView::interactivityChanged(void) + ?interactivityChanged@QGraphicsWebView@@IAEXXZ @ 239 NONAME ABSENT ; void QGraphicsWebView::interactivityChanged(void) ?isContentEditable@QWebHitTestResult@@QBE_NXZ @ 240 NONAME ; bool QWebHitTestResult::isContentEditable(void) const ?isContentEditable@QWebPage@@QBE_NXZ @ 241 NONAME ; bool QWebPage::isContentEditable(void) const ?isContentSelected@QWebHitTestResult@@QBE_NXZ @ 242 NONAME ; bool QWebHitTestResult::isContentSelected(void) const ?isEnabled@QWebPluginInfo@@QBE_NXZ @ 243 NONAME ; bool QWebPluginInfo::isEnabled(void) const - ?isInteractive@QGraphicsWebView@@QBE_NXZ @ 244 NONAME ; bool QGraphicsWebView::isInteractive(void) const + ?isInteractive@QGraphicsWebView@@QBE_NXZ @ 244 NONAME ABSENT ; bool QGraphicsWebView::isInteractive(void) const ?isModified@QWebPage@@QBE_NXZ @ 245 NONAME ; bool QWebPage::isModified(void) const ?isModified@QWebView@@QBE_NXZ @ 246 NONAME ; bool QWebView::isModified(void) const ?isNull@QWebElement@@QBE_NXZ @ 247 NONAME ; bool QWebElement::isNull(void) const @@ -355,8 +355,8 @@ EXPORTS ?printRequested@QWebPage@@IAEXPAVQWebFrame@@@Z @ 354 NONAME ; void QWebPage::printRequested(class QWebFrame *) ?printingMaximumShrinkFactor@QWebSettings@@QBEMXZ @ 355 NONAME ; float QWebSettings::printingMaximumShrinkFactor(void) const ?printingMinimumShrinkFactor@QWebSettings@@QBEMXZ @ 356 NONAME ; float QWebSettings::printingMinimumShrinkFactor(void) const - ?progress@QGraphicsWebView@@QBEMXZ @ 357 NONAME ; float QGraphicsWebView::progress(void) const - ?progressChanged@QGraphicsWebView@@IAEXM@Z @ 358 NONAME ; void QGraphicsWebView::progressChanged(float) + ?progress@QGraphicsWebView@@QBEMXZ @ 357 NONAME ABSENT ; float QGraphicsWebView::progress(void) const + ?progressChanged@QGraphicsWebView@@IAEXM@Z @ 358 NONAME ABSENT ; void QGraphicsWebView::progressChanged(float) ?provisionalLoad@QWebFrame@@IAEXXZ @ 359 NONAME ; void QWebFrame::provisionalLoad(void) ?qWebKitMajorVersion@@YAHXZ @ 360 NONAME ; int qWebKitMajorVersion(void) ?qWebKitMinorVersion@@YAHXZ @ 361 NONAME ; int qWebKitMinorVersion(void) @@ -463,7 +463,7 @@ EXPORTS ?setHtml@QWebView@@QAEXABVQString@@ABVQUrl@@@Z @ 462 NONAME ; void QWebView::setHtml(class QString const &, class QUrl const &) ?setIconDatabasePath@QWebSettings@@SAXABVQString@@@Z @ 463 NONAME ; void QWebSettings::setIconDatabasePath(class QString const &) ?setInnerXml@QWebElement@@QAEXABVQString@@@Z @ 464 NONAME ; void QWebElement::setInnerXml(class QString const &) - ?setInteractive@QGraphicsWebView@@QAEX_N@Z @ 465 NONAME ; void QGraphicsWebView::setInteractive(bool) + ?setInteractive@QGraphicsWebView@@QAEX_N@Z @ 465 NONAME ABSENT ; void QGraphicsWebView::setInteractive(bool) ?setLinkDelegationPolicy@QWebPage@@QAEXW4LinkDelegationPolicy@1@@Z @ 466 NONAME ; void QWebPage::setLinkDelegationPolicy(enum QWebPage::LinkDelegationPolicy) ?setLocalStoragePath@QWebSettings@@QAEXABVQString@@@Z @ 467 NONAME ; void QWebSettings::setLocalStoragePath(class QString const &) ?setMaximumItemCount@QWebHistory@@QAEXH@Z @ 468 NONAME ; void QWebHistory::setMaximumItemCount(int) @@ -513,11 +513,11 @@ EXPORTS ?size@QWebDatabase@@QBE_JXZ @ 512 NONAME ; long long QWebDatabase::size(void) const ?sizeHint@QWebInspector@@UBE?AVQSize@@XZ @ 513 NONAME ; class QSize QWebInspector::sizeHint(void) const ?sizeHint@QWebView@@UBE?AVQSize@@XZ @ 514 NONAME ; class QSize QWebView::sizeHint(void) const - ?status@QGraphicsWebView@@QBE?AVQString@@XZ @ 515 NONAME ; class QString QGraphicsWebView::status(void) const + ?status@QGraphicsWebView@@QBE?AVQString@@XZ @ 515 NONAME ABSENT ; class QString QGraphicsWebView::status(void) const ?statusBarMessage@QWebPage@@IAEXABVQString@@@Z @ 516 NONAME ; void QWebPage::statusBarMessage(class QString const &) ?statusBarMessage@QWebView@@IAEXABVQString@@@Z @ 517 NONAME ; void QWebView::statusBarMessage(class QString const &) ?statusBarVisibilityChangeRequested@QWebPage@@IAEX_N@Z @ 518 NONAME ; void QWebPage::statusBarVisibilityChangeRequested(bool) - ?statusChanged@QGraphicsWebView@@IAEXXZ @ 519 NONAME ; void QGraphicsWebView::statusChanged(void) + ?statusChanged@QGraphicsWebView@@IAEXXZ @ 519 NONAME ABSENT ; void QGraphicsWebView::statusChanged(void) ?stop@QGraphicsWebView@@QAEXXZ @ 520 NONAME ; void QGraphicsWebView::stop(void) ?stop@QWebView@@QAEXXZ @ 521 NONAME ; void QWebView::stop(void) ?styleProperty@QWebElement@@QBE?AVQString@@ABV2@W4StyleResolveStrategy@1@@Z @ 522 NONAME ; class QString QWebElement::styleProperty(class QString const &, enum QWebElement::StyleResolveStrategy) const @@ -538,7 +538,7 @@ EXPORTS ?titleChanged@QGraphicsWebView@@IAEXABVQString@@@Z @ 537 NONAME ; void QGraphicsWebView::titleChanged(class QString const &) ?titleChanged@QWebFrame@@IAEXABVQString@@@Z @ 538 NONAME ; void QWebFrame::titleChanged(class QString const &) ?titleChanged@QWebView@@IAEXABVQString@@@Z @ 539 NONAME ; void QWebView::titleChanged(class QString const &) - ?toHtml@QGraphicsWebView@@QBE?AVQString@@XZ @ 540 NONAME ; class QString QGraphicsWebView::toHtml(void) const + ?toHtml@QGraphicsWebView@@QBE?AVQString@@XZ @ 540 NONAME ABSENT ; class QString QGraphicsWebView::toHtml(void) const ?toHtml@QWebFrame@@QBE?AVQString@@XZ @ 541 NONAME ; class QString QWebFrame::toHtml(void) const ?toInnerXml@QWebElement@@QBE?AVQString@@XZ @ 542 NONAME ; class QString QWebElement::toInnerXml(void) const ?toList@QWebElementCollection@@QBE?AV?$QList@VQWebElement@@@@XZ @ 543 NONAME ; class QList QWebElementCollection::toList(void) const @@ -600,14 +600,14 @@ EXPORTS ?viewportSize@QWebPage@@QBE?AVQSize@@XZ @ 599 NONAME ; class QSize QWebPage::viewportSize(void) const ?webFrame@QWebElement@@QBEPAVQWebFrame@@XZ @ 600 NONAME ; class QWebFrame * QWebElement::webFrame(void) const ?webGraphic@QWebSettings@@SA?AVQPixmap@@W4WebGraphic@1@@Z @ 601 NONAME ; class QPixmap QWebSettings::webGraphic(enum QWebSettings::WebGraphic) - ?webInspectorTriggered@QWebPage@@IAEXABVQWebElement@@@Z @ 602 NONAME ; void QWebPage::webInspectorTriggered(class QWebElement const &) + ?webInspectorTriggered@QWebPage@@IAEXABVQWebElement@@@Z @ 602 NONAME ABSENT ; void QWebPage::webInspectorTriggered(class QWebElement const &) ?wheelEvent@QGraphicsWebView@@MAEXPAVQGraphicsSceneWheelEvent@@@Z @ 603 NONAME ; void QGraphicsWebView::wheelEvent(class QGraphicsSceneWheelEvent *) ?wheelEvent@QWebView@@MAEXPAVQWheelEvent@@@Z @ 604 NONAME ; void QWebView::wheelEvent(class QWheelEvent *) ?windowCloseRequested@QWebPage@@IAEXXZ @ 605 NONAME ; void QWebPage::windowCloseRequested(void) ?zoomFactor@QGraphicsWebView@@QBEMXZ @ 606 NONAME ; float QGraphicsWebView::zoomFactor(void) const ?zoomFactor@QWebFrame@@QBEMXZ @ 607 NONAME ; float QWebFrame::zoomFactor(void) const ?zoomFactor@QWebView@@QBEMXZ @ 608 NONAME ; float QWebView::zoomFactor(void) const - ?zoomFactorChanged@QGraphicsWebView@@IAEXXZ @ 609 NONAME ; void QGraphicsWebView::zoomFactorChanged(void) + ?zoomFactorChanged@QGraphicsWebView@@IAEXXZ @ 609 NONAME ABSENT ; void QGraphicsWebView::zoomFactorChanged(void) ?staticMetaObject@QWebPluginDatabase@@2UQMetaObject@@B @ 610 NONAME ; struct QMetaObject const QWebPluginDatabase::staticMetaObject ?staticMetaObject@QWebFrame@@2UQMetaObject@@B @ 611 NONAME ; struct QMetaObject const QWebFrame::staticMetaObject ?staticMetaObject@QWebHistoryInterface@@2UQMetaObject@@B @ 612 NONAME ; struct QMetaObject const QWebHistoryInterface::staticMetaObject @@ -616,4 +616,17 @@ EXPORTS ?staticMetaObject@QGraphicsWebView@@2UQMetaObject@@B @ 615 NONAME ; struct QMetaObject const QGraphicsWebView::staticMetaObject ?staticMetaObject@QWebPage@@2UQMetaObject@@B @ 616 NONAME ; struct QMetaObject const QWebPage::staticMetaObject ?staticMetaObject@QWebView@@2UQMetaObject@@B @ 617 NONAME ; struct QMetaObject const QWebView::staticMetaObject + ?begin@QWebElementCollection@@QAE?AViterator@1@XZ @ 618 NONAME ; class QWebElementCollection::iterator QWebElementCollection::begin(void) + ?constBegin@QWebElementCollection@@QBE?AVconst_iterator@1@XZ @ 619 NONAME ; class QWebElementCollection::const_iterator QWebElementCollection::constBegin(void) const + ?constEnd@QWebElementCollection@@QBE?AVconst_iterator@1@XZ @ 620 NONAME ; class QWebElementCollection::const_iterator QWebElementCollection::constEnd(void) const + ?end@QWebElementCollection@@QAE?AViterator@1@XZ @ 621 NONAME ; class QWebElementCollection::iterator QWebElementCollection::end(void) + ?findText@QGraphicsWebView@@QAE_NABVQString@@V?$QFlags@W4FindFlag@QWebPage@@@@@Z @ 622 NONAME ; bool QGraphicsWebView::findText(class QString const &, class QFlags) + ?inputMethodQuery@QGraphicsWebView@@UBE?AVQVariant@@W4InputMethodQuery@Qt@@@Z @ 623 NONAME ; class QVariant QGraphicsWebView::inputMethodQuery(enum Qt::InputMethodQuery) const + ?isModified@QGraphicsWebView@@QBE_NXZ @ 624 NONAME ; bool QGraphicsWebView::isModified(void) const + ?linkClicked@QGraphicsWebView@@IAEXABVQUrl@@@Z @ 625 NONAME ; void QGraphicsWebView::linkClicked(class QUrl const &) + ?loadProgress@QGraphicsWebView@@IAEXH@Z @ 626 NONAME ; void QGraphicsWebView::loadProgress(int) + ?pageAction@QGraphicsWebView@@QBEPAVQAction@@W4WebAction@QWebPage@@@Z @ 627 NONAME ; class QAction * QGraphicsWebView::pageAction(enum QWebPage::WebAction) const + ?sizeHint@QGraphicsWebView@@UBE?AVQSizeF@@W4SizeHint@Qt@@ABV2@@Z @ 628 NONAME ; class QSizeF QGraphicsWebView::sizeHint(enum Qt::SizeHint, class QSizeF const &) const + ?statusBarMessage@QGraphicsWebView@@IAEXABVQString@@@Z @ 629 NONAME ; void QGraphicsWebView::statusBarMessage(class QString const &) + ?triggerPageAction@QGraphicsWebView@@QAEXW4WebAction@QWebPage@@_N@Z @ 630 NONAME ; void QGraphicsWebView::triggerPageAction(enum QWebPage::WebAction, bool) diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index a8149bb..65caeab 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -3618,4 +3618,5 @@ EXPORTS _ZN21QAbstractConcatenable16convertFromAsciiEPKciRP5QChar @ 3617 NONAME _ZN25QSequentialAnimationGroup11insertPauseEii @ 3618 NONAME _ZNK18QAbstractAnimation15currentLoopTimeEv @ 3619 NONAME + _ZNK7QRegExp12captureCountEv @ 3620 NONAME diff --git a/src/s60installs/eabi/QtGuiu.def b/src/s60installs/eabi/QtGuiu.def index d5f1c7e..0c71486 100644 --- a/src/s60installs/eabi/QtGuiu.def +++ b/src/s60installs/eabi/QtGuiu.def @@ -11715,4 +11715,15 @@ EXPORTS _ZTI18QTapAndHoldGesture @ 11714 NONAME _ZTV11QTapGesture @ 11715 NONAME _ZTV18QTapAndHoldGesture @ 11716 NONAME + _ZN10QLCDNumber13setDigitCountEi @ 11717 NONAME + _ZN19QAbstractScrollArea18setViewportMarginsERK8QMargins @ 11718 NONAME + _ZN6QImage13setColorCountEi @ 11719 NONAME + _ZN7QLayout18setContentsMarginsERK8QMargins @ 11720 NONAME + _ZN9QLineEdit14setTextMarginsERK8QMargins @ 11721 NONAME + _ZNK10QLCDNumber10digitCountEv @ 11722 NONAME + _ZNK6QImage10colorCountEv @ 11723 NONAME + _ZNK6QImage9byteCountEv @ 11724 NONAME + _ZNK7QLayout15contentsMarginsEv @ 11725 NONAME + _ZNK7QRegion9rectCountEv @ 11726 NONAME + _ZNK9QLineEdit11textMarginsEv @ 11727 NONAME diff --git a/src/s60installs/eabi/QtMultimediau.def b/src/s60installs/eabi/QtMultimediau.def index db9b761..dc8b891 100644 --- a/src/s60installs/eabi/QtMultimediau.def +++ b/src/s60installs/eabi/QtMultimediau.def @@ -73,7 +73,7 @@ EXPORTS _ZN12QAudioOutputD0Ev @ 72 NONAME _ZN12QAudioOutputD1Ev @ 73 NONAME _ZN12QAudioOutputD2Ev @ 74 NONAME - _ZN16QAudioDeviceInfo10deviceListEN6QAudio4ModeE @ 75 NONAME + _ZN16QAudioDeviceInfo10deviceListEN6QAudio4ModeE @ 75 NONAME ABSENT _ZN16QAudioDeviceInfo18defaultInputDeviceEv @ 76 NONAME _ZN16QAudioDeviceInfo19defaultOutputDeviceEv @ 77 NONAME _ZN16QAudioDeviceInfoC1ERK7QStringRK10QByteArrayN6QAudio4ModeE @ 78 NONAME @@ -167,11 +167,11 @@ EXPORTS _ZNK11QAudioInput10metaObjectEv @ 166 NONAME _ZNK11QAudioInput10periodSizeEv @ 167 NONAME _ZNK11QAudioInput14notifyIntervalEv @ 168 NONAME - _ZNK11QAudioInput5clockEv @ 169 NONAME + _ZNK11QAudioInput5clockEv @ 169 NONAME ABSENT _ZNK11QAudioInput5errorEv @ 170 NONAME _ZNK11QAudioInput5stateEv @ 171 NONAME _ZNK11QAudioInput6formatEv @ 172 NONAME - _ZNK11QAudioInput9totalTimeEv @ 173 NONAME + _ZNK11QAudioInput9totalTimeEv @ 173 NONAME ABSENT _ZNK11QVideoFrame10handleTypeEv @ 174 NONAME _ZNK11QVideoFrame10isReadableEv @ 175 NONAME _ZNK11QVideoFrame10isWritableEv @ 176 NONAME @@ -192,7 +192,7 @@ EXPORTS _ZNK12QAudioFormat10sampleSizeEv @ 191 NONAME _ZNK12QAudioFormat10sampleTypeEv @ 192 NONAME _ZNK12QAudioFormat5codecEv @ 193 NONAME - _ZNK12QAudioFormat6isNullEv @ 194 NONAME + _ZNK12QAudioFormat6isNullEv @ 194 NONAME ABSENT _ZNK12QAudioFormat8channelsEv @ 195 NONAME _ZNK12QAudioFormat9byteOrderEv @ 196 NONAME _ZNK12QAudioFormat9frequencyEv @ 197 NONAME @@ -202,12 +202,12 @@ EXPORTS _ZNK12QAudioOutput10metaObjectEv @ 201 NONAME _ZNK12QAudioOutput10periodSizeEv @ 202 NONAME _ZNK12QAudioOutput14notifyIntervalEv @ 203 NONAME - _ZNK12QAudioOutput5clockEv @ 204 NONAME + _ZNK12QAudioOutput5clockEv @ 204 NONAME ABSENT _ZNK12QAudioOutput5errorEv @ 205 NONAME _ZNK12QAudioOutput5stateEv @ 206 NONAME _ZNK12QAudioOutput6formatEv @ 207 NONAME _ZNK12QAudioOutput9bytesFreeEv @ 208 NONAME - _ZNK12QAudioOutput9totalTimeEv @ 209 NONAME + _ZNK12QAudioOutput9totalTimeEv @ 209 NONAME ABSENT _ZNK16QAudioDeviceInfo10deviceNameEv @ 210 NONAME _ZNK16QAudioDeviceInfo13nearestFormatERK12QAudioFormat @ 211 NONAME _ZNK16QAudioDeviceInfo15preferredFormatEv @ 212 NONAME @@ -288,4 +288,12 @@ EXPORTS _ZNK21QAbstractVideoSurface13nearestFormatERK19QVideoSurfaceFormat @ 287 NONAME _ZNK21QAbstractVideoSurface17isFormatSupportedERK19QVideoSurfaceFormat @ 288 NONAME _ZNK21QAbstractVideoSurface8isActiveEv @ 289 NONAME + _ZN11QAudioInput5startEv @ 290 NONAME + _ZN12QAudioOutput5startEv @ 291 NONAME + _ZN16QAudioDeviceInfo16availableDevicesEN6QAudio4ModeE @ 292 NONAME + _ZNK11QAudioInput12elapsedUSecsEv @ 293 NONAME + _ZNK11QAudioInput14processedUSecsEv @ 294 NONAME + _ZNK12QAudioFormat7isValidEv @ 295 NONAME + _ZNK12QAudioOutput12elapsedUSecsEv @ 296 NONAME + _ZNK12QAudioOutput14processedUSecsEv @ 297 NONAME diff --git a/src/s60installs/eabi/QtScriptu.def b/src/s60installs/eabi/QtScriptu.def index 1e81977..946f3a3 100644 --- a/src/s60installs/eabi/QtScriptu.def +++ b/src/s60installs/eabi/QtScriptu.def @@ -359,4 +359,38 @@ EXPORTS _ZNK14QScriptProgram8fileNameEv @ 358 NONAME _ZNK14QScriptProgrameqERKS_ @ 359 NONAME _ZNK14QScriptProgramneERKS_ @ 360 NONAME + _ZN23QScriptDeclarativeClass11scriptClassERK12QScriptValue @ 361 NONAME + _ZN23QScriptDeclarativeClass11setPropertyEPNS_6ObjectERKPvRK12QScriptValue @ 362 NONAME + _ZN23QScriptDeclarativeClass12toArrayIndexERKPvPb @ 363 NONAME + _ZN23QScriptDeclarativeClass13propertyFlagsEPNS_6ObjectERKPv @ 364 NONAME + _ZN23QScriptDeclarativeClass13propertyNamesEPNS_6ObjectE @ 365 NONAME + _ZN23QScriptDeclarativeClass13queryPropertyEPNS_6ObjectERKPv6QFlagsIN12QScriptClass9QueryFlagEE @ 366 NONAME + _ZN23QScriptDeclarativeClass15scopeChainValueEP14QScriptContexti @ 367 NONAME + _ZN23QScriptDeclarativeClass16pushCleanContextEP13QScriptEngine @ 368 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifierC1ERKS0_ @ 369 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifierC1Ev @ 370 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifierC2ERKS0_ @ 371 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifierC2Ev @ 372 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifierD1Ev @ 373 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifierD2Ev @ 374 NONAME + _ZN23QScriptDeclarativeClass20PersistentIdentifieraSERKS0_ @ 375 NONAME + _ZN23QScriptDeclarativeClass26createPersistentIdentifierERK7QString @ 376 NONAME + _ZN23QScriptDeclarativeClass26createPersistentIdentifierERKPv @ 377 NONAME + _ZN23QScriptDeclarativeClass6objectERK12QScriptValue @ 378 NONAME + _ZN23QScriptDeclarativeClass8functionERK12QScriptValueRKPv @ 379 NONAME + _ZN23QScriptDeclarativeClass8propertyEPNS_6ObjectERKPv @ 380 NONAME + _ZN23QScriptDeclarativeClass8propertyERK12QScriptValueRKPv @ 381 NONAME + _ZN23QScriptDeclarativeClass8toStringERKPv @ 382 NONAME + _ZN23QScriptDeclarativeClass9newObjectEP13QScriptEnginePS_PNS_6ObjectE @ 383 NONAME + _ZN23QScriptDeclarativeClass9toQObjectEPNS_6ObjectEPb @ 384 NONAME + _ZN23QScriptDeclarativeClass9toVariantEPNS_6ObjectEPb @ 385 NONAME + _ZN23QScriptDeclarativeClassC1EP13QScriptEngine @ 386 NONAME + _ZN23QScriptDeclarativeClassC2EP13QScriptEngine @ 387 NONAME + _ZN23QScriptDeclarativeClassD0Ev @ 388 NONAME + _ZN23QScriptDeclarativeClassD1Ev @ 389 NONAME + _ZN23QScriptDeclarativeClassD2Ev @ 390 NONAME + _ZNK23QScriptDeclarativeClass6engineEv @ 391 NONAME + _ZNK23QScriptDeclarativeClass7contextEv @ 392 NONAME + _ZTI23QScriptDeclarativeClass @ 393 NONAME + _ZTV23QScriptDeclarativeClass @ 394 NONAME diff --git a/src/s60installs/eabi/QtWebKitu.def b/src/s60installs/eabi/QtWebKitu.def index 2ca393c..704d060 100644 --- a/src/s60installs/eabi/QtWebKitu.def +++ b/src/s60installs/eabi/QtWebKitu.def @@ -165,25 +165,25 @@ EXPORTS _ZN16QGraphicsWebView13focusOutEventEP11QFocusEvent @ 164 NONAME _ZN16QGraphicsWebView13keyPressEventEP9QKeyEvent @ 165 NONAME _ZN16QGraphicsWebView13setZoomFactorEf @ 166 NONAME - _ZN16QGraphicsWebView13statusChangedEv @ 167 NONAME + _ZN16QGraphicsWebView13statusChangedEv @ 167 NONAME ABSENT _ZN16QGraphicsWebView14dragEnterEventEP27QGraphicsSceneDragDropEvent @ 168 NONAME _ZN16QGraphicsWebView14dragLeaveEventEP27QGraphicsSceneDragDropEvent @ 169 NONAME _ZN16QGraphicsWebView14hoverMoveEventEP24QGraphicsSceneHoverEvent @ 170 NONAME _ZN16QGraphicsWebView14mouseMoveEventEP24QGraphicsSceneMouseEvent @ 171 NONAME - _ZN16QGraphicsWebView14setInteractiveEb @ 172 NONAME + _ZN16QGraphicsWebView14setInteractiveEb @ 172 NONAME ABSENT _ZN16QGraphicsWebView14updateGeometryEv @ 173 NONAME _ZN16QGraphicsWebView15hoverLeaveEventEP24QGraphicsSceneHoverEvent @ 174 NONAME _ZN16QGraphicsWebView15keyReleaseEventEP9QKeyEvent @ 175 NONAME _ZN16QGraphicsWebView15mousePressEventEP24QGraphicsSceneMouseEvent @ 176 NONAME - _ZN16QGraphicsWebView15progressChangedEf @ 177 NONAME + _ZN16QGraphicsWebView15progressChangedEf @ 177 NONAME ABSENT _ZN16QGraphicsWebView16contextMenuEventEP30QGraphicsSceneContextMenuEvent @ 178 NONAME _ZN16QGraphicsWebView16inputMethodEventEP17QInputMethodEvent @ 179 NONAME _ZN16QGraphicsWebView16staticMetaObjectE @ 180 NONAME DATA 16 _ZN16QGraphicsWebView17mouseReleaseEventEP24QGraphicsSceneMouseEvent @ 181 NONAME - _ZN16QGraphicsWebView17zoomFactorChangedEv @ 182 NONAME + _ZN16QGraphicsWebView17zoomFactorChangedEv @ 182 NONAME ABSENT _ZN16QGraphicsWebView18focusNextPrevChildEb @ 183 NONAME _ZN16QGraphicsWebView19getStaticMetaObjectEv @ 184 NONAME - _ZN16QGraphicsWebView20interactivityChangedEv @ 185 NONAME + _ZN16QGraphicsWebView20interactivityChangedEv @ 185 NONAME ABSENT _ZN16QGraphicsWebView21mouseDoubleClickEventEP24QGraphicsSceneMouseEvent @ 186 NONAME _ZN16QGraphicsWebView4backEv @ 187 NONAME _ZN16QGraphicsWebView4loadERK15QNetworkRequestN21QNetworkAccessManager9OperationERK10QByteArray @ 188 NONAME @@ -292,7 +292,7 @@ EXPORTS _ZN8QWebPage19getStaticMetaObjectEv @ 291 NONAME _ZN8QWebPage20windowCloseRequestedEv @ 292 NONAME _ZN8QWebPage21databaseQuotaExceededEP9QWebFrame7QString @ 293 NONAME - _ZN8QWebPage21webInspectorTriggeredERK11QWebElement @ 294 NONAME + _ZN8QWebPage21webInspectorTriggeredERK11QWebElement @ 294 NONAME ABSENT _ZN8QWebPage23acceptNavigationRequestEP9QWebFrameRK15QNetworkRequestNS_14NavigationTypeE @ 295 NONAME _ZN8QWebPage23geometryChangeRequestedERK5QRect @ 296 NONAME _ZN8QWebPage23saveFrameStateRequestedEP9QWebFrameP15QWebHistoryItem @ 297 NONAME @@ -488,15 +488,15 @@ EXPORTS _ZNK15QWebHistoryItem8userDataEv @ 487 NONAME _ZNK16QGraphicsWebView10metaObjectEv @ 488 NONAME _ZNK16QGraphicsWebView10zoomFactorEv @ 489 NONAME - _ZNK16QGraphicsWebView13isInteractiveEv @ 490 NONAME + _ZNK16QGraphicsWebView13isInteractiveEv @ 490 NONAME ABSENT _ZNK16QGraphicsWebView3urlEv @ 491 NONAME _ZNK16QGraphicsWebView4iconEv @ 492 NONAME _ZNK16QGraphicsWebView4pageEv @ 493 NONAME _ZNK16QGraphicsWebView5titleEv @ 494 NONAME - _ZNK16QGraphicsWebView6statusEv @ 495 NONAME - _ZNK16QGraphicsWebView6toHtmlEv @ 496 NONAME + _ZNK16QGraphicsWebView6statusEv @ 495 NONAME ABSENT + _ZNK16QGraphicsWebView6toHtmlEv @ 496 NONAME ABSENT _ZNK16QGraphicsWebView7historyEv @ 497 NONAME - _ZNK16QGraphicsWebView8progressEv @ 498 NONAME + _ZNK16QGraphicsWebView8progressEv @ 498 NONAME ABSENT _ZNK16QGraphicsWebView8settingsEv @ 499 NONAME _ZNK17QWebHitTestResult11linkElementEv @ 500 NONAME _ZNK17QWebHitTestResult12boundingRectEv @ 501 NONAME @@ -678,4 +678,15 @@ EXPORTS _ZNK8QWebPage21preferredContentsSizeEv @ 677 NONAME _ZNK8QWebPage24setPreferredContentsSizeERK5QSize @ 678 NONAME _ZThn8_N16QGraphicsWebView10itemChangeEN13QGraphicsItem18GraphicsItemChangeERK8QVariant @ 679 NONAME + _ZN16QGraphicsWebView11linkClickedERK4QUrl @ 680 NONAME + _ZN16QGraphicsWebView12loadProgressEi @ 681 NONAME + _ZN16QGraphicsWebView16statusBarMessageERK7QString @ 682 NONAME + _ZN16QGraphicsWebView17triggerPageActionEN8QWebPage9WebActionEb @ 683 NONAME + _ZN16QGraphicsWebView8findTextERK7QString6QFlagsIN8QWebPage8FindFlagEE @ 684 NONAME + _ZNK16QGraphicsWebView10isModifiedEv @ 685 NONAME + _ZNK16QGraphicsWebView10pageActionEN8QWebPage9WebActionE @ 686 NONAME + _ZNK16QGraphicsWebView16inputMethodQueryEN2Qt16InputMethodQueryE @ 687 NONAME + _ZNK16QGraphicsWebView8sizeHintEN2Qt8SizeHintERK6QSizeF @ 688 NONAME + _ZThn16_NK16QGraphicsWebView8sizeHintEN2Qt8SizeHintERK6QSizeF @ 689 NONAME + _ZThn8_NK16QGraphicsWebView16inputMethodQueryEN2Qt16InputMethodQueryE @ 690 NONAME -- cgit v0.12 From ef06b4672e5a89cc460e26ba8209ab46991e7cfa Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Tue, 10 Nov 2009 14:28:43 +0100 Subject: Switch on DEF files DEF files containing the frozen DLL exports are in use for Symbian OS builds, except developer builds (configured with -developer-build) The reason for this exception is that developer builds export additional private interfaces to allow autotests to inject or monitor the internal data of a class. These autotest exports are not part of the API or the binary interface, so they are excluded from DEF files. Task-number: QTBUG-4436 Reviewed-by: Jason Barron --- src/qbase.pri | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/src/qbase.pri b/src/qbase.pri index 4639ca1..6428130 100644 --- a/src/qbase.pri +++ b/src/qbase.pri @@ -101,16 +101,25 @@ symbian { "DEFFILE ../s60installs/eabi/$${TARGET}.def" \ "$${LITERAL_HASH}endif" - #with defBlock enabled, removed exported symbols are treated as errors - #and there is binary compatibility between successive builds. - #with defBlock disabled, binary compatibility is broken every time you build - #MMP_RULES += defBlock - - #with EXPORTUNFROZEN enabled, new exports are included in the dll without - #needing to run abld freeze, however binary compatibility is only maintained - #for symbols that are frozen (and only if defBlock is also enabled) - #the downside of EXPORTUNFROZEN is that the linker gets run twice - MMP_RULES += EXPORTUNFROZEN + contains(QT_CONFIG, private_tests) { + #When building autotest configuration, there are extra exports from + #the Qt DLLs, which we don't want in the frozen DEF files. + MMP_RULES += EXPORTUNFROZEN + } else { + #When building without autotests, DEF files are used by default. + #This is to maintain binary compatibility with previous releases. + + #with defBlock enabled, removed exported symbols are treated as errors + #and there is binary compatibility between successive builds. + #with defBlock disabled, binary compatibility is broken every time you build + MMP_RULES += defBlock + + #with EXPORTUNFROZEN enabled, new exports are included in the dll without + #needing to run abld freeze, however binary compatibility is only maintained + #for symbols that are frozen (and only if defBlock is also enabled) + #the downside of EXPORTUNFROZEN is that the linker gets run twice + #MMP_RULES += EXPORTUNFROZEN + } } load(armcc_warnings) } -- cgit v0.12 From 17976aa8e74c0a0a6adf69a08ad39cae77715b4b Mon Sep 17 00:00:00 2001 From: Alessandro Portale Date: Tue, 10 Nov 2009 14:27:24 +0100 Subject: Removed unused public Api from QS60Style QS60Style::setStyleProperty() and QS60Style::styleProperty() were intended as generic property setter/getters, but are not needed anymore. Reviewed-by: Sami Merila modified: src/gui/styles/qs60style.cpp modified: src/gui/styles/qs60style.h modified: src/gui/styles/qs60style_p.h modified: src/gui/styles/qs60style_s60.cpp modified: src/gui/styles/qs60style_simulated.cpp modified: src/s60installs/eabi/QtGuiu.def --- src/gui/styles/qs60style.cpp | 44 ---------------------------------- src/gui/styles/qs60style.h | 4 ---- src/gui/styles/qs60style_p.h | 8 ------- src/gui/styles/qs60style_s60.cpp | 17 ------------- src/gui/styles/qs60style_simulated.cpp | 10 -------- src/s60installs/eabi/QtGuiu.def | 4 ++-- 6 files changed, 2 insertions(+), 85 deletions(-) diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index eeaf7e8..5edc8c2 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -301,32 +301,6 @@ short QS60StylePrivate::pixelMetric(int metric) return returnValue; } -void QS60StylePrivate::setStyleProperty(const char *name, const QVariant &value) -{ - if (name == propertyKeyCurrentlayout) { - static const QStringList layouts = styleProperty(propertyKeyLayouts).toStringList(); - const QString layout = value.toString(); - Q_ASSERT(layouts.contains(layout)); - const int layoutIndex = layouts.indexOf(layout); - setCurrentLayout(layoutIndex); - QApplication::setLayoutDirection(m_layoutHeaders[layoutIndex].mirroring ? Qt::RightToLeft : Qt::LeftToRight); - clearCaches(); - refreshUI(); - } -} - -QVariant QS60StylePrivate::styleProperty(const char *name) const -{ - if (name == propertyKeyLayouts) { - static QStringList layouts; - if (layouts.isEmpty()) - for (int i = 0; i < m_numberOfLayouts; i++) - layouts.append(QLatin1String(m_layoutHeaders[i].layoutName)); - return layouts; - } - return QVariant(); -} - QColor QS60StylePrivate::stateColor(const QColor &color, const QStyleOption *option) { QColor retColor (color); @@ -2873,24 +2847,6 @@ void QS60Style::unpolish(QApplication *application) } /*! - Sets the style property \a name to the \a value. - */ -void QS60Style::setStyleProperty(const char *name, const QVariant &value) -{ - Q_D(QS60Style); - d->setStyleProperty_specific(name, value); -} - -/*! - Returns the value of style property \a name. - */ -QVariant QS60Style::styleProperty(const char *name) const -{ - Q_D(const QS60Style); - return d->styleProperty_specific(name); -} - -/*! \reimp */ bool QS60Style::event(QEvent *e) diff --git a/src/gui/styles/qs60style.h b/src/gui/styles/qs60style.h index ab10792..885ea40 100644 --- a/src/gui/styles/qs60style.h +++ b/src/gui/styles/qs60style.h @@ -79,10 +79,6 @@ public: #ifndef Q_NO_USING_KEYWORD using QCommonStyle::polish; #endif - - void setStyleProperty(const char *name, const QVariant &value); - QVariant styleProperty(const char *name) const; - bool event(QEvent *e); #ifndef Q_WS_S60 diff --git a/src/gui/styles/qs60style_p.h b/src/gui/styles/qs60style_p.h index 46547bf..b9789b9 100644 --- a/src/gui/styles/qs60style_p.h +++ b/src/gui/styles/qs60style_p.h @@ -388,14 +388,6 @@ public: // draws a specific skin part static void drawSkinPart(QS60StyleEnums::SkinParts part, QPainter *painter, const QRect &rect, SkinElementFlags flags = KDefaultSkinElementFlags); - // sets style property - void setStyleProperty(const char *name, const QVariant &value); - // sets specific style property - void setStyleProperty_specific(const char *name, const QVariant &value); - // gets style property - QVariant styleProperty(const char *name) const; - // gets specific style property - QVariant styleProperty_specific(const char *name) const; // gets pixel metrics value static short pixelMetric(int metric); // gets color. 'index' is NOT 0-based. diff --git a/src/gui/styles/qs60style_s60.cpp b/src/gui/styles/qs60style_s60.cpp index c2a207c..b5f2d1c 100644 --- a/src/gui/styles/qs60style_s60.cpp +++ b/src/gui/styles/qs60style_s60.cpp @@ -1014,23 +1014,6 @@ QS60StylePrivate::QS60StylePrivate() setActiveLayout(); } -void QS60StylePrivate::setStyleProperty_specific(const char *name, const QVariant &value) -{ - if (QLatin1String(name) == QLatin1String("foo")) { - // BaR - } else { - setStyleProperty(name, value); - } -} - -QVariant QS60StylePrivate::styleProperty_specific(const char *name) const -{ - if (QLatin1String(name) == QLatin1String("foo")) - return QLatin1String("Bar"); - else - return styleProperty(name); -} - QColor QS60StylePrivate::s60Color(QS60StyleEnums::ColorLists list, int index, const QStyleOption *option) { diff --git a/src/gui/styles/qs60style_simulated.cpp b/src/gui/styles/qs60style_simulated.cpp index 706b4e9..4317483 100644 --- a/src/gui/styles/qs60style_simulated.cpp +++ b/src/gui/styles/qs60style_simulated.cpp @@ -308,16 +308,6 @@ QPixmap QS60StylePrivate::frame(SkinFrameElements frame, const QSize &size, return result; } -void QS60StylePrivate::setStyleProperty_specific(const char *name, const QVariant &value) -{ - setStyleProperty(name, value); -} - -QVariant QS60StylePrivate::styleProperty_specific(const char *name) const -{ - return styleProperty(name); -} - QPixmap QS60StylePrivate::backgroundTexture() { if (!m_background) { diff --git a/src/s60installs/eabi/QtGuiu.def b/src/s60installs/eabi/QtGuiu.def index 0c71486..3ecf9d2 100644 --- a/src/s60installs/eabi/QtGuiu.def +++ b/src/s60installs/eabi/QtGuiu.def @@ -7006,7 +7006,7 @@ EXPORTS _ZN9QPolygonFC2ERK8QPolygon @ 7005 NONAME _ZN9QS60Style11qt_metacallEN11QMetaObject4CallEiPPv @ 7006 NONAME _ZN9QS60Style11qt_metacastEPKc @ 7007 NONAME - _ZN9QS60Style16setStylePropertyEPKcRK8QVariant @ 7008 NONAME + _ZN9QS60Style16setStylePropertyEPKcRK8QVariant @ 7008 NONAME ABSENT _ZN9QS60Style16staticMetaObjectE @ 7009 NONAME DATA 16 _ZN9QS60Style19getStaticMetaObjectEv @ 7010 NONAME _ZN9QS60Style5eventEP6QEvent @ 7011 NONAME @@ -10445,7 +10445,7 @@ EXPORTS _ZNK9QS60Style11drawControlEN6QStyle14ControlElementEPK12QStyleOptionP8QPainterPK7QWidget @ 10444 NONAME _ZNK9QS60Style11pixelMetricEN6QStyle11PixelMetricEPK12QStyleOptionPK7QWidget @ 10445 NONAME _ZNK9QS60Style13drawPrimitiveEN6QStyle16PrimitiveElementEPK12QStyleOptionP8QPainterPK7QWidget @ 10446 NONAME - _ZNK9QS60Style13stylePropertyEPKc @ 10447 NONAME + _ZNK9QS60Style13stylePropertyEPKc @ 10447 NONAME ABSENT _ZNK9QS60Style14subControlRectEN6QStyle14ComplexControlEPK19QStyleOptionComplexNS0_10SubControlEPK7QWidget @ 10448 NONAME _ZNK9QS60Style14subElementRectEN6QStyle10SubElementEPK12QStyleOptionPK7QWidget @ 10449 NONAME _ZNK9QS60Style16sizeFromContentsEN6QStyle12ContentsTypeEPK12QStyleOptionRK5QSizePK7QWidget @ 10450 NONAME -- cgit v0.12 From d4089399a3ab7548a864d5a399e08df85c444783 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sami=20Meril=C3=A4?= Date: Tue, 10 Nov 2009 17:06:26 +0200 Subject: QS60Style palette is not updated after orientation switch Due to bad first fix for QT-1478, palette is still not updated correctly. Changed palette needs to be set back to QApplication. Task-number: QT-1478 Reviewed-by: Alessandro Portale --- src/gui/styles/qs60style.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index 5edc8c2..f15a6a5 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -473,7 +473,7 @@ void QS60StylePrivate::setBackgroundTexture(QApplication *app) const Q_UNUSED(app) QPalette applicationPalette = QApplication::palette(); applicationPalette.setBrush(QPalette::Window, backgroundTexture()); - setThemePalette(app); + setThemePalette(&applicationPalette); } void QS60StylePrivate::deleteBackground() -- cgit v0.12 From 05eacd9ad40f8adb5aaa12a8b90113a73b43f642 Mon Sep 17 00:00:00 2001 From: Jouni Hiltunen Date: Tue, 3 Nov 2009 13:50:49 +0200 Subject: Long-press shortcuts for symbols on QWERTY keyboard don't work Qt key event was not handled properly in the case of long key press. With long key press, QCoeFepInputContext::commitCurrentString gets called 3 times("q", "", "1"). (Normal key press is causing one call). This is how aknfep works, so commitCurrentString was modified to replace first character if long key press event detected. E.g. "q" is replaced with "1". qlinecontrol modified to keep cursor position correct. Signed-off-by: axis --- src/gui/inputmethod/qcoefepinputcontext_p.h | 2 ++ src/gui/inputmethod/qcoefepinputcontext_s60.cpp | 15 +++++++++++++-- src/gui/widgets/qlinecontrol.cpp | 2 +- 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/gui/inputmethod/qcoefepinputcontext_p.h b/src/gui/inputmethod/qcoefepinputcontext_p.h index 452aa75..28c1c67 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_p.h +++ b/src/gui/inputmethod/qcoefepinputcontext_p.h @@ -146,6 +146,8 @@ private: int m_inlinePosition; MFepInlineTextFormatRetriever *m_formatRetriever; MFepPointerEventHandlerDuringInlineEdit *m_pointerHandler; + int m_longPress; + int m_cursorPos; }; QT_END_NAMESPACE diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp index ea5e29b..ceace4a 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp +++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp @@ -71,7 +71,9 @@ QCoeFepInputContext::QCoeFepInputContext(QObject *parent) m_cursorVisibility(1), m_inlinePosition(0), m_formatRetriever(0), - m_pointerHandler(0) + m_pointerHandler(0), + m_longPress(0), + m_cursorPos(0) { m_fepState->SetObjectProvider(this); m_fepState->SetFlags(EAknEditorFlagDefault); @@ -488,6 +490,8 @@ void QCoeFepInputContext::StartFepInlineEditL(const TDesC& aInitialInlineText, m_isEditing = true; + m_cursorPos = w->inputMethodQuery(Qt::ImCursorPosition).toInt(); + QList attributes; m_cursorVisibility = aCursorVisibility ? 1 : 0; @@ -691,15 +695,22 @@ void QCoeFepInputContext::DoCommitFepInlineEditL() void QCoeFepInputContext::commitCurrentString(bool triggeredBySymbian) { if (m_preeditString.size() == 0) { + QWidget *w = focusWidget(); + if(triggeredBySymbian && w){ + // We must replace the last character only if the input box has already accepted one + if (w->inputMethodQuery(Qt::ImCursorPosition).toInt() != m_cursorPos) + m_longPress = 1; + } return; } QList attributes; QInputMethodEvent event(QLatin1String(""), attributes); - event.setCommitString(m_preeditString, 0, 0);//m_preeditString.size()); + event.setCommitString(m_preeditString, 0-m_longPress, m_longPress); m_preeditString.clear(); sendEvent(event); + m_longPress = 0; m_isEditing = false; if (!triggeredBySymbian) { diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp index 2914164..300a2ea 100644 --- a/src/gui/widgets/qlinecontrol.cpp +++ b/src/gui/widgets/qlinecontrol.cpp @@ -414,7 +414,7 @@ void QLineControl::processInputMethodEvent(QInputMethodEvent *event) int c = m_cursor; // cursor position after insertion of commit string - if (event->replacementStart() <= 0) + if (event->replacementStart() == 0) c += event->commitString().length() + qMin(-event->replacementStart(), event->replacementLength()); m_cursor += event->replacementStart(); -- cgit v0.12 From b59349a06aeb0933085f76b7401085e63d4d4088 Mon Sep 17 00:00:00 2001 From: axis Date: Tue, 10 Nov 2009 16:45:08 +0100 Subject: Fixed indentation. --- src/gui/inputmethod/qcoefepinputcontext_s60.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp index ceace4a..5db6f0d 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp +++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp @@ -695,12 +695,12 @@ void QCoeFepInputContext::DoCommitFepInlineEditL() void QCoeFepInputContext::commitCurrentString(bool triggeredBySymbian) { if (m_preeditString.size() == 0) { - QWidget *w = focusWidget(); - if(triggeredBySymbian && w){ - // We must replace the last character only if the input box has already accepted one - if (w->inputMethodQuery(Qt::ImCursorPosition).toInt() != m_cursorPos) - m_longPress = 1; - } + QWidget *w = focusWidget(); + if (triggeredBySymbian && w) { + // We must replace the last character only if the input box has already accepted one + if (w->inputMethodQuery(Qt::ImCursorPosition).toInt() != m_cursorPos) + m_longPress = 1; + } return; } -- cgit v0.12 From b16bc052a4b7b83e5295b5f62daeebdbb46d0973 Mon Sep 17 00:00:00 2001 From: Alessandro Portale Date: Tue, 10 Nov 2009 18:08:21 +0100 Subject: Qt covers BC break in Symbian Workaround: fntstore.h has an inlined function 'COpenFont* CBitmapFont::OpenFont()' that returns a private data member. The header will change between minor SDK versions, thus break BC. But Qt has to build on any SDK version and run on other versions of Symbian OS. Also Qt does not want to deliver that BC to Qt based apps. This hack performs the needed pointer arithmetic to get the right COpenFont* pointer, no matter if the 'Flexible Memory Model' is already supported or not. The author is not proud of this commit. Task-number: QT-2250 Reviewed-by: Iain Reviewed-by: Shane Kearns modified: src/gui/text/qfontdatabase_s60.cpp --- src/gui/text/qfontdatabase_s60.cpp | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/src/gui/text/qfontdatabase_s60.cpp b/src/gui/text/qfontdatabase_s60.cpp index 1a6bb11..ca5be0e 100644 --- a/src/gui/text/qfontdatabase_s60.cpp +++ b/src/gui/text/qfontdatabase_s60.cpp @@ -136,6 +136,23 @@ QFontDatabaseS60StoreImplementation::~QFontDatabaseS60StoreImplementation() m_heap->Close(); } +#ifndef FNTSTORE_H_INLINES_SUPPORT_FMM +/* + Workaround: fntstore.h has an inlined function 'COpenFont* CBitmapFont::OpenFont()' + that returns a private data member. The header will change between SDKs. But Qt has + to build on any SDK version and run on other versions of Symbian OS. + This function performs the needed pointer arithmetic to get the right COpenFont* +*/ +COpenFont* OpenFontFromBitmapFont(const CBitmapFont* aBitmapFont) +{ + const TInt offsetIOpenFont = 92; // '_FOFF(CBitmapFont, iOpenFont)' ..if iOpenFont weren't private + const TUint valueIOpenFont = *(TUint*)PtrAdd(aBitmapFont, offsetIOpenFont); + return (valueIOpenFont & 1) ? + (COpenFont*)PtrAdd(aBitmapFont, valueIOpenFont & ~1) : // New behavior: iOpenFont is offset + (COpenFont*)valueIOpenFont; // Old behavior: iOpenFont is pointer +} +#endif // FNTSTORE_H_INLINES_SUPPORT_FMM + const QFontEngineS60Extensions *QFontDatabaseS60StoreImplementation::extension(const QString &typeface) const { if (!m_extensions.contains(typeface)) { @@ -144,8 +161,14 @@ const QFontEngineS60Extensions *QFontDatabaseS60StoreImplementation::extension(c spec.iHeight = 1; const TInt err = m_store->GetNearestFontToDesignHeightInPixels(font, spec); Q_ASSERT(err == KErrNone && font); - CBitmapFont *bitmapFont = static_cast(font); - m_extensions.insert(typeface, new QFontEngineS60Extensions(font, bitmapFont->OpenFont())); + const CBitmapFont *bitmapFont = static_cast(font); + COpenFont *openFont = +#ifdef FNTSTORE_H_INLINES_SUPPORT_FMM + bitmapFont->openFont(); +#else + OpenFontFromBitmapFont(bitmapFont); +#endif // FNTSTORE_H_INLINES_SUPPORT_FMM + m_extensions.insert(typeface, new QFontEngineS60Extensions(font, openFont)); } return m_extensions.value(typeface); } -- cgit v0.12 From 55522dca2f004b9e4433cb1bf43c4bf85a92ed89 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Tue, 10 Nov 2009 19:01:03 +0100 Subject: Update winscw def file for 17976aa8e74c0a0a6adf69a08ad39cae77715b4b Reviewed-by: Trust Me --- src/s60installs/bwins/QtGuiu.def | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/s60installs/bwins/QtGuiu.def b/src/s60installs/bwins/QtGuiu.def index 3fd4940..c1ebb7f 100644 --- a/src/s60installs/bwins/QtGuiu.def +++ b/src/s60installs/bwins/QtGuiu.def @@ -3409,7 +3409,7 @@ EXPORTS ??_0QTransform@@QAEAAV0@M@Z @ 3408 NONAME ; class QTransform & QTransform::operator/=(float) ?staticMetaObject@QLineControl@@2UQMetaObject@@B @ 3409 NONAME ; struct QMetaObject const QLineControl::staticMetaObject ?viewportEvent@QGraphicsView@@MAE_NPAVQEvent@@@Z @ 3410 NONAME ; bool QGraphicsView::viewportEvent(class QEvent *) - ?styleProperty@QS60Style@@QBE?AVQVariant@@PBD@Z @ 3411 NONAME ; class QVariant QS60Style::styleProperty(char const *) const + ?styleProperty@QS60Style@@QBE?AVQVariant@@PBD@Z @ 3411 NONAME ABSENT ; class QVariant QS60Style::styleProperty(char const *) const ?setStackingMode@QStackedLayout@@QAEXW4StackingMode@1@@Z @ 3412 NONAME ; void QStackedLayout::setStackingMode(enum QStackedLayout::StackingMode) ?event@QScrollBar@@UAE_NPAVQEvent@@@Z @ 3413 NONAME ; bool QScrollBar::event(class QEvent *) ?metaObject@QPushButton@@UBEPBUQMetaObject@@XZ @ 3414 NONAME ; struct QMetaObject const * QPushButton::metaObject(void) const @@ -11915,7 +11915,7 @@ EXPORTS ?submitPolicy@QDataWidgetMapper@@QBE?AW4SubmitPolicy@1@XZ @ 11914 NONAME ; enum QDataWidgetMapper::SubmitPolicy QDataWidgetMapper::submitPolicy(void) const ??1QGraphicsSystem@@UAE@XZ @ 11915 NONAME ; QGraphicsSystem::~QGraphicsSystem(void) ?setSceneRect@QGraphicsView@@QAEXABVQRectF@@@Z @ 11916 NONAME ; void QGraphicsView::setSceneRect(class QRectF const &) - ?setStyleProperty@QS60Style@@QAEXPBDABVQVariant@@@Z @ 11917 NONAME ; void QS60Style::setStyleProperty(char const *, class QVariant const &) + ?setStyleProperty@QS60Style@@QAEXPBDABVQVariant@@@Z @ 11917 NONAME ABSENT ; void QS60Style::setStyleProperty(char const *, class QVariant const &) ?hasExtendedInfo@QKeyEvent@@QBE_NXZ @ 11918 NONAME ; bool QKeyEvent::hasExtendedInfo(void) const ?pen@QGraphicsLineItem@@QBE?AVQPen@@XZ @ 11919 NONAME ; class QPen QGraphicsLineItem::pen(void) const ?standardPixmap@QCommonStyle@@UBE?AVQPixmap@@W4StandardPixmap@QStyle@@PBVQStyleOption@@PBVQWidget@@@Z @ 11920 NONAME ; class QPixmap QCommonStyle::standardPixmap(enum QStyle::StandardPixmap, class QStyleOption const *, class QWidget const *) const -- cgit v0.12 From 71d05ae1f212793b59c2f0fcb68ec5f21732073e Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Wed, 11 Nov 2009 12:26:46 +1000 Subject: Support OpenVG graphics systems that inherit from QVGPixmapData Custom graphics systems, may want to inherit from QVGPixmapData to implement alternative pixmap management strategies. We make toVGImage() overridable and the data members protected to support this. Reviewed-by: Sarah Smith --- src/openvg/qpixmapdata_vg_p.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/openvg/qpixmapdata_vg_p.h b/src/openvg/qpixmapdata_vg_p.h index f552c7b..f6fac88 100644 --- a/src/openvg/qpixmapdata_vg_p.h +++ b/src/openvg/qpixmapdata_vg_p.h @@ -89,10 +89,10 @@ public: // Return the VGImage form of this pixmap, creating it if necessary. // This assumes that there is a VG context current. - VGImage toVGImage(); + virtual VGImage toVGImage(); // Return the VGImage form for a specific opacity setting. - VGImage toVGImage(qreal opacity); + virtual VGImage toVGImage(qreal opacity); QSize size() const { return QSize(w, h); } @@ -108,7 +108,7 @@ protected: void cleanup(); #endif -private: +protected: VGImage vgImage; VGImage vgImageOpacity; qreal cachedOpacity; -- cgit v0.12 From fe23fd01b4fc61b109bc81bcbac2f832929fb482 Mon Sep 17 00:00:00 2001 From: Jason Barron Date: Wed, 11 Nov 2009 09:38:53 +0100 Subject: Add edit menu support for phones with a 'pencil' key. The native FEP handles the 'pencil' key on some platforms by opening an edit menu on the screen that contains things like 'Insert Symbol' and 'Writing Language' for text input widgets. This was previously not working in the Qt input method implementation because in order for the FEP system to open the menu, it must be able to access the menu bar (CBA). This is done my using the object provider mechanism (MOP) and an implementation of the MopNext() function was missing. Adding this and also setting the AppUi as the MOP parent for top level widgets allowed the FEP framework to find it's way to the menubar and thus open a menu. Task-number: QTBUG-5606 Reviewed-by: axis Reviewed-by: mread --- src/gui/inputmethod/qcoefepinputcontext_p.h | 1 + src/gui/inputmethod/qcoefepinputcontext_s60.cpp | 8 ++++++++ src/gui/kernel/qwidget_s60.cpp | 1 + 3 files changed, 10 insertions(+) diff --git a/src/gui/inputmethod/qcoefepinputcontext_p.h b/src/gui/inputmethod/qcoefepinputcontext_p.h index 28c1c67..6aee669 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_p.h +++ b/src/gui/inputmethod/qcoefepinputcontext_p.h @@ -132,6 +132,7 @@ public: // From MObjectProvider public: TTypeUid::Ptr MopSupplyObject(TTypeUid id); + MObjectProvider *MopNext(); private: QSymbianControl *m_parent; diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp index 5db6f0d..0ed3cc0 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp +++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp @@ -752,6 +752,14 @@ TTypeUid::Ptr QCoeFepInputContext::MopSupplyObject(TTypeUid /*id*/) return TTypeUid::Null(); } +MObjectProvider *QCoeFepInputContext::MopNext() +{ + QWidget *w = focusWidget(); + if (w) + return w->effectiveWinId(); + return 0; +} + QT_END_NAMESPACE #endif // QT_NO_IM diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp index 88cd63d..915d308 100644 --- a/src/gui/kernel/qwidget_s60.cpp +++ b/src/gui/kernel/qwidget_s60.cpp @@ -359,6 +359,7 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de QScopedPointer control( q_check_ptr(new QSymbianControl(q)) ); QT_TRAP_THROWING(control->ConstructL(true, desktop)); + control->SetMopParent(static_cast(S60->appUi())); // Symbian windows are always created in an inactive state // We perform this assignment for the case where the window is being re-created -- cgit v0.12 From 223b5de63e56c6c3dfbc5000b460baa653ab3f75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Samuel=20R=C3=B8dal?= Date: Thu, 5 Nov 2009 13:10:19 +0100 Subject: Fixed compilation on AIX 6.1 with xlC 10.1 Task-number: QTBUG-3368 Reviewed-by: Thiago Macieira --- src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h | 6 ++++++ src/gui/painting/qpathclipper.cpp | 2 +- src/xmlpatterns/data/qderivedinteger_p.h | 8 ++++---- src/xmlpatterns/functions/qcomparingaggregator.cpp | 2 +- 4 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h b/src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h index 73212db..9174dce 100644 --- a/src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h +++ b/src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h @@ -98,6 +98,10 @@ /* regardless of operating environment */ #if defined(_AIX) #define WTF_PLATFORM_AIX 1 +/* 64-bit mode on AIX */ +#ifdef __64BIT__ +#define WTF_PLATFORM_AIX64 1 +#endif #endif /* PLATFORM(HPUX) */ @@ -704,6 +708,8 @@ #define WTF_USE_JSVALUE64 1 #elif (PLATFORM(IA64) && !PLATFORM(IA64_32)) || PLATFORM(SPARC64) #define WTF_USE_JSVALUE64 1 +#elif PLATFORM(AIX64) +#define WTF_USE_JSVALUE64 1 #elif PLATFORM(ARM) || PLATFORM(PPC64) #define WTF_USE_JSVALUE32 1 #elif PLATFORM(WIN_OS) && COMPILER(MINGW) diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp index ab2dc33..51d6195 100644 --- a/src/gui/painting/qpathclipper.cpp +++ b/src/gui/painting/qpathclipper.cpp @@ -1650,7 +1650,7 @@ static void clear(QWingedEdge& list, int edge, QPathEdge::Traversal traversal) template InputIterator qFuzzyFind(InputIterator first, InputIterator last, qreal val) { - while (first != last && !qFuzzyCompare(qreal(*first), qreal(val))) + while (first != last && !QT_PREPEND_NAMESPACE(qFuzzyCompare)(qreal(*first), qreal(val))) ++first; return first; } diff --git a/src/xmlpatterns/data/qderivedinteger_p.h b/src/xmlpatterns/data/qderivedinteger_p.h index 859e03d..19dc4c4 100644 --- a/src/xmlpatterns/data/qderivedinteger_p.h +++ b/src/xmlpatterns/data/qderivedinteger_p.h @@ -401,18 +401,18 @@ namespace QPatternist { return ValidationError::createError(QtXmlPatterns::tr( "Value %1 of type %2 exceeds maximum (%3).") - .arg(formatData(static_cast(num))) + .arg(QPatternist::formatData(static_cast(num))) .arg(formatType(np, itemType())) - .arg(formatData(static_cast(maxInclusive)))); + .arg(QPatternist::formatData(static_cast(maxInclusive)))); } else if((limitsUsage & LimitDownwards) && lessThan(num, minimum)) { return ValidationError::createError(QtXmlPatterns::tr( "Value %1 of type %2 is below minimum (%3).") - .arg(formatData(static_cast(num))) + .arg(QPatternist::formatData(static_cast(num))) .arg(formatType(np, itemType())) - .arg(formatData(static_cast(minInclusive)))); + .arg(QPatternist::formatData(static_cast(minInclusive)))); } else return AtomicValue::Ptr(new DerivedInteger(num)); diff --git a/src/xmlpatterns/functions/qcomparingaggregator.cpp b/src/xmlpatterns/functions/qcomparingaggregator.cpp index 6d07109..acda08c 100644 --- a/src/xmlpatterns/functions/qcomparingaggregator.cpp +++ b/src/xmlpatterns/functions/qcomparingaggregator.cpp @@ -195,7 +195,7 @@ ComparingAggregator::typeCheck(const StaticContext::Ptr &context, !BuiltinTypes::xsYearMonthDuration->xdtTypeMatches(t1)) { context->error(QtXmlPatterns::tr("The first argument to %1 cannot be of type %2.") - .arg(formatFunction(context->namePool(), signature())) + .arg(QPatternist::formatFunction(context->namePool(), signature())) .arg(formatType(context->namePool(), m_operands.first()->staticType())), ReportContext::FORG0006, this); return me; -- cgit v0.12 From 05920c102d506378401a383aa820cabc9d0419c5 Mon Sep 17 00:00:00 2001 From: Janne Anttila Date: Wed, 11 Nov 2009 13:36:33 +0200 Subject: Fix for qmessagebox softkey dimming in Symbian. QMessageBox softkeys gets dimmed by TAknPopupFader since we currently have one global softkey instance. Task-number: QTBUG-5691 Reviewed-by: Jason Barron --- src/gui/kernel/qsoftkeymanager.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/gui/kernel/qsoftkeymanager.cpp b/src/gui/kernel/qsoftkeymanager.cpp index 6d148fe..22ac319 100644 --- a/src/gui/kernel/qsoftkeymanager.cpp +++ b/src/gui/kernel/qsoftkeymanager.cpp @@ -213,12 +213,13 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList &softkeys) CEikButtonGroupContainer* nativeContainer = S60->buttonGroupContainer(); nativeContainer->DrawableWindow()->SetOrdinalPosition(0); nativeContainer->DrawableWindow()->SetPointerCapturePriority(1); //keep softkeys available in modal dialog + nativeContainer->DrawableWindow()->SetFaded(EFalse, RWindowTreeNode::EFadeIncludeChildren); int position = -1; bool needsExitButton = true; QT_TRAP_THROWING( //Using -1 instead of EAknSoftkeyEmpty to avoid flickering. - nativeContainer->SetCommandL(0, -1, KNullDesC); + nativeContainer->SetCommandL(0, -1, KNullDesC); nativeContainer->SetCommandL(2, -1, KNullDesC); ); -- cgit v0.12 From a8b5418c70e0e2d3b4f9dc25c1383a78c4da8f22 Mon Sep 17 00:00:00 2001 From: Janne Anttila Date: Wed, 11 Nov 2009 14:20:40 +0200 Subject: Fix for qmessagebox default softkey visibility + some tab/space fixes. Default actions get added after the QDialogButtonBox::event receives show event. That's why 'ok' softkey action will not get added to the widget. Changed implementation so that softkey actions are added to widget when they are created. This implementation is also more safe in a sence that if actions are changed when message box is visible, the softkeys will be updated. Task-number: QTBUG-5644 Task-number: QT-2211 Reviewed-by: Sami Merila --- src/gui/widgets/qdialogbuttonbox.cpp | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/src/gui/widgets/qdialogbuttonbox.cpp b/src/gui/widgets/qdialogbuttonbox.cpp index 2231b98..2ee5751 100644 --- a/src/gui/widgets/qdialogbuttonbox.cpp +++ b/src/gui/widgets/qdialogbuttonbox.cpp @@ -315,9 +315,9 @@ void QDialogButtonBoxPrivate::initLayout() buttonLayout = new QVBoxLayout(q); } - int left, top, right, bottom; + int left, top, right, bottom; setLayoutItemMargins(QStyle::SE_PushButtonLayoutItem); - getLayoutItemMargins(&left, &top, &right, &bottom); + getLayoutItemMargins(&left, &top, &right, &bottom); buttonLayout->setContentsMargins(-left, -top, -right, -bottom); if (!q->testAttribute(Qt::WA_WState_OwnSizePolicy)) { @@ -356,7 +356,7 @@ void QDialogButtonBoxPrivate::addButtonsToLayout(const QList void QDialogButtonBoxPrivate::layoutButtons() { Q_Q(QDialogButtonBox); - const int MacGap = 36 - 8; // 8 is the default gap between a widget and a spacer item + const int MacGap = 36 - 8; // 8 is the default gap between a widget and a spacer item for (int i = buttonLayout->count() - 1; i >= 0; --i) { QLayoutItem *item = buttonLayout->takeAt(i); @@ -581,6 +581,22 @@ QAction* QDialogButtonBoxPrivate::createSoftKey(QAbstractButton *button, QDialog } QObject::connect(action, SIGNAL(triggered()), button, SIGNAL(clicked())); action->setSoftKeyRole(softkeyRole); + + + QWidget *dialog = 0; + QWidget *p = q; + while (p && !p->isWindow()) { + p = p->parentWidget(); + if ((dialog = qobject_cast(p))) + break; + } + + if (dialog) { + dialog->addAction(action); + } else { + q->addAction(action); + } + return action; } #endif @@ -1193,12 +1209,8 @@ bool QDialogButtonBox::event(QEvent *event) if (!hasDefault && firstAcceptButton) firstAcceptButton->setDefault(true); #ifdef QT_SOFTKEYS_ENABLED - if (dialog) { + if (dialog) setFixedSize(0,0); - dialog->addActions(d->softKeyActions.values()); - } else { - addActions(d->softKeyActions.values()); - } #endif }else if (event->type() == QEvent::LanguageChange) { d->retranslateStrings(); -- cgit v0.12 From c327076817dad875bd057bf28eab36b1d4e732ef Mon Sep 17 00:00:00 2001 From: Aleksandar Sasha Babic Date: Tue, 10 Nov 2009 21:02:35 +0100 Subject: Revert "Check that we're not using double where qreal should be used" This reverts commit d9a275b3cc4a248da1f392fb5649b9fe7a93b12c. --- src/gui/styles/qs60style.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index f15a6a5..16a81b3 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -1723,7 +1723,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, optionMenuItem.palette.setColor(QPalette::Disabled, QPalette::Text, QS60StylePrivate::lighterColor( optionMenuItem.palette.color(QPalette::Disabled, QPalette::Text))); painter->save(); - painter->setOpacity(qreal(0.75)); + painter->setOpacity(0.5); } QCommonStyle::drawItemText(painter, textRect, text_flags, optionMenuItem.palette, enabled, @@ -1829,7 +1829,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, painter->save(); if (widget) painter->setBrush(widget->palette().button()); - painter->setOpacity(qreal(0.3)); + painter->setOpacity(0.3); painter->fillRect(toolBar->rect, painter->brush()); painter->restore(); } -- cgit v0.12 From 72c170b64056a59dce9f849a5789d2968071f7b9 Mon Sep 17 00:00:00 2001 From: Aleksandar Sasha Babic Date: Tue, 10 Nov 2009 21:04:41 +0100 Subject: Revert "Using qreal more consistently in code (prevent misuse of double)" This reverts commit 676780d515cedca85829ae962e4f501c5e5b6581. Conflicts: src/gui/painting/qblendfunctions.cpp --- mkspecs/common/symbian/symbian.conf | 2 +- src/3rdparty/easing/easing.cpp | 180 ++++++++++++------------ src/corelib/global/qglobal.h | 4 +- src/corelib/global/qnumeric_p.h | 6 - src/corelib/kernel/qmath.h | 45 ++---- src/corelib/tools/qdatetime.cpp | 2 +- src/corelib/tools/qeasingcurve.cpp | 20 +-- src/corelib/tools/qline.cpp | 12 +- src/gui/graphicsview/qgraphicsitem.cpp | 3 +- src/gui/graphicsview/qgraphicsitemanimation.cpp | 18 +-- src/gui/graphicsview/qgraphicsscene.cpp | 6 +- src/gui/graphicsview/qgraphicsview.cpp | 2 +- src/gui/graphicsview/qgraphicswidget_p.cpp | 6 +- src/gui/graphicsview/qgridlayoutengine.cpp | 88 ++++++------ src/gui/graphicsview/qsimplex_p.cpp | 4 +- src/gui/image/qimage.cpp | 30 ++-- src/gui/image/qpaintengine_pic.cpp | 4 +- src/gui/image/qpicture.cpp | 4 +- src/gui/image/qpixmap_raster.cpp | 4 +- src/gui/image/qpixmap_s60.cpp | 9 +- src/gui/image/qpnghandler.cpp | 4 +- src/gui/math3d/qmatrix4x4.cpp | 145 +++++++++---------- src/gui/math3d/qquaternion.cpp | 29 ++-- src/gui/math3d/qvector2d.cpp | 6 +- src/gui/math3d/qvector3d.cpp | 8 +- src/gui/math3d/qvector4d.cpp | 16 +-- src/gui/painting/qbezier.cpp | 104 +++++++------- src/gui/painting/qbezier_p.h | 45 +++--- src/gui/painting/qblendfunctions.cpp | 18 ++- src/gui/painting/qbrush.cpp | 2 +- src/gui/painting/qcolor.cpp | 89 ++++++------ src/gui/painting/qdrawhelper.cpp | 111 ++++++++------- src/gui/painting/qdrawutil.cpp | 70 +++++---- src/gui/painting/qmath_p.h | 5 +- src/gui/painting/qpaintbuffer.cpp | 2 +- src/gui/painting/qpaintengine_raster.cpp | 32 ++--- src/gui/painting/qpaintengineex.cpp | 13 +- src/gui/painting/qpainter.cpp | 27 ++-- src/gui/painting/qpainterpath.cpp | 27 ++-- src/gui/painting/qpainterpath_p.h | 2 +- src/gui/painting/qpathclipper.cpp | 18 +-- src/gui/painting/qrasterizer.cpp | 32 ++--- src/gui/painting/qstroker.cpp | 25 ++-- src/gui/painting/qstroker_p.h | 2 +- src/gui/painting/qtransform.cpp | 27 ++-- src/gui/styles/qcommonstyle.cpp | 17 ++- src/gui/styles/qs60style.cpp | 16 +-- src/gui/styles/qstyle.cpp | 2 +- src/gui/styles/qstylehelper.cpp | 26 ++-- src/gui/styles/qstylesheetstyle.cpp | 8 +- src/gui/text/qfont.cpp | 6 +- src/gui/text/qfontdatabase.cpp | 6 +- src/svg/qsvggenerator.cpp | 9 +- src/svg/qsvggraphics.cpp | 11 +- src/svg/qsvghandler.cpp | 73 +++++----- src/svg/qsvgtinydocument.cpp | 13 +- 56 files changed, 710 insertions(+), 785 deletions(-) diff --git a/mkspecs/common/symbian/symbian.conf b/mkspecs/common/symbian/symbian.conf index 0f06b92..79bac42 100644 --- a/mkspecs/common/symbian/symbian.conf +++ b/mkspecs/common/symbian/symbian.conf @@ -7,7 +7,7 @@ CONFIG += qt warn_on release incremental QT += core gui QMAKE_INCREMENTAL_STYLE = sublib -DEFINES += UNICODE QT_KEYPAD_NAVIGATION QT_SOFTKEYS_ENABLED QT_USE_MATH_H_FLOATS +DEFINES += UNICODE QT_KEYPAD_NAVIGATION QT_SOFTKEYS_ENABLED QMAKE_COMPILER_DEFINES += SYMBIAN QMAKE_EXT_OBJ = .o diff --git a/src/3rdparty/easing/easing.cpp b/src/3rdparty/easing/easing.cpp index 65e9f95..81af40f 100644 --- a/src/3rdparty/easing/easing.cpp +++ b/src/3rdparty/easing/easing.cpp @@ -18,7 +18,13 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND */ #include -#include +#include +#ifndef M_PI +#define M_PI 3.14159265358979323846 +#endif +#ifndef M_PI_2 +#define M_PI_2 (M_PI / 2) +#endif QT_USE_NAMESPACE @@ -63,12 +69,12 @@ static qreal easeOutQuad(qreal t) */ static qreal easeInOutQuad(qreal t) { - t*=qreal(2.0); + t*=2.0; if (t < 1) { - return t*t*qreal(0.5); + return t*t/qreal(2); } else { --t; - return qreal(-0.5) * (t*(t-2) - 1); + return -0.5 * (t*(t-2) - 1); } } @@ -80,8 +86,8 @@ static qreal easeInOutQuad(qreal t) */ static qreal easeOutInQuad(qreal t) { - if (t < qreal(0.5)) return easeOutQuad (t*2) * qreal(0.5); - return easeInQuad((2*t)-1) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutQuad (t*2)/2; + return easeInQuad((2*t)-1)/2 + 0.5; } /** @@ -103,7 +109,7 @@ static qreal easeInCubic(qreal t) */ static qreal easeOutCubic(qreal t) { - t-=qreal(1.0); + t-=1.0; return t*t*t + 1; } @@ -115,12 +121,12 @@ static qreal easeOutCubic(qreal t) */ static qreal easeInOutCubic(qreal t) { - t*=qreal(2.0); + t*=2.0; if(t < 1) { - return qreal(0.5)*t*t*t; + return 0.5*t*t*t; } else { t -= qreal(2.0); - return qreal(0.5)*(t*t*t + 2); + return 0.5*(t*t*t + 2); } } @@ -132,8 +138,8 @@ static qreal easeInOutCubic(qreal t) */ static qreal easeOutInCubic(qreal t) { - if (t < qreal(0.5)) return easeOutCubic (2*t) * qreal(0.5); - return easeInCubic(2*t - 1) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutCubic (2*t)/2; + return easeInCubic(2*t - 1)/2 + 0.5; } /** @@ -168,10 +174,10 @@ static qreal easeOutQuart(qreal t) static qreal easeInOutQuart(qreal t) { t*=2; - if (t < 1) return qreal(0.5)*t*t*t*t; + if (t < 1) return 0.5*t*t*t*t; else { t -= 2.0f; - return qreal(-0.5) * (t*t*t*t- 2); + return -0.5 * (t*t*t*t- 2); } } @@ -183,8 +189,8 @@ static qreal easeInOutQuart(qreal t) */ static qreal easeOutInQuart(qreal t) { - if (t < qreal(0.5)) return easeOutQuart (2*t) * qreal(0.5); - return easeInQuart(2*t-1) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutQuart (2*t)/2; + return easeInQuart(2*t-1)/2 + 0.5; } /** @@ -206,7 +212,7 @@ static qreal easeInQuint(qreal t) */ static qreal easeOutQuint(qreal t) { - t-=qreal(1.0); + t-=1.0; return t*t*t*t*t + 1; } @@ -218,11 +224,11 @@ static qreal easeOutQuint(qreal t) */ static qreal easeInOutQuint(qreal t) { - t*=qreal(2.0); - if (t < 1) return qreal(0.5)*t*t*t*t*t; + t*=2.0; + if (t < 1) return 0.5*t*t*t*t*t; else { - t -= qreal(2.0); - return qreal(0.5)*(t*t*t*t*t + 2); + t -= 2.0; + return 0.5*(t*t*t*t*t + 2); } } @@ -234,8 +240,8 @@ static qreal easeInOutQuint(qreal t) */ static qreal easeOutInQuint(qreal t) { - if (t < qreal(0.5)) return easeOutQuint (2*t) * qreal(0.5); - return easeInQuint(2*t - 1) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutQuint (2*t)/2; + return easeInQuint(2*t - 1)/2 + 0.5; } /** @@ -246,7 +252,7 @@ static qreal easeOutInQuint(qreal t) */ static qreal easeInSine(qreal t) { - return (t == qreal(1.0)) ? qreal(1.0) : -qCos(t * Q_PI2) + qreal(1.0); + return (t == 1.0) ? 1.0 : -::cos(t * M_PI_2) + 1.0; } /** @@ -257,7 +263,7 @@ static qreal easeInSine(qreal t) */ static qreal easeOutSine(qreal t) { - return qSin(t* Q_PI2); + return ::sin(t* M_PI_2); } /** @@ -268,7 +274,7 @@ static qreal easeOutSine(qreal t) */ static qreal easeInOutSine(qreal t) { - return qreal(-0.5) * (qCos(Q_PI*t) - 1); + return -0.5 * (::cos(M_PI*t) - 1); } /** @@ -279,8 +285,8 @@ static qreal easeInOutSine(qreal t) */ static qreal easeOutInSine(qreal t) { - if (t < qreal(0.5)) return easeOutSine (2*t) * qreal(0.5); - return easeInSine(2*t - 1) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutSine (2*t)/2; + return easeInSine(2*t - 1)/2 + 0.5; } /** @@ -291,7 +297,7 @@ static qreal easeOutInSine(qreal t) */ static qreal easeInExpo(qreal t) { - return (t==0 || t == qreal(1.0)) ? t : ::qPow(qreal(2.0), 10 * (t - 1)) - qreal(0.001); + return (t==0 || t == 1.0) ? t : ::qPow(2.0, 10 * (t - 1)) - qreal(0.001); } /** @@ -302,7 +308,7 @@ static qreal easeInExpo(qreal t) */ static qreal easeOutExpo(qreal t) { - return (t==qreal(1.0)) ? qreal(1.0) : qreal(1.001) * (-::qPow(2.0f, -10 * t) + 1); + return (t==1.0) ? 1.0 : 1.001 * (-::qPow(2.0f, -10 * t) + 1); } /** @@ -313,11 +319,11 @@ static qreal easeOutExpo(qreal t) */ static qreal easeInOutExpo(qreal t) { - if (t==qreal(0.0)) return qreal(0.0); - if (t==qreal(1.0)) return qreal(1.0); - t*=qreal(2.0); - if (t < 1) return qreal(0.5) * ::qPow(qreal(2.0), 10 * (t - 1)) - qreal(0.0005); - return qreal(0.5) * qreal(1.0005) * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2); + if (t==0.0) return qreal(0.0); + if (t==1.0) return qreal(1.0); + t*=2.0; + if (t < 1) return 0.5 * ::qPow(qreal(2.0), 10 * (t - 1)) - 0.0005; + return 0.5 * 1.0005 * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2); } /** @@ -328,8 +334,8 @@ static qreal easeInOutExpo(qreal t) */ static qreal easeOutInExpo(qreal t) { - if (t < qreal(0.5)) return easeOutExpo (2*t) * qreal(0.5); - return easeInExpo(2*t - 1) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutExpo (2*t)/2; + return easeInExpo(2*t - 1)/2 + 0.5; } /** @@ -340,7 +346,7 @@ static qreal easeOutInExpo(qreal t) */ static qreal easeInCirc(qreal t) { - return -(::qSqrt(1 - t*t) - 1); + return -(::sqrt(1 - t*t) - 1); } /** @@ -352,7 +358,7 @@ static qreal easeInCirc(qreal t) static qreal easeOutCirc(qreal t) { t-= qreal(1.0); - return ::qSqrt(1 - t* t); + return ::sqrt(1 - t* t); } /** @@ -365,10 +371,10 @@ static qreal easeInOutCirc(qreal t) { t*=qreal(2.0); if (t < 1) { - return qreal(-0.5) * (::qSqrt(1 - t*t) - 1); + return -0.5 * (::sqrt(1 - t*t) - 1); } else { t -= qreal(2.0); - return qreal(0.5) * (::qSqrt(1 - t*t) + 1); + return 0.5 * (::sqrt(1 - t*t) + 1); } } @@ -380,26 +386,26 @@ static qreal easeInOutCirc(qreal t) */ static qreal easeOutInCirc(qreal t) { - if (t < qreal(0.5)) return easeOutCirc (2*t)*qreal(0.5); - return easeInCirc(2*t - 1)*qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutCirc (2*t)/2; + return easeInCirc(2*t - 1)/2 + 0.5; } static qreal easeInElastic_helper(qreal t, qreal b, qreal c, qreal d, qreal a, qreal p) { if (t==0) return b; - qreal t_adj = t / d; + qreal t_adj = (qreal)t / (qreal)d; if (t_adj==1) return b+c; qreal s; - if(a < ::qAbs(c)) { + if(a < ::fabs(c)) { a = c; - s = p * 0.25f; + s = p / 4.0f; } else { - s = p / (Q_2PI) * ::qAsin(c / a); + s = p / (2 * M_PI) * ::asin(c / a); } t_adj -= 1.0f; - return -(a*::qPow(2.0f,10*t_adj) * qSin( (t_adj*d-s)*(Q_2PI)/p )) + b; + return -(a*::qPow(2.0f,10*t_adj) * ::sin( (t_adj*d-s)*(2*M_PI)/p )) + b; } /** @@ -423,12 +429,12 @@ static qreal easeOutElastic_helper(qreal t, qreal /*b*/, qreal c, qreal /*d*/, q qreal s; if(a < c) { a = c; - s = p * 0.25f; + s = p / 4.0f; } else { - s = p / (Q_2PI) * ::qAsin(c / a); + s = p / (2 * M_PI) * ::asin(c / a); } - return (a*::qPow(2.0f,-10*t) * ::qSin( (t-s)*(Q_2PI)/p ) + c); + return (a*::qPow(2.0f,-10*t) * ::sin( (t-s)*(2*M_PI)/p ) + c); } /** @@ -454,20 +460,20 @@ static qreal easeOutElastic(qreal t, qreal a, qreal p) */ static qreal easeInOutElastic(qreal t, qreal a, qreal p) { - if (t==0) return qreal(0.0); - t*=qreal(2.0); - if (t==2) return qreal(1.0); + if (t==0) return 0.0; + t*=2.0; + if (t==2) return 1.0; qreal s; - if(a < qreal(1.0)) { - a = qreal(1.0); - s = p * 0.25f; + if(a < 1.0) { + a = 1.0; + s = p / 4.0f; } else { - s = p / (Q_2PI) * ::qAsin(qreal(1.0) / a); + s = p / (2 * M_PI) * ::asin(1.0 / a); } - if (t < 1) return qreal(-.5)*(a*::qPow(2.0f,10*(t-1)) * ::qSin( (t-1-s)*(Q_2PI)/p )); - return a*::qPow(2.0f,-10*(t-1)) * ::qSin( (t-1-s)*(Q_2PI)/p )*qreal(.5) + qreal(1.0); + if (t < 1) return -.5*(a*::qPow(2.0f,10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p )); + return a*::qPow(2.0f,-10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p )*.5 + 1.0; } /** @@ -480,8 +486,8 @@ static qreal easeInOutElastic(qreal t, qreal a, qreal p) */ static qreal easeOutInElastic(qreal t, qreal a, qreal p) { - if (t < qreal(0.5)) return easeOutElastic_helper(t*2, 0, qreal(0.5), qreal(1.0), a, p); - return easeInElastic_helper(2*t - qreal(1.0), qreal(0.5), qreal(0.5), qreal(1.0), a, p); + if (t < 0.5) return easeOutElastic_helper(t*2, 0, 0.5, 1.0, a, p); + return easeInElastic_helper(2*t - 1.0, 0.5, 0.5, 1.0, a, p); } /** @@ -518,14 +524,14 @@ static qreal easeOutBack(qreal t, qreal s) */ static qreal easeInOutBack(qreal t, qreal s) { - t *= qreal(2.0); + t *= 2.0; if (t < 1) { s *= 1.525f; - return qreal(0.5)*(t*t*((s+1)*t - s)); + return 0.5*(t*t*((s+1)*t - s)); } else { t -= 2; s *= 1.525f; - return qreal(0.5)*(t*t*((s+1)*t+ s) + 2); + return 0.5*(t*t*((s+1)*t+ s) + 2); } } @@ -538,26 +544,24 @@ static qreal easeInOutBack(qreal t, qreal s) */ static qreal easeOutInBack(qreal t, qreal s) { - if (t < qreal(0.5)) return easeOutBack (2*t, s) * qreal(0.5); - return easeInBack(2*t - 1, s) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeOutBack (2*t, s)/2; + return easeInBack(2*t - 1, s)/2 + 0.5; } static qreal easeOutBounce_helper(qreal t, qreal c, qreal a) { - const qreal inv_22 = 1 / qreal(22.0); - const qreal inv_11 = 2 * inv_22; - if (t == qreal(1.0)) return c; - if (t < (4 * inv_11)) { - return c*(qreal(7.5625)*t*t); - } else if (t < (8 * inv_11)) { - t -= (6 * inv_11); - return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.75))) + c; - } else if (t < (10 * inv_11)) { - t -= (9 * inv_11); - return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.9375))) + c; + if (t == 1.0) return c; + if (t < (4/11.0)) { + return c*(7.5625*t*t); + } else if (t < (8/11.0)) { + t -= (6/11.0); + return -a * (1. - (7.5625*t*t + .75)) + c; + } else if (t < (10/11.0)) { + t -= (9/11.0); + return -a * (1. - (7.5625*t*t + .9375)) + c; } else { - t -= (21 * inv_22); - return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.984375))) + c; + t -= (21/22.0); + return -a * (1. - (7.5625*t*t + .984375)) + c; } } @@ -582,7 +586,7 @@ static qreal easeOutBounce(qreal t, qreal a) */ static qreal easeInBounce(qreal t, qreal a) { - return qreal(1.0) - easeOutBounce_helper(qreal(1.0)-t, qreal(1.0), a); + return 1.0 - easeOutBounce_helper(1.0-t, 1.0, a); } @@ -595,8 +599,8 @@ static qreal easeInBounce(qreal t, qreal a) */ static qreal easeInOutBounce(qreal t, qreal a) { - if (t < qreal(0.5)) return easeInBounce (2*t, a) * qreal(0.5); - else return (t == qreal(1.0)) ? qreal(1.0) : easeOutBounce (2*t - 1, a) * qreal(0.5) + qreal(0.5); + if (t < 0.5) return easeInBounce (2*t, a)/2; + else return (t == 1.0) ? 1.0 : easeOutBounce (2*t - 1, a)/2 + 0.5; } /** @@ -608,13 +612,13 @@ static qreal easeInOutBounce(qreal t, qreal a) */ static qreal easeOutInBounce(qreal t, qreal a) { - if (t < qreal(0.5)) return easeOutBounce_helper(t*2, qreal(0.5), a); - return qreal(1.0) - easeOutBounce_helper (qreal(2.0)-2*t, qreal(0.5), a); + if (t < 0.5) return easeOutBounce_helper(t*2, 0.5, a); + return 1.0 - easeOutBounce_helper (2.0-2*t, 0.5, a); } static inline qreal qt_sinProgress(qreal value) { - return qSin((value * Q_PI) - Q_PI2) * qreal(0.5) + qreal(0.5); + return qSin((value * M_PI) - M_PI_2) / 2 + qreal(0.5); } static inline qreal qt_smoothBeginEndMixFactor(qreal value) @@ -652,7 +656,7 @@ static qreal easeOutCurve(qreal t) */ static qreal easeSineCurve(qreal t) { - return (qSin(((t * Q_2PI)) - Q_PI2) + 1) * qreal(0.5); + return (qSin(((t * M_PI * 2)) - M_PI_2) + 1) / 2; } /** @@ -661,6 +665,6 @@ static qreal easeSineCurve(qreal t) */ static qreal easeCosineCurve(qreal t) { - return (qCos(((t * Q_2PI)) - Q_PI2) + 1) * qreal(0.5); + return (qCos(((t * M_PI * 2)) - M_PI_2) + 1) / 2; } diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h index 6befb33..9558256 100644 --- a/src/corelib/global/qglobal.h +++ b/src/corelib/global/qglobal.h @@ -1081,14 +1081,14 @@ template inline T qAbs(const T &t) { return t >= 0 ? t : -t; } inline int qRound(qreal d) -{ return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); } +{ return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); } #if defined(QT_NO_FPU) || defined(QT_ARCH_ARM) || defined(QT_ARCH_WINDOWSCE) || defined(QT_ARCH_SYMBIAN) inline qint64 qRound64(double d) { return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); } #else inline qint64 qRound64(qreal d) -{ return d >= 0.0 ? qint64(d + qreal(0.5)) : qint64(d - qreal(qint64(d-1)) + qreal(0.5)) + qint64(d-1); } +{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); } #endif template diff --git a/src/corelib/global/qnumeric_p.h b/src/corelib/global/qnumeric_p.h index 3f7b5b5..c8b5735 100644 --- a/src/corelib/global/qnumeric_p.h +++ b/src/corelib/global/qnumeric_p.h @@ -57,12 +57,6 @@ QT_BEGIN_NAMESPACE -static const qreal Q_PI = qreal(3.14159265358979323846); // pi -static const qreal Q_2PI = qreal(6.28318530717958647693); // 2*pi -static const qreal Q_PI2 = qreal(1.57079632679489661923); // pi/2 -static const qreal Q_PI180 = qreal(0.01745329251994329577); // pi/180 -static const qreal Q_180PI = qreal(57.29577951308232087685); // 180/pi - #if !defined(Q_CC_MIPS) static const union { unsigned char c[8]; double d; } qt_be_inf_bytes = { { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } }; diff --git a/src/corelib/kernel/qmath.h b/src/corelib/kernel/qmath.h index ef3a4b0..a9e4378 100644 --- a/src/corelib/kernel/qmath.h +++ b/src/corelib/kernel/qmath.h @@ -45,7 +45,6 @@ #include #include -#include QT_BEGIN_HEADER @@ -107,16 +106,6 @@ inline qreal qAcos(qreal v) return acos(v); } -inline qreal qAsin(qreal v) -{ -#ifdef QT_USE_MATH_H_FLOATS - if (sizeof(qreal) == sizeof(float)) - return asinf(float(v)); - else -#endif - return asin(v); -} - inline qreal qSqrt(qreal v) { #ifdef QT_USE_MATH_H_FLOATS @@ -147,42 +136,28 @@ inline qreal qPow(qreal x, qreal y) return pow(x, y); } +#ifndef M_PI +#define M_PI (3.14159265358979323846) +#endif + inline qreal qFastSin(qreal x) { - int si = int(x * (qreal(0.5) * QT_SINE_TABLE_SIZE / Q_PI)); // Would be more accurate with qRound, but slower. - qreal d = x - si * (qreal(2.0) * Q_PI / QT_SINE_TABLE_SIZE); + int si = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower. + qreal d = x - si * (2.0 * M_PI / QT_SINE_TABLE_SIZE); int ci = si + QT_SINE_TABLE_SIZE / 4; si &= QT_SINE_TABLE_SIZE - 1; ci &= QT_SINE_TABLE_SIZE - 1; - return qt_sine_table[si] + (qt_sine_table[ci] - qreal(0.5) * qt_sine_table[si] * d) * d; + return qt_sine_table[si] + (qt_sine_table[ci] - 0.5 * qt_sine_table[si] * d) * d; } inline qreal qFastCos(qreal x) { - int ci = int(x * (qreal(0.5) * QT_SINE_TABLE_SIZE / Q_PI)); // Would be more accurate with qRound, but slower. - qreal d = x - ci * (qreal(2.0) * Q_PI / QT_SINE_TABLE_SIZE); + int ci = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower. + qreal d = x - ci * (2.0 * M_PI / QT_SINE_TABLE_SIZE); int si = ci + QT_SINE_TABLE_SIZE / 4; si &= QT_SINE_TABLE_SIZE - 1; ci &= QT_SINE_TABLE_SIZE - 1; - return qt_sine_table[si] - (qt_sine_table[ci] + qreal(0.5) * qt_sine_table[si] * d) * d; -} - -inline qreal qFabs(qreal x) -{ -#ifdef QT_USE_MATH_H_FLOATS - if(sizeof(qreal) == sizeof(float)) - return fabsf(x); -#endif - return fabs(x); -} - -inline qreal qAtan2(qreal x, qreal y) -{ -#ifdef QT_USE_MATH_H_FLOATS - if(sizeof(qreal) == sizeof(float)) - return atan2f(x, y); -#endif - return atan2(x, y); + return qt_sine_table[si] - (qt_sine_table[ci] + 0.5 * qt_sine_table[si] * d) * d; } QT_END_NAMESPACE diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp index 5ae2dde..db6435e 100644 --- a/src/corelib/tools/qdatetime.cpp +++ b/src/corelib/tools/qdatetime.cpp @@ -1915,7 +1915,7 @@ QTime QTime::fromString(const QString& s, Qt::DateFormat f) const float msec(msec_s.toFloat(&ok)); if (!ok) return QTime(); - return QTime(hour, minute, second, qMin(qRound(msec * qreal(1000.0)), 999)); + return QTime(hour, minute, second, qMin(qRound(msec * 1000.0), 999)); } } } diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp index a629ebc..3e1e1ee 100644 --- a/src/corelib/tools/qeasingcurve.cpp +++ b/src/corelib/tools/qeasingcurve.cpp @@ -317,7 +317,7 @@ class QEasingCurveFunction public: enum Type { In, Out, InOut, OutIn }; - QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = qreal(0.3), qreal amplitude = qreal(1.0), + QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = 0.3, qreal amplitude = 1.0, qreal overshoot = 1.70158f) : _t(type), _p(period), _a(amplitude), _o(overshoot) { } @@ -667,7 +667,7 @@ bool QEasingCurve::operator==(const QEasingCurve &other) const */ qreal QEasingCurve::amplitude() const { - return d_ptr->config ? d_ptr->config->_a : qreal(1.0); + return d_ptr->config ? d_ptr->config->_a : 1.0; } /*! @@ -691,7 +691,7 @@ void QEasingCurve::setAmplitude(qreal amplitude) */ qreal QEasingCurve::period() const { - return d_ptr->config ? d_ptr->config->_p : qreal(0.3); + return d_ptr->config ? d_ptr->config->_p : 0.3; } /*! @@ -742,9 +742,9 @@ QEasingCurve::Type QEasingCurve::type() const void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType) { - qreal amp = qreal(-1.0); - qreal period = qreal(-1.0); - qreal overshoot = qreal(-1.0); + qreal amp = -1.0; + qreal period = -1.0; + qreal overshoot = -1.0; if (config) { amp = config->_a; @@ -754,13 +754,13 @@ void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType) config = 0; } - if (isConfigFunction(newType) || (amp != qreal(-1.0)) || (period != qreal(-1.0)) || (overshoot != qreal(-1.0))) { + if (isConfigFunction(newType) || (amp != -1.0) || (period != -1.0) || (overshoot != -1.0)) { config = curveToFunctionObject(newType); - if (amp != qreal(-1.0)) + if (amp != -1.0) config->_a = amp; - if (period != qreal(-1.0)) + if (period != -1.0) config->_p = period; - if (overshoot != qreal(-1.0)) + if (overshoot != -1.0) config->_o = overshoot; func = 0; } else if (newType != QEasingCurve::Custom) { diff --git a/src/corelib/tools/qline.cpp b/src/corelib/tools/qline.cpp index 5b30c97..d0afb7a 100644 --- a/src/corelib/tools/qline.cpp +++ b/src/corelib/tools/qline.cpp @@ -574,7 +574,7 @@ qreal QLineF::angle() const const qreal dx = pt2.x() - pt1.x(); const qreal dy = pt2.y() - pt1.y(); - const qreal theta = qAtan2(-dy, dx) * qreal(360.0) / Q_2PI; + const qreal theta = atan2(-dy, dx) * 360.0 / M_2PI; const qreal theta_normalized = theta < 0 ? theta + 360 : theta; @@ -598,7 +598,7 @@ qreal QLineF::angle() const */ void QLineF::setAngle(qreal angle) { - const qreal angleR = angle * Q_2PI / qreal(360.0); + const qreal angleR = angle * M_2PI / 360.0; const qreal l = length(); const qreal dx = qCos(angleR) * l; @@ -620,7 +620,7 @@ void QLineF::setAngle(qreal angle) */ QLineF QLineF::fromPolar(qreal length, qreal angle) { - const qreal angleR = angle * Q_2PI / qreal(360.0); + const qreal angleR = angle * M_2PI / 360.0; return QLineF(0, 0, qCos(angleR) * length, -qSin(angleR) * length); } @@ -639,7 +639,7 @@ QLineF QLineF::unitVector() const QLineF f(p1(), QPointF(pt1.x() + x/len, pt1.y() + y/len)); #ifndef QT_NO_DEBUG - if (qAbs(f.length() - 1) >= qreal(0.001)) + if (qAbs(f.length() - 1) >= 0.001) qWarning("QLine::unitVector: New line does not have unit length"); #endif @@ -814,8 +814,8 @@ qreal QLineF::angle(const QLineF &l) const qreal cos_line = (dx()*l.dx() + dy()*l.dy()) / (length()*l.length()); qreal rad = 0; // only accept cos_line in the range [-1,1], if it is outside, use 0 (we return 0 rather than PI for those cases) - if (cos_line >= qreal(-1.0) && cos_line <= qreal(1.0)) rad = qAcos( cos_line ); - return rad * 360 / Q_2PI; + if (cos_line >= -1.0 && cos_line <= 1.0) rad = acos( cos_line ); + return rad * 360 / M_2PI; } diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp index bcd060e..9d495e9 100644 --- a/src/gui/graphicsview/qgraphicsitem.cpp +++ b/src/gui/graphicsview/qgraphicsitem.cpp @@ -8460,9 +8460,8 @@ QPainterPath QGraphicsEllipseItem::shape() const if (d->rect.isNull()) return path; if (d->spanAngle != 360 * 16) { - const qreal inv_16 = 1 / qreal(16.0); path.moveTo(d->rect.center()); - path.arcTo(d->rect, d->startAngle * inv_16, d->spanAngle * inv_16); + path.arcTo(d->rect, d->startAngle / 16.0, d->spanAngle / 16.0); } else { path.addEllipse(d->rect); } diff --git a/src/gui/graphicsview/qgraphicsitemanimation.cpp b/src/gui/graphicsview/qgraphicsitemanimation.cpp index 1516e46..be2f300 100644 --- a/src/gui/graphicsview/qgraphicsitemanimation.cpp +++ b/src/gui/graphicsview/qgraphicsitemanimation.cpp @@ -165,7 +165,7 @@ qreal QGraphicsItemAnimationPrivate::linearValueForStep(qreal step, QList void QGraphicsItemAnimationPrivate::insertUniquePair(qreal step, qreal value, QList *binList, const char* method) { - if (step < qreal(0.0) || step > qreal(1.0)) { + if (step < 0.0 || step > 1.0) { qWarning("QGraphicsItemAnimation::%s: invalid step = %f", method, step); return; } @@ -255,7 +255,7 @@ void QGraphicsItemAnimation::setTimeLine(QTimeLine *timeLine) */ QPointF QGraphicsItemAnimation::posAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::posAt: invalid step = %f", step); return QPointF(d->linearValueForStep(step, &d->xPosition, d->startPos.x()), @@ -294,7 +294,7 @@ QList > QGraphicsItemAnimation::posList() const */ QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::matrixAt: invalid step = %f", step); QMatrix matrix; @@ -316,7 +316,7 @@ QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const */ qreal QGraphicsItemAnimation::rotationAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::rotationAt: invalid step = %f", step); return d->linearValueForStep(step, &d->rotation); @@ -405,7 +405,7 @@ QList > QGraphicsItemAnimation::translationList() const */ qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::verticalScaleAt: invalid step = %f", step); return d->linearValueForStep(step, &d->verticalScale, 1); @@ -418,7 +418,7 @@ qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const */ qreal QGraphicsItemAnimation::horizontalScaleAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::horizontalScaleAt: invalid step = %f", step); return d->linearValueForStep(step, &d->horizontalScale, 1); @@ -457,7 +457,7 @@ QList > QGraphicsItemAnimation::scaleList() const */ qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::verticalShearAt: invalid step = %f", step); return d->linearValueForStep(step, &d->verticalShear, 0); @@ -470,7 +470,7 @@ qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const */ qreal QGraphicsItemAnimation::horizontalShearAt(qreal step) const { - if (step < qreal(0.0) || step > qreal(1.0)) + if (step < 0.0 || step > 1.0) qWarning("QGraphicsItemAnimation::horizontalShearAt: invalid step = %f", step); return d->linearValueForStep(step, &d->horizontalShear, 0); @@ -527,7 +527,7 @@ void QGraphicsItemAnimation::clear() */ void QGraphicsItemAnimation::setStep(qreal x) { - if (x < qreal(0.0) || x > qreal(1.0)) { + if (x < 0.0 || x > 1.0) { qWarning("QGraphicsItemAnimation::setStep: invalid step = %f", x); return; } diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp index 917d3ae..13f31b8 100644 --- a/src/gui/graphicsview/qgraphicsscene.cpp +++ b/src/gui/graphicsview/qgraphicsscene.cpp @@ -4168,13 +4168,13 @@ static void _q_paintItem(QGraphicsItem *item, QPainter *painter, QGraphicsWidget *widgetItem = static_cast(item); QGraphicsProxyWidget *proxy = qobject_cast(widgetItem); const qreal windowOpacity = (proxy && proxy->widget() && useWindowOpacity) - ? proxy->widget()->windowOpacity() : qreal(1.0); + ? proxy->widget()->windowOpacity() : 1.0; const qreal oldPainterOpacity = painter->opacity(); if (qFuzzyIsNull(windowOpacity)) return; // Set new painter opacity. - if (windowOpacity < qreal(1.0)) + if (windowOpacity < 1.0) painter->setOpacity(oldPainterOpacity * windowOpacity); // set layoutdirection on the painter @@ -4268,7 +4268,7 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte QGraphicsProxyWidget *proxy = item->isWidget() ? qobject_cast(static_cast(item)) : 0; if (proxy && proxy->widget()) { const qreal windowOpacity = proxy->widget()->windowOpacity(); - if (windowOpacity < qreal(1.0)) + if (windowOpacity < 1.0) newPainterOpacity *= windowOpacity; } diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp index 61a3758..27fd09e 100644 --- a/src/gui/graphicsview/qgraphicsview.cpp +++ b/src/gui/graphicsview/qgraphicsview.cpp @@ -297,7 +297,7 @@ inline int q_round_bound(qreal d) //### (int)(qreal) INT_MAX != INT_MAX for sing return INT_MIN; else if (d >= (qreal) INT_MAX) return INT_MAX; - return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); + return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); } void QGraphicsViewPrivate::translateTouchEvent(QGraphicsViewPrivate *d, QTouchEvent *touchEvent) diff --git a/src/gui/graphicsview/qgraphicswidget_p.cpp b/src/gui/graphicsview/qgraphicswidget_p.cpp index 7847635..b747a30 100644 --- a/src/gui/graphicsview/qgraphicswidget_p.cpp +++ b/src/gui/graphicsview/qgraphicswidget_p.cpp @@ -457,13 +457,13 @@ static QSizeF closestAcceptableSize(const QSizeF &proposed, min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget); do { - if (maxw - minw < qreal(0.1)) { + if (maxw - minw < 0.1) { // we still havent found anything, cut off binary search minw = maxw; minh = maxh; } - middlew = minw + (maxw - minw) * qreal(0.5); - middleh = minh + (maxh - minh) * qreal(0.5); + middlew = minw + (maxw - minw)/2.0; + middleh = minh + (maxh - minh)/2.0; min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget); diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp index f6fa16b..f61360a 100644 --- a/src/gui/graphicsview/qgridlayoutengine.cpp +++ b/src/gui/graphicsview/qgridlayoutengine.cpp @@ -69,22 +69,21 @@ static void insertOrRemoveItems(QVector &items, int index, int delta) static qreal growthFactorBelowPreferredSize(qreal desired, qreal sumAvailable, qreal sumDesired) { - Q_ASSERT(sumDesired != qreal(0.0)); - const qreal inv_sumDesired = 1 / sumDesired; - return desired * ::pow(sumAvailable * inv_sumDesired, desired * inv_sumDesired); + Q_ASSERT(sumDesired != 0.0); + return desired * ::pow(sumAvailable / sumDesired, desired / sumDesired); } static qreal fixedDescent(qreal descent, qreal ascent, qreal targetSize) { - if (descent < qreal(0.0)) - return qreal(-1.0); + if (descent < 0.0) + return -1.0; - Q_ASSERT(descent >= qreal(0.0)); - Q_ASSERT(ascent >= qreal(0.0)); + Q_ASSERT(descent >= 0.0); + Q_ASSERT(ascent >= 0.0); Q_ASSERT(targetSize >= ascent + descent); qreal extra = targetSize - (ascent + descent); - return descent + (extra * qreal(0.5)); + return descent + (extra / 2.0); } static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int which) @@ -101,7 +100,7 @@ static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int void QGridLayoutBox::add(const QGridLayoutBox &other, int stretch, qreal spacing) { - Q_ASSERT(q_minimumDescent < qreal(0.0)); + Q_ASSERT(q_minimumDescent < 0.0); q_minimumSize += other.q_minimumSize + spacing; q_preferredSize += other.q_preferredSize + spacing; @@ -135,7 +134,7 @@ void QGridLayoutBox::normalize() q_preferredSize = qBound(q_minimumSize, q_preferredSize, q_maximumSize); q_minimumDescent = qMin(q_minimumDescent, q_minimumSize); - Q_ASSERT((q_minimumDescent < qreal(0.0)) == (q_minimumAscent < qreal(0.0))); + Q_ASSERT((q_minimumDescent < 0.0) == (q_minimumAscent < 0.0)); } #ifdef QT_DEBUG @@ -162,7 +161,7 @@ void QGridLayoutRowData::reset(int count) boxes.fill(QGridLayoutBox(), count); multiCellMap.clear(); stretches.fill(0, count); - spacings.fill(qreal(0.0), count); + spacings.fill(0.0, count); hasIgnoreFlag = false; } @@ -183,7 +182,7 @@ void QGridLayoutRowData::distributeMultiCells() for (int j = 0; j < NSizes; ++j) { qreal extra = compare(totalBox, box, j); - if (extra > qreal(0.0)) { + if (extra > 0.0) { calculateGeometries(start, end, totalBox.q_sizes(j), dummy.data(), newSizes.data(), 0, totalBox); @@ -211,7 +210,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz int n = end - start; QVarLengthArray newSizes(n); QVarLengthArray factors(n); - qreal sumFactors = qreal(0.0); + qreal sumFactors = 0.0; int sumStretches = 0; qreal sumAvailable; @@ -224,25 +223,24 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz stealBox(start, end, MinimumSize, positions, sizes); sumAvailable = targetSize - totalBox.q_minimumSize; - if (sumAvailable > qreal(0.0)) { - const qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize; + if (sumAvailable > 0.0) { + qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize; for (int i = 0; i < n; ++i) { if (ignore.testBit(start + i)) { - factors[i] = qreal(0.0); + factors[i] = 0.0; continue; } const QGridLayoutBox &box = boxes.at(start + i); - const qreal desired = box.q_preferredSize - box.q_minimumSize; + qreal desired = box.q_preferredSize - box.q_minimumSize; factors[i] = growthFactorBelowPreferredSize(desired, sumAvailable, sumDesired); sumFactors += factors[i]; } - const qreal inv_sumFactors = 1 / sumFactors; for (int i = 0; i < n; ++i) { - Q_ASSERT(sumFactors > qreal(0.0)); - const qreal delta = sumAvailable * factors[i] * inv_sumFactors; + Q_ASSERT(sumFactors > 0.0); + qreal delta = sumAvailable * factors[i] / sumFactors; newSizes[i] = sizes[i] + delta; } } @@ -250,46 +248,46 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz stealBox(start, end, PreferredSize, positions, sizes); sumAvailable = targetSize - totalBox.q_preferredSize; - if (sumAvailable > qreal(0.0)) { + if (sumAvailable > 0.0) { bool somethingHasAMaximumSize = false; - qreal sumPreferredSizes = qreal(0.0); + qreal sumPreferredSizes = 0.0; for (int i = 0; i < n; ++i) sumPreferredSizes += sizes[i]; for (int i = 0; i < n; ++i) { if (ignore.testBit(start + i)) { - newSizes[i] = qreal(0.0); - factors[i] = qreal(0.0); + newSizes[i] = 0.0; + factors[i] = 0.0; continue; } const QGridLayoutBox &box = boxes.at(start + i); - const qreal desired = box.q_maximumSize - box.q_preferredSize; - if (desired == qreal(0.0)) { + qreal desired = box.q_maximumSize - box.q_preferredSize; + if (desired == 0.0) { newSizes[i] = sizes[i]; - factors[i] = qreal(0.0); + factors[i] = 0.0; } else { - Q_ASSERT(desired > qreal(0.0)); + Q_ASSERT(desired > 0.0); int stretch = stretches[start + i]; if (sumStretches == 0) { if (hasIgnoreFlag) { - factors[i] = (stretch < 0) ? qreal(1.0) : qreal(0.0); + factors[i] = (stretch < 0) ? 1.0 : 0.0; } else { - factors[i] = (stretch < 0) ? sizes[i] : qreal(0.0); + factors[i] = (stretch < 0) ? sizes[i] : 0.0; } } else if (stretch == sumStretches) { - factors[i] = qreal(1.0); + factors[i] = 1.0; } else if (stretch <= 0) { - factors[i] = qreal(0.0); + factors[i] = 0.0; } else { qreal ultimatePreferredSize; qreal ultimateSumPreferredSizes; qreal x = ((stretch * sumPreferredSizes) - (sumStretches * box.q_preferredSize)) / (sumStretches - stretch); - if (x >= qreal(0.0)) { + if (x >= 0.0) { ultimatePreferredSize = box.q_preferredSize + x; ultimateSumPreferredSizes = sumPreferredSizes + x; } else { @@ -303,8 +301,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz (at the expense of the stretch factors, which are not fully respected during the transition). */ - ultimatePreferredSize = ultimatePreferredSize * qreal(1.5); - ultimateSumPreferredSizes = ultimateSumPreferredSizes * qreal(1.5); + ultimatePreferredSize = ultimatePreferredSize * 3 / 2; + ultimateSumPreferredSizes = ultimateSumPreferredSizes * 3 / 2; qreal ultimateFactor = (stretch * ultimateSumPreferredSizes / sumStretches) @@ -325,7 +323,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz if (desired < sumAvailable) somethingHasAMaximumSize = true; - newSizes[i] = qreal(-1.0); + newSizes[i] = -1.0; } } @@ -334,7 +332,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz keepGoing = false; for (int i = 0; i < n; ++i) { - if (newSizes[i] >= qreal(0.0)) + if (newSizes[i] >= 0.0) continue; const QGridLayoutBox &box = boxes.at(start + i); @@ -343,7 +341,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz newSizes[i] = box.q_maximumSize; sumAvailable -= box.q_maximumSize - sizes[i]; sumFactors -= factors[i]; - keepGoing = (sumAvailable > qreal(0.0)); + keepGoing = (sumAvailable > 0.0); if (!keepGoing) break; } @@ -351,8 +349,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz } for (int i = 0; i < n; ++i) { - if (newSizes[i] < qreal(0.0)) { - qreal delta = (sumFactors == qreal(0.0)) ? qreal(0.0) + if (newSizes[i] < 0.0) { + qreal delta = (sumFactors == 0.0) ? 0.0 : sumAvailable * factors[i] / sumFactors; newSizes[i] = sizes[i] + delta; } @@ -408,8 +406,8 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const { QGridLayoutBox result; if (start < end) { - result.q_maximumSize = qreal(0.0); - qreal nextSpacing = qreal(0.0); + result.q_maximumSize = 0.0; + qreal nextSpacing = 0.0; for (int i = start; i < end; ++i) { result.add(boxes.at(i), stretches.at(i), nextSpacing); nextSpacing = spacings.at(i); @@ -420,11 +418,11 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes) { - qreal offset = qreal(0.0); - qreal nextSpacing = qreal(0.0); + qreal offset = 0.0; + qreal nextSpacing = 0.0; for (int i = start; i < end; ++i) { - qreal avail = qreal(0.0); + qreal avail = 0.0; if (!ignore.testBit(i)) { const QGridLayoutBox &box = boxes.at(i); diff --git a/src/gui/graphicsview/qsimplex_p.cpp b/src/gui/graphicsview/qsimplex_p.cpp index 1b3eaf9..cd40f9e 100644 --- a/src/gui/graphicsview/qsimplex_p.cpp +++ b/src/gui/graphicsview/qsimplex_p.cpp @@ -485,8 +485,8 @@ bool QSimplex::iterate() // Normalize Pivot Row qreal pivot = valueAt(pivotRow, pivotColumn); - if (pivot != qreal(1.0)) - combineRows(pivotRow, pivotRow, (qreal(1.0) - pivot) / pivot); + if (pivot != 1.0) + combineRows(pivotRow, pivotRow, (1.0 - pivot) / pivot); // Update other rows for (int row=0; row < rows; ++row) { diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp index ebad019..6d96d7a 100644 --- a/src/gui/image/qimage.cpp +++ b/src/gui/image/qimage.cpp @@ -5351,19 +5351,19 @@ int QImage::metric(PaintDeviceMetric metric) const break; case PdmDpiX: - return qRound(d->dpmx * qreal(0.0254)); + return qRound(d->dpmx * 0.0254); break; case PdmDpiY: - return qRound(d->dpmy * qreal(0.0254)); + return qRound(d->dpmy * 0.0254); break; case PdmPhysicalDpiX: - return qRound(d->dpmx * qreal(0.0254)); + return qRound(d->dpmx * 0.0254); break; case PdmPhysicalDpiY: - return qRound(d->dpmy * qreal(0.0254)); + return qRound(d->dpmy * 0.0254); break; default: @@ -5429,12 +5429,12 @@ bool qt_xForm_helper(const QTransform &trueMat, int xoffset, int type, int depth uchar *dptr, int dbpl, int p_inc, int dHeight, const uchar *sptr, int sbpl, int sWidth, int sHeight) { - int m11 = int(trueMat.m11()*qreal(4096.0)); - int m12 = int(trueMat.m12()*qreal(4096.0)); - int m21 = int(trueMat.m21()*qreal(4096.0)); - int m22 = int(trueMat.m22()*qreal(4096.0)); - int dx = qRound(trueMat.dx()*qreal(4096.0)); - int dy = qRound(trueMat.dy()*qreal(4096.0)); + int m11 = int(trueMat.m11()*4096.0); + int m12 = int(trueMat.m12()*4096.0); + int m21 = int(trueMat.m21()*4096.0); + int m22 = int(trueMat.m22()*4096.0); + int dx = qRound(trueMat.dx()*4096.0); + int dy = qRound(trueMat.dy()*4096.0); int m21ydx = dx + (xoffset<<16) + (m11 + m21) / 2; int m22ydy = dy + (m12 + m22) / 2; @@ -6018,22 +6018,22 @@ QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode if (mat.type() <= QTransform::TxScale) { if (mat.type() == QTransform::TxNone) // identity matrix return *this; - else if (mat.m11() == qreal(-1.) && mat.m22() == qreal(-1.)) + else if (mat.m11() == -1. && mat.m22() == -1.) return rotated180(*this); if (mode == Qt::FastTransformation) { hd = qRound(qAbs(mat.m22()) * hs); wd = qRound(qAbs(mat.m11()) * ws); } else { - hd = int(qAbs(mat.m22()) * hs + qreal(0.9999)); - wd = int(qAbs(mat.m11()) * ws + qreal(0.9999)); + hd = int(qAbs(mat.m22()) * hs + 0.9999); + wd = int(qAbs(mat.m11()) * ws + 0.9999); } scale_xform = true; } else { if (mat.type() <= QTransform::TxRotate && mat.m11() == 0 && mat.m22() == 0) { - if (mat.m12() == qreal(1.) && mat.m21() == qreal(-1.)) + if (mat.m12() == 1. && mat.m21() == -1.) return rotated90(*this); - else if (mat.m12() == qreal(-1.) && mat.m21() == qreal(1.)) + else if (mat.m12() == -1. && mat.m21() == 1.) return rotated270(*this); } diff --git a/src/gui/image/qpaintengine_pic.cpp b/src/gui/image/qpaintengine_pic.cpp index b6fea8b..80b16cf 100644 --- a/src/gui/image/qpaintengine_pic.cpp +++ b/src/gui/image/qpaintengine_pic.cpp @@ -342,7 +342,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr) } d->pic_d->pictb.seek(newpos); // set to new position - if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) { + if (br.width() > 0.0 || br.height() > 0.0) { if (corr) { // widen bounding rect int w2 = painter()->pen().width() / 2; br.setCoords(br.left() - w2, br.top() - w2, @@ -354,7 +354,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr) br &= cr; } - if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) { + if (br.width() > 0.0 || br.height() > 0.0) { int minx = qFloor(br.left()); int miny = qFloor(br.top()); int maxx = qCeil(br.right()); diff --git a/src/gui/image/qpicture.cpp b/src/gui/image/qpicture.cpp index 39a4fcc..f502827 100644 --- a/src/gui/image/qpicture.cpp +++ b/src/gui/image/qpicture.cpp @@ -967,10 +967,10 @@ int QPicture::metric(PaintDeviceMetric m) const val = brect.height(); break; case PdmWidthMM: - val = int(qreal(25.4)/qt_defaultDpiX()*brect.width()); + val = int(25.4/qt_defaultDpiX()*brect.width()); break; case PdmHeightMM: - val = int(qreal(25.4)/qt_defaultDpiY()*brect.height()); + val = int(25.4/qt_defaultDpiY()*brect.height()); break; case PdmDpiX: case PdmPhysicalDpiX: diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp index 5ff3109..1b01e6f 100644 --- a/src/gui/image/qpixmap_raster.cpp +++ b/src/gui/image/qpixmap_raster.cpp @@ -373,9 +373,9 @@ int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const case QPaintDevice::PdmHeight: return h; case QPaintDevice::PdmWidthMM: - return qRound(d->width * qreal(25.4) / qt_defaultDpiX()); + return qRound(d->width * 25.4 / qt_defaultDpiX()); case QPaintDevice::PdmHeightMM: - return qRound(d->width * qreal(25.4) / qt_defaultDpiY()); + return qRound(d->width * 25.4 / qt_defaultDpiY()); case QPaintDevice::PdmNumColors: return d->colortable.size(); case QPaintDevice::PdmDepth: diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp index cc73e3e..f7a880c 100644 --- a/src/gui/image/qpixmap_s60.cpp +++ b/src/gui/image/qpixmap_s60.cpp @@ -568,7 +568,6 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const if (!cfbsBitmap) return 0; - qreal div_by_KTwipsPerInch = 1 / (qreal)KTwipsPerInch; switch (metric) { case QPaintDevice::PdmWidth: return cfbsBitmap->SizeInPixels().iWidth; @@ -576,23 +575,23 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const return cfbsBitmap->SizeInPixels().iHeight; case QPaintDevice::PdmWidthMM: { TInt twips = cfbsBitmap->SizeInTwips().iWidth; - return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch)); + return (int)(twips * (25.4/KTwipsPerInch)); } case QPaintDevice::PdmHeightMM: { TInt twips = cfbsBitmap->SizeInTwips().iHeight; - return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch)); + return (int)(twips * (25.4/KTwipsPerInch)); } case QPaintDevice::PdmNumColors: return TDisplayModeUtils::NumDisplayModeColors(cfbsBitmap->DisplayMode()); case QPaintDevice::PdmDpiX: case QPaintDevice::PdmPhysicalDpiX: { - qreal inches = cfbsBitmap->SizeInTwips().iWidth * div_by_KTwipsPerInch; + TReal inches = cfbsBitmap->SizeInTwips().iWidth / (TReal)KTwipsPerInch; TInt pixels = cfbsBitmap->SizeInPixels().iWidth; return pixels / inches; } case QPaintDevice::PdmDpiY: case QPaintDevice::PdmPhysicalDpiY: { - qreal inches = cfbsBitmap->SizeInTwips().iHeight * div_by_KTwipsPerInch; + TReal inches = cfbsBitmap->SizeInTwips().iHeight / (TReal)KTwipsPerInch; TInt pixels = cfbsBitmap->SizeInPixels().iHeight; return pixels / inches; } diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp index a52ba77..14c863b 100644 --- a/src/gui/image/qpnghandler.cpp +++ b/src/gui/image/qpnghandler.cpp @@ -732,8 +732,8 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in, png_set_compression_level(png_ptr, quality); } - if (gamma != qreal(0.0)) { - png_set_gAMA(png_ptr, info_ptr, qreal(1.0)/gamma); + if (gamma != 0.0) { + png_set_gAMA(png_ptr, info_ptr, 1.0/gamma); } png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn); diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp index 031c5ef..2c3d616 100644 --- a/src/gui/math3d/qmatrix4x4.cpp +++ b/src/gui/math3d/qmatrix4x4.cpp @@ -40,7 +40,6 @@ ****************************************************************************/ #include "qmatrix4x4.h" -#include #include #include #include @@ -59,7 +58,7 @@ QT_BEGIN_NAMESPACE \sa QVector3D, QGenericMatrix */ -static const qreal inv_dist_to_plane = qreal(1.) / qreal(1024.); +static const qreal inv_dist_to_plane = 1. / 1024.; /*! \fn QMatrix4x4::QMatrix4x4() @@ -507,23 +506,22 @@ QMatrix4x4 QMatrix4x4::transposed() const */ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor) { - const qreal inv_divisor = (1 / divisor); - m[0][0] *= inv_divisor; - m[0][1] *= inv_divisor; - m[0][2] *= inv_divisor; - m[0][3] *= inv_divisor; - m[1][0] *= inv_divisor; - m[1][1] *= inv_divisor; - m[1][2] *= inv_divisor; - m[1][3] *= inv_divisor; - m[2][0] *= inv_divisor; - m[2][1] *= inv_divisor; - m[2][2] *= inv_divisor; - m[2][3] *= inv_divisor; - m[3][0] *= inv_divisor; - m[3][1] *= inv_divisor; - m[3][2] *= inv_divisor; - m[3][3] *= inv_divisor; + m[0][0] /= divisor; + m[0][1] /= divisor; + m[0][2] /= divisor; + m[0][3] /= divisor; + m[1][0] /= divisor; + m[1][1] /= divisor; + m[1][2] /= divisor; + m[1][3] /= divisor; + m[2][0] /= divisor; + m[2][1] /= divisor; + m[2][2] /= divisor; + m[2][3] /= divisor; + m[3][0] /= divisor; + m[3][1] /= divisor; + m[3][2] /= divisor; + m[3][3] /= divisor; flagBits = General; return *this; } @@ -664,24 +662,23 @@ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor) */ QMatrix4x4 operator/(const QMatrix4x4& matrix, qreal divisor) { - const qreal inv_divisor = (1 / divisor); QMatrix4x4 m(1); // The "1" says to not load the identity. - m.m[0][0] = matrix.m[0][0] * inv_divisor; - m.m[0][1] = matrix.m[0][1] * inv_divisor; - m.m[0][2] = matrix.m[0][2] * inv_divisor; - m.m[0][3] = matrix.m[0][3] * inv_divisor; - m.m[1][0] = matrix.m[1][0] * inv_divisor; - m.m[1][1] = matrix.m[1][1] * inv_divisor; - m.m[1][2] = matrix.m[1][2] * inv_divisor; - m.m[1][3] = matrix.m[1][3] * inv_divisor; - m.m[2][0] = matrix.m[2][0] * inv_divisor; - m.m[2][1] = matrix.m[2][1] * inv_divisor; - m.m[2][2] = matrix.m[2][2] * inv_divisor; - m.m[2][3] = matrix.m[2][3] * inv_divisor; - m.m[3][0] = matrix.m[3][0] * inv_divisor; - m.m[3][1] = matrix.m[3][1] * inv_divisor; - m.m[3][2] = matrix.m[3][2] * inv_divisor; - m.m[3][3] = matrix.m[3][3] * inv_divisor; + m.m[0][0] = matrix.m[0][0] / divisor; + m.m[0][1] = matrix.m[0][1] / divisor; + m.m[0][2] = matrix.m[0][2] / divisor; + m.m[0][3] = matrix.m[0][3] / divisor; + m.m[1][0] = matrix.m[1][0] / divisor; + m.m[1][1] = matrix.m[1][1] / divisor; + m.m[1][2] = matrix.m[1][2] / divisor; + m.m[1][3] = matrix.m[1][3] / divisor; + m.m[2][0] = matrix.m[2][0] / divisor; + m.m[2][1] = matrix.m[2][1] / divisor; + m.m[2][2] = matrix.m[2][2] / divisor; + m.m[2][3] = matrix.m[2][3] / divisor; + m.m[3][0] = matrix.m[3][0] / divisor; + m.m[3][1] = matrix.m[3][1] / divisor; + m.m[3][2] = matrix.m[3][2] / divisor; + m.m[3][3] = matrix.m[3][3] / divisor; return m; } @@ -1014,7 +1011,7 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z) s = 0.0f; c = -1.0f; } else { - qreal a = angle * Q_PI180; + qreal a = angle * M_PI / 180.0f; c = qCos(a); s = qSin(a); } @@ -1069,11 +1066,10 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z) if (!quick) { qreal len = x * x + y * y + z * z; if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) { - const qreal inv_len = 1 / len; len = qSqrt(len); - x *= inv_len; - y *= inv_len; - z *= inv_len; + x /= len; + y /= len; + z /= len; } ic = 1.0f - c; m.m[0][0] = x * x * ic + c; @@ -1122,7 +1118,7 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z) s = 0.0f; c = -1.0f; } else { - qreal a = angle * Q_PI180; + qreal a = angle * M_PI / 180.0f; c = qCos(a); s = qSin(a); } @@ -1173,11 +1169,10 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z) if (!quick) { qreal len = x * x + y * y + z * z; if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) { - const qreal inv_len = 1 / len; len = qSqrt(len); - x *= inv_len; - y *= inv_len; - z *= inv_len; + x /= len; + y /= len; + z /= len; } ic = 1.0f - c; m.m[0][0] = x * x * ic + c; @@ -1304,39 +1299,35 @@ void QMatrix4x4::ortho(qreal left, qreal right, qreal bottom, qreal top, qreal n qreal width = right - left; qreal invheight = top - bottom; qreal clip = farPlane - nearPlane; - qreal inv_width = 1 / width; - qreal inv_invheight = 1 / invheight; - qreal inv_clip = 1 / clip; #ifndef QT_NO_VECTOR3D if (clip == 2.0f && (nearPlane + farPlane) == 0.0f) { // We can express this projection as a translate and scale // which will be more efficient to modify with further // transformations than producing a "General" matrix. - translate(QVector3D - (-(left + right) * inv_width, - -(top + bottom) * inv_invheight, + (-(left + right) / width, + -(top + bottom) / invheight, 0.0f)); scale(QVector3D - (2.0f * inv_width, - 2.0f * inv_invheight, + (2.0f / width, + 2.0f / invheight, -1.0f)); return; } #endif QMatrix4x4 m(1); - m.m[0][0] = 2.0f * inv_width; + m.m[0][0] = 2.0f / width; m.m[1][0] = 0.0f; m.m[2][0] = 0.0f; - m.m[3][0] = -(left + right) * inv_width; + m.m[3][0] = -(left + right) / width; m.m[0][1] = 0.0f; - m.m[1][1] = 2.0f * inv_invheight; + m.m[1][1] = 2.0f / invheight; m.m[2][1] = 0.0f; - m.m[3][1] = -(top + bottom) * inv_invheight; + m.m[3][1] = -(top + bottom) / invheight; m.m[0][2] = 0.0f; m.m[1][2] = 0.0f; - m.m[2][2] = -2.0f * inv_clip; - m.m[3][2] = -(nearPlane + farPlane) * inv_clip; + m.m[2][2] = -2.0f / clip; + m.m[3][2] = -(nearPlane + farPlane) / clip; m.m[0][3] = 0.0f; m.m[1][3] = 0.0f; m.m[2][3] = 0.0f; @@ -1363,24 +1354,21 @@ void QMatrix4x4::frustum(qreal left, qreal right, qreal bottom, qreal top, qreal // Construct the projection. QMatrix4x4 m(1); - const qreal width = right - left; - const qreal invheight = top - bottom; - const qreal clip = farPlane - nearPlane; - const qreal inv_width = 1 / width; - const qreal inv_invheight = 1 / invheight; - const qreal inv_clip = 1 / clip; - m.m[0][0] = 2.0f * nearPlane * inv_width; + qreal width = right - left; + qreal invheight = top - bottom; + qreal clip = farPlane - nearPlane; + m.m[0][0] = 2.0f * nearPlane / width; m.m[1][0] = 0.0f; - m.m[2][0] = (left + right) * inv_width; + m.m[2][0] = (left + right) / width; m.m[3][0] = 0.0f; m.m[0][1] = 0.0f; - m.m[1][1] = 2.0f * nearPlane * inv_invheight; - m.m[2][1] = (top + bottom) * inv_invheight; + m.m[1][1] = 2.0f * nearPlane / invheight; + m.m[2][1] = (top + bottom) / invheight; m.m[3][1] = 0.0f; m.m[0][2] = 0.0f; m.m[1][2] = 0.0f; - m.m[2][2] = -(nearPlane + farPlane) * inv_clip; - m.m[3][2] = -2.0f * nearPlane * farPlane * inv_clip; + m.m[2][2] = -(nearPlane + farPlane) / clip; + m.m[3][2] = -2.0f * nearPlane * farPlane / clip; m.m[0][3] = 0.0f; m.m[1][3] = 0.0f; m.m[2][3] = -1.0f; @@ -1406,13 +1394,12 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f // Construct the projection. QMatrix4x4 m(1); - const qreal radians = (angle * 0.5f) * Q_PI180; - const qreal sine = qSin(radians); + qreal radians = (angle / 2.0f) * M_PI / 180.0f; + qreal sine = qSin(radians); if (sine == 0.0f) return; - const qreal cotan = qCos(radians) / sine; - const qreal clip = farPlane - nearPlane; - const qreal inv_clip = 1 / clip; + qreal cotan = qCos(radians) / sine; + qreal clip = farPlane - nearPlane; m.m[0][0] = cotan / aspect; m.m[1][0] = 0.0f; m.m[2][0] = 0.0f; @@ -1423,8 +1410,8 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f m.m[3][1] = 0.0f; m.m[0][2] = 0.0f; m.m[1][2] = 0.0f; - m.m[2][2] = -(nearPlane + farPlane) * inv_clip; - m.m[3][2] = -(2.0f * nearPlane * farPlane) * inv_clip; + m.m[2][2] = -(nearPlane + farPlane) / clip; + m.m[3][2] = -(2.0f * nearPlane * farPlane) / clip; m.m[0][3] = 0.0f; m.m[1][3] = 0.0f; m.m[2][3] = -1.0f; diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp index da629e6..626cb3c 100644 --- a/src/gui/math3d/qquaternion.cpp +++ b/src/gui/math3d/qquaternion.cpp @@ -269,12 +269,11 @@ void QQuaternion::normalize() return; len = qSqrt(len); - const double inv_len = 1 / len; - xp *= inv_len; - yp *= inv_len; - zp *= inv_len; - wp *= inv_len; + xp /= len; + yp /= len; + zp /= len; + wp /= len; } /*! @@ -358,7 +357,7 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, qreal angle) // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56 // We normalize the result just in case the values are close // to zero, as suggested in the above FAQ. - qreal a = (angle * 0.5f) * Q_PI180; + qreal a = (angle / 2.0f) * M_PI / 180.0f; qreal s = qSin(a); qreal c = qCos(a); QVector3D ax = axis.normalized(); @@ -376,12 +375,11 @@ QQuaternion QQuaternion::fromAxisAndAngle { qreal length = qSqrt(x * x + y * y + z * z); if (!qFuzzyIsNull(length - 1.0f) && !qFuzzyIsNull(length)) { - const qreal inv_length = 1 / length; - x *= inv_length; - y *= inv_length; - z *= inv_length; + x /= length; + y /= length; + z /= length; } - qreal a = (angle * 0.5f) * Q_PI180; + qreal a = (angle / 2.0f) * M_PI / 180.0f; qreal s = qSin(a); qreal c = qCos(a); return QQuaternion(c, x * s, y * s, z * s).normalized(); @@ -518,13 +516,12 @@ QQuaternion QQuaternion::slerp // then revert to simple linear interpolation. qreal factor1 = 1.0f - t; qreal factor2 = t; - if ((1.0f - dot) > qreal(0.0000001)) { + if ((1.0f - dot) > 0.0000001) { qreal angle = qreal(qAcos(dot)); qreal sinOfAngle = qreal(qSin(angle)); - if (sinOfAngle > qreal(0.0000001)) { - const qreal inv_sinOfAngle = 1 / sinOfAngle; - factor1 = qreal(qSin((1.0f - t) * angle)) * inv_sinOfAngle; - factor2 = qreal(qSin(t * angle)) * inv_sinOfAngle; + if (sinOfAngle > 0.0000001) { + factor1 = qreal(qSin((1.0f - t) * angle)) / sinOfAngle; + factor2 = qreal(qSin(t * angle)) / sinOfAngle; } } diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp index a959979..2555a6f 100644 --- a/src/gui/math3d/qvector2d.cpp +++ b/src/gui/math3d/qvector2d.cpp @@ -216,9 +216,9 @@ void QVector2D::normalize() return; len = qSqrt(len); - const double inv_len = 1 / len; - xp *= inv_len; - yp *= inv_len; + + xp /= len; + yp /= len; } /*! diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp index a8cc807..9552e3a 100644 --- a/src/gui/math3d/qvector3d.cpp +++ b/src/gui/math3d/qvector3d.cpp @@ -233,10 +233,10 @@ void QVector3D::normalize() return; len = qSqrt(len); - const double inv_len = 1 / len; - xp *= inv_len; - yp *= inv_len; - zp *= inv_len; + + xp /= len; + yp /= len; + zp /= len; } /*! diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp index e4b2b82..1691a6d 100644 --- a/src/gui/math3d/qvector4d.cpp +++ b/src/gui/math3d/qvector4d.cpp @@ -285,11 +285,11 @@ void QVector4D::normalize() return; len = qSqrt(len); - const double inv_len = 1 / len; - xp *= inv_len; - yp *= inv_len; - zp *= inv_len; - wp *= inv_len; + + xp /= len; + yp /= len; + zp /= len; + wp /= len; } /*! @@ -459,8 +459,7 @@ QVector2D QVector4D::toVector2DAffine() const { if (qIsNull(wp)) return QVector2D(); - const qreal inv_wp = 1 / wp; - return QVector2D(xp * inv_wp, yp * inv_wp, 1); + return QVector2D(xp / wp, yp / wp, 1); } #endif @@ -487,8 +486,7 @@ QVector3D QVector4D::toVector3DAffine() const { if (qIsNull(wp)) return QVector3D(); - const qreal inv_wp = 1 / wp; - return QVector3D(xp * inv_wp, yp * inv_wp, zp * inv_wp, 1); + return QVector3D(xp / wp, yp / wp, zp / wp, 1); } #endif diff --git a/src/gui/painting/qbezier.cpp b/src/gui/painting/qbezier.cpp index c49086b..a6b4cef 100644 --- a/src/gui/painting/qbezier.cpp +++ b/src/gui/painting/qbezier.cpp @@ -62,10 +62,10 @@ QT_BEGIN_NAMESPACE #endif #ifndef M_SQRT2 -#define M_SQRT2 qreal(1.41421356237309504880) +#define M_SQRT2 1.41421356237309504880 #endif -#define log2(x) (qLn(qreal(x))/qLn(qreal(2.))) +#define log2(x) (qLn(x)/qLn(2.)) static inline qreal log4(qreal x) { @@ -132,7 +132,7 @@ static inline void flattenBezierWithoutInflections(QBezier &bez, qreal d = qAbs(dx * (bez.y3 - bez.y2) - dy * (bez.x3 - bez.x2)); - qreal t = qSqrt(qreal(4.) / qreal(3.) * normalized * flatness / d); + qreal t = qSqrt(4. / 3. * normalized * flatness / d); if (t > 1 || qFuzzyIsNull(t - (qreal)1.)) break; bez.parameterSplitLeft(t, &left); @@ -267,7 +267,7 @@ void QBezier::addToPolygonMixed(QPolygonF *polygon) const qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3); l = 1.; } - if (d < qreal(.5)*l || b == beziers + 31) { + if (d < .5*l || b == beziers + 31) { // good enough, we pop it off and add the endpoint polygon->append(QPointF(b->x4, b->y4)); --b; @@ -327,8 +327,8 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse const qreal o2 = offset*offset; const qreal max_dist_line = threshold*offset*offset; const qreal max_dist_normal = threshold*offset; - const qreal spacing = qreal(0.25); - for (qreal i = spacing; i < qreal(0.99); i += spacing) { + const qreal spacing = 0.25; + for (qreal i = spacing; i < 0.99; i += spacing) { QPointF p1 = b1->pointAt(i); QPointF p2 = b2->pointAt(i); qreal d = (p1.x() - p2.x())*(p1.x() - p2.x()) + (p1.y() - p2.y())*(p1.y() - p2.y()); @@ -337,7 +337,7 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse QPointF normalPoint = b1->normalVector(i); qreal l = qAbs(normalPoint.x()) + qAbs(normalPoint.y()); - if (l != qreal(0.)) { + if (l != 0.) { d = qAbs( normalPoint.x()*(p1.y() - p2.y()) - normalPoint.y()*(p1.x() - p2.x()) ) / l; if (d > max_dist_normal) return Split; @@ -418,14 +418,14 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr } QRectF b = orig->bounds(); - if (np == 4 && b.width() < qreal(.1)*offset && b.height() < qreal(.1)*offset) { + if (np == 4 && b.width() < .1*offset && b.height() < .1*offset) { qreal l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) + (orig->y1 - orig->y2)*(orig->y1 - orig->y1) * (orig->x3 - orig->x4)*(orig->x3 - orig->x4) + (orig->y3 - orig->y4)*(orig->y3 - orig->y4); qreal dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) + (orig->y1 - orig->y2)*(orig->y3 - orig->y4); - if (dot < 0 && dot*dot < qreal(0.8)*l) + if (dot < 0 && dot*dot < 0.8*l) // the points are close and reverse dirction. Approximate the whole // thing by a semi circle return Circle; @@ -444,7 +444,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr QPointF normal_sum = prev_normal + next_normal; - qreal r = qreal(1.0) + prev_normal.x() * next_normal.x() + qreal r = 1.0 + prev_normal.x() * next_normal.x() + prev_normal.y() * next_normal.y(); if (qFuzzyIsNull(r)) { @@ -468,7 +468,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr // This value is used to determine the length of control point vectors // when approximating arc segments as curves. The factor is multiplied // with the radius of the circle. -#define KAPPA qreal(0.5522847498) +#define KAPPA 0.5522847498 static bool addCircle(const QBezier *b, qreal offset, QBezier *o) @@ -490,32 +490,32 @@ static bool addCircle(const QBezier *b, qreal offset, QBezier *o) normals[1] /= -1*qSqrt(normals[1].x()*normals[1].x() + normals[1].y()*normals[1].y()); qreal angles[2]; - qreal sign = qreal(1.); + qreal sign = 1.; for (int i = 0; i < 2; ++i) { qreal cos_a = normals[i].x()*normals[i+1].x() + normals[i].y()*normals[i+1].y(); - if (cos_a > qreal(1.)) - cos_a = qreal(1.); - if (cos_a < qreal(-1.)) + if (cos_a > 1.) + cos_a = 1.; + if (cos_a < -1.) cos_a = -1; - angles[i] = qAcos(cos_a)/Q_PI; + angles[i] = acos(cos_a)/Q_PI; } - if (angles[0] + angles[1] > qreal(1.)) { + if (angles[0] + angles[1] > 1.) { // more than 180 degrees normals[1] = -normals[1]; - angles[0] = qreal(1.) - angles[0]; - angles[1] = qreal(1.) - angles[1]; - sign = qreal(-1.); + angles[0] = 1. - angles[0]; + angles[1] = 1. - angles[1]; + sign = -1.; } QPointF circle[3]; circle[0] = QPointF(b->x1, b->y1) + normals[0]*offset; - circle[1] = QPointF(qreal(0.5)*(b->x1 + b->x4), qreal(0.5)*(b->y1 + b->y4)) + normals[1]*offset; + circle[1] = QPointF(0.5*(b->x1 + b->x4), 0.5*(b->y1 + b->y4)) + normals[1]*offset; circle[2] = QPointF(b->x4, b->y4) + normals[2]*offset; for (int i = 0; i < 2; ++i) { - qreal kappa = qreal(2.)*KAPPA * sign * offset * angles[i]; + qreal kappa = 2.*KAPPA * sign * offset * angles[i]; o->x1 = circle[i].x(); o->y1 = circle[i].y(); @@ -695,7 +695,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth if (deptha > 0) { QBezier A[2]; a.split(&A[0], &A[1]); - qreal tmid = (t0+t1)*qreal(0.5); + qreal tmid = (t0+t1)*0.5; //qDebug()<<"\t1)"< 0) { QBezier B[2]; b.split(&B[0], &B[1]); - qreal umid = (u0 + u1)*qreal(0.5); + qreal umid = (u0 + u1)*0.5; depthb--; if (IntersectBB(a, B[0])) { //fprintf(stderr, "\t 7 from %d\n", currentD); @@ -783,13 +783,13 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth qreal xmk = b.x1 - a.x1; qreal ymk = b.y1 - a.y1; qreal det = xnm * ylk - ynm * xlk; - if (qreal(1.0) + det == qreal(1.0)) { + if (1.0 + det == 1.0) { return false; } else { qreal detinv = 1.0 / det; qreal rs = (xnm * ymk - ynm *xmk) * detinv; qreal rt = (xlk * ymk - ylk * xmk) * detinv; - if ((rs < qreal(0.0)) || (rs > qreal(1.0)) || (rt < qreal(0.0)) || (rt > qreal(1.0))) + if ((rs < 0.0) || (rs > 1.0) || (rt < 0.0) || (rt > 1.0)) return false; if (t) { @@ -816,17 +816,17 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b, QVector > *t) { if (IntersectBB(a, b)) { - QPointF la1(qFabs((a.x3 - a.x2) - (a.x2 - a.x1)), - qFabs((a.y3 - a.y2) - (a.y2 - a.y1))); - QPointF la2(qFabs((a.x4 - a.x3) - (a.x3 - a.x2)), - qFabs((a.y4 - a.y3) - (a.y3 - a.y2))); + QPointF la1(fabs((a.x3 - a.x2) - (a.x2 - a.x1)), + fabs((a.y3 - a.y2) - (a.y2 - a.y1))); + QPointF la2(fabs((a.x4 - a.x3) - (a.x3 - a.x2)), + fabs((a.y4 - a.y3) - (a.y3 - a.y2))); QPointF la; if (la1.x() > la2.x()) la.setX(la1.x()); else la.setX(la2.x()); if (la1.y() > la2.y()) la.setY(la1.y()); else la.setY(la2.y()); - QPointF lb1(qFabs((b.x3 - b.x2) - (b.x2 - b.x1)), - qFabs((b.y3 - b.y2) - (b.y2 - b.y1))); - QPointF lb2(qFabs((b.x4 - b.x3) - (b.x3 - b.x2)), - qFabs((b.y4 - b.y3) - (b.y3 - b.y2))); + QPointF lb1(fabs((b.x3 - b.x2) - (b.x2 - b.x1)), + fabs((b.y3 - b.y2) - (b.y2 - b.y1))); + QPointF lb2(fabs((b.x4 - b.x3) - (b.x3 - b.x2)), + fabs((b.y4 - b.y3) - (b.y3 - b.y2))); QPointF lb; if (lb1.x() > lb2.x()) lb.setX(lb1.x()); else lb.setX(lb2.x()); if (lb1.y() > lb2.y()) lb.setY(lb1.y()); else lb.setY(lb2.y()); @@ -836,27 +836,27 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b, else l0 = la.y(); int ra; - if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0)) + if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0) ra = 0; else - ra = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0)); + ra = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0)); if (lb.x() > lb.y()) l0 = lb.x(); else l0 = lb.y(); int rb; - if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0)) + if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0) rb = 0; else - rb = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0)); + rb = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0)); // if qreal is float then halve the number of subdivisions if (sizeof(qreal) == 4) { - ra *= qreal(0.5); - rb *= qreal(0.5); + ra /= 2; + rb /= 2; } - return RecursivelyIntersect(a, qreal(0.), qreal(1.), ra, b, qreal(0.), qreal(1.), rb, t); + return RecursivelyIntersect(a, 0., 1., ra, b, 0., 1., rb, t); } //Don't sort here because it breaks the orders of corresponding @@ -934,7 +934,7 @@ QVector< QList > QBezier::splitAtIntersections(QBezier &b) qreal QBezier::length(qreal error) const { - qreal length = qreal(0.0); + qreal length = 0.0; addIfClose(&length, error); @@ -945,7 +945,7 @@ void QBezier::addIfClose(qreal *length, qreal error) const { QBezier left, right; /* bez poly splits */ - qreal len = qreal(0.0); /* arc length */ + qreal len = 0.0; /* arc length */ qreal chord; /* chord length */ len = len + QLineF(QPointF(x1, y1),QPointF(x2, y2)).length(); @@ -988,7 +988,7 @@ qreal QBezier::tForY(qreal t0, qreal t1, qreal y) const qreal lt = t0; qreal dt; do { - qreal t = qreal(0.5) * (t0 + t1); + qreal t = 0.5 * (t0 + t1); qreal a, b, c, d; QBezier::coefficients(t, a, b, c, d); @@ -1054,15 +1054,15 @@ int QBezier::stationaryYPoints(qreal &t0, qreal &t1) const qreal QBezier::tAtLength(qreal l) const { qreal len = length(); - qreal t = qreal(1.0); - const qreal error = qreal(0.01); + qreal t = 1.0; + const qreal error = (qreal)0.01; if (l > len || qFuzzyCompare(l, len)) return t; - t *= qreal(0.5); + t *= 0.5; //int iters = 0; //qDebug()<<"LEN is "<x2 = (x1 + x2)*qreal(.5); - secondHalf->x3 = (x3 + x4)*qreal(.5); + qreal c = (x2 + x3)*.5; + firstHalf->x2 = (x1 + x2)*.5; + secondHalf->x3 = (x3 + x4)*.5; firstHalf->x1 = x1; secondHalf->x4 = x4; - firstHalf->x3 = (firstHalf->x2 + c)*qreal(.5); - secondHalf->x2 = (secondHalf->x3 + c)*qreal(.5); - firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*qreal(.5); + firstHalf->x3 = (firstHalf->x2 + c)*.5; + secondHalf->x2 = (secondHalf->x3 + c)*.5; + firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*.5; - c = (y2 + y3)*qreal(.5); - firstHalf->y2 = (y1 + y2)*qreal(.5); - secondHalf->y3 = (y3 + y4)*qreal(.5); + c = (y2 + y3)/2; + firstHalf->y2 = (y1 + y2)*.5; + secondHalf->y3 = (y3 + y4)*.5; firstHalf->y1 = y1; secondHalf->y4 = y4; - firstHalf->y3 = (firstHalf->y2 + c)*qreal(.5); - secondHalf->y2 = (secondHalf->y3 + c)*qreal(.5); - firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*qreal(.5); + firstHalf->y3 = (firstHalf->y2 + c)*.5; + secondHalf->y2 = (secondHalf->y3 + c)*.5; + firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*.5; } inline void QBezier::parameterSplitLeft(qreal t, QBezier *left) diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp index 2d434d3..ba1b642 100644 --- a/src/gui/painting/qblendfunctions.cpp +++ b/src/gui/painting/qblendfunctions.cpp @@ -223,9 +223,13 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl, int h = ty2 - ty1; int w = tx2 - tx1; + quint32 basex; quint32 srcy; + const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1; + const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1; + if (sx < 0) { int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1; basex = quint32(srcRect.right() * 65536) + dstx; @@ -738,6 +742,10 @@ template void qt_scale_image_32bit(uchar *destPixels, int dbpl, quint32 basex; quint32 srcy; + const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1; + const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1; + + if (sx < 0) { int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1; basex = quint32(srcRect.right() * 65536) + dstx; @@ -842,8 +850,8 @@ void qt_transform_image_rasterize(DestT *destPixels, int dbpl, qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y); int dx_l = int(leftSlope * 0x10000); int dx_r = int(rightSlope * 0x10000); - int x_l = int((topLeft.x + (qreal(0.5) + fromY - topLeft.y) * leftSlope + qreal(0.5)) * 0x10000); - int x_r = int((topRight.x + (qreal(0.5) + fromY - topRight.y) * rightSlope + qreal(0.5)) * 0x10000); + int x_l = int((topLeft.x + (0.5 + fromY - topLeft.y) * leftSlope + 0.5) * 0x10000); + int x_r = int((topRight.x + (0.5 + fromY - topRight.y) * rightSlope + 0.5) * 0x10000); int fromX, toX, x1, x2, u, v, i, ii; DestT *line; @@ -1020,7 +1028,7 @@ void qt_transform_image(DestT *destPixels, int dbpl, if (det == 0) return; - qreal invDet = qreal(1.0) / det; + qreal invDet = 1.0 / det; qreal m11, m12, m21, m22, mdx, mdy; m11 = (u.u * w.y - u.y * w.u) * invDet; @@ -1034,8 +1042,8 @@ void qt_transform_image(DestT *destPixels, int dbpl, int dvdx = int(m21 * 0x10000); int dudy = int(m12 * 0x10000); int dvdy = int(m22 * 0x10000); - int u0 = qCeil((qreal(0.5) * m11 + qreal(0.5) * m12 + mdx) * 0x10000) - 1; - int v0 = qCeil((qreal(0.5) * m21 + qreal(0.5) * m22 + mdy) * 0x10000) - 1; + int u0 = qCeil((0.5 * m11 + 0.5 * m12 + mdx) * 0x10000) - 1; + int v0 = qCeil((0.5 * m21 + 0.5 * m22 + mdy) * 0x10000) - 1; int x1 = qFloor(sourceRect.left()); int y1 = qFloor(sourceRect.top()); diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp index 9a8e09b..afe9986 100644 --- a/src/gui/painting/qbrush.cpp +++ b/src/gui/painting/qbrush.cpp @@ -1774,7 +1774,7 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF ¢er, // We have a one pixel buffer zone to avoid numerical instability on the // circle border //### this is hacky because technically we should adjust based on current matrix - const qreal compensated_radius = radius - radius * qreal(0.001); + const qreal compensated_radius = radius - radius * 0.001; QLineF line(center, focalPoint); if (line.length() > (compensated_radius)) line.setLength(compensated_radius); diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp index acbad3e..4da993b 100644 --- a/src/gui/painting/qcolor.cpp +++ b/src/gui/painting/qcolor.cpp @@ -604,13 +604,12 @@ void QColor::getHsvF(qreal *h, qreal *s, qreal *v, qreal *a) const return; } - const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); - *h = ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0); - *s = ct.ahsv.saturation * inv_USHRT_MAX; - *v = ct.ahsv.value * inv_USHRT_MAX; + *h = ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0; + *s = ct.ahsv.saturation / qreal(USHRT_MAX); + *v = ct.ahsv.value / qreal(USHRT_MAX); if (a) - *a = ct.ahsv.alpha * inv_USHRT_MAX; + *a = ct.ahsv.alpha / qreal(USHRT_MAX); } /*! @@ -716,13 +715,12 @@ void QColor::getHslF(qreal *h, qreal *s, qreal *l, qreal *a) const return; } - const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); - *h = ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0); - *s = ct.ahsl.saturation * inv_USHRT_MAX; - *l = ct.ahsl.lightness * inv_USHRT_MAX; + *h = ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0; + *s = ct.ahsl.saturation / qreal(USHRT_MAX); + *l = ct.ahsl.lightness / qreal(USHRT_MAX); if (a) - *a = ct.ahsl.alpha * inv_USHRT_MAX; + *a = ct.ahsl.alpha / qreal(USHRT_MAX); } /*! @@ -1302,7 +1300,7 @@ qreal QColor::hsvHueF() const { if (cspec != Invalid && cspec != Hsv) return toHsv().hueF(); - return ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0); + return ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0; } /*! @@ -1398,7 +1396,7 @@ qreal QColor::hslHueF() const { if (cspec != Invalid && cspec != Hsl) return toHsl().hslHueF(); - return ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0); + return ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0; } /*! @@ -1549,8 +1547,6 @@ QColor QColor::toRgb() const color.ct.argb.alpha = ct.argb.alpha; color.ct.argb.pad = 0; - const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); - switch (cspec) { case Hsv: { @@ -1561,15 +1557,15 @@ QColor QColor::toRgb() const } // chromatic case - const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / qreal(6000.); - const qreal s = ct.ahsv.saturation * inv_USHRT_MAX; - const qreal v = ct.ahsv.value * inv_USHRT_MAX; + const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / 6000.; + const qreal s = ct.ahsv.saturation / qreal(USHRT_MAX); + const qreal v = ct.ahsv.value / qreal(USHRT_MAX); const int i = int(h); const qreal f = h - i; - const qreal p = v * (qreal(1.0) - s); + const qreal p = v * (1.0 - s); if (i & 1) { - const qreal q = v * (qreal(1.0) - (s * f)); + const qreal q = v * (1.0 - (s * f)); switch (i) { case 1: @@ -1589,7 +1585,7 @@ QColor QColor::toRgb() const break; } } else { - const qreal t = v * (qreal(1.0) - (s * (qreal(1.0) - f))); + const qreal t = v * (1.0 - (s * (1.0 - f))); switch (i) { case 0: @@ -1621,9 +1617,9 @@ QColor QColor::toRgb() const color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = 0; } else { // chromatic case - const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / qreal(36000.); - const qreal s = ct.ahsl.saturation * inv_USHRT_MAX; - const qreal l = ct.ahsl.lightness * inv_USHRT_MAX; + const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / 36000.; + const qreal s = ct.ahsl.saturation / qreal(USHRT_MAX); + const qreal l = ct.ahsl.lightness / qreal(USHRT_MAX); qreal temp2; if (l < qreal(0.5)) @@ -1660,14 +1656,14 @@ QColor QColor::toRgb() const } case Cmyk: { - const qreal c = ct.acmyk.cyan * inv_USHRT_MAX; - const qreal m = ct.acmyk.magenta * inv_USHRT_MAX; - const qreal y = ct.acmyk.yellow * inv_USHRT_MAX; - const qreal k = ct.acmyk.black * inv_USHRT_MAX; - - color.ct.argb.red = qRound((qreal(1.0) - (c * (qreal(1.0) - k) + k)) * USHRT_MAX); - color.ct.argb.green = qRound((qreal(1.0) - (m * (qreal(1.0) - k) + k)) * USHRT_MAX); - color.ct.argb.blue = qRound((qreal(1.0) - (y * (qreal(1.0) - k) + k)) * USHRT_MAX); + const qreal c = ct.acmyk.cyan / qreal(USHRT_MAX); + const qreal m = ct.acmyk.magenta / qreal(USHRT_MAX); + const qreal y = ct.acmyk.yellow / qreal(USHRT_MAX); + const qreal k = ct.acmyk.black / qreal(USHRT_MAX); + + color.ct.argb.red = qRound((1.0 - (c * (1.0 - k) + k)) * USHRT_MAX); + color.ct.argb.green = qRound((1.0 - (m * (1.0 - k) + k)) * USHRT_MAX); + color.ct.argb.blue = qRound((1.0 - (y * (1.0 - k) + k)) * USHRT_MAX); break; } default: @@ -1701,10 +1697,9 @@ QColor QColor::toHsv() const color.ct.ahsv.alpha = ct.argb.alpha; color.ct.ahsv.pad = 0; - const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); - const qreal r = ct.argb.red * inv_USHRT_MAX; - const qreal g = ct.argb.green * inv_USHRT_MAX; - const qreal b = ct.argb.blue * inv_USHRT_MAX; + const qreal r = ct.argb.red / qreal(USHRT_MAX); + const qreal g = ct.argb.green / qreal(USHRT_MAX); + const qreal b = ct.argb.blue / qreal(USHRT_MAX); const qreal max = Q_MAX_3(r, g, b); const qreal min = Q_MIN_3(r, g, b); const qreal delta = max - min; @@ -1720,15 +1715,15 @@ QColor QColor::toHsv() const if (qFuzzyCompare(r, max)) { hue = ((g - b) /delta); } else if (qFuzzyCompare(g, max)) { - hue = (qreal(2.0) + (b - r) / delta); + hue = (2.0 + (b - r) / delta); } else if (qFuzzyCompare(b, max)) { - hue = (qreal(4.0) + (r - g) / delta); + hue = (4.0 + (r - g) / delta); } else { Q_ASSERT_X(false, "QColor::toHsv", "internal error"); } - hue *= qreal(60.0); - if (hue < qreal(0.0)) - hue += qreal(360.0); + hue *= 60.0; + if (hue < 0.0) + hue += 360.0; color.ct.ahsv.hue = qRound(hue * 100); } @@ -1809,10 +1804,9 @@ QColor QColor::toCmyk() const color.ct.acmyk.alpha = ct.argb.alpha; // rgb -> cmy - const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX); - const qreal r = ct.argb.red * inv_USHRT_MAX; - const qreal g = ct.argb.green * inv_USHRT_MAX; - const qreal b = ct.argb.blue * inv_USHRT_MAX; + const qreal r = ct.argb.red / qreal(USHRT_MAX); + const qreal g = ct.argb.green / qreal(USHRT_MAX); + const qreal b = ct.argb.blue / qreal(USHRT_MAX); qreal c = 1.0 - r; qreal m = 1.0 - g; qreal y = 1.0 - b; @@ -1821,10 +1815,9 @@ QColor QColor::toCmyk() const const qreal k = qMin(c, qMin(m, y)); if (!qFuzzyIsNull(k - 1)) { - const qreal div_by_one_minus_k = 1 / (qreal(1.0) - k); - c = (c - k) * div_by_one_minus_k; - m = (m - k) * div_by_one_minus_k; - y = (y - k) * div_by_one_minus_k; + c = (c - k) / (1.0 - k); + m = (m - k) / (1.0 - k); + y = (y - k) / (1.0 - k); } color.ct.acmyk.cyan = qRound(c * USHRT_MAX); diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp index 8d7a15d..4df7f8a 100644 --- a/src/gui/painting/qdrawhelper.cpp +++ b/src/gui/painting/qdrawhelper.cpp @@ -565,8 +565,8 @@ const uint * QT_FASTCALL fetchTransformed(uint *buffer, const Operator *, const int image_width = data->texture.width; int image_height = data->texture.height; - const qreal cx = x + qreal(0.5); - const qreal cy = y + qreal(0.5); + const qreal cx = x + 0.5; + const qreal cy = y + 0.5; const uint *end = buffer + length; uint *b = buffer; @@ -670,8 +670,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator * int image_width = data->texture.width; int image_height = data->texture.height; - const qreal cx = x + qreal(0.5); - const qreal cy = y + qreal(0.5); + const qreal cx = x + 0.5; + const qreal cy = y + 0.5; const uint *end = buffer + length; uint *b = buffer; @@ -747,8 +747,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator * while (b < end) { const qreal iw = fw == 0 ? 1 : 1 / fw; - const qreal px = fx * iw - qreal(0.5); - const qreal py = fy * iw - qreal(0.5); + const qreal px = fx * iw - 0.5; + const qreal py = fy * iw - 0.5; int x1 = int(px) - (px < 0); int x2 = x1 + 1; @@ -927,7 +927,7 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = { static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos) { - int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5)); + int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + 0.5); // calculate the actual offset. if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) { @@ -1008,8 +1008,8 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator if (op->linear.l == 0) { t = inc = 0; } else { - rx = data->m21 * (y + qreal(0.5)) + data->m11 * (x + qreal(0.5)) + data->dx; - ry = data->m22 * (y + qreal(0.5)) + data->m12 * (x + qreal(0.5)) + data->dy; + rx = data->m21 * (y + 0.5) + data->m11 * (x + 0.5) + data->dx; + ry = data->m22 * (y + 0.5) + data->m12 * (x + 0.5) + data->dy; t = op->linear.dx*rx + op->linear.dy*ry + op->linear.off; inc = op->linear.dx * data->m11 + op->linear.dy * data->m12; affine = !data->m13 && !data->m23; @@ -1045,7 +1045,7 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator } } } else { // fall back to float math here as well - qreal rw = data->m23 * (y + qreal(0.5)) + data->m13 * (x + qreal(0.5)) + data->m33; + qreal rw = data->m23 * (y + 0.5) + data->m13 * (x + 0.5) + data->m33; while (buffer < end) { qreal x = rx/rw; qreal y = ry/rw; @@ -1092,10 +1092,10 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator int y, int x, int length) { const uint *b = buffer; - qreal rx = data->m21 * (y + qreal(0.5)) - + data->dx + data->m11 * (x + qreal(0.5)); - qreal ry = data->m22 * (y + qreal(0.5)) - + data->dy + data->m12 * (x + qreal(0.5)); + qreal rx = data->m21 * (y + 0.5) + + data->dx + data->m11 * (x + 0.5); + qreal ry = data->m22 * (y + 0.5) + + data->dy + data->m12 * (x + 0.5); bool affine = !data->m13 && !data->m23; //qreal r = data->gradient.radial.radius; @@ -1141,8 +1141,8 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator ++buffer; } } else { - qreal rw = data->m23 * (y + qreal(0.5)) - + data->m33 + data->m13 * (x + qreal(0.5)); + qreal rw = data->m23 * (y + 0.5) + + data->m33 + data->m13 * (x + 0.5); if (!rw) rw = 1; while (buffer < end) { @@ -1171,10 +1171,10 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato int y, int x, int length) { const uint *b = buffer; - qreal rx = data->m21 * (y + qreal(0.5)) - + data->dx + data->m11 * (x + qreal(0.5)); - qreal ry = data->m22 * (y + qreal(0.5)) - + data->dy + data->m12 * (x + qreal(0.5)); + qreal rx = data->m21 * (y + 0.5) + + data->dx + data->m11 * (x + 0.5); + qreal ry = data->m22 * (y + 0.5) + + data->dy + data->m12 * (x + 0.5); bool affine = !data->m13 && !data->m23; const uint *end = buffer + length; @@ -1182,25 +1182,25 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato rx -= data->gradient.conical.center.x; ry -= data->gradient.conical.center.y; while (buffer < end) { - qreal angle = qAtan2(ry, rx) + data->gradient.conical.angle; + qreal angle = atan2(ry, rx) + data->gradient.conical.angle; - *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / Q_2PI); + *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / (2*Q_PI)); rx += data->m11; ry += data->m12; ++buffer; } } else { - qreal rw = data->m23 * (y + qreal(0.5)) - + data->m33 + data->m13 * (x + qreal(0.5)); + qreal rw = data->m23 * (y + 0.5) + + data->m33 + data->m13 * (x + 0.5); if (!rw) rw = 1; while (buffer < end) { - qreal angle = qAtan2(ry/rw - data->gradient.conical.center.x, + qreal angle = atan2(ry/rw - data->gradient.conical.center.x, rx/rw - data->gradient.conical.center.y) + data->gradient.conical.angle; - *buffer = qt_gradient_pixel(&data->gradient, qreal(1.) - angle / Q_2PI); + *buffer = qt_gradient_pixel(&data->gradient, 1. - angle / (2*Q_PI)); rx += data->m11; ry += data->m12; @@ -5166,8 +5166,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale) - half_point; @@ -5241,8 +5241,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -5256,8 +5256,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const uint *b = buffer; while (b < end) { const qreal iw = w == 0 ? 1 : 1 / w; - const qreal px = x * iw - qreal(0.5); - const qreal py = y * iw - qreal(0.5); + const qreal px = x * iw - 0.5; + const qreal py = y * iw - 0.5; int x1 = int(px) - (px < 0); int x2 = x1 + 1; @@ -5668,8 +5668,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale) - half_point; @@ -5751,8 +5751,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -5766,8 +5766,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, uint *b = buffer; while (b < end) { const qreal iw = w == 0 ? 1 : 1 / w; - const qreal px = x * iw - qreal(0.5); - const qreal py = y * iw - qreal(0.5); + const qreal px = x * iw - 0.5; + const qreal py = y * iw - 0.5; int x1 = int(px) - (px < 0); int x2 = x1 + 1; @@ -5859,8 +5859,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale); @@ -5907,8 +5907,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -6259,8 +6259,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; int x = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale); @@ -6311,8 +6311,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS uint *target = ((uint *)t) + spans->x; uint *image_bits = (uint *)data->texture.imageData; - const qreal cx = spans->x + qreal(0.5); - const qreal cy = spans->y + qreal(0.5); + const qreal cx = spans->x + 0.5; + const qreal cy = spans->y + 0.5; qreal x = data->m21 * cy + data->m11 * cx + data->dx; qreal y = data->m22 * cy + data->m12 * cx + data->dy; @@ -6996,7 +6996,7 @@ static void qt_gradient_quint32(int count, const QSpan *spans, void *userData) */ const int gss = GRADIENT_STOPTABLE_SIZE - 1; int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE); - int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE)); + int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE)); while (count--) { int y = spans->y; @@ -7044,7 +7044,7 @@ static void qt_gradient_quint16(int count, const QSpan *spans, void *userData) */ const int gss = GRADIENT_STOPTABLE_SIZE - 1; int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE); - int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE)); + int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE)); uint oldColor = data->solid.color; while (count--) { @@ -7123,13 +7123,13 @@ void qt_build_pow_tables() { #ifdef Q_WS_MAC // decided by testing a few things on an iMac, should probably get this from the // system... - smoothing = qreal(2.0); + smoothing = 2.0; #endif #ifdef Q_WS_WIN int winSmooth; if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0)) - smoothing = winSmooth / qreal(1000.0); + smoothing = winSmooth / 1000.0; #endif #ifdef Q_WS_X11 @@ -7139,19 +7139,18 @@ void qt_build_pow_tables() { qt_pow_rgb_invgamma[i] = uchar(i); } #else - const qreal inv_255 = 1 / qreal(255.0); for (int i=0; i<256; ++i) { - qt_pow_rgb_gamma[i] = uchar(qRound(qPow(i * inv_255, smoothing) * 255)); - qt_pow_rgb_invgamma[i] = uchar(qRound(qPow(i * inv_255, 1 / smoothing) * 255)); + qt_pow_rgb_gamma[i] = uchar(qRound(pow(i / qreal(255.0), smoothing) * 255)); + qt_pow_rgb_invgamma[i] = uchar(qRound(pow(i / qreal(255.), 1 / smoothing) * 255)); } #endif #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) - const qreal gray_gamma = qreal(2.31); + const qreal gray_gamma = 2.31; for (int i=0; i<256; ++i) - qt_pow_gamma[i] = uint(qRound(qPow(i / qreal(255.), gray_gamma) * 2047)); + qt_pow_gamma[i] = uint(qRound(pow(i / qreal(255.), gray_gamma) * 2047)); for (int i=0; i<2048; ++i) - qt_pow_invgamma[i] = uchar(qRound(qPow(i / qreal(2047.0), 1 / gray_gamma) * 255)); + qt_pow_invgamma[i] = uchar(qRound(pow(i / 2047.0, 1 / gray_gamma) * 255)); #endif } diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp index be9061f..1182b9a 100644 --- a/src/gui/painting/qdrawutil.cpp +++ b/src/gui/painting/qdrawutil.cpp @@ -1180,48 +1180,46 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin for (int i = 2; i < rows - 1; ++i) yTarget[i] = yTarget[i - 1] + dy; - const qreal inv_d_source_width = 1 / (qreal)d.source.width(); - const qreal inv_d_source_height = 1 / (qreal)d.source.height(); // corners if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left d.point.setX(0.5 * (xTarget[1] + xTarget[0])); d.point.setY(0.5 * (yTarget[1] + yTarget[0])); d.source = QRectF(sourceRect.left(), sourceRect.top(), sourceMargins.left(), sourceMargins.top()); - d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width; - d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height; + d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width(); + d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height(); if (hints & QDrawBorderPixmap::OpaqueTopLeft) opaqueData.append(d); else translucentData.append(d); } if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right - d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1])); - d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0])); + d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1])); + d.point.setY(0.5 * (yTarget[1] + yTarget[0])); d.source = QRectF(sourceCenterRight, sourceRect.top(), sourceMargins.right(), sourceMargins.top()); - d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width; - d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height; + d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width(); + d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height(); if (hints & QDrawBorderPixmap::OpaqueTopRight) opaqueData.append(d); else translucentData.append(d); } if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left - d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0])); - d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1])); + d.point.setX(0.5 * (xTarget[1] + xTarget[0])); + d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1])); d.source = QRectF(sourceRect.left(), sourceCenterBottom, sourceMargins.left(), sourceMargins.bottom()); - d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width; - d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height; + d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width(); + d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height(); if (hints & QDrawBorderPixmap::OpaqueBottomLeft) opaqueData.append(d); else translucentData.append(d); } if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right - d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1])); - d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1])); + d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1])); + d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1])); d.source = QRectF(sourceCenterRight, sourceCenterBottom, sourceMargins.right(), sourceMargins.bottom()); - d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width; - d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height; + d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width(); + d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height(); if (hints & QDrawBorderPixmap::OpaqueBottomRight) opaqueData.append(d); else @@ -1233,11 +1231,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData; d.source = QRectF(sourceCenterLeft, sourceRect.top(), sourceCenterWidth, sourceMargins.top()); - d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0])); - d.scaleX = dx * inv_d_source_width; - d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height; + d.point.setY(0.5 * (yTarget[1] + yTarget[0])); + d.scaleX = dx / d.source.width(); + d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height(); for (int i = 1; i < columns - 1; ++i) { - d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i])); + d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i])); data.append(d); } if (rules.horizontal == Qt::RepeatTile) @@ -1246,11 +1244,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData; d.source = QRectF(sourceCenterLeft, sourceCenterBottom, sourceCenterWidth, sourceMargins.bottom());; - d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1])); - d.scaleX = dx * inv_d_source_width; - d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height; + d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1])); + d.scaleX = dx / d.source.width(); + d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height(); for (int i = 1; i < columns - 1; ++i) { - d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i])); + d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i])); data.append(d); } if (rules.horizontal == Qt::RepeatTile) @@ -1263,11 +1261,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData; d.source = QRectF(sourceRect.left(), sourceCenterTop, sourceMargins.left(), sourceCenterHeight); - d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0])); - d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width; - d.scaleY = dy * inv_d_source_height; + d.point.setX(0.5 * (xTarget[1] + xTarget[0])); + d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width(); + d.scaleY = dy / d.source.height(); for (int i = 1; i < rows - 1; ++i) { - d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i])); + d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i])); data.append(d); } if (rules.vertical == Qt::RepeatTile) @@ -1276,11 +1274,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData; d.source = QRectF(sourceCenterRight, sourceCenterTop, sourceMargins.right(), sourceCenterHeight); - d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1])); - d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width; - d.scaleY = dy * inv_d_source_height; + d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1])); + d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width(); + d.scaleY = dy / d.source.height(); for (int i = 1; i < rows - 1; ++i) { - d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i])); + d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i])); data.append(d); } if (rules.vertical == Qt::RepeatTile) @@ -1292,16 +1290,16 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) { QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData; d.source = QRectF(sourceCenterLeft, sourceCenterTop, sourceCenterWidth, sourceCenterHeight); - d.scaleX = dx * inv_d_source_width; - d.scaleY = dy * inv_d_source_height; + d.scaleX = dx / d.source.width(); + d.scaleY = dy / d.source.height(); qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX; qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY; for (int j = 1; j < rows - 1; ++j) { - d.point.setY(qreal(0.5) * (yTarget[j + 1] + yTarget[j])); + d.point.setY(0.5 * (yTarget[j + 1] + yTarget[j])); for (int i = 1; i < columns - 1; ++i) { - d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i])); + d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i])); data.append(d); } if (rules.horizontal == Qt::RepeatTile) diff --git a/src/gui/painting/qmath_p.h b/src/gui/painting/qmath_p.h index 53ed8ab..f4a3982 100644 --- a/src/gui/painting/qmath_p.h +++ b/src/gui/painting/qmath_p.h @@ -54,10 +54,13 @@ // #include -#include QT_BEGIN_NAMESPACE +static const qreal Q_PI = qreal(3.14159265358979323846); // pi +static const qreal Q_2PI = qreal(6.28318530717958647693); // 2*pi +static const qreal Q_PI2 = qreal(1.57079632679489661923); // pi/2 + QT_END_NAMESPACE #endif // QMATH_P_H diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp index fc6726e..b8700c3 100644 --- a/src/gui/painting/qpaintbuffer.cpp +++ b/src/gui/painting/qpaintbuffer.cpp @@ -426,7 +426,7 @@ void QPaintBufferEngine::penChanged() QPointF transformedWidth(penWidth, penWidth); if (!pen.isCosmetic()) transformedWidth = painter()->transform().map(transformedWidth); - buffer->penWidthAdjustment = transformedWidth.x() * qreal(0.5); + buffer->penWidthAdjustment = transformedWidth.x() / 2.0; } } #ifdef QPAINTBUFFER_DEBUG_DRAW diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp index 22bb9d2..3f33319 100644 --- a/src/gui/painting/qpaintengine_raster.cpp +++ b/src/gui/painting/qpaintengine_raster.cpp @@ -126,7 +126,7 @@ void dumpClip(int width, int height, const QClipData *clip); #define int_dim(pos, dim) (int(pos+dim) - int(pos)) // use the same rounding as in qrasterizer.cpp (6 bit fixed point) -static const qreal aliasedCoordinateDelta = qreal(0.5) - qreal(0.015625); +static const qreal aliasedCoordinateDelta = 0.5 - 0.015625; #ifdef Q_WS_WIN extern bool qt_cleartype_enabled; @@ -1743,8 +1743,8 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen) if (lines[i].p1() == lines[i].p2()) { if (s->lastPen.capStyle() != Qt::FlatCap) { QPointF p = lines[i].p1(); - QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*qreal(0.5), p.y()), - QPointF(p.x() + width*qreal(0.5), p.y()))); + QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()), + QPointF(p.x() + width*0.5, p.y()))); d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1); } continue; @@ -1958,9 +1958,8 @@ static bool splitPolygon(const QPointF *points, int pointCount, QVector QVector sorted; sorted.reserve(pointCount); - const qreal three_quarters = qreal(3) / qreal(4); - upper->reserve(pointCount * three_quarters); - lower->reserve(pointCount * three_quarters); + upper->reserve(pointCount * 3 / 4); + lower->reserve(pointCount * 3 / 4); for (int i = 0; i < pointCount; ++i) sorted << points + i; @@ -2337,13 +2336,13 @@ void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCo int x1 = points[pointCount-1].x() * m11 + dx; int y1 = points[pointCount-1].y() * m22 + dy; - qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + qreal(1.); + qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + 1.; w = 1/w; x1 = int(x1*w); y1 = int(y1*w); int x2 = points[0].x() * m11 + dx; int y2 = points[0].y() * m22 + dy; - w = m13*points[0].x() + m23*points[0].y() + qreal(1.); + w = m13*points[0].x() + m23*points[0].y() + 1.; w = 1/w; x2 = int(x2 * w); y2 = int(y2 * w); @@ -4868,7 +4867,7 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint uint next_color; qreal incr = 1 / qreal(size); // the double increment. - qreal dpos = qreal(1.5) * incr; // current position in gradient stop list (0 to 1) + qreal dpos = 1.5 * incr; // current position in gradient stop list (0 to 1) // Up to first point colorTable[pos++] = PREMUL(current_color); @@ -5042,7 +5041,7 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode QPointF center = g->center(); conicalData.center.x = center.x(); conicalData.center.y = center.y(); - conicalData.angle = g->angle() * Q_2PI / qreal(360.0); + conicalData.angle = g->angle() * 2 * Q_PI / 360.0; } break; @@ -5141,8 +5140,7 @@ void QSpanData::setupMatrix(const QTransform &matrix, int bilin) { QTransform delta; // make sure we round off correctly in qdrawhelper.cpp - const qreal inv_65536 = qreal(1.0) / 65536; - delta.translate(inv_65536, inv_65536); + delta.translate(1.0 / 65536, 1.0 / 65536); QTransform inv = (delta * matrix).inverted(); m11 = inv.m11(); @@ -6051,9 +6049,9 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip, const QFixed b = QFixed(rect.height()) >> 1; QFixed d = b*b - (a*a*b) + ((a*a) >> 2); #else - const qreal a = qreal(rect.width()) * qreal(0.5); - const qreal b = qreal(rect.height()) * qreal(0.5); - qreal d = b*b - (a*a*b) + qreal(0.25)*a*a; + const qreal a = qreal(rect.width()) / 2; + const qreal b = qreal(rect.height()) / 2; + qreal d = b*b - (a*a*b) + 0.25*a*a; #endif int x = 0; @@ -6081,7 +6079,7 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip, d = b*b*(x + (QFixed(1) >> 1))*(x + (QFixed(1) >> 1)) + a*a*((y - 1)*(y - 1) - b*b); #else - d = b*b*(x + qreal(0.5))*(x + qreal(0.5)) + a*a*(qreal(y - 1)*qreal(y - 1) - b*b); + d = b*b*(x + 0.5)*(x + 0.5) + a*a*((y - 1)*(y - 1) - b*b); #endif const int miny = rect.height() & 0x1; while (y > miny) { @@ -6152,4 +6150,4 @@ void dumpClip(int width, int height, const QClipData *clip) #endif -QT_END_NAMESPACE \ No newline at end of file +QT_END_NAMESPACE diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp index 225e593..7d1c109 100644 --- a/src/gui/painting/qpaintengineex.cpp +++ b/src/gui/painting/qpaintengineex.cpp @@ -731,9 +731,8 @@ void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yR qreal y2 = rect.bottom(); if (mode == Qt::RelativeSize) { - const qreal inv_200 = 1 / qreal(200.); - xRadius = xRadius * rect.width() * inv_200; - yRadius = yRadius * rect.height() * inv_200; + xRadius = xRadius * rect.width() / 200.; + yRadius = yRadius * rect.height() / 200.; } xRadius = qMin(xRadius, rect.width() / 2); @@ -847,7 +846,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount) for (int i=0; imatrix).boundingRect(); } else { - strokeOffsetX = qAbs(penWidth * state->matrix.m11() * qreal(0.5)); - strokeOffsetY = qAbs(penWidth * state->matrix.m22() * qreal(0.5)); + strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0); + strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0); } } } @@ -467,7 +467,7 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio pt.end(); p.resetTransform(); p.setCompositionMode(QPainter::CompositionMode_SourceAtop); - p.setOpacity(qreal(0.5)); + p.setOpacity(0.5); p.fillRect(0, 0, image.width(), image.height(), QBrush(block)); } #endif @@ -3565,7 +3565,7 @@ void QPainter::drawPoints(const QPointF *points, int pointCount) QPainterPath path; for (int i=0; idraw_helper(path, QPainterPrivate::StrokeDraw); if (flat_pen) @@ -3627,7 +3627,7 @@ void QPainter::drawPoints(const QPoint *points, int pointCount) QPainterPath path; for (int i=0; idraw_helper(path, QPainterPrivate::StrokeDraw); if (flat_pen) @@ -4270,9 +4270,8 @@ void QPainter::drawArc(const QRectF &r, int a, int alen) QRectF rect = r.normalized(); QPainterPath path; - const qreal inv_16 = 1 / qreal(16.0); - path.arcMoveTo(rect, a * inv_16); - path.arcTo(rect, a * inv_16, alen * inv_16); + path.arcMoveTo(rect, a/16.0); + path.arcTo(rect, a/16.0, alen/16.0); strokePath(path, d->state->pen); } @@ -4341,9 +4340,8 @@ void QPainter::drawPie(const QRectF &r, int a, int alen) QRectF rect = r.normalized(); QPainterPath path; - const qreal inv_16 = 1 / qreal(16.0); path.moveTo(rect.center()); - path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a * inv_16, alen * inv_16); + path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a/16.0, alen/16.0); path.closeSubpath(); drawPath(path); @@ -4404,9 +4402,8 @@ void QPainter::drawChord(const QRectF &r, int a, int alen) QRectF rect = r.normalized(); QPainterPath path; - const qreal inv_16 = 1 / qreal(16.0); - path.arcMoveTo(rect, a * inv_16); - path.arcTo(rect, a * inv_16, alen * inv_16); + path.arcMoveTo(rect, a/16.0); + path.arcTo(rect, a/16.0, alen/16.0); path.closeSubpath(); drawPath(path); } @@ -5908,7 +5905,7 @@ static QPainterPath generateWavyPath(qreal minWidth, qreal maxRadius, QPaintDevi QPainterPath path; bool up = true; - const qreal radius = qMax(qreal(.5), qMin(qreal(1.25) * device->logicalDpiY() / qt_defaultDpi(), maxRadius)); + const qreal radius = qMax(qreal(.5), qMin(qreal(1.25 * device->logicalDpiY() / qt_defaultDpi()), maxRadius)); qreal xs, ys; int i = 0; path.moveTo(0, radius); @@ -5988,7 +5985,7 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const if (ti.flags & QTextItem::StrikeOut) { QLineF strikeOutLine = line; - strikeOutLine.translate(qreal(0.), - fe->ascent().toReal() / qreal(3.)); + strikeOutLine.translate(0., - fe->ascent().toReal() / 3.); painter->setPen(pen); painter->drawLine(strikeOutLine); } diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp index 0f31cca..8133793 100644 --- a/src/gui/painting/qpainterpath.cpp +++ b/src/gui/painting/qpainterpath.cpp @@ -799,9 +799,8 @@ void QPainterPath::quadTo(const QPointF &c, const QPointF &e) if (prev == c && c == e) return; - const qreal inv_3 = 1 / qreal(3); - QPointF c1((prev.x() + 2*c.x()) * inv_3, (prev.y() + 2*c.y()) * inv_3); - QPointF c2((e.x() + 2*c.x()) * inv_3, (e.y() + 2*c.y()) * inv_3); + QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3); + QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3); cubicTo(c1, c2, e); } @@ -1805,24 +1804,22 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y return false; if (p1 | p2) { - const qreal dx = x2 - x1; - const qreal dy = y2 - y1; - const qreal dx_dy_ratio = dx / dy; - const qreal dy_dx_ratio = dy / dx; + qreal dx = x2 - x1; + qreal dy = y2 - y1; // clip x coordinates if (x1 < left) { - y1 += dy_dx_ratio * (left - x1); + y1 += dy/dx * (left - x1); x1 = left; } else if (x1 > right) { - y1 -= dy_dx_ratio * (x1 - right); + y1 -= dy/dx * (x1 - right); x1 = right; } if (x2 < left) { - y2 += dy_dx_ratio * (left - x2); + y2 += dy/dx * (left - x2); x2 = left; } else if (x2 > right) { - y2 -= dy_dx_ratio * (x2 - right); + y2 -= dy/dx * (x2 - right); x2 = right; } @@ -1836,17 +1833,17 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y // clip y coordinates if (y1 < top) { - x1 += dx_dy_ratio * (top - y1); + x1 += dx/dy * (top - y1); y1 = top; } else if (y1 > bottom) { - x1 -= dx_dy_ratio * (y1 - bottom); + x1 -= dx/dy * (y1 - bottom); y1 = bottom; } if (y2 < top) { - x2 += dx_dy_ratio * (top - y2); + x2 += dx/dy * (top - y2); y2 = top; } else if (y2 > bottom) { - x2 -= dx_dy_ratio * (y2 - bottom); + x2 -= dx/dy * (y2 - bottom); y2 = bottom; } diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h index a2bc905..54b9392 100644 --- a/src/gui/painting/qpainterpath_p.h +++ b/src/gui/painting/qpainterpath_p.h @@ -258,7 +258,7 @@ inline void QPainterPathData::maybeMoveTo() } } -#define KAPPA qreal(0.5522847498) +#define KAPPA 0.5522847498 QT_END_NAMESPACE diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp index 1568ad8..ab2dc33 100644 --- a/src/gui/painting/qpathclipper.cpp +++ b/src/gui/painting/qpathclipper.cpp @@ -321,11 +321,11 @@ void QIntersectionFinder::intersectLines(const QLineF &a, const QLineF &b, QData if (p1_equals_q1 || p1_equals_q2 || p2_equals_q1 || p2_equals_q2) return; - const qreal inv_par = 1 / qreal(par); + const qreal tp = (qDelta.y() * (q1.x() - p1.x()) - - qDelta.x() * (q1.y() - p1.y())) * inv_par; + qDelta.x() * (q1.y() - p1.y())) / par; const qreal tq = (pDelta.y() * (q1.x() - p1.x()) - - pDelta.x() * (q1.y() - p1.y())) * inv_par; + pDelta.x() * (q1.y() - p1.y())) / par; if (tp<0 || tp>1 || tq<0 || tq>1) return; @@ -1192,24 +1192,24 @@ static qreal computeAngle(const QPointF &v) { #if 1 if (v.x() == 0) { - return v.y() <= 0 ? 0 : qreal(64.); + return v.y() <= 0 ? 0 : 64.; } else if (v.y() == 0) { - return v.x() <= 0 ? qreal(32.) : qreal(96.); + return v.x() <= 0 ? 32. : 96.; } QPointF nv = normalize(v); if (nv.y() < 0) { if (nv.x() < 0) { // 0 - 32 - return qreal(-32.) * nv.x(); + return -32. * nv.x(); } else { // 96 - 128 - return qreal(128.) - qreal(32.) * nv.x(); + return 128. - 32. * nv.x(); } } else { // 32 - 96 - return qreal(64.) + 32 * nv.x(); + return 64. + 32 * nv.x(); } #else // doesn't seem to be robust enough - return qAtan2(v.x(), v.y()) + Q_PI; + return atan2(v.x(), v.y()) + Q_PI; #endif } diff --git a/src/gui/painting/qrasterizer.cpp b/src/gui/painting/qrasterizer.cpp index ba5eda6..b602690 100644 --- a/src/gui/painting/qrasterizer.cpp +++ b/src/gui/painting/qrasterizer.cpp @@ -44,7 +44,6 @@ #include #include -#include #include #include #include @@ -52,8 +51,8 @@ QT_BEGIN_NAMESPACE typedef int Q16Dot16; -#define Q16Dot16ToFloat(i) ((i)/qreal(65536.)) -#define FloatToQ16Dot16(i) (int)((i) * qreal(65536.)) +#define Q16Dot16ToFloat(i) ((i)/65536.) +#define FloatToQ16Dot16(i) (int)((i) * 65536.) #define IntToQ16Dot16(i) ((i) << 16) #define Q16Dot16ToInt(i) ((i) >> 16) #define Q16Dot16Factor 65536 @@ -708,12 +707,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, if (a == b || width == 0 || d->clipRect.isEmpty()) return; - Q_ASSERT(width > qreal(0.0)); + Q_ASSERT(width > 0.0); QPointF pa = a; QPointF pb = b; - QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * qreal(0.5); + QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * 0.5; if (squareCap) offs += QPointF(offs.y(), offs.x()); const QRectF clip(d->clipRect.topLeft() - offs, d->clipRect.bottomRight() + QPoint(1, 1) + offs); @@ -751,12 +750,10 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, } if (!d->antialiased) { - const qreal inv_64 = 1 / qreal(64.); - const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64; - pa.rx() += delta; - pa.ry() += delta; - pb.rx() += delta; - pb.ry() += delta; + pa.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.; + pa.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.; + pb.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.; + pb.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.; } { @@ -781,7 +778,7 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, return; // adjust width which is given relative to |b - a| - width *= qSqrt(w0 / w); + width *= sqrt(w0 / w); } QSpanBuffer buffer(d->blend, d->data, d->clipRect); @@ -796,11 +793,10 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, pa = QPointF(x, y - dy); pb = QPointF(x, y + dy); - const qreal inv_width = 1 / width; if (squareCap) - width = inv_width + 1.0f; + width = 1 / width + 1.0f; else - width = inv_width; + width = 1 / width; squareCap = false; } @@ -1196,10 +1192,8 @@ void QRasterizer::rasterize(const QPainterPath &path, Qt::FillRule fillRule) QRectF bounds = path.controlPointRect(); - const qreal inv_64 = 1 / qreal(64.); - const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64 ; - int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + qreal(0.5) + delta)); - int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - qreal(0.5) + delta)); + int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.)); + int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.)); if (iTopBound > iBottomBound) return; diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp index b33d86b..228a6b1 100644 --- a/src/gui/painting/qstroker.cpp +++ b/src/gui/painting/qstroker.cpp @@ -788,12 +788,12 @@ qreal qt_t_for_arc_angle(qreal angle) if (qFuzzyCompare(angle, qreal(90))) return 1; - qreal radians = Q_PI180 * angle; + qreal radians = Q_PI * angle / 180; qreal cosAngle = qCos(radians); qreal sinAngle = qSin(radians); // initial guess - qreal tc = angle / qreal(90); + qreal tc = angle / 90; // do some iterations of newton's method to approximate cosAngle // finds the zero of the function b.pointAt(tc).x() - cosAngle tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value @@ -812,7 +812,7 @@ qreal qt_t_for_arc_angle(qreal angle) // use the average of the t that best approximates cosAngle // and the t that best approximates sinAngle - qreal t = qreal(0.5) * (tc + ts); + qreal t = 0.5 * (tc + ts); #if 0 printf("angle: %f, t: %f\n", angle, t); @@ -861,11 +861,11 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt qreal y = rect.y(); qreal w = rect.width(); - qreal w2 = rect.width() * qreal(0.5); + qreal w2 = rect.width() / 2; qreal w2k = w2 * QT_PATH_KAPPA; qreal h = rect.height(); - qreal h2 = rect.height() * qreal(0.5); + qreal h2 = rect.height() / 2; qreal h2k = h2 * QT_PATH_KAPPA; QPointF points[16] = @@ -898,24 +898,23 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt else if (sweepLength < -360) sweepLength = -360; // Special case fast paths - if (startAngle == qreal(0.0)) { - if (sweepLength == qreal(360.0)) { + if (startAngle == 0.0) { + if (sweepLength == 360.0) { for (int i = 11; i >= 0; --i) curves[(*point_count)++] = points[i]; return points[12]; - } else if (sweepLength == qreal(-360.0)) { + } else if (sweepLength == -360.0) { for (int i = 1; i <= 12; ++i) curves[(*point_count)++] = points[i]; return points[0]; } } - qreal inv_90 = qreal(1) / qreal(90); - int startSegment = int(floor(startAngle * inv_90)); - int endSegment = int(floor((startAngle + sweepLength) * inv_90)); + int startSegment = int(floor(startAngle / 90)); + int endSegment = int(floor((startAngle + sweepLength) / 90)); - qreal startT = (startAngle - startSegment * 90) * inv_90; - qreal endT = (startAngle + sweepLength - endSegment * 90) * inv_90; + qreal startT = (startAngle - startSegment * 90) / 90; + qreal endT = (startAngle + sweepLength - endSegment * 90) / 90; int delta = sweepLength > 0 ? 1 : -1; if (delta < 0) { diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h index 5ff9d87..a10ebd9 100644 --- a/src/gui/painting/qstroker_p.h +++ b/src/gui/painting/qstroker_p.h @@ -110,7 +110,7 @@ struct qfixed2d }; #endif -#define QT_PATH_KAPPA qreal(0.5522847498) +#define QT_PATH_KAPPA 0.5522847498 QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength, QPointF *controlPoints, int *point_count); diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp index 27a1503..45db80a 100644 --- a/src/gui/painting/qtransform.cpp +++ b/src/gui/painting/qtransform.cpp @@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE -#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? qreal(0.000001) : qreal(0.0001)) +#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001) #ifdef MAP # undef MAP @@ -82,7 +82,7 @@ QT_BEGIN_NAMESPACE if (t == TxProject) { \ qreal w = (m_13 * FX_ + m_23 * FY_ + m_33); \ if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP); \ - w = qreal(1.)/w; \ + w = 1./w; \ nx *= w; \ ny *= w; \ } \ @@ -369,8 +369,8 @@ QTransform QTransform::inverted(bool *invertible) const inv = !qFuzzyIsNull(affine._m11); inv &= !qFuzzyIsNull(affine._m22); if (inv) { - invert.affine._m11 = qreal(1.) / affine._m11; - invert.affine._m22 = qreal(1.) / affine._m22; + invert.affine._m11 = 1. / affine._m11; + invert.affine._m22 = 1. / affine._m22; invert.affine._dx = -affine._dx * invert.affine._m11; invert.affine._dy = -affine._dy * invert.affine._m22; } @@ -1087,7 +1087,7 @@ QPoint QTransform::map(const QPoint &p) const x = affine._m11 * fx + affine._m21 * fy + affine._dx; y = affine._m12 * fx + affine._m22 * fy + affine._dy; if (t == TxProject) { - qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33); + qreal w = 1./(m_13 * fx + m_23 * fy + m_33); x *= w; y *= w; } @@ -1138,7 +1138,7 @@ QPointF QTransform::map(const QPointF &p) const x = affine._m11 * fx + affine._m21 * fy + affine._dx; y = affine._m12 * fx + affine._m22 * fy + affine._dy; if (t == TxProject) { - qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33); + qreal w = 1./(m_13 * fx + m_23 * fy + m_33); x *= w; y *= w; } @@ -1217,10 +1217,10 @@ QLine QTransform::map(const QLine &l) const x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx; y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy; if (t == TxProject) { - qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33); + qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33); x1 *= w; y1 *= w; - w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33); + w = 1./(m_13 * fx2 + m_23 * fy2 + m_33); x2 *= w; y2 *= w; } @@ -1276,10 +1276,10 @@ QLineF QTransform::map(const QLineF &l) const x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx; y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy; if (t == TxProject) { - qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33); + qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33); x1 *= w; y1 *= w; - w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33); + w = 1./(m_13 * fx2 + m_23 * fy2 + m_33); x2 *= w; y2 *= w; } @@ -1438,7 +1438,7 @@ struct QHomogeneousCoordinate QHomogeneousCoordinate(qreal x_, qreal y_, qreal w_) : x(x_), y(y_), w(w_) {} const QPointF toPoint() const { - qreal iw = qreal(1.) / w; + qreal iw = 1. / w; return QPointF(x * iw, y * iw); } }; @@ -1695,9 +1695,8 @@ bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans) if (!bottom) return false; - double inv_bottom = 1 / bottom; - g = gtop * inv_bottom; - h = htop * inv_bottom; + g = gtop/bottom; + h = htop/bottom; a = dx1 - dx0 + g * dx1; b = dx3 - dx0 + h * dx3; diff --git a/src/gui/styles/qcommonstyle.cpp b/src/gui/styles/qcommonstyle.cpp index 4d3272c..4c9541b 100644 --- a/src/gui/styles/qcommonstyle.cpp +++ b/src/gui/styles/qcommonstyle.cpp @@ -3070,9 +3070,9 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a) int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition); if (dial->maximum == dial->minimum) - a = Q_PI2; + a = Q_PI / 2; else if (dial->dialWrapping) - a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI + a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI / (dial->maximum - dial->minimum); else a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI @@ -3087,13 +3087,12 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a) int back = len / 2; QPolygonF arrow(3); - const qreal five_div_by_six = 5 / 6; - arrow[0] = QPointF(qreal(0.5) + xc + len * qCos(a), - qreal(0.5) + yc - len * qSin(a)); - arrow[1] = QPointF(qreal(0.5) + xc + back * qCos(a + Q_PI * five_div_by_six), - qreal(0.5) + yc - back * qSin(a + Q_PI * five_div_by_six)); - arrow[2] = QPointF(qreal(0.5) + xc + back * qCos(a - Q_PI * five_div_by_six), - qreal(0.5) + yc - back * qSin(a - Q_PI * five_div_by_six)); + arrow[0] = QPointF(0.5 + xc + len * qCos(a), + 0.5 + yc - len * qSin(a)); + arrow[1] = QPointF(0.5 + xc + back * qCos(a + Q_PI * 5 / 6), + 0.5 + yc - back * qSin(a + Q_PI * 5 / 6)); + arrow[2] = QPointF(0.5 + xc + back * qCos(a - Q_PI * 5 / 6), + 0.5 + yc - back * qSin(a - Q_PI * 5 / 6)); return arrow; } diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index 16a81b3..a1dab86 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -553,7 +553,7 @@ void QS60StylePrivate::drawRow(QS60StyleEnums::SkinParts start, #if 0 painter->save(); - painter->setOpacity(qreal(.3)); + painter->setOpacity(.3); painter->fillRect(startRect, Qt::red); painter->fillRect(middleRect, Qt::green); painter->fillRect(endRect, Qt::blue); @@ -1598,7 +1598,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, QS60StylePrivate::SF_PointNorth : QS60StylePrivate::SF_PointWest; QS60StylePrivate::drawSkinPart(QS60StyleEnums::SP_QgnGrafBarWait, painter, progressRect, flags | orientationFlag); } else { - const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? qreal(1.0) + const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? 1.0 : (qreal)optionProgressBar->progress / optionProgressBar->maximum; if (optionProgressBar->orientation == Qt::Horizontal) { progressRect.setWidth(int(progressRect.width() * progressFactor)); @@ -1886,12 +1886,12 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, if (focusFrame->widget() && focusFrame->widget()->hasEditFocus()) editFocus = true; } - const qreal opacity = editFocus ? qreal(0.65) : qreal(0.45); // Trial and error factors. Feel free to improve. + const qreal opacity = editFocus ? 0.65 : 0.45; // Trial and error factors. Feel free to improve. #else - const qreal opacity = qreal(0.5); + const qreal opacity = 0.5; #endif // Because of Qts coordinate system, we need to tweak the rect by .5 pixels, otherwise it gets blurred. - const qreal rectAdjustment = (penWidth % 2) ? qreal(-.5) : 0; + const qreal rectAdjustment = (penWidth % 2) ? -.5 : 0; // Make sure that the pen stroke is inside the rect const QRectF adjustedRect = @@ -1915,7 +1915,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option, case CE_Splitter: if (option->state & State_Sunken && option->state & State_Enabled) { painter->save(); - painter->setOpacity(qreal(0.5)); + painter->setOpacity(0.5); painter->setBrush(d->themePalette()->light()); painter->setRenderHint(QPainter::Antialiasing); const qreal roundRectRadius = 4 * goldenRatio; @@ -1993,8 +1993,8 @@ void QS60Style::drawPrimitive(PrimitiveElement element, const QStyleOption *opti case PE_IndicatorRadioButton: { QRect buttonRect = option->rect; //there is empty (a. 33%) space in svg graphics for radiobutton - const qreal reduceWidth = (qreal)buttonRect.width()/qreal(3.0); - const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : qreal(1.0); + const qreal reduceWidth = (qreal)buttonRect.width()/3.0; + const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : 1.0; // Try to occupy the full area const qreal scaler = 1 + (reduceWidth/rectWidth); buttonRect.setWidth((int)((buttonRect.width()-reduceWidth) * scaler)); diff --git a/src/gui/styles/qstyle.cpp b/src/gui/styles/qstyle.cpp index 6733209..ec238a9 100644 --- a/src/gui/styles/qstyle.cpp +++ b/src/gui/styles/qstyle.cpp @@ -2132,7 +2132,7 @@ int QStyle::sliderPositionFromValue(int min, int max, int logicalValue, int span uint p = upsideDown ? max - logicalValue : logicalValue - min; if (range > (uint)INT_MAX/4096) { - qreal dpos = (qreal(p))/(qreal(range)/span); + double dpos = (double(p))/(double(range)/span); return int(dpos); } else if (range > (uint)span) { return (2 * p * span + range) / (2*range); diff --git a/src/gui/styles/qstylehelper.cpp b/src/gui/styles/qstylehelper.cpp index 5b6f72f..af30f15 100644 --- a/src/gui/styles/qstylehelper.cpp +++ b/src/gui/styles/qstylehelper.cpp @@ -117,15 +117,15 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset) const int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition); qreal a = 0; if (dial->maximum == dial->minimum) - a = Q_PI2; + a = Q_PI / 2; else if (dial->dialWrapping) - a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI + a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI / (dial->maximum - dial->minimum); else a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI / (dial->maximum - dial->minimum)) / 6; - const qreal xc = width * qreal(0.5); - const qreal yc = height * qreal(0.5); + qreal xc = width / 2.0; + qreal yc = height / 2.0; qreal len = r - QStyleHelper::calcBigLineSize(r) - 3; qreal back = offset * len; QPointF pos(QPointF(xc + back * qCos(a), yc - back * qSin(a))); @@ -134,7 +134,7 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset) qreal angle(const QPointF &p1, const QPointF &p2) { - static const qreal rad_factor = Q_PI180; + static const qreal rad_factor = 180 / Q_PI; qreal _angle = 0; if (p1.x() == p2.x()) { @@ -186,7 +186,7 @@ QPolygonF calcLines(const QStyleOptionSlider *dial) poly.resize(2 + 2 * notches); int smallLineSize = bigLineSize / 2; for (int i = 0; i <= notches; ++i) { - qreal angle = dial->dialWrapping ? Q_PI2 * 3 - i * Q_2PI / notches + qreal angle = dial->dialWrapping ? Q_PI * 3 / 2 - i * 2 * Q_PI / notches : (Q_PI * 8 - i * 10 * Q_PI / notches) / 6; qreal s = qSin(angle); qreal c = qCos(angle); @@ -215,7 +215,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) const bool enabled = option->state & QStyle::State_Enabled; qreal r = qMin(width, height) / 2; r -= r/50; - const qreal penSize = r/qreal(20.0); + const qreal penSize = r/20.0; painter->save(); painter->setRenderHint(QPainter::Antialiasing); @@ -234,7 +234,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) const qreal dx = option->rect.x() + d_ + (width - 2 * r) / 2 + 1; const qreal dy = option->rect.y() + d_ + (height - 2 * r) / 2 + 1; - QRectF br = QRectF(dx + qreal(0.5), dy + qreal(0.5), + QRectF br = QRectF(dx + 0.5, dy + 0.5, int(r * 2 - 2 * d_ - 2), int(r * 2 - 2 * d_ - 2)); buttonColor.setHsv(buttonColor .hue(), @@ -244,11 +244,11 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) if (enabled) { // Drop shadow - const qreal shadowSize = qMax(qreal(1.0), penSize * qreal(0.5)); + qreal shadowSize = qMax(1.0, penSize/2.0); QRectF shadowRect= br.adjusted(-2*shadowSize, -2*shadowSize, 2*shadowSize, 2*shadowSize); QRadialGradient shadowGradient(shadowRect.center().x(), - shadowRect.center().y(), shadowRect.width() * qreal(0.5), + shadowRect.center().y(), shadowRect.width()/2.0, shadowRect.center().x(), shadowRect.center().y()); shadowGradient.setColorAt(qreal(0.91), QColor(0, 0, 0, 40)); shadowGradient.setColorAt(qreal(1.0), Qt::transparent); @@ -260,7 +260,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) // Main gradient QRadialGradient gradient(br.center().x() - br.width()/3, dy, - br.width()*qreal(1.3), br.center().x(), + br.width()*1.3, br.center().x(), br.center().y() - br.height()/2); gradient.setColorAt(0, buttonColor.lighter(110)); gradient.setColorAt(qreal(0.5), buttonColor); @@ -283,7 +283,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) qMin(160, highlight.saturation()), qMax(230, highlight.value())); highlight.setAlpha(127); - p->setPen(QPen(highlight, qreal(2.0))); + p->setPen(QPen(highlight, 2.0)); p->setBrush(Qt::NoBrush); p->drawEllipse(br.adjusted(-1, -1, 1, 1)); } @@ -302,7 +302,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter) dialGradient.setColorAt(1, buttonColor.darker(140)); dialGradient.setColorAt(qreal(0.4), buttonColor.darker(120)); dialGradient.setColorAt(0, buttonColor.darker(110)); - if (penSize > qreal(3.0)) { + if (penSize > 3.0) { painter->setPen(QPen(QColor(0, 0, 0, 25), penSize)); painter->drawLine(calcRadialPos(option, qreal(0.90)), calcRadialPos(option, qreal(0.96))); } diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp index 1c24a03..ce73fd8 100644 --- a/src/gui/styles/qstylesheetstyle.cpp +++ b/src/gui/styles/qstylesheetstyle.cpp @@ -1252,20 +1252,20 @@ QPainterPath QRenderRule::borderClip(QRect r) const QRectF rect(r); const int *borders = border()->borders; QPainterPath path; - qreal curY = rect.y() + borders[TopEdge]*qreal(0.5); + qreal curY = rect.y() + borders[TopEdge]/2.0; path.moveTo(rect.x() + tlr.width(), curY); path.lineTo(rect.right() - trr.width(), curY); - qreal curX = rect.right() - borders[RightEdge]*qreal(0.5); + qreal curX = rect.right() - borders[RightEdge]/2.0; path.arcTo(curX - 2*trr.width() + borders[RightEdge], curY, trr.width()*2 - borders[RightEdge], trr.height()*2 - borders[TopEdge], 90, -90); path.lineTo(curX, rect.bottom() - brr.height()); - curY = rect.bottom() - borders[BottomEdge]*qreal(0.5); + curY = rect.bottom() - borders[BottomEdge]/2.0; path.arcTo(curX - 2*brr.width() + borders[RightEdge], curY - 2*brr.height() + borders[BottomEdge], brr.width()*2 - borders[RightEdge], brr.height()*2 - borders[BottomEdge], 0, -90); path.lineTo(rect.x() + blr.width(), curY); - curX = rect.left() + borders[LeftEdge]*qreal(0.5); + curX = rect.left() + borders[LeftEdge]/2.0; path.arcTo(curX, rect.bottom() - 2*blr.height() + borders[BottomEdge]/2, blr.width()*2 - borders[LeftEdge], blr.height()*2 - borders[BottomEdge], 270, -90); diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp index 4511709..447087c 100644 --- a/src/gui/text/qfont.cpp +++ b/src/gui/text/qfont.cpp @@ -309,7 +309,7 @@ QFontPrivate *QFontPrivate::smallCapsFontPrivate() const QFont font(const_cast(this)); qreal pointSize = font.pointSizeF(); if (pointSize > 0) - font.setPointSizeF(pointSize * qreal(.7)); + font.setPointSizeF(pointSize * .7); else font.setPixelSize((font.pixelSize() * 7 + 5) / 10); scFont = font.d.data(); @@ -2143,7 +2143,7 @@ QDataStream &operator<<(QDataStream &s, const QFont &font) if (s.version() >= QDataStream::Qt_4_0) { // 4.0 - qreal pointSize = font.d->request.pointSize; + double pointSize = font.d->request.pointSize; qint32 pixelSize = font.d->request.pixelSize; s << pointSize; s << pixelSize; @@ -2205,7 +2205,7 @@ QDataStream &operator>>(QDataStream &s, QFont &font) if (s.version() >= QDataStream::Qt_4_0) { // 4.0 - qreal pointSize; + double pointSize; qint32 pixelSize; s >> pointSize; s >> pixelSize; diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp index e8a0068..7e93aa0 100644 --- a/src/gui/text/qfontdatabase.cpp +++ b/src/gui/text/qfontdatabase.cpp @@ -1885,12 +1885,11 @@ QList QFontDatabase::pointSizes(const QString &family, smoothScalable = true; goto end; } - const qreal pointsize_factor = qreal(72.0) / dpi; for (int l = 0; l < style->count; l++) { const QtFontSize *size = style->pixelSizes + l; if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) { - const uint pointSize = qRound(size->pixelSize * pointsize_factor); + const uint pointSize = qRound(size->pixelSize * 72.0 / dpi); if (! sizes.contains(pointSize)) sizes.append(pointSize); } @@ -1993,12 +1992,11 @@ QList QFontDatabase::smoothSizes(const QString &family, smoothScalable = true; goto end; } - const qreal pointsize_factor = qreal(72.0) / dpi; for (int l = 0; l < style->count; l++) { const QtFontSize *size = style->pixelSizes + l; if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) { - const uint pointSize = qRound(size->pixelSize * pointsize_factor); + const uint pointSize = qRound(size->pixelSize * 72.0 / dpi); if (! sizes.contains(pointSize)) sizes.append(pointSize); } diff --git a/src/svg/qsvggenerator.cpp b/src/svg/qsvggenerator.cpp index 248bf55..2f80a92 100644 --- a/src/svg/qsvggenerator.cpp +++ b/src/svg/qsvggenerator.cpp @@ -796,9 +796,9 @@ int QSvgGenerator::metric(QPaintDevice::PaintDeviceMetric metric) const case QPaintDevice::PdmDpiY: return d->engine->resolution(); case QPaintDevice::PdmHeightMM: - return qRound(d->engine->size().height() * (d->engine->resolution() / qreal(25.4))); + return qRound(d->engine->size().height() * 25.4 / d->engine->resolution()); case QPaintDevice::PdmWidthMM: - return qRound(d->engine->size().width() * (d->engine->resolution() / qreal(25.4))); + return qRound(d->engine->size().width() * 25.4 / d->engine->resolution()); case QPaintDevice::PdmNumColors: return 0xffffffff; case QPaintDevice::PdmPhysicalDpiX: @@ -842,9 +842,8 @@ bool QSvgPaintEngine::begin(QPaintDevice *) *d->stream << "" << endl << "size.isValid()) { - const qreal mm_factor = d->resolution / qreal(25.4); - const qreal wmm = d->size.width() * mm_factor; - const qreal hmm = d->size.height() * mm_factor; + qreal wmm = d->size.width() * 25.4 / d->resolution; + qreal hmm = d->size.height() * 25.4 / d->resolution; *d->stream << " width=\"" << wmm << "mm\" height=\"" << hmm << "mm\"" << endl; } diff --git a/src/svg/qsvggraphics.cpp b/src/svg/qsvggraphics.cpp index cc3c170..6552b69 100644 --- a/src/svg/qsvggraphics.cpp +++ b/src/svg/qsvggraphics.cpp @@ -332,12 +332,11 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) // Force the font to have a size of 100 pixels to avoid truncation problems // when the font is very small. - const qreal scale = qreal(100.0) / p->font().pointSizeF(); - const qreal inv_scale = p->font().pointSizeF() / qreal(100.0); // like '1/scale' but with less rounding errors + qreal scale = 100.0 / p->font().pointSizeF(); Qt::Alignment alignment = states.textAnchor; QTransform oldTransform = p->worldTransform(); - p->scale(inv_scale, inv_scale); + p->scale(1 / scale, 1 / scale); qreal y = 0; bool initial = true; @@ -347,7 +346,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) if (m_type == TEXTAREA) { if (alignment == Qt::AlignHCenter) - px += scaledSize.width() * qreal(0.5); + px += scaledSize.width() / 2; else if (alignment == Qt::AlignRight) px += scaledSize.width(); } @@ -460,7 +459,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) qreal x = 0; if (alignment == Qt::AlignHCenter) - x -= qreal(0.5) * line.naturalTextWidth(); + x -= 0.5 * line.naturalTextWidth(); else if (alignment == Qt::AlignRight) x -= line.naturalTextWidth(); @@ -480,7 +479,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states) break; } - y += qreal(1.1) * line.height(); + y += 1.1 * line.height(); } tl.draw(p, QPointF(px, py), QVector(), bounds); diff --git a/src/svg/qsvghandler.cpp b/src/svg/qsvghandler.cpp index a340c05..3ed918e 100644 --- a/src/svg/qsvghandler.cpp +++ b/src/svg/qsvghandler.cpp @@ -66,7 +66,6 @@ #include "qnumeric.h" #include "qvarlengtharray.h" #include "private/qmath_p.h" -#include "private/qnumeric_p.h" #include "float.h" @@ -909,7 +908,7 @@ static inline qreal convertToNumber(const QString &str, QSvgHandler *handler, bo QSvgHandler::LengthType type; qreal num = parseLength(str, type, handler, ok); if (type == QSvgHandler::LT_PERCENT) { - num = num * qreal(0.01); + num = num/100.0; } return num; } @@ -944,13 +943,13 @@ static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type) case QSvgHandler::LT_PC: break; case QSvgHandler::LT_PT: - return len * qreal(1.25); + return len * 1.25; break; case QSvgHandler::LT_MM: - return len * qreal(3.543307); + return len * 3.543307; break; case QSvgHandler::LT_CM: - return len * qreal(35.43307); + return len * 35.43307; break; case QSvgHandler::LT_IN: return len * 90; @@ -1373,16 +1372,16 @@ static void pathArcSegment(QPainterPath &path, qreal t; qreal thHalf; - sinTh = qSin(xAxisRotation * Q_PI180); - cosTh = qCos(xAxisRotation * Q_PI180); + sinTh = qSin(xAxisRotation * (Q_PI / 180.0)); + cosTh = qCos(xAxisRotation * (Q_PI / 180.0)); a00 = cosTh * rx; a01 = -sinTh * ry; a10 = sinTh * rx; a11 = cosTh * ry; - thHalf = qreal(0.5) * (th1 - th0); - t = (qreal(8.0) / qreal(3.0)) * qSin(thHalf * qreal(0.5)) * qSin(thHalf * qreal(0.5)) / qSin(thHalf); + thHalf = 0.5 * (th1 - th0); + t = (8.0 / 3.0) * qSin(thHalf * 0.5) * qSin(thHalf * 0.5) / qSin(thHalf); x1 = xc + qCos(th0) - t * qSin(th0); y1 = yc + qSin(th0) + t * qCos(th0); x3 = xc + qCos(th1); @@ -1442,11 +1441,11 @@ static void pathArc(QPainterPath &path, rx = qAbs(rx); ry = qAbs(ry); - sin_th = qSin(x_axis_rotation * Q_PI180); - cos_th = qCos(x_axis_rotation * Q_PI180); + sin_th = qSin(x_axis_rotation * (Q_PI / 180.0)); + cos_th = qCos(x_axis_rotation * (Q_PI / 180.0)); - dx = (curx - x) * qreal(0.5); - dy = (cury - y) * qreal(0.5); + dx = (curx - x) / 2.0; + dy = (cury - y) / 2.0; dx1 = cos_th * dx + sin_th * dy; dy1 = -sin_th * dx + cos_th * dy; Pr1 = rx * rx; @@ -1460,12 +1459,10 @@ static void pathArc(QPainterPath &path, ry = ry * qSqrt(check); } - const qreal inv_rx = 1 / rx; - const qreal inv_ry = 1 / ry; - a00 = cos_th * inv_rx; - a01 = sin_th * inv_rx; - a10 = -sin_th * inv_ry; - a11 = cos_th * inv_ry; + a00 = cos_th / rx; + a01 = sin_th / rx; + a10 = -sin_th / ry; + a11 = cos_th / ry; x0 = a00 * curx + a01 * cury; y0 = a10 * curx + a11 * cury; x1 = a00 * x + a01 * y; @@ -1476,12 +1473,12 @@ static void pathArc(QPainterPath &path, The arc fits a unit-radius circle in this space. */ d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0); - sfactor_sq = qreal(1.0) / d - qreal(0.25); + sfactor_sq = 1.0 / d - 0.25; if (sfactor_sq < 0) sfactor_sq = 0; sfactor = qSqrt(sfactor_sq); if (sweep_flag == large_arc_flag) sfactor = -sfactor; - xc = qreal(0.5) * (x0 + x1) - sfactor * (y1 - y0); - yc = qreal(0.5) * (y0 + y1) + sfactor * (x1 - x0); + xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0); + yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0); /* (xc, yc) is center of the circle. */ th0 = atan2(y0 - yc, x0 - xc); @@ -1489,18 +1486,16 @@ static void pathArc(QPainterPath &path, th_arc = th1 - th0; if (th_arc < 0 && sweep_flag) - th_arc += Q_2PI; + th_arc += 2 * Q_PI; else if (th_arc > 0 && !sweep_flag) - th_arc -= Q_2PI; + th_arc -= 2 * Q_PI; - n_segs = qCeil(qAbs(th_arc / (Q_PI2 + qreal(0.001)))); + n_segs = qCeil(qAbs(th_arc / (Q_PI * 0.5 + 0.001))); - const qreal th_arc_div_n_segs = th_arc / n_segs; for (i = 0; i < n_segs; i++) { - const qreal i_mul_th_arc_div_n_segs = i * th_arc_div_n_segs; pathArcSegment(path, xc, yc, - th0 + i_mul_th_arc_div_n_segs, - th0 + i_mul_th_arc_div_n_segs + th_arc_div_n_segs, + th0 + i * th_arc / n_segs, + th0 + (i + 1) * th_arc / n_segs, rx, ry, x_axis_rotation); } } @@ -2974,10 +2969,10 @@ static QSvgNode *createRectNode(QSvgNode *parent, //9.2 The 'rect' element clearly specifies it // but the case might in fact be handled because // we draw rounded rectangles differently - if (nrx > bounds.width()*qreal(0.5)) - nrx = bounds.width()*qreal(0.5); - if (nry > bounds.height()*qreal(0.5)) - nry = bounds.height()*qreal(0.5); + if (nrx > bounds.width()/2) + nrx = bounds.width()/2; + if (nry > bounds.height()/2) + nry = bounds.height()/2; if (nrx && !nry) nry = nrx; @@ -2987,8 +2982,8 @@ static QSvgNode *createRectNode(QSvgNode *parent, //we draw rounded rect from 0...99 //svg from 0...bounds.width()/2 so we're adjusting the //coordinates - nrx *= (200/bounds.width()); - nry *= (200/bounds.height()); + nrx *= (100/(bounds.width()/2)); + nry *= (100/(bounds.height()/2)); QSvgNode *rect = new QSvgRect(parent, bounds, int(nrx), @@ -3078,7 +3073,7 @@ static bool parseStopNode(QSvgStyleProperty *parent, bool ok = true; qreal offset = convertToNumber(offsetStr, handler, &ok); if (!ok) - offset = qreal(0.0); + offset = 0.0; QString black = QString::fromLatin1("#000000"); if (colorStr.isEmpty()) { colorStr = QStringRef(&black); @@ -3098,9 +3093,9 @@ static bool parseStopNode(QSvgStyleProperty *parent, } // If offset is greater than one, it must be clamped to one. - if (offset > qreal(1.0)) { - if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < qreal(1.0) - FLT_EPSILON)) { - stops.back().first = qreal(1.0) - FLT_EPSILON; + if (offset > 1.0) { + if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < 1.0 - FLT_EPSILON)) { + stops.back().first = 1.0 - FLT_EPSILON; grad->setStops(stops); } offset = 1.0; diff --git a/src/svg/qsvgtinydocument.cpp b/src/svg/qsvgtinydocument.cpp index 21e9e9f..e2cefeb 100644 --- a/src/svg/qsvgtinydocument.cpp +++ b/src/svg/qsvgtinydocument.cpp @@ -466,19 +466,20 @@ QMatrix QSvgTinyDocument::matrixForElement(const QString &id) const int QSvgTinyDocument::currentFrame() const { - const qreal runningPercentage = qMin(qreal(m_time.elapsed()) / qreal(m_animationDuration), qreal(1.)); + double runningPercentage = qMin(m_time.elapsed()/double(m_animationDuration), 1.); - const int totalFrames = m_fps * m_animationDuration; + int totalFrames = m_fps * m_animationDuration; return int(runningPercentage * totalFrames); } void QSvgTinyDocument::setCurrentFrame(int frame) { - const int totalFrames = m_fps * m_animationDuration; - const qreal framePercentage = frame / totalFrames; - const qreal timeForFrame = m_animationDuration * framePercentage * 1000; //in ms - const int timeToAdd = int(timeForFrame - m_time.elapsed()); + int totalFrames = m_fps * m_animationDuration; + double framePercentage = frame/double(totalFrames); + double timeForFrame = m_animationDuration * framePercentage; //in S + timeForFrame *= 1000; //in ms + int timeToAdd = int(timeForFrame - m_time.elapsed()); m_time = m_time.addMSecs(timeToAdd); } -- cgit v0.12 From 258e751b7f4c3ff5e44fdbd654ce45d0693934bf Mon Sep 17 00:00:00 2001 From: Janne Anttila Date: Wed, 11 Nov 2009 15:34:15 +0200 Subject: Fix for assertion failure in in QWidget::grabMouse for Symbian. Docs say: "Note that only visible widgets can grab mouse input. If isVisible() returns false for a widget, that widget cannot call grabMouse()." qwidget_x11.cpp uses the similar condition in grabMouse as symbian after this commit. Task-number: QTBUG-5658 Reviewed-by: Jason Barron --- src/gui/kernel/qwidget_s60.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp index 915d308..504a538 100644 --- a/src/gui/kernel/qwidget_s60.cpp +++ b/src/gui/kernel/qwidget_s60.cpp @@ -1236,7 +1236,7 @@ void QWidget::releaseKeyboard() void QWidget::grabMouse() { - if (!qt_nograb()) { + if (isVisible() && !qt_nograb()) { if (QWidgetPrivate::mouseGrabber && QWidgetPrivate::mouseGrabber != this) QWidgetPrivate::mouseGrabber->releaseMouse(); Q_ASSERT(testAttribute(Qt::WA_WState_Created)); @@ -1253,7 +1253,7 @@ void QWidget::grabMouse() #ifndef QT_NO_CURSOR void QWidget::grabMouse(const QCursor &cursor) { - if (!qt_nograb()) { + if (isVisible() && !qt_nograb()) { if (QWidgetPrivate::mouseGrabber && QWidgetPrivate::mouseGrabber != this) QWidgetPrivate::mouseGrabber->releaseMouse(); Q_ASSERT(testAttribute(Qt::WA_WState_Created)); -- cgit v0.12 From 0779fbb16838a5d857665a0d70e30e2ba49cefba Mon Sep 17 00:00:00 2001 From: Jani Hautakangas Date: Wed, 11 Nov 2009 17:13:36 +0200 Subject: Fix to symbian transparent window backing store format. Symbian semi-transparent window surface needs backing store pixmap in argb32 format. Normally QPixmap contains only rgb32 or argb32_pre pixels. This fix locks semi-transparent window backing store pixmap to argb32 format. Reviewed-by: Shane Kearns --- src/gui/image/qpixmap_s60.cpp | 12 ++++++++---- src/gui/image/qpixmap_s60_p.h | 2 ++ 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp index f7a880c..21415d3 100644 --- a/src/gui/image/qpixmap_s60.cpp +++ b/src/gui/image/qpixmap_s60.cpp @@ -349,7 +349,8 @@ QS60PixmapData::QS60PixmapData(PixelType type) : QRasterPixmapData(type), bitmapDevice(0), bitmapGc(0), pengine(0), - bytes(0) + bytes(0), + formatLocked(false) { } @@ -425,11 +426,12 @@ void QS60PixmapData::release() } /*! - * Takes ownership of bitmap + * Takes ownership of bitmap. Used by window surface */ void QS60PixmapData::fromSymbianBitmap(CFbsBitmap* bitmap) { cfbsBitmap = bitmap; + formatLocked = true; if(!initSymbianBitmapContext()) { qWarning("Could not create CBitmapContext"); @@ -693,8 +695,10 @@ void QS60PixmapData::beginDataAccess() bytes = newBytes; TDisplayMode mode = cfbsBitmap->DisplayMode(); QImage::Format format = qt_TDisplayMode2Format(mode); - //on S60 3.1, premultiplied alpha pixels are stored in a bitmap with 16MA type - if (format == QImage::Format_ARGB32) + // On S60 3.1, premultiplied alpha pixels are stored in a bitmap with 16MA type. + // S60 window surface needs backing store pixmap for transparent window in ARGB32 format. + // In that case formatLocked is true. + if (!formatLocked && format == QImage::Format_ARGB32) format = QImage::Format_ARGB32_Premultiplied; // pixel data is actually in premultiplied format QVector savedColorTable; diff --git a/src/gui/image/qpixmap_s60_p.h b/src/gui/image/qpixmap_s60_p.h index b23961a..b1b5824 100644 --- a/src/gui/image/qpixmap_s60_p.h +++ b/src/gui/image/qpixmap_s60_p.h @@ -118,6 +118,8 @@ private: QPaintEngine *pengine; uchar* bytes; + bool formatLocked; + friend class QPixmap; friend class QS60WindowSurface; friend class QS60PaintEngine; -- cgit v0.12 From 929dd1e7bc02c51e324425a79243f0ff08fb1508 Mon Sep 17 00:00:00 2001 From: axis Date: Wed, 11 Nov 2009 16:28:57 +0100 Subject: Fixed some initializers and saved some memory. RevBy: Trust me --- src/gui/kernel/qapplication_s60.cpp | 6 +++++- src/gui/kernel/qt_s60_p.h | 4 ++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp index 5578a72..0c2099b 100644 --- a/src/gui/kernel/qapplication_s60.cpp +++ b/src/gui/kernel/qapplication_s60.cpp @@ -319,7 +319,11 @@ void QLongTapTimer::RunL() } QSymbianControl::QSymbianControl(QWidget *w) - : CCoeControl(), qwidget(w), m_ignoreFocusChanged(false) + : CCoeControl() + , qwidget(w) + , m_longTapDetector(0) + , m_ignoreFocusChanged(0) + , m_previousEventLongTap(0) { } diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h index a1e760c..3ae76ae 100644 --- a/src/gui/kernel/qt_s60_p.h +++ b/src/gui/kernel/qt_s60_p.h @@ -202,9 +202,9 @@ private: private: QWidget *qwidget; - bool m_ignoreFocusChanged; QLongTapTimer* m_longTapDetector; - bool m_previousEventLongTap; + bool m_ignoreFocusChanged : 1; + bool m_previousEventLongTap : 1; #ifdef Q_WS_S60 // Fader object used to fade everything except this menu and the CBA. -- cgit v0.12 From 06baf7f173b0331a5192616b8ecf9611130f278b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Samuel=20R=C3=B8dal?= Date: Wed, 11 Nov 2009 16:38:00 +0100 Subject: Printing QTextDocument doesn't include custom objects. We need to copy the abstract text layout's custom object handlers as well when we temporarily use a different QTextDocument. Task-number: QTBUG-5397 Reviewed-by: Simon Hausmann --- src/gui/text/qabstracttextdocumentlayout.h | 1 + src/gui/text/qtextcontrol.cpp | 4 ++++ src/gui/text/qtextdocument.cpp | 4 ++++ 3 files changed, 9 insertions(+) diff --git a/src/gui/text/qabstracttextdocumentlayout.h b/src/gui/text/qabstracttextdocumentlayout.h index 2f8a746..438b291 100644 --- a/src/gui/text/qabstracttextdocumentlayout.h +++ b/src/gui/text/qabstracttextdocumentlayout.h @@ -122,6 +122,7 @@ protected: QTextCharFormat format(int pos); private: + friend class QTextControl; friend class QTextDocument; friend class QTextDocumentPrivate; friend class QTextEngine; diff --git a/src/gui/text/qtextcontrol.cpp b/src/gui/text/qtextcontrol.cpp index 9497b6f..62039f3 100644 --- a/src/gui/text/qtextcontrol.cpp +++ b/src/gui/text/qtextcontrol.cpp @@ -55,6 +55,7 @@ #include #include #include "private/qtextdocumentlayout_p.h" +#include "private/qabstracttextdocumentlayout_p.h" #include "private/qtextedit_p.h" #include "qtextdocument.h" #include "private/qtextdocument_p.h" @@ -2313,6 +2314,9 @@ void QTextControl::print(QPrinter *printer) const tempDoc->setUseDesignMetrics(doc->useDesignMetrics()); QTextCursor(tempDoc).insertFragment(d->cursor.selection()); doc = tempDoc; + + // copy the custom object handlers + doc->documentLayout()->d_func()->handlers = d->doc->documentLayout()->d_func()->handlers; } doc->print(printer); delete tempDoc; diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp index 1aad385..048325c 100644 --- a/src/gui/text/qtextdocument.cpp +++ b/src/gui/text/qtextdocument.cpp @@ -64,6 +64,7 @@ #include "qtextdocument_p.h" #include +#include #include @@ -1722,6 +1723,9 @@ void QTextDocument::print(QPrinter *printer) const QAbstractTextDocumentLayout *layout = doc->documentLayout(); layout->setPaintDevice(p.device()); + // copy the custom object handlers + layout->d_func()->handlers = documentLayout()->d_func()->handlers; + int dpiy = p.device()->logicalDpiY(); int margin = 0; if (printer->fullPage() && !printer->d_func()->hasCustomPageMargins) { -- cgit v0.12 From fab1ce65da8bacfce92b1df7656780e729d31b74 Mon Sep 17 00:00:00 2001 From: Eskil Abrahamsen Blomfeldt Date: Wed, 11 Nov 2009 16:59:37 +0100 Subject: Add option to ingore unused navigation events in QTextControl QFxTextEdit, as well as systems with keypad navigation, needs the text control to ignore navigation events that have no effect (like hitting the right navigation key at the end of the text.) Previously, we would only support this for keypad navigation. This patch introduces a flag that you can set to tell the QTextControl to ignore these events. If the flag is not explicitly set, behavior should remain as before. The if-test has been refactored to make it more readable. Done-with: Alan Alpert Reviewed-by: Samuel --- src/gui/text/qtextcontrol.cpp | 33 ++++++++++++++++++++++++++------- src/gui/text/qtextcontrol_p.h | 4 ++++ src/gui/text/qtextcontrol_p_p.h | 1 + 3 files changed, 31 insertions(+), 7 deletions(-) diff --git a/src/gui/text/qtextcontrol.cpp b/src/gui/text/qtextcontrol.cpp index 62039f3..e96d445 100644 --- a/src/gui/text/qtextcontrol.cpp +++ b/src/gui/text/qtextcontrol.cpp @@ -127,6 +127,7 @@ QTextControlPrivate::QTextControlPrivate() #endif isEnabled(true), hadSelectionOnMousePress(false), + ignoreUnusedNavigationEvents(false), openExternalLinks(false) {} @@ -265,19 +266,25 @@ bool QTextControlPrivate::cursorMoveKeyEvent(QKeyEvent *e) cursor.setVisualNavigation(visualNavigation); q->ensureCursorVisible(); + bool ignoreNavigationEvents = ignoreUnusedNavigationEvents; + bool isNavigationEvent = e->key() == Qt::Key_Up || e->key() == Qt::Key_Down; + +#ifdef QT_KEYPAD_NAVIGATION + ignoreNavigationEvents = ignoreNavigationEvents || QApplication::keypadNavigationEnabled(); + isNavigationEvent = isNavigationEvent || + (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional + && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right)); +#else + isNavigationEvent = isNavigationEvent || e->key() == Qt::Key_Left || e->key() == Qt::Key_Right; +#endif + if (moved) { if (cursor.position() != oldCursorPos) emit q->cursorPositionChanged(); emit q->microFocusChanged(); - } -#ifdef QT_KEYPAD_NAVIGATION - else if (QApplication::keypadNavigationEnabled() - && ((e->key() == Qt::Key_Up || e->key() == Qt::Key_Down) - || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional - && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right))) { + } else if (ignoreNavigationEvents && isNavigationEvent) { return false; } -#endif selectionChanged(/*forceEmitSelectionChanged =*/(mode == QTextCursor::KeepAnchor)); @@ -2258,6 +2265,18 @@ bool QTextControl::openExternalLinks() const return d->openExternalLinks; } +bool QTextControl::ignoreUnusedNavigationEvents() const +{ + Q_D(const QTextControl); + return d->ignoreUnusedNavigationEvents; +} + +void QTextControl::setIgnoreUnusedNavigationEvents(bool ignore) +{ + Q_D(QTextControl); + d->ignoreUnusedNavigationEvents = ignore; +} + void QTextControl::moveCursor(QTextCursor::MoveOperation op, QTextCursor::MoveMode mode) { Q_D(QTextControl); diff --git a/src/gui/text/qtextcontrol_p.h b/src/gui/text/qtextcontrol_p.h index 263af31..bc8e063 100644 --- a/src/gui/text/qtextcontrol_p.h +++ b/src/gui/text/qtextcontrol_p.h @@ -95,6 +95,7 @@ class Q_GUI_EXPORT QTextControl : public QObject Q_PROPERTY(int cursorWidth READ cursorWidth WRITE setCursorWidth) Q_PROPERTY(Qt::TextInteractionFlags textInteractionFlags READ textInteractionFlags WRITE setTextInteractionFlags) Q_PROPERTY(bool openExternalLinks READ openExternalLinks WRITE setOpenExternalLinks) + Q_PROPERTY(bool ignoreUnusedNavigationEvents READ ignoreUnusedNavigationEvents WRITE setIgnoreUnusedNavigationEvents) public: explicit QTextControl(QObject *parent = 0); explicit QTextControl(const QString &text, QObject *parent = 0); @@ -163,6 +164,9 @@ public: void setOpenExternalLinks(bool open); bool openExternalLinks() const; + void setIgnoreUnusedNavigationEvents(bool ignore); + bool ignoreUnusedNavigationEvents() const; + void moveCursor(QTextCursor::MoveOperation op, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor); bool canPaste() const; diff --git a/src/gui/text/qtextcontrol_p_p.h b/src/gui/text/qtextcontrol_p_p.h index ca9db9f..af3b521 100644 --- a/src/gui/text/qtextcontrol_p_p.h +++ b/src/gui/text/qtextcontrol_p_p.h @@ -206,6 +206,7 @@ public: QString anchorOnMousePress; bool hadSelectionOnMousePress; + bool ignoreUnusedNavigationEvents; bool openExternalLinks; QString linkToCopy; -- cgit v0.12 From 3826d81d96c53f253f2f75683cd1802faa1628df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sami=20Meril=C3=A4?= Date: Thu, 12 Nov 2009 12:49:11 +0200 Subject: Tab shapes have the wrong size and distance between them on Symbian With certain themes it is really apparent that the tabshape rect and position deduction in QS60Style has some issues. See for example 5800Xm's default theme. TabShapes have huge spaces between them. Problem is that the initializer in style for tab shape assumes that the side parts of the frame are squares and will use 1:1 ratio (width:height) when upscaling the theme graphic draw area. This leads to that tabshape graphics will not fill in the whole area reserved for them. When initial area has ratio of 1:2 (for horizontal tab shape), upscaling pruduces correct rect and graphic is drawn correctly. Task-number: QTBUG-5659 Reviewed-by: Alessandro Portale --- src/gui/styles/qs60style.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index a1dab86..9179237 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -799,6 +799,9 @@ QSize QS60StylePrivate::partSize(QS60StyleEnums::SkinParts part, SkinElementFlag case QS60StyleEnums::SP_QgnGrafTabPassiveR: case QS60StyleEnums::SP_QgnGrafTabPassiveL: case QS60StyleEnums::SP_QgnGrafTabActiveL: + //Returned QSize for tabs must not be square, but narrow rectangle with width:height + //ratio of 1:2 for horizontal tab bars (and 2:1 for vertical ones). + result.setWidth(10); break; case QS60StyleEnums::SP_QgnIndiSliderEdit: result.scale(pixelMetric(QStyle::PM_SliderLength), @@ -809,7 +812,7 @@ QSize QS60StylePrivate::partSize(QS60StyleEnums::SkinParts part, SkinElementFlag case QS60StyleEnums::SP_QgnGrafBarFrameSideR: result.setWidth(pixelMetric(PM_Custom_FrameCornerWidth)); break; - + case QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed: case QS60StyleEnums::SP_QsnCpScrollHandleTopPressed: case QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed: -- cgit v0.12 From 42d990bde3ea5e825d90d245a958c7faf7a6aa5b Mon Sep 17 00:00:00 2001 From: axis Date: Wed, 11 Nov 2009 14:05:27 +0100 Subject: Fixed a focusing bug on Symbian. When Symbian pops up a menu or dialog, Qt should produce FocusOut events using PopupFocusReason rather than deactivating the whole window. This keeps input widgets from losing focus when FEP wants to pop up dialogs. AutoTest: QWidget passed RevBy: Jason Barron --- src/gui/kernel/qapplication_s60.cpp | 20 ++++++++++++++++++++ src/gui/kernel/qt_s60_p.h | 1 + 2 files changed, 21 insertions(+) diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp index 0c2099b..dd2ccf2 100644 --- a/src/gui/kernel/qapplication_s60.cpp +++ b/src/gui/kernel/qapplication_s60.cpp @@ -324,6 +324,7 @@ QSymbianControl::QSymbianControl(QWidget *w) , m_longTapDetector(0) , m_ignoreFocusChanged(0) , m_previousEventLongTap(0) + , m_symbianPopupIsOpen(0) { } @@ -915,6 +916,15 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */) return; if (IsFocused() && IsVisible()) { + if (m_symbianPopupIsOpen) { + QWidget *fw = QApplication::focusWidget(); + if (fw) { + QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason); + QCoreApplication::sendEvent(fw, &event); + } + m_symbianPopupIsOpen = false; + } + QApplication::setActiveWindow(qwidget->window()); #ifdef Q_WS_S60 // If widget is fullscreen, hide status pane and button container @@ -928,6 +938,16 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */) buttonGroup->MakeVisible(!isFullscreen); #endif } else if (QApplication::activeWindow() == qwidget->window()) { + if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog()) { + QWidget *fw = QApplication::focusWidget(); + if (fw) { + QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason); + QCoreApplication::sendEvent(fw, &event); + } + m_symbianPopupIsOpen = true; + return; + } + QApplication::setActiveWindow(0); } // else { We don't touch the active window unless we were explicitly activated or deactivated } diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h index 3ae76ae..d45c34a 100644 --- a/src/gui/kernel/qt_s60_p.h +++ b/src/gui/kernel/qt_s60_p.h @@ -205,6 +205,7 @@ private: QLongTapTimer* m_longTapDetector; bool m_ignoreFocusChanged : 1; bool m_previousEventLongTap : 1; + bool m_symbianPopupIsOpen : 1; #ifdef Q_WS_S60 // Fader object used to fade everything except this menu and the CBA. -- cgit v0.12 From fae182ebe716cf805805564af95fd2d4c73ae20e Mon Sep 17 00:00:00 2001 From: Oswald Buddenhagen Date: Thu, 12 Nov 2009 11:31:15 +0100 Subject: remove dependency on git line end conversions consistently use QIODevice::Text --- tests/auto/linguist/lconvert/tst_lconvert.cpp | 8 +++++--- tests/auto/linguist/lrelease/tst_lrelease.cpp | 8 ++++---- tests/auto/linguist/lupdate/testlupdate.cpp | 4 ++-- tests/auto/linguist/lupdate/tst_lupdate.cpp | 12 ++++++------ 4 files changed, 17 insertions(+), 15 deletions(-) diff --git a/tests/auto/linguist/lconvert/tst_lconvert.cpp b/tests/auto/linguist/lconvert/tst_lconvert.cpp index e38e22c..10098a4 100644 --- a/tests/auto/linguist/lconvert/tst_lconvert.cpp +++ b/tests/auto/linguist/lconvert/tst_lconvert.cpp @@ -105,7 +105,7 @@ void tst_lconvert::doCompare(QIODevice *actualDev, const QString &expectedFn) QList actual = actualDev->readAll().split('\n'); QFile file(expectedFn); - QVERIFY(file.open(QIODevice::ReadOnly)); + QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Text)); QList expected = file.readAll().split('\n'); int i = 0, ei = expected.size(), gi = actual.size(); @@ -179,7 +179,7 @@ void tst_lconvert::convertChain(const QString &_inFileName, const QString &_outF if (!argList.isEmpty()) args += argList[i]; args << "-if" << stations[i] << "-i" << "-" << "-of" << stations[i + 1]; - cvts.at(i)->start(binDir + "/lconvert", args); + cvts.at(i)->start(binDir + "/lconvert", args, QIODevice::ReadWrite | QIODevice::Text); } int st = 0; foreach (QProcess *cvt, cvts) @@ -243,7 +243,9 @@ void tst_lconvert::converts() QString outFileNameFq = dataDir + outFileName; QProcess cvt; - cvt.start(binDir + "/lconvert", QStringList() << "-i" << (dataDir + inFileName) << "-of" << format); + cvt.start(binDir + "/lconvert", + QStringList() << "-i" << (dataDir + inFileName) << "-of" << format, + QIODevice::ReadWrite | QIODevice::Text); doWait(&cvt, 0); if (QTest::currentTestFailed()) return; diff --git a/tests/auto/linguist/lrelease/tst_lrelease.cpp b/tests/auto/linguist/lrelease/tst_lrelease.cpp index 9a3bba6..9d30fe7 100644 --- a/tests/auto/linguist/lrelease/tst_lrelease.cpp +++ b/tests/auto/linguist/lrelease/tst_lrelease.cpp @@ -70,8 +70,8 @@ private: void tst_lrelease::doCompare(const QStringList &actual, const QString &expectedFn) { QFile file(expectedFn); - QVERIFY(file.open(QIODevice::ReadOnly)); - QStringList expected = QString(file.readAll()).trimmed().remove('\r').split('\n'); + QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Text)); + QStringList expected = QString(file.readAll()).trimmed().split('\n'); int i = 0, ei = expected.size(), gi = actual.size(); for (; ; i++) { @@ -200,10 +200,10 @@ void tst_lrelease::compressed() void tst_lrelease::dupes() { QProcess proc; - proc.start(binDir + "/lrelease testdata/dupes.ts"); + proc.start(binDir + "/lrelease testdata/dupes.ts", QIODevice::ReadWrite | QIODevice::Text); QVERIFY(proc.waitForFinished()); QVERIFY(proc.exitStatus() == QProcess::NormalExit); - doCompare(QString(proc.readAllStandardError()).trimmed().remove('\r').split('\n'), "testdata/dupes.errors"); + doCompare(QString(proc.readAllStandardError()).trimmed().split('\n'), "testdata/dupes.errors"); } QTEST_MAIN(tst_lrelease) diff --git a/tests/auto/linguist/lupdate/testlupdate.cpp b/tests/auto/linguist/lupdate/testlupdate.cpp index 8e57323..d43fbc4 100644 --- a/tests/auto/linguist/lupdate/testlupdate.cpp +++ b/tests/auto/linguist/lupdate/testlupdate.cpp @@ -98,9 +98,9 @@ bool TestLUpdate::runChild( bool showOutput, const QString &program, const QStri connect(childProc, SIGNAL(finished(int)), this, SLOT(childReady(int))); childProc->setProcessChannelMode(QProcess::MergedChannels); if (argList.isEmpty()) { - childProc->start( program ); + childProc->start( program, QIODevice::ReadWrite | QIODevice::Text ); } else { - childProc->start( program, argList ); + childProc->start( program, argList, QIODevice::ReadWrite | QIODevice::Text ); } bool ok; diff --git a/tests/auto/linguist/lupdate/tst_lupdate.cpp b/tests/auto/linguist/lupdate/tst_lupdate.cpp index 8443621..359c5a10 100644 --- a/tests/auto/linguist/lupdate/tst_lupdate.cpp +++ b/tests/auto/linguist/lupdate/tst_lupdate.cpp @@ -80,8 +80,8 @@ private: void tst_lupdate::doCompare(const QStringList &actual, const QString &expectedFn, bool err) { QFile file(expectedFn); - QVERIFY(file.open(QIODevice::ReadOnly)); - QStringList expected = QString(file.readAll()).trimmed().remove('\r').split('\n'); + QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Text)); + QStringList expected = QString(file.readAll()).trimmed().split('\n'); int i = 0, ei = expected.size(), gi = actual.size(); for (; ; i++) { @@ -130,8 +130,8 @@ void tst_lupdate::doCompare(const QStringList &actual, const QString &expectedFn void tst_lupdate::doCompare(const QString &actualFn, const QString &expectedFn, bool err) { QFile afile(actualFn); - QVERIFY(afile.open(QIODevice::ReadOnly)); - QStringList actual = QString(afile.readAll()).trimmed().remove('\r').split('\n'); + QVERIFY(afile.open(QIODevice::ReadOnly | QIODevice::Text)); + QStringList actual = QString(afile.readAll()).trimmed().split('\n'); doCompare(actual, expectedFn, err); } @@ -169,7 +169,7 @@ void tst_lupdate::good() QString lupdatecmd; QFile file(dir + "/lupdatecmd"); if (file.exists()) { - QVERIFY(file.open(QIODevice::ReadOnly)); + QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Text)); while (!file.atEnd()) { QByteArray cmdstring = file.readLine().simplified(); if (cmdstring.startsWith('#')) @@ -215,7 +215,7 @@ void tst_lupdate::output_ts() QString lupdatecmd; QFile file(dir + "/lupdatecmd"); if (file.exists()) { - QVERIFY(file.open(QIODevice::ReadOnly)); + QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Text)); while (!file.atEnd()) { QByteArray cmdstring = file.readLine().simplified(); if (cmdstring.startsWith('#')) -- cgit v0.12 From 65f38e884f40f02be6497819c876013750cce4ea Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 12 Nov 2009 14:32:52 +0100 Subject: Fixa regression that could make a dockwidget disappear if unfloatable Task-number: QTBUG-5740 Reviewed-by: ogoffart --- src/gui/widgets/qmainwindowlayout.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/gui/widgets/qmainwindowlayout.cpp b/src/gui/widgets/qmainwindowlayout.cpp index 027a5d6..fa6f7a1 100644 --- a/src/gui/widgets/qmainwindowlayout.cpp +++ b/src/gui/widgets/qmainwindowlayout.cpp @@ -1641,6 +1641,9 @@ void QMainWindowLayout::animationFinished(QWidget *widget) savedState.clear(); currentGapPos.clear(); pluggingWidget = 0; + //applying the state will make sure that the currentGap is updated correctly + //and all the geometries (especially the one from the central widget) is correct + layoutState.apply(false); } if (!widgetAnimator.animating()) { -- cgit v0.12 From 037c1c3b3e1abc07f0570336bd7958121f32848a Mon Sep 17 00:00:00 2001 From: Olivier Goffart Date: Thu, 12 Nov 2009 14:34:01 +0100 Subject: QLabel: Fixed text underlined when te label has a control and the text contains & We need to search for '&' in the text each time the QTextControl's document is updated. Also make sure not to match && Task-number: QTBUG-4154 Reviewed-by: Thierry --- src/gui/widgets/qlabel.cpp | 38 +++++++++++++++++------------- src/gui/widgets/qlabel_p.h | 2 +- tests/auto/qlabel/tst_qlabel.cpp | 51 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 74 insertions(+), 17 deletions(-) diff --git a/src/gui/widgets/qlabel.cpp b/src/gui/widgets/qlabel.cpp index 3d908a1..ea711e8 100644 --- a/src/gui/widgets/qlabel.cpp +++ b/src/gui/widgets/qlabel.cpp @@ -1170,22 +1170,10 @@ void QLabelPrivate::updateShortcut() // But then we do want to hide the ampersands, so we can't use shortcutId. hasShortcut = false; - if (control) { - ensureTextPopulated(); - // Underline the first character that follows an ampersand - shortcutCursor = control->document()->find(QLatin1String("&")); - if (shortcutCursor.isNull()) - return; - hasShortcut = true; - shortcutId = q->grabShortcut(QKeySequence::mnemonic(text)); - shortcutCursor.deleteChar(); // remove the ampersand - shortcutCursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor); - } else { - if (!text.contains(QLatin1Char('&'))) - return; - hasShortcut = true; - shortcutId = q->grabShortcut(QKeySequence::mnemonic(text)); - } + if (!text.contains(QLatin1Char('&'))) + return; + hasShortcut = true; + shortcutId = q->grabShortcut(QKeySequence::mnemonic(text)); } #endif // QT_NO_SHORTCUT @@ -1456,6 +1444,24 @@ void QLabelPrivate::ensureTextPopulated() const doc->setPlainText(text); #endif doc->setUndoRedoEnabled(false); + +#ifndef QT_NO_SHORTCUT + if (hasShortcut) { + // Underline the first character that follows an ampersand (and remove the others ampersands) + int from = 0; + bool found = false; + QTextCursor cursor; + while (!(cursor = control->document()->find((QLatin1String("&")), from)).isNull()) { + cursor.deleteChar(); // remove the ampersand + cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor); + from = cursor.position(); + if (!found && cursor.selectedText() != QLatin1String("&")) { //not a second & + found = true; + shortcutCursor = cursor; + } + } + } +#endif } } textDirty = false; diff --git a/src/gui/widgets/qlabel_p.h b/src/gui/widgets/qlabel_p.h index c5a74e2..ca17a35 100644 --- a/src/gui/widgets/qlabel_p.h +++ b/src/gui/widgets/qlabel_p.h @@ -113,7 +113,7 @@ public: mutable uint hasShortcut : 1; Qt::TextFormat textformat; mutable QTextControl *control; - QTextCursor shortcutCursor; + mutable QTextCursor shortcutCursor; Qt::TextInteractionFlags textInteractionFlags; inline bool needTextControl() const { diff --git a/tests/auto/qlabel/tst_qlabel.cpp b/tests/auto/qlabel/tst_qlabel.cpp index 9d957a5..6b7e106 100644 --- a/tests/auto/qlabel/tst_qlabel.cpp +++ b/tests/auto/qlabel/tst_qlabel.cpp @@ -51,6 +51,7 @@ #include #include #include +#include //TESTED_CLASS= //TESTED_FILES= @@ -116,6 +117,9 @@ private slots: void unicodeText_data(); void unicodeText(); + void mnemonic_data(); + void mnemonic(); + private: QLabel *testWidget; QPointer test_box; @@ -224,6 +228,7 @@ void tst_QLabel::setBuddy() QVERIFY( !test_edit->hasFocus() ); QTest::keyClick( test_box, 't', Qt::AltModifier ); QVERIFY( test_edit->hasFocus() ); + delete test_box; } void tst_QLabel::text() @@ -245,6 +250,7 @@ void tst_QLabel::setText_data() QTest::newRow( QString(prefix + "data1").toLatin1() ) << QString("This is the first line\nThis is the second line") << QString("Courier"); QTest::newRow( QString(prefix + "data2").toLatin1() ) << QString("This is the first line\nThis is the second line\nThis is the third line") << QString("Helvetica"); QTest::newRow( QString(prefix + "data3").toLatin1() ) << QString("This is bold richtext") << QString("Courier"); + QTest::newRow( QString(prefix + "data4").toLatin1() ) << QString("I Have a &shortcut") << QString("Helvetica"); } void tst_QLabel::setText() @@ -509,5 +515,50 @@ void tst_QLabel::unicodeText() testWidget->show(); } +void tst_QLabel::mnemonic_data() +{ + QTest::addColumn("text"); + QTest::addColumn("expectedDocText"); + QTest::addColumn("expectedShortcutCursor"); + + QTest::newRow("1") << QString("Normal") << QString("Normal") << QString(); + QTest::newRow("2") << QString("&Simple") << QString("Simple") << QString("S"); + QTest::newRow("3") << QString("Also &simple") << QString("Also simple") << QString("s"); + QTest::newRow("4") << QString("&&With &Double &&") << QString("&With Double &") << QString("D"); + QTest::newRow("5") << QString("Hep&&Hop") << QString("Hep&Hop") << QString(""); + QTest::newRow("6") << QString("Hep&&&Hop") << QString("Hep&Hop") << QString("H"); +} + + +void tst_QLabel::mnemonic() +{ + // this test that the mnemonics appears correctly when the label has a text control. + + QFETCH(QString, text); + QFETCH(QString, expectedDocText); + QFETCH(QString, expectedShortcutCursor); + + QWidget w; + QHBoxLayout *hbox = new QHBoxLayout; + QLabel *lab = new QLabel(text); + //lab->setText("plop &plop"); + QLineEdit *lineedit = new QLineEdit; + lab->setBuddy(lineedit); + lab->setTextInteractionFlags(Qt::TextSelectableByMouse); + + hbox->addWidget(lab); + hbox->addWidget(lineedit); + hbox->addWidget(new QLineEdit); + w.setLayout(hbox); + w.show(); + QTest::qWaitForWindowShown(&w); + + QLabelPrivate *d = static_cast(QObjectPrivate::get(lab)); + QVERIFY(d->control); + QCOMPARE(d->control->document()->toPlainText(), expectedDocText); + QCOMPARE(d->shortcutCursor.selectedText(), expectedShortcutCursor); +} + + QTEST_MAIN(tst_QLabel) #include "tst_qlabel.moc" -- cgit v0.12 From 7be079e1b1f13b58f5d69f86e5854edd25065532 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Trond=20Kjern=C3=A5sen?= Date: Thu, 12 Nov 2009 14:47:42 +0100 Subject: Fixed a crash which could occur when perspective transforming QRegions. This made the padnavigator example crash. Task-number: QTBUG-5674 Reviewed-by: Gunnar --- src/gui/painting/qregion.cpp | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/gui/painting/qregion.cpp b/src/gui/painting/qregion.cpp index b48b024..401773b 100644 --- a/src/gui/painting/qregion.cpp +++ b/src/gui/painting/qregion.cpp @@ -3859,23 +3859,28 @@ QRegion::QRegion(const QRect &r, RegionType t) QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule) { if (a.count() > 2) { - d = new QRegionData; - d->ref = 1; + QRegionPrivate *qt_rgn = PolygonRegion(a.constData(), a.size(), + fillRule == Qt::WindingFill ? WindingRule : EvenOddRule); + if (qt_rgn) { + d = new QRegionData; + d->ref = 1; #if defined(Q_WS_X11) - d->rgn = 0; - d->xrectangles = 0; + d->rgn = 0; + d->xrectangles = 0; #elif defined(Q_WS_WIN) - d->rgn = 0; + d->rgn = 0; #endif - d->qt_rgn = PolygonRegion(a.constData(), a.size(), - fillRule == Qt::WindingFill ? WindingRule : EvenOddRule); + d->qt_rgn = qt_rgn; + } else { + d = &shared_empty; + d->ref.ref(); + } } else { d = &shared_empty; d->ref.ref(); } } - QRegion::QRegion(const QRegion &r) { d = r.d; -- cgit v0.12 From fbf5e7b103626bb07fbb43449eaf014bdd299939 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20Lind?= Date: Tue, 10 Nov 2009 09:56:29 +0100 Subject: Fix QT_NO_PHONON_SETTINGSGROUP Reviewed-by: paul --- src/3rdparty/phonon/phonon/audiooutput.cpp | 6 ++++++ src/3rdparty/phonon/phonon/backendcapabilities.cpp | 2 ++ src/3rdparty/phonon/phonon/globalconfig.cpp | 10 ++++++---- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/3rdparty/phonon/phonon/audiooutput.cpp b/src/3rdparty/phonon/phonon/audiooutput.cpp index 00b2ebd..962f828 100644 --- a/src/3rdparty/phonon/phonon/audiooutput.cpp +++ b/src/3rdparty/phonon/phonon/audiooutput.cpp @@ -257,6 +257,7 @@ void AudioOutputPrivate::setupBackendObject() // set up attributes pINTERFACE_CALL(setVolume(pow(volume, VOLTAGE_TO_LOUDNESS_EXPONENT))); +#ifndef QT_NO_PHONON_SETTINGSGROUP // if the output device is not available and the device was not explicitly set if (!callSetOutputDevice(this, device) && !outputDeviceOverridden) { // fall back in the preference list of output devices @@ -276,6 +277,7 @@ void AudioOutputPrivate::setupBackendObject() callSetOutputDevice(this, none); handleAutomaticDeviceChange(none, FallbackChange); } +#endif //QT_NO_PHONON_SETTINGSGROUP } void AudioOutputPrivate::_k_volumeChanged(qreal newVolume) @@ -305,6 +307,7 @@ void AudioOutputPrivate::_k_audioDeviceFailed() pDebug() << Q_FUNC_INFO; // outputDeviceIndex identifies a failing device // fall back in the preference list of output devices +#ifndef QT_NO_PHONON_SETTINGSGROUP const QList deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices); for (int i = 0; i < deviceList.count(); ++i) { const int devIndex = deviceList.at(i); @@ -317,6 +320,7 @@ void AudioOutputPrivate::_k_audioDeviceFailed() } } } +#endif //QT_NO_PHONON_SETTINGSGROUP // if we get here there is no working output device. Tell the backend. const AudioOutputDevice none; callSetOutputDevice(this, none); @@ -326,6 +330,7 @@ void AudioOutputPrivate::_k_audioDeviceFailed() void AudioOutputPrivate::_k_deviceListChanged() { pDebug() << Q_FUNC_INFO; +#ifndef QT_NO_PHONON_SETTINGSGROUP // let's see if there's a usable device higher in the preference list const QList deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings); DeviceChangeType changeType = HigherPreferenceChange; @@ -351,6 +356,7 @@ void AudioOutputPrivate::_k_deviceListChanged() break; // found one with higher preference that works } } +#endif //QT_NO_PHONON_SETTINGSGROUP } static struct diff --git a/src/3rdparty/phonon/phonon/backendcapabilities.cpp b/src/3rdparty/phonon/phonon/backendcapabilities.cpp index 62c9cc9..5defe09 100644 --- a/src/3rdparty/phonon/phonon/backendcapabilities.cpp +++ b/src/3rdparty/phonon/phonon/backendcapabilities.cpp @@ -75,10 +75,12 @@ bool BackendCapabilities::isMimeTypeAvailable(const QString &mimeType) QList BackendCapabilities::availableAudioOutputDevices() { QList ret; +#ifndef QT_NO_PHONON_SETTINGSGROUP const QList deviceIndexes = GlobalConfig().audioOutputDeviceListFor(Phonon::NoCategory); for (int i = 0; i < deviceIndexes.count(); ++i) { ret.append(AudioOutputDevice::fromIndex(deviceIndexes.at(i))); } +#endif //QT_NO_PHONON_SETTINGSGROUP return ret; } diff --git a/src/3rdparty/phonon/phonon/globalconfig.cpp b/src/3rdparty/phonon/phonon/globalconfig.cpp index 3718c6a..429a29f 100644 --- a/src/3rdparty/phonon/phonon/globalconfig.cpp +++ b/src/3rdparty/phonon/phonon/globalconfig.cpp @@ -178,13 +178,15 @@ QList GlobalConfig::audioOutputDeviceListFor(Phonon::Category category, int return listSortedByConfig(backendConfig, category, defaultList); } -#endif //QT_NO_SETTINGSGROUPS +#endif //QT_NO_PHONON_SETTINGSGROUP int GlobalConfig::audioOutputDeviceFor(Phonon::Category category, int override) const { +#ifndef QT_NO_PHONON_SETTINGSGROUP QList ret = audioOutputDeviceListFor(category, override); - if (ret.isEmpty()) - return -1; - return ret.first(); + if (!ret.isEmpty()) + return ret.first(); +#endif //QT_NO_PHONON_SETTINGSGROUP + return -1; } #ifndef QT_NO_PHONON_AUDIOCAPTURE -- cgit v0.12 From c3b06980e96a809709c08e5b8ca98c6d7acbc9e5 Mon Sep 17 00:00:00 2001 From: Paul Olav Tvete Date: Tue, 10 Nov 2009 13:23:52 +0100 Subject: Make the render() test pass when pixmaps aren't 32 bit. Reviewed-by: Simon Hausmann --- src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp b/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp index 117393a..bbb676b 100644 --- a/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp +++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp @@ -971,7 +971,10 @@ void tst_QWebElement::render() QImage testImage(resource.width(), resource.height(), QImage::Format_ARGB32); QPainter painter0(&testImage); painter0.fillRect(imageRect, Qt::white); - painter0.drawImage(0, 0, resource); + //render() uses pixmaps internally, and pixmaps might have bit depths + // other than 32, giving different pixel values due to rounding. + QPixmap pix = QPixmap::fromImage(resource); + painter0.drawPixmap(0, 0, pix); painter0.end(); QImage image1(resource.width(), resource.height(), QImage::Format_ARGB32); -- cgit v0.12 From e6558e8b25897ba9ac0a553509a0056915b0eb5c Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 12 Nov 2009 16:21:25 +0100 Subject: QTreeWidget visualRect now returns the rect for all columns The autotest will follow Task-number: QTBUG-2844 Reviewed-by: ogoffart --- src/gui/itemviews/qtreewidget.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/gui/itemviews/qtreewidget.cpp b/src/gui/itemviews/qtreewidget.cpp index 040c498..c133ae4 100644 --- a/src/gui/itemviews/qtreewidget.cpp +++ b/src/gui/itemviews/qtreewidget.cpp @@ -2851,7 +2851,14 @@ QTreeWidgetItem *QTreeWidget::itemAt(const QPoint &p) const QRect QTreeWidget::visualItemRect(const QTreeWidgetItem *item) const { Q_D(const QTreeWidget); - return visualRect(d->index(item)); + //the visual rect for an item is across all columns. So we need to determine + //what is the first and last column and get their visual index rects + QModelIndex base = d->index(item); + const int firstVisiblesection = header()->logicalIndexAt(- header()->offset()); + const int lastVisibleSection = header()->logicalIndexAt(header()->length() - header()->offset() - 1); + QModelIndex first = base.sibling(base.row(), header()->logicalIndex(firstVisiblesection)); + QModelIndex last = base.sibling(base.row(), header()->logicalIndex(lastVisibleSection)); + return visualRect(first) | visualRect(last); } /*! -- cgit v0.12 From 185655f01ffa288bed5cbb433843b6db26cdb632 Mon Sep 17 00:00:00 2001 From: axis Date: Thu, 12 Nov 2009 15:59:12 +0100 Subject: Removed unused variable. RevBy: Trust me --- src/gui/inputmethod/qcoefepinputcontext_p.h | 3 +-- src/gui/inputmethod/qcoefepinputcontext_s60.cpp | 7 ------- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/src/gui/inputmethod/qcoefepinputcontext_p.h b/src/gui/inputmethod/qcoefepinputcontext_p.h index 6aee669..d0b488e 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_p.h +++ b/src/gui/inputmethod/qcoefepinputcontext_p.h @@ -84,7 +84,7 @@ public: bool filterEvent(const QEvent *event); void mouseHandler( int x, QMouseEvent *event); - bool isComposing() const { return m_isEditing; } + bool isComposing() const { return !m_preeditString.isEmpty(); } void setFocusWidget(QWidget * w); void widgetDestroyed(QWidget *w); @@ -140,7 +140,6 @@ private: QString m_preeditString; Qt::InputMethodHints m_lastImHints; TUint m_textCapabilities; - bool m_isEditing; bool m_inDestruction; bool m_pendingInputCapabilitiesChanged; int m_cursorVisibility; diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp index 0ed3cc0..806df07 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp +++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp @@ -65,7 +65,6 @@ QCoeFepInputContext::QCoeFepInputContext(QObject *parent) m_fepState(q_check_ptr(new CAknEdwinState)), // CBase derived object needs check on new m_lastImHints(Qt::ImhNone), m_textCapabilities(TCoeInputCapabilities::EAllText), - m_isEditing(false), m_inDestruction(false), m_pendingInputCapabilitiesChanged(false), m_cursorVisibility(1), @@ -245,7 +244,6 @@ bool QCoeFepInputContext::filterEvent(const QEvent *event) void QCoeFepInputContext::mouseHandler( int x, QMouseEvent *event) { - Q_ASSERT(m_isEditing); Q_ASSERT(focusWidget()); if (event->type() == QEvent::MouseButtonPress && event->button() == Qt::LeftButton) { @@ -488,8 +486,6 @@ void QCoeFepInputContext::StartFepInlineEditL(const TDesC& aInitialInlineText, if (!w) return; - m_isEditing = true; - m_cursorPos = w->inputMethodQuery(Qt::ImCursorPosition).toInt(); QList attributes; @@ -555,8 +551,6 @@ void QCoeFepInputContext::CancelFepInlineEdit() event.setCommitString(QLatin1String(""), 0, 0); m_preeditString.clear(); sendEvent(event); - - m_isEditing = false; } TInt QCoeFepInputContext::DocumentLengthForFep() const @@ -711,7 +705,6 @@ void QCoeFepInputContext::commitCurrentString(bool triggeredBySymbian) sendEvent(event); m_longPress = 0; - m_isEditing = false; if (!triggeredBySymbian) { CCoeFep* fep = CCoeEnv::Static()->Fep(); -- cgit v0.12 From 5bc53cb71f22d74cf13bef7e8cae25833b40d0b4 Mon Sep 17 00:00:00 2001 From: axis Date: Thu, 12 Nov 2009 16:20:48 +0100 Subject: Made the select button commit the T9 word rather than exit widget. Task: QTBUG-5661 RevBy: Janne Koskinen --- src/gui/inputmethod/qcoefepinputcontext_s60.cpp | 28 ++++++++++++++++++------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp index 806df07..08d86d7 100644 --- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp +++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp @@ -203,14 +203,26 @@ bool QCoeFepInputContext::filterEvent(const QEvent *event) if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) { const QKeyEvent *keyEvent = static_cast(event); - Q_ASSERT(m_lastImHints == focusWidget()->inputMethodHints()); - if (keyEvent->key() == Qt::Key_F20 && m_lastImHints & Qt::ImhHiddenText) { - // Special case in Symbian. On editors with secret text, F20 is for some reason - // considered to be a backspace. - QKeyEvent modifiedEvent(keyEvent->type(), Qt::Key_Backspace, keyEvent->modifiers(), - keyEvent->text(), keyEvent->isAutoRepeat(), keyEvent->count()); - QApplication::sendEvent(focusWidget(), &modifiedEvent); - return true; + switch (keyEvent->key()) { + case Qt::Key_F20: + Q_ASSERT(m_lastImHints == focusWidget()->inputMethodHints()); + if (m_lastImHints & Qt::ImhHiddenText) { + // Special case in Symbian. On editors with secret text, F20 is for some reason + // considered to be a backspace. + QKeyEvent modifiedEvent(keyEvent->type(), Qt::Key_Backspace, keyEvent->modifiers(), + keyEvent->text(), keyEvent->isAutoRepeat(), keyEvent->count()); + QApplication::sendEvent(focusWidget(), &modifiedEvent); + return true; + } + break; + case Qt::Key_Select: + if (!m_preeditString.isEmpty()) { + commitCurrentString(false); + return true; + } + break; + default: + break; } } -- cgit v0.12 From cec18d91bfd113d5402e5fc45160a5225362dd4c Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Thu, 12 Nov 2009 17:45:55 +0100 Subject: Fix MWC warning Reviewed-by: Trust Me --- src/gui/painting/qpaintbuffer_p.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/painting/qpaintbuffer_p.h b/src/gui/painting/qpaintbuffer_p.h index adf0564..e100512 100644 --- a/src/gui/painting/qpaintbuffer_p.h +++ b/src/gui/painting/qpaintbuffer_p.h @@ -66,7 +66,7 @@ class QPaintBufferPlayback; class Q_GUI_EXPORT QPaintBuffer : public QPaintDevice { - Q_DECLARE_PRIVATE(QPaintBuffer); + Q_DECLARE_PRIVATE(QPaintBuffer) public: QPaintBuffer(); QPaintBuffer(const QPaintBuffer &other); -- cgit v0.12 From c460009821fd646355bb2cd3d1909992483a4678 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Thu, 12 Nov 2009 19:21:25 +0100 Subject: Fix corelib def files for the new atomics implementation 4.6.0 has the wrong atomics implementation for symbian, as the team branch was not merged before the freeze. This updates the def files to match the implementation on the team branch so that it can be cherry-picked. Task-number: QTBUG-5752 Reviewed-by: Iain --- src/s60installs/bwins/QtCoreu.def | 3 +++ src/s60installs/eabi/QtCoreu.def | 15 +++++++++++---- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/s60installs/bwins/QtCoreu.def b/src/s60installs/bwins/QtCoreu.def index 146d47e..1218b75 100644 --- a/src/s60installs/bwins/QtCoreu.def +++ b/src/s60installs/bwins/QtCoreu.def @@ -4384,4 +4384,7 @@ EXPORTS ?staticMetaObject@QAbstractTableModel@@2UQMetaObject@@B @ 4383 NONAME ; struct QMetaObject const QAbstractTableModel::staticMetaObject ?staticMetaObject@QFile@@2UQMetaObject@@B @ 4384 NONAME ; struct QMetaObject const QFile::staticMetaObject ?staticMetaObject@QHistoryState@@2UQMetaObject@@B @ 4385 NONAME ; struct QMetaObject const QHistoryState::staticMetaObject + ?QBasicAtomicPointer_isFetchAndAddNative@@YA_NXZ @ 4386 NONAME ; bool QBasicAtomicPointer_isFetchAndAddNative(void) + ?QBasicAtomicPointer_isFetchAndStoreNative@@YA_NXZ @ 4387 NONAME ; bool QBasicAtomicPointer_isFetchAndStoreNative(void) + ?QBasicAtomicPointer_isTestAndSetNative@@YA_NXZ @ 4388 NONAME ; bool QBasicAtomicPointer_isTestAndSetNative(void) diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index faf8b1e..99be68e 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -13,7 +13,7 @@ EXPORTS _Z11qt_int_sqrtj @ 12 NONAME _Z12noforcepointR11QTextStream @ 13 NONAME _Z12qSharedBuildv @ 14 NONAME - _Z12q_atomic_swpPVcc @ 15 NONAME + _Z12q_atomic_swpPVcc @ 15 NONAME ABSENT _Z12qt_s60GetRFsv @ 16 NONAME _Z13lowercasebaseR11QTextStream @ 17 NONAME _Z13qErrnoWarningPKcz @ 18 NONAME @@ -24,7 +24,7 @@ EXPORTS _Z15lowercasedigitsR11QTextStream @ 23 NONAME _Z15qAddPostRoutinePFvvE @ 24 NONAME _Z15qInitResourceIOv @ 25 NONAME - _Z15qt_atomic_yieldPi @ 26 NONAME + _Z15qt_atomic_yieldPi @ 26 NONAME ABSENT _Z15qt_error_stringi @ 27 NONAME _Z15uppercasedigitsR11QTextStream @ 28 NONAME _Z16qt_QString2HBufCRK7QString @ 29 NONAME @@ -706,7 +706,7 @@ EXPORTS _ZN15QAnimationGroupD0Ev @ 705 NONAME _ZN15QAnimationGroupD1Ev @ 706 NONAME _ZN15QAnimationGroupD2Ev @ 707 NONAME - _ZN15QBasicAtomicInt20fetchAndStoreOrderedEi @ 708 NONAME + _ZN15QBasicAtomicInt20fetchAndStoreOrderedEi @ 708 NONAME ABSENT _ZN15QDateTimeParser11parseFormatERK7QString @ 709 NONAME _ZN15QLinkedListData11shared_nullE @ 710 NONAME DATA 20 _ZN15QObjectUserDataD0Ev @ 711 NONAME @@ -3566,7 +3566,7 @@ EXPORTS inflateSync @ 3565 NONAME inflateSyncPoint @ 3566 NONAME qMetaTypeGuiHelper @ 3567 NONAME DATA 4 - q_atomic_lock @ 3568 NONAME DATA 1 + q_atomic_lock @ 3568 NONAME DATA 1 ABSENT qt_addObject @ 3569 NONAME qt_global_mutexpool @ 3570 NONAME DATA 4 qt_locale_initialized @ 3571 NONAME DATA 1 @@ -3612,4 +3612,11 @@ EXPORTS _ZNK13QStateMachine10isAnimatedEv @ 3611 NONAME _ZNK18QAbstractAnimation15currentLoopTimeEv @ 3612 NONAME _ZNK7QRegExp12captureCountEv @ 3613 NONAME + _Z38QBasicAtomicPointer_isTestAndSetNativev @ 3614 NONAME + _Z39QBasicAtomicPointer_isFetchAndAddNativev @ 3615 NONAME + _Z41QBasicAtomicPointer_isFetchAndStoreNativev @ 3616 NONAME + _ZN15QBasicAtomicInt18isTestAndSetNativeEv @ 3617 NONAME + _ZN15QBasicAtomicInt19isFetchAndAddNativeEv @ 3618 NONAME + _ZN15QBasicAtomicInt21isFetchAndStoreNativeEv @ 3619 NONAME + _ZN15QBasicAtomicInt25isReferenceCountingNativeEv @ 3620 NONAME -- cgit v0.12 From e7689dbab0e9a491d0ac6ead5b9412bf6ff86be0 Mon Sep 17 00:00:00 2001 From: "Eduardo M. Fleury" Date: Wed, 11 Nov 2009 19:22:42 -0300 Subject: QGAL (Test): Fix order of parameters in QCOMPARE The order is relevant when the test fails and QTest prints the failure message refering to the values as the expected and actual ones. Signed-off-by: Eduardo M. Fleury Reviewed-by: Caio Marcelo de Oliveira Filho --- tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp index 0fbd069..bca59c3 100644 --- a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp +++ b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp @@ -1722,7 +1722,7 @@ void tst_QGraphicsAnchorLayout1::testBasicLayout() QRectF expected = truncate(item.rect); QRectF actual = truncate(widgets[item.index]->geometry()); - QCOMPARE(expected, actual); + QCOMPARE(actual, expected); } // Test mirrored mode @@ -1739,7 +1739,7 @@ void tst_QGraphicsAnchorLayout1::testBasicLayout() QRectF expected = truncate(mirroredRect); QRectF actual = truncate(widgets[item.index]->geometry()); - QCOMPARE(expected, actual); + QCOMPARE(actual, expected); delete widgets[item.index]; } -- cgit v0.12 From 0f5a0ec164b3a5bc1f2a48ae56688a984b990bbd Mon Sep 17 00:00:00 2001 From: "Eduardo M. Fleury" Date: Tue, 10 Nov 2009 13:00:44 -0300 Subject: QGAL (Test): Add test to ensure persistency of user-defined spacing Currently the user-defined spacing is saved inside "AnchorData->prefSize". However this value may be modified if spacing is negative or if the anchor's policy is "QSizePolicy::Ignored". Signed-off-by: Eduardo M. Fleury Reviewed-by: Caio Marcelo de Oliveira Filho --- .../tst_qgraphicsanchorlayout.cpp | 26 ++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp index c7ed309..2ad024f 100644 --- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp +++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp @@ -85,6 +85,7 @@ private slots: void simplificationVsOrder(); void parallelSimplificationOfCenter(); void simplificationVsRedundance(); + void spacingPersistency(); }; class RectWidget : public QGraphicsWidget @@ -1866,5 +1867,30 @@ void tst_QGraphicsAnchorLayout::simplificationVsRedundance() QCOMPARE(usedSimplex(l, Qt::Vertical), false); } +/* + Avoid regression where the saved prefSize would be lost. This was + solved by saving the original spacing in the QGraphicsAnchorPrivate class +*/ +void tst_QGraphicsAnchorLayout::spacingPersistency() +{ + QGraphicsWidget w; + QGraphicsWidget *a = createItem(); + QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&w); + + l->addAnchors(l, a, Qt::Horizontal); + QGraphicsAnchor *anchor = l->anchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft); + + anchor->setSpacing(-30); + QCOMPARE(anchor->spacing(), -30.0); + + anchor->setSpacing(30); + QCOMPARE(anchor->spacing(), 30.0); + + anchor->setSizePolicy(QSizePolicy::Ignored); + w.effectiveSizeHint(Qt::PreferredSize); + + QCOMPARE(anchor->spacing(), 30.0); +} + QTEST_MAIN(tst_QGraphicsAnchorLayout) #include "tst_qgraphicsanchorlayout.moc" -- cgit v0.12 From bf0e30ce2987a9e93369fe01ab0f01eeb1d3afdb Mon Sep 17 00:00:00 2001 From: "Eduardo M. Fleury" Date: Tue, 10 Nov 2009 15:51:53 -0300 Subject: QGAL: Update header documentation in QGALPrivate As part of the refactoring of the setSpacing logic, we are encoraging the analogy between the references to QGraphicsLayoutItem and to QGraphicsAnchor, from the AnchorData point of view. It happens that leaf anchors (ie, those that were not created by the simplification) either represent an item or an user-created anchor. This means that they should fetch their size information either from a QGraphicsLayoutItem (member AnchorData->item) or from a QGraphicsAnchor (member AnchorData->graphicsAnchor). Thus, I'm organizing the header to make it more consistent to the new concept. Signed-off-by: Eduardo M. Fleury Reviewed-by: Caio Marcelo de Oliveira Filho --- src/gui/graphicsview/qgraphicsanchorlayout_p.h | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h index 5f50c85..26df109 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h @@ -121,10 +121,10 @@ struct AnchorData : public QSimplexVariable { }; AnchorData() - : QSimplexVariable(), item(0), from(0), to(0), + : QSimplexVariable(), from(0), to(0), minSize(0), prefSize(0), maxSize(0), sizeAtMinimum(0), sizeAtPreferred(0), - sizeAtMaximum(0), + sizeAtMaximum(0), item(0), graphicsAnchor(0), skipInPreferred(0), type(Normal), hasSize(true), isLayoutAnchor(false), isCenterAnchor(false), orientation(0), @@ -152,27 +152,32 @@ struct AnchorData : public QSimplexVariable { hasSize = false; } - // Internal anchors have associated items - QGraphicsLayoutItem *item; - // Anchor is semantically directed AnchorVertex *from; AnchorVertex *to; - // Size restrictions of this edge. For anchors internal to items, these - // values are derived from the respective item size hints. For anchors - // that were added by users, these values are equal to the specified anchor - // size. + // Nominal sizes + // These are the intrinsic size restrictions for a given item. They are + // used as input for the calculation of the actual sizes. + // These values are filled by the refreshSizeHints method, based on the + // anchor size policy, the size hints of the item it (possibly) represents + // and the layout spacing information. qreal minSize; qreal prefSize; qreal maxSize; + // Calculated sizes // These attributes define which sizes should that anchor be in when the // layout is at its minimum, preferred or maximum sizes. Values are // calculated by the Simplex solver based on the current layout setup. qreal sizeAtMinimum; qreal sizeAtPreferred; qreal sizeAtMaximum; + + // References to the classes that represent this anchor in the public world + // An anchor may represent a LayoutItem, it may also be acessible externally + // through a GraphicsAnchor "handler". + QGraphicsLayoutItem *item; QGraphicsAnchor *graphicsAnchor; uint skipInPreferred : 1; -- cgit v0.12 From 6cc1703af1f403168b7251616a7685aa83de8caa Mon Sep 17 00:00:00 2001 From: "Eduardo M. Fleury" Date: Tue, 10 Nov 2009 16:55:43 -0300 Subject: QGAL: Move size information from AnchorData to QGraphicsAnchorPrivate To solve the spacing persistency bug, this commit saves the preferredSize (spacing) information inside QGraphicsAnchorPrivate. The problem started when we could not rely on "AnchorData->prefSize" to keep the spacing information for user-defined anchors. This happens because that member can be overriden if the spacing is negative (anchor is inverted) or its sizePolicy is of type "Ignored" (it is overriden by minSize). Then, to decide where to store it, we aimed to make something similar to what happens with item-internal anchors. Those can rely on their items to get fresh information regarding their size, so we decided that user-anchors (that don't have items, but do have QGraphicsAnchors) could read such information from there. This refactory also reduced the deep indirection that existed in the "QGraphicsAnchor->setSpacing" call. Previously it would call internal layout methods to do some black magic, that's now gone. As the spacing information is now stored in the anchor itself, it can do pretty much all the work and, after that, just invalidate the layout. Also, moved information like "AnchorData->hasSize" to QGAnchor as its pretty much related to the preferredSize information itself. Signed-off-by: Eduardo M. Fleury Reviewed-by: Caio Marcelo de Oliveira Filho --- src/gui/graphicsview/qgraphicsanchorlayout.h | 1 + src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 148 +++++++++-------------- src/gui/graphicsview/qgraphicsanchorlayout_p.h | 25 ++-- 3 files changed, 66 insertions(+), 108 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout.h b/src/gui/graphicsview/qgraphicsanchorlayout.h index 01c3a86..1a0c458 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout.h @@ -76,6 +76,7 @@ private: Q_DECLARE_PRIVATE(QGraphicsAnchor) friend class QGraphicsAnchorLayoutPrivate; + friend class AnchorData; }; class Q_GUI_EXPORT QGraphicsAnchorLayout : public QGraphicsLayout diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp index 182594e..872fecb 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp @@ -55,7 +55,8 @@ QT_BEGIN_NAMESPACE QGraphicsAnchorPrivate::QGraphicsAnchorPrivate(int version) : QObjectPrivate(version), layoutPrivate(0), data(0), - sizePolicy(QSizePolicy::Fixed) + sizePolicy(QSizePolicy::Fixed), preferredSize(0), + hasSize(true), reversed(false) { } @@ -76,31 +77,60 @@ void QGraphicsAnchorPrivate::setSizePolicy(QSizePolicy::Policy policy) void QGraphicsAnchorPrivate::setSpacing(qreal value) { - if (data) { - layoutPrivate->setAnchorSize(data, &value); - } else { + if (!data) { qWarning("QGraphicsAnchor::setSpacing: The anchor does not exist."); + return; } + + const qreal rawValue = reversed ? -preferredSize : preferredSize; + if (hasSize && (rawValue == value)) + return; + + // The anchor has an user-defined size + hasSize = true; + + // The simplex solver cannot handle negative sizes. To workaround that, + // if value is less than zero, we reverse the anchor and set the absolute + // value; + if (value >= 0) { + preferredSize = value; + if (reversed) + qSwap(data->from, data->to); + reversed = false; + } else { + preferredSize = -value; + if (!reversed) + qSwap(data->from, data->to); + reversed = true; + } + + layoutPrivate->q_func()->invalidate(); } void QGraphicsAnchorPrivate::unsetSpacing() { - if (data) { - layoutPrivate->setAnchorSize(data, 0); - } else { + if (!data) { qWarning("QGraphicsAnchor::setSpacing: The anchor does not exist."); + return; } + + // Return to standard direction + hasSize = false; + if (reversed) + qSwap(data->from, data->to); + reversed = false; + + layoutPrivate->q_func()->invalidate(); } qreal QGraphicsAnchorPrivate::spacing() const { - qreal size = 0; - if (data) { - layoutPrivate->anchorSize(data, 0, &size, 0); - } else { + if (!data) { qWarning("QGraphicsAnchor::setSpacing: The anchor does not exist."); + return 0; } - return size; + + return reversed ? -preferredSize : preferredSize; } @@ -146,8 +176,8 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) qreal prefSizeHint; qreal maxSizeHint; - // It is an internal anchor if (item) { + // It is an internal anchor, fetch size information from the item if (isLayoutAnchor) { minSize = 0; prefSize = 0; @@ -175,14 +205,16 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) } } } else { + // It is a user-created anchor, fetch size information from the associated QGraphicsAnchor Q_ASSERT(graphicsAnchor); - policy = graphicsAnchor->sizePolicy(); + QGraphicsAnchorPrivate *anchorPrivate = graphicsAnchor->d_func(); + policy = anchorPrivate->sizePolicy; minSizeHint = 0; - if (hasSize) { + if (anchorPrivate->hasSize) { // One can only configure the preferred size of a normal anchor. Their minimum and // maximum "size hints" are always 0 and QWIDGETSIZE_MAX, correspondingly. However, // their effective size hints might be narrowed down due to their size policies. - prefSizeHint = prefSize; + prefSizeHint = anchorPrivate->preferredSize; } else { const Qt::Orientation orient = Qt::Orientation(QGraphicsAnchorLayoutPrivate::edgeOrientation(from->m_edge) + 1); qreal s = styleInfo->defaultSpacing(orient); @@ -1565,7 +1597,13 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi correctEdgeDirection(firstItem, firstEdge, secondItem, secondEdge); AnchorData *data = new AnchorData; - if (!spacing) { + QGraphicsAnchor *graphicsAnchor = acquireGraphicsAnchor(data); + + addAnchor_helper(firstItem, firstEdge, secondItem, secondEdge, data); + + if (spacing) { + graphicsAnchor->setSpacing(*spacing); + } else { // If firstItem or secondItem is the layout itself, the spacing will default to 0. // Otherwise, the following matrix is used (questionmark means that the spacing // is queried from the style): @@ -1578,22 +1616,13 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi || secondItem == q || pickEdge(firstEdge, Horizontal) == Qt::AnchorHorizontalCenter || oppositeEdge(firstEdge) != secondEdge) { - data->setPreferredSize(0); + graphicsAnchor->setSpacing(0); } else { - data->unsetSize(); + graphicsAnchor->unsetSpacing(); } - addAnchor_helper(firstItem, firstEdge, secondItem, secondEdge, data); - - } else if (*spacing >= 0) { - data->setPreferredSize(*spacing); - addAnchor_helper(firstItem, firstEdge, secondItem, secondEdge, data); - - } else { - data->setPreferredSize(-*spacing); - addAnchor_helper(secondItem, secondEdge, firstItem, firstEdge, data); } - return acquireGraphicsAnchor(data); + return graphicsAnchor; } void QGraphicsAnchorLayoutPrivate::addAnchor_helper(QGraphicsLayoutItem *firstItem, @@ -1753,67 +1782,6 @@ void QGraphicsAnchorLayoutPrivate::removeAnchor_helper(AnchorVertex *v1, AnchorV removeInternalVertex(v2->m_item, v2->m_edge); } -/*! - \internal - Only called from outside. (calls invalidate()) -*/ -void QGraphicsAnchorLayoutPrivate::setAnchorSize(AnchorData *data, const qreal *anchorSize) -{ - Q_Q(QGraphicsAnchorLayout); - // ### we can avoid restoration if we really want to, but we would have to - // search recursively through all composite anchors - Q_ASSERT(data); - restoreSimplifiedGraph(edgeOrientation(data->from->m_edge)); - - QGraphicsLayoutItem *firstItem = data->from->m_item; - QGraphicsLayoutItem *secondItem = data->to->m_item; - Qt::AnchorPoint firstEdge = data->from->m_edge; - Qt::AnchorPoint secondEdge = data->to->m_edge; - - // Use heuristics to find out what the user meant with this anchor. - correctEdgeDirection(firstItem, firstEdge, secondItem, secondEdge); - if (data->from->m_item != firstItem) - qSwap(data->from, data->to); - - if (anchorSize) { - // ### The current implementation makes "setAnchorSize" behavior - // dependent on the argument order for cases where we have - // no heuristic. Ie. two widgets, same anchor point. - - // We cannot have negative sizes inside the graph. This would cause - // the simplex solver to fail because all simplex variables are - // positive by definition. - // "negative spacing" is handled by inverting the standard item order. - if (*anchorSize >= 0) { - data->setPreferredSize(*anchorSize); - } else { - data->setPreferredSize(-*anchorSize); - qSwap(data->from, data->to); - } - } else { - data->unsetSize(); - } - q->invalidate(); -} - -void QGraphicsAnchorLayoutPrivate::anchorSize(const AnchorData *data, - qreal *minSize, - qreal *prefSize, - qreal *maxSize) const -{ - Q_ASSERT(minSize || prefSize || maxSize); - Q_ASSERT(data); - QGraphicsAnchorLayoutPrivate *that = const_cast(this); - that->restoreSimplifiedGraph(Orientation(data->orientation)); - - if (minSize) - *minSize = data->minSize; - if (prefSize) - *prefSize = data->prefSize; - if (maxSize) - *maxSize = data->maxSize; -} - AnchorVertex *QGraphicsAnchorLayoutPrivate::addInternalVertex(QGraphicsLayoutItem *item, Qt::AnchorPoint edge) { diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h index 26df109..cb8c4dd 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h @@ -126,7 +126,7 @@ struct AnchorData : public QSimplexVariable { sizeAtMinimum(0), sizeAtPreferred(0), sizeAtMaximum(0), item(0), graphicsAnchor(0), skipInPreferred(0), - type(Normal), hasSize(true), isLayoutAnchor(false), + type(Normal), isLayoutAnchor(false), isCenterAnchor(false), orientation(0), dependency(Independent) {} @@ -141,17 +141,6 @@ struct AnchorData : public QSimplexVariable { QString name; #endif - inline void setPreferredSize(qreal size) - { - prefSize = size; - hasSize = true; - } - - inline void unsetSize() - { - hasSize = false; - } - // Anchor is semantically directed AnchorVertex *from; AnchorVertex *to; @@ -182,7 +171,6 @@ struct AnchorData : public QSimplexVariable { uint skipInPreferred : 1; uint type : 2; // either Normal, Sequential or Parallel - uint hasSize : 1; // if false, get size from style. uint isLayoutAnchor : 1; // if this anchor is an internal layout anchor uint isCenterAnchor : 1; uint orientation : 1; @@ -355,7 +343,13 @@ public: QGraphicsAnchorLayoutPrivate *layoutPrivate; AnchorData *data; + + // Size information for user controlled anchor QSizePolicy::Policy sizePolicy; + qreal preferredSize; + + uint hasSize : 1; // if false, get size from style. + uint reversed : 1; // if true, the anchor was inverted to keep its value positive }; @@ -450,11 +444,6 @@ public: void removeAnchor(AnchorVertex *firstVertex, AnchorVertex *secondVertex); void removeAnchor_helper(AnchorVertex *v1, AnchorVertex *v2); - void setAnchorSize(AnchorData *data, const qreal *anchorSize); - void anchorSize(const AnchorData *data, - qreal *minSize = 0, - qreal *prefSize = 0, - qreal *maxSize = 0) const; void removeAnchors(QGraphicsLayoutItem *item); -- cgit v0.12 From 604b6d9d00e36de7ed516e4fa5c277946216f1e9 Mon Sep 17 00:00:00 2001 From: "Eduardo M. Fleury" Date: Thu, 12 Nov 2009 13:48:54 -0300 Subject: QGAL: Update code documentation Signed-off-by: Eduardo M. Fleury Reviewed-by: Caio Marcelo de Oliveira Filho --- src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 39 ++++++++++++++++-------- 1 file changed, 26 insertions(+), 13 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp index 872fecb..a15e473 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp @@ -1537,15 +1537,21 @@ void QGraphicsAnchorLayoutPrivate::removeCenterConstraints(QGraphicsLayoutItem * /*! * \internal + * Implements the high level "addAnchor" feature. Called by the public API + * addAnchor method. * - * Helper function that is called from the anchor functions in the public API. - * If \a spacing is 0, it will pick up the spacing defined by the style. + * The optional \a spacing argument defines the size of the anchor. If not provided, + * the anchor size is either 0 or not-set, depending on type of anchor created (see + * matrix below). + * + * All anchors that remain with size not-set will assume the standard spacing, + * set either by the layout style or through the "setSpacing" layout API. */ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *firstItem, - Qt::AnchorPoint firstEdge, - QGraphicsLayoutItem *secondItem, - Qt::AnchorPoint secondEdge, - qreal *spacing) + Qt::AnchorPoint firstEdge, + QGraphicsLayoutItem *secondItem, + Qt::AnchorPoint secondEdge, + qreal *spacing) { Q_Q(QGraphicsAnchorLayout); if ((firstItem == 0) || (secondItem == 0)) { @@ -1625,11 +1631,20 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi return graphicsAnchor; } +/* + \internal + + This method adds an AnchorData to the internal graph. It is responsible for doing + the boilerplate part of such task. + + If another AnchorData exists between the mentioned vertices, it is deleted and + the new one is inserted. +*/ void QGraphicsAnchorLayoutPrivate::addAnchor_helper(QGraphicsLayoutItem *firstItem, - Qt::AnchorPoint firstEdge, - QGraphicsLayoutItem *secondItem, - Qt::AnchorPoint secondEdge, - AnchorData *data) + Qt::AnchorPoint firstEdge, + QGraphicsLayoutItem *secondItem, + Qt::AnchorPoint secondEdge, + AnchorData *data) { Q_Q(QGraphicsAnchorLayout); @@ -1639,13 +1654,11 @@ void QGraphicsAnchorLayoutPrivate::addAnchor_helper(QGraphicsLayoutItem *firstIt // anchor manipulation always happen in the full graph restoreSimplifiedGraph(orientation); - // Is the Vertex (firstItem, firstEdge) already represented in our - // internal structure? + // Create or increase the reference count for the related vertices. AnchorVertex *v1 = addInternalVertex(firstItem, firstEdge); AnchorVertex *v2 = addInternalVertex(secondItem, secondEdge); // Remove previous anchor - // ### Could we update the existing edgeData rather than creating a new one? if (graph[orientation].edgeData(v1, v2)) { removeAnchor_helper(v1, v2); } -- cgit v0.12 From 41cc464ec332033127b88433ffa0a2a990fec83d Mon Sep 17 00:00:00 2001 From: Caio Marcelo de Oliveira Filho Date: Wed, 11 Nov 2009 22:09:11 -0300 Subject: QGAL: fix update size hints logic in parallel anchors When filling sizeAt* values for parallel anchors, we have to identify the case when the second anchor in the parallel doesn't have the same direction as the parallel itself. However, relying on the parallel group vertices to identify this case is not safe, because after a parallel group a new vertex simplification can happen. So, the comparing the 'from' with the first edge is the correct way to verify whether the second is backwards. Code was fixed to follow that. Note that, without negative spacing the case "out-of-order" for parallels is only the trivial case (size == 0). Signed-off-by: Caio Marcelo de Oliveira Filho Reviewed-by: Eduardo M. Fleury --- src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp index a15e473..8520ebd 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp @@ -256,8 +256,13 @@ void ParallelAnchorData::updateChildrenSizes() firstEdge->sizeAtPreferred = sizeAtPreferred; firstEdge->sizeAtMaximum = sizeAtMaximum; - const bool secondFwd = (secondEdge->from == from); - if (secondFwd) { + // We have the convention that the first children will define the direction of the + // pararell group. So we can check whether the second edge is "forward" in relation + // to the group if it have the same direction as the first edge. Note that we don't + // use 'this->from' because it might be changed by vertex simplification. + const bool secondForward = (firstEdge->from == secondEdge->from); + + if (secondForward) { secondEdge->sizeAtMinimum = sizeAtMinimum; secondEdge->sizeAtPreferred = sizeAtPreferred; secondEdge->sizeAtMaximum = sizeAtMaximum; @@ -287,10 +292,12 @@ bool ParallelAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *styleIn // Account for parallel anchors where the second edge is backwards. // We rely on the fact that a forward anchor of sizes min, pref, max is equivalent // to a backwards anchor of size (-max, -pref, -min) - const bool secondFwd = (secondEdge->from == from); - const qreal secondMin = secondFwd ? secondEdge->minSize : -secondEdge->maxSize; - const qreal secondPref = secondFwd ? secondEdge->prefSize : -secondEdge->prefSize; - const qreal secondMax = secondFwd ? secondEdge->maxSize : -secondEdge->minSize; + + // Also see comments in updateChildrenSizes(). + const bool secondForward = (firstEdge->from == secondEdge->from); + const qreal secondMin = secondForward ? secondEdge->minSize : -secondEdge->maxSize; + const qreal secondPref = secondForward ? secondEdge->prefSize : -secondEdge->prefSize; + const qreal secondMax = secondForward ? secondEdge->maxSize : -secondEdge->minSize; minSize = qMax(firstEdge->minSize, secondMin); maxSize = qMin(firstEdge->maxSize, secondMax); -- cgit v0.12 From 7a11b8ca00f49e22cfd3706b59606775d6792e29 Mon Sep 17 00:00:00 2001 From: Caio Marcelo de Oliveira Filho Date: Wed, 11 Nov 2009 16:37:53 -0300 Subject: QGAL: remove the caching of simplified graph After discussion with Jan-Arve, we decided to remove for good the caching of simplified graph. This avoided recalculating the simplification (but not the simplex) in some situations. Since vertex simplification, this was temporarily disabled already. To know whether if we could the cached version or not, we needed to track individual anchors to see whether they reached size 0 or they were 0 and changed the size. This is because the vertex simplification depend on that fact. Now the simplified version of the graph exists only during the execution of calculateGraphs() function. This and next commits clear up the code to take advantage of that fact. Signed-off-by: Caio Marcelo de Oliveira Filho Reviewed-by: Eduardo M. Fleury --- src/gui/graphicsview/qgraphicsanchorlayout.cpp | 3 - src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 89 ++++++------------------ src/gui/graphicsview/qgraphicsanchorlayout_p.h | 2 - 3 files changed, 22 insertions(+), 72 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout.cpp b/src/gui/graphicsview/qgraphicsanchorlayout.cpp index 872ec3c..7e5929e 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout.cpp @@ -477,9 +477,6 @@ void QGraphicsAnchorLayout::removeAt(int index) return; // Removing an item affects both horizontal and vertical graphs - d->restoreSimplifiedGraph(QGraphicsAnchorLayoutPrivate::Horizontal); - d->restoreSimplifiedGraph(QGraphicsAnchorLayoutPrivate::Vertical); - d->removeCenterConstraints(item, QGraphicsAnchorLayoutPrivate::Horizontal); d->removeCenterConstraints(item, QGraphicsAnchorLayoutPrivate::Vertical); d->removeAnchors(item); diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp index 8520ebd..5b1e36c 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp @@ -62,8 +62,6 @@ QGraphicsAnchorPrivate::QGraphicsAnchorPrivate(int version) QGraphicsAnchorPrivate::~QGraphicsAnchorPrivate() { - // ### - layoutPrivate->restoreSimplifiedGraph(QGraphicsAnchorLayoutPrivate::Orientation(data->orientation)); layoutPrivate->removeAnchor(data->from, data->to); } @@ -529,7 +527,6 @@ QGraphicsAnchorLayoutPrivate::QGraphicsAnchorLayoutPrivate() interpolationProgress[i] = -1; spacings[i] = -1; - graphSimplified[i] = false; graphHasConflicts[i] = false; layoutFirstVertex[i] = 0; @@ -735,16 +732,18 @@ static AnchorData *createSequence(Graph *graph, */ bool QGraphicsAnchorLayoutPrivate::simplifyGraph(Orientation orientation) { - static bool noSimplification = !qgetenv("QT_ANCHORLAYOUT_NO_SIMPLIFICATION").isEmpty(); - if (noSimplification || items.isEmpty()) + if (items.isEmpty()) return true; - if (graphSimplified[orientation]) - return true; - -#if 0 +#if defined(QT_DEBUG) && 0 qDebug("Simplifying Graph for %s", orientation == Horizontal ? "Horizontal" : "Vertical"); + + static int count = 0; + if (orientation == Horizontal) { + count++; + dumpGraph(QString::fromAscii("%1-full").arg(count)); + } #endif // Vertex simplification @@ -762,13 +761,16 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraph(Orientation orientation) // Note that if we are not feasible, we fallback and make sure that the graph is fully restored if (!feasible) { - graphSimplified[orientation] = true; restoreSimplifiedGraph(orientation); restoreVertices(orientation); return false; } - graphSimplified[orientation] = true; +#if defined(QT_DEBUG) && 0 + dumpGraph(QString::fromAscii("%1-simplified-%2").arg(count).arg( + QString::fromAscii(orientation == Horizontal ? "Horizontal" : "Vertical"))); +#endif + return true; } @@ -1173,10 +1175,6 @@ void QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints(ParallelAnchorDa void QGraphicsAnchorLayoutPrivate::restoreSimplifiedGraph(Orientation orientation) { - if (!graphSimplified[orientation]) - return; - graphSimplified[orientation] = false; - #if 0 qDebug("Restoring Simplified Graph for %s", orientation == Horizontal ? "Horizontal" : "Vertical"); @@ -1331,8 +1329,6 @@ void QGraphicsAnchorLayoutPrivate::deleteLayoutEdges() void QGraphicsAnchorLayoutPrivate::createItemEdges(QGraphicsLayoutItem *item) { - Q_ASSERT(!graphSimplified[Horizontal] && !graphSimplified[Vertical]); - items.append(item); // Create horizontal and vertical internal anchors for the item and @@ -1375,8 +1371,6 @@ void QGraphicsAnchorLayoutPrivate::createCenterAnchors( return; } - Q_ASSERT(!graphSimplified[orientation]); - // Check if vertex already exists if (internalVertex(item, centerEdge)) return; @@ -1443,8 +1437,6 @@ void QGraphicsAnchorLayoutPrivate::removeCenterAnchors( return; } - Q_ASSERT(!graphSimplified[orientation]); - // Orientation code Qt::AnchorPoint firstEdge; Qt::AnchorPoint lastEdge; @@ -1512,8 +1504,6 @@ void QGraphicsAnchorLayoutPrivate::removeCenterAnchors( void QGraphicsAnchorLayoutPrivate::removeCenterConstraints(QGraphicsLayoutItem *item, Orientation orientation) { - Q_ASSERT(!graphSimplified[orientation]); - // Remove the item center constraints associated to this item // ### This is a temporary solution. We should probably use a better // data structure to hold items and/or their associated constraints @@ -1579,10 +1569,6 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi return 0; } - // Guarantee that the graph is no simplified when adding this anchor, - // anchor manipulation always happen in the full graph - restoreSimplifiedGraph(edgeOrientation(firstEdge)); - // In QGraphicsAnchorLayout, items are represented in its internal // graph as four anchors that connect: // - Left -> HCenter @@ -1592,12 +1578,10 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi // Ensure that the internal anchors have been created for both items. if (firstItem != q && !items.contains(firstItem)) { - restoreSimplifiedGraph(edgeOrientation(firstEdge) == Horizontal ? Vertical : Horizontal); createItemEdges(firstItem); addChildLayoutItem(firstItem); } if (secondItem != q && !items.contains(secondItem)) { - restoreSimplifiedGraph(edgeOrientation(firstEdge) == Horizontal ? Vertical : Horizontal); createItemEdges(secondItem); addChildLayoutItem(secondItem); } @@ -1657,10 +1641,6 @@ void QGraphicsAnchorLayoutPrivate::addAnchor_helper(QGraphicsLayoutItem *firstIt const Orientation orientation = edgeOrientation(firstEdge); - // Guarantee that the graph is no simplified when adding this anchor, - // anchor manipulation always happen in the full graph - restoreSimplifiedGraph(orientation); - // Create or increase the reference count for the related vertices. AnchorVertex *v1 = addInternalVertex(firstItem, firstEdge); AnchorVertex *v2 = addInternalVertex(secondItem, secondEdge); @@ -1696,15 +1676,13 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::getAnchor(QGraphicsLayoutItem *fi QGraphicsLayoutItem *secondItem, Qt::AnchorPoint secondEdge) { - Orientation orient = edgeOrientation(firstEdge); - restoreSimplifiedGraph(orient); - + const Orientation orientation = edgeOrientation(firstEdge); AnchorVertex *v1 = internalVertex(firstItem, firstEdge); AnchorVertex *v2 = internalVertex(secondItem, secondEdge); QGraphicsAnchor *graphicsAnchor = 0; - AnchorData *data = graph[orient].edgeData(v1, v2); + AnchorData *data = graph[orientation].edgeData(v1, v2); if (data) graphicsAnchor = acquireGraphicsAnchor(data); return graphicsAnchor; @@ -1789,12 +1767,9 @@ void QGraphicsAnchorLayoutPrivate::removeAnchor(AnchorVertex *firstVertex, void QGraphicsAnchorLayoutPrivate::removeAnchor_helper(AnchorVertex *v1, AnchorVertex *v2) { Q_ASSERT(v1 && v2); - // Guarantee that the graph is no simplified when removing this anchor, - // anchor manipulation always happen in the full graph - Orientation o = edgeOrientation(v1->m_edge); - restoreSimplifiedGraph(o); // Remove edge from graph + const Orientation o = edgeOrientation(v1->m_edge); graph[o].removeEdge(v1, v2); // Decrease vertices reference count (may trigger a deletion) @@ -1867,8 +1842,6 @@ void QGraphicsAnchorLayoutPrivate::removeVertex(QGraphicsLayoutItem *item, Qt::A void QGraphicsAnchorLayoutPrivate::removeAnchors(QGraphicsLayoutItem *item) { - Q_ASSERT(!graphSimplified[Horizontal] && !graphSimplified[Vertical]); - // remove the center anchor first!! removeCenterAnchors(item, Qt::AnchorHorizontalCenter, false); removeVertex(item, Qt::AnchorLeft); @@ -1971,20 +1944,8 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs() { if (!calculateGraphCacheDirty) return; - -#if defined(QT_DEBUG) && 0 - static int count = 0; - count++; - dumpGraph(QString::fromAscii("%1-before").arg(count)); -#endif - calculateGraphs(Horizontal); calculateGraphs(Vertical); - -#if defined(QT_DEBUG) && 0 - dumpGraph(QString::fromAscii("%1-after").arg(count)); -#endif - calculateGraphCacheDirty = false; } @@ -2032,18 +1993,9 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs( lastCalculationUsedSimplex[orientation] = false; #endif - // ### This is necessary because now we do vertex simplification, we still don't know - // differentiate between invalidate()s that doesn't need resimplification and those which - // need. For example, when size hint of an item changes, this may cause an anchor to reach 0 or to - // leave 0 and get a size. In both cases we need resimplify. - // - // ### one possible solution would be tracking all the 0-sized anchors, if this set change, we need - // resimplify. - restoreSimplifiedGraph(orientation); + static bool simplificationEnabled = qgetenv("QT_ANCHORLAYOUT_NO_SIMPLIFICATION").isEmpty(); - // Reset the nominal sizes of each anchor based on the current item sizes. This function - // works with both simplified and non-simplified graphs, so it'll work when the - // simplification is going to be reused. + // Reset the nominal sizes of each anchor based on the current item sizes. if (!refreshAllSizeHints(orientation)) { qWarning("QGraphicsAnchorLayout: anchor setup is not feasible."); graphHasConflicts[orientation] = true; @@ -2051,7 +2003,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs( } // Simplify the graph - if (!simplifyGraph(orientation)) { + if (simplificationEnabled && !simplifyGraph(orientation)) { qWarning("QGraphicsAnchorLayout: anchor setup is not feasible."); graphHasConflicts[orientation] = true; return; @@ -2115,6 +2067,9 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs( qDeleteAll(constraints[orientation]); constraints[orientation].clear(); graphPaths[orientation].clear(); // ### + + if (simplificationEnabled) + restoreSimplifiedGraph(orientation); } /*! diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h index cb8c4dd..7e2e00e 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h @@ -570,8 +570,6 @@ public: Interval interpolationInterval[2]; qreal interpolationProgress[2]; - // ### - bool graphSimplified[2]; bool graphHasConflicts[2]; QSet m_floatItems[2]; -- cgit v0.12 From e52ce79b8eee44742d71bf945e806aa2db06818b Mon Sep 17 00:00:00 2001 From: Caio Marcelo de Oliveira Filho Date: Thu, 12 Nov 2009 10:30:15 -0300 Subject: QGAL: clean up interpolation code Now the interpolation doesn't need to know how to traverse complex anchors, since when it runs, the graph is not simplified anymore. This commit removes unnecessary code for dealing with that. Signed-off-by: Caio Marcelo de Oliveira Filho Reviewed-by: Eduardo M. Fleury --- src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 109 ++++------------------- src/gui/graphicsview/qgraphicsanchorlayout_p.h | 2 - 2 files changed, 16 insertions(+), 95 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp index 5b1e36c..7646d4c 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp @@ -2564,21 +2564,6 @@ void QGraphicsAnchorLayoutPrivate::setItemsGeometries(const QRectF &geom) } /*! - \internal - - Fill the distance in the vertex and in the sub-vertices if its a combined vertex. -*/ -static void setVertexDistance(AnchorVertex *v, qreal distance) -{ - v->distance = distance; - if (v->m_type == AnchorVertex::Pair) { - AnchorVertexPair *pair = static_cast(v); - setVertexDistance(pair->m_first, distance); - setVertexDistance(pair->m_second, distance); - } -} - -/*! \internal Calculate the position of each vertex based on the paths to each of @@ -2593,7 +2578,7 @@ void QGraphicsAnchorLayoutPrivate::calculateVertexPositions( // Get root vertex AnchorVertex *root = layoutFirstVertex[orientation]; - setVertexDistance(root, 0); + root->distance = 0; visited.insert(root); // Add initial edges to the queue @@ -2604,16 +2589,12 @@ void QGraphicsAnchorLayoutPrivate::calculateVertexPositions( // Do initial calculation required by "interpolateEdge()" setupEdgesInterpolation(orientation); - // Traverse the graph and calculate vertex positions, we need to - // visit all pairs since each of them could have a sequential - // anchor inside, which hides more vertices. + // Traverse the graph and calculate vertex positions while (!queue.isEmpty()) { QPair pair = queue.dequeue(); AnchorData *edge = graph[orientation].edgeData(pair.first, pair.second); - // Both vertices were interpolated, and the anchor itself can't have other - // anchors inside (it's not a complex anchor). - if (edge->type == AnchorData::Normal && visited.contains(pair.second)) + if (visited.contains(pair.second)) continue; visited.insert(pair.second); @@ -2653,24 +2634,20 @@ void QGraphicsAnchorLayoutPrivate::setupEdgesInterpolation( } /*! - \internal - - Calculate the current Edge size based on the current Layout size and the - size the edge is supposed to have when the layout is at its: + \internal - - minimum size, - - preferred size, - - maximum size. + Calculate the current Edge size based on the current Layout size and the + size the edge is supposed to have when the layout is at its: - These three key values are calculated in advance using linear - programming (more expensive) or the simplification algorithm, then - subsequential resizes of the parent layout require a simple - interpolation. + - minimum size, + - preferred size, + - maximum size. - If the edge is sequential or parallel, it's possible to have more - vertices to be initalized, so it calls specialized functions that - will recurse back to interpolateEdge(). - */ + These three key values are calculated in advance using linear + programming (more expensive) or the simplification algorithm, then + subsequential resizes of the parent layout require a simple + interpolation. +*/ void QGraphicsAnchorLayoutPrivate::interpolateEdge(AnchorVertex *base, AnchorData *edge) { const Orientation orientation = Orientation(edge->orientation); @@ -2684,64 +2661,10 @@ void QGraphicsAnchorLayoutPrivate::interpolateEdge(AnchorVertex *base, AnchorDat // Calculate the distance for the vertex opposite to the base if (edge->from == base) { - setVertexDistance(edge->to, base->distance + edgeDistance); + edge->to->distance = base->distance + edgeDistance; } else { - setVertexDistance(edge->from, base->distance - edgeDistance); - } - - // Process child anchors - if (edge->type == AnchorData::Sequential) - interpolateSequentialEdges(static_cast(edge)); - else if (edge->type == AnchorData::Parallel) - interpolateParallelEdges(static_cast(edge)); -} - -void QGraphicsAnchorLayoutPrivate::interpolateParallelEdges(ParallelAnchorData *data) -{ - // In parallels the boundary vertices are already calculate, we - // just need to look for sequential groups inside, because only - // them may have new vertices associated. - - // First edge - if (data->firstEdge->type == AnchorData::Sequential) - interpolateSequentialEdges(static_cast(data->firstEdge)); - else if (data->firstEdge->type == AnchorData::Parallel) - interpolateParallelEdges(static_cast(data->firstEdge)); - - // Second edge - if (data->secondEdge->type == AnchorData::Sequential) - interpolateSequentialEdges(static_cast(data->secondEdge)); - else if (data->secondEdge->type == AnchorData::Parallel) - interpolateParallelEdges(static_cast(data->secondEdge)); -} - -void QGraphicsAnchorLayoutPrivate::interpolateSequentialEdges(SequentialAnchorData *data) -{ - // This method is supposed to handle any sequential anchor, even out-of-order - // ones. However, in the current QGAL implementation we should get only the - // well behaved ones. - Q_ASSERT(data->m_edges.first()->from == data->from); - Q_ASSERT(data->m_edges.last()->to == data->to); - - // At this point, the two outter vertices already have their distance - // calculated. - // We use the first as the base to calculate the internal ones - - AnchorVertex *prev = data->from; - - for (int i = 0; i < data->m_edges.count() - 1; ++i) { - AnchorData *edge = data->m_edges.at(i); - interpolateEdge(prev, edge); - - // Use the recently calculated vertex as the base for the next one - const bool edgeIsForward = (edge->from == prev); - prev = edgeIsForward ? edge->to : edge->from; + edge->from->distance = base->distance - edgeDistance; } - - // Treat the last specially, since we already calculated it's end - // vertex, so it's only interesting if it's a complex one - if (data->m_edges.last()->type != AnchorData::Normal) - interpolateEdge(prev, data->m_edges.last()); } bool QGraphicsAnchorLayoutPrivate::solveMinMax(const QList &constraints, diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h index 7e2e00e..fd82dd9 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h @@ -522,8 +522,6 @@ public: void calculateVertexPositions(Orientation orientation); void setupEdgesInterpolation(Orientation orientation); void interpolateEdge(AnchorVertex *base, AnchorData *edge); - void interpolateSequentialEdges(SequentialAnchorData *edge); - void interpolateParallelEdges(ParallelAnchorData *edge); // Linear Programming solver methods bool solveMinMax(const QList &constraints, -- cgit v0.12 From 3dcc9d6bc6385e2c4f4d7d7366c84b6dcc74508c Mon Sep 17 00:00:00 2001 From: Caio Marcelo de Oliveira Filho Date: Thu, 12 Nov 2009 12:21:51 -0300 Subject: QGAL: clean up size hint refresh code The code for refreshing size hints of items / user-created anchors now happens with a graph in full (not simplified). So we don't need to now how to refresh size hints for complex anchors. The code for refreshing complex anchors was used also to initialize the complex anchors (the '_helper' functions). Those were changed to calculateSizeHints() and refreshSizeHints() doesn't need to be virtual anymore. Signed-off-by: Caio Marcelo de Oliveira Filho Reviewed-by: Eduardo M. Fleury --- src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 78 +++++++----------------- src/gui/graphicsview/qgraphicsanchorlayout_p.h | 12 ++-- 2 files changed, 25 insertions(+), 65 deletions(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp index 7646d4c..2e80857 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp @@ -167,7 +167,7 @@ static void internalSizeHints(QSizePolicy::Policy policy, *prefSize = prefSizeHint; } -bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) +void AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) { QSizePolicy::Policy policy; qreal minSizeHint; @@ -182,7 +182,7 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) maxSize = QWIDGETSIZE_MAX; if (isCenterAnchor) maxSize /= 2; - return true; + return; } else { if (orientation == QGraphicsAnchorLayoutPrivate::Horizontal) { policy = item->sizePolicy().horizontalPolicy(); @@ -244,8 +244,6 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) sizeAtMinimum = prefSize; sizeAtPreferred = prefSize; sizeAtMaximum = prefSize; - - return true; } void ParallelAnchorData::updateChildrenSizes() @@ -274,18 +272,11 @@ void ParallelAnchorData::updateChildrenSizes() secondEdge->updateChildrenSizes(); } -bool ParallelAnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) +bool ParallelAnchorData::calculateSizeHints() { - return refreshSizeHints_helper(styleInfo); -} - -bool ParallelAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *styleInfo, - bool refreshChildren) -{ - if (refreshChildren && (!firstEdge->refreshSizeHints(styleInfo) - || !secondEdge->refreshSizeHints(styleInfo))) { - return false; - } + // Note that parallel groups can lead to unfeasibility, so during calculation, we can + // find out one unfeasibility. Because of that this method return boolean. This can't + // happen in sequential, so there the method is void. // Account for parallel anchors where the second edge is backwards. // We rely on the fact that a forward anchor of sizes min, pref, max is equivalent @@ -423,13 +414,7 @@ void SequentialAnchorData::updateChildrenSizes() } } -bool SequentialAnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo) -{ - return refreshSizeHints_helper(styleInfo); -} - -bool SequentialAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *styleInfo, - bool refreshChildren) +void SequentialAnchorData::calculateSizeHints() { minSize = 0; prefSize = 0; @@ -437,11 +422,6 @@ bool SequentialAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *style for (int i = 0; i < m_edges.count(); ++i) { AnchorData *edge = m_edges.at(i); - - // If it's the case refresh children information first - if (refreshChildren && !edge->refreshSizeHints(styleInfo)) - return false; - minSize += edge->minSize; prefSize += edge->prefSize; maxSize += edge->maxSize; @@ -451,8 +431,6 @@ bool SequentialAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *style sizeAtMinimum = prefSize; sizeAtPreferred = prefSize; sizeAtMaximum = prefSize; - - return true; } #ifdef QT_DEBUG @@ -627,7 +605,7 @@ AnchorData *QGraphicsAnchorLayoutPrivate::addAnchorMaybeParallel(AnchorData *new // At this point we can identify that the parallel anchor is not feasible, e.g. one // anchor minimum size is bigger than the other anchor maximum size. - *feasible = parallel->refreshSizeHints_helper(0, false); + *feasible = parallel->calculateSizeHints(); newAnchor = parallel; } @@ -688,7 +666,7 @@ static AnchorData *createSequence(Graph *graph, sequence->from = before; sequence->to = after; - sequence->refreshSizeHints_helper(0, false); + sequence->calculateSizeHints(); return sequence; } @@ -1335,11 +1313,11 @@ void QGraphicsAnchorLayoutPrivate::createItemEdges(QGraphicsLayoutItem *item) // refresh its size hint / policy values. AnchorData *data = new AnchorData; addAnchor_helper(item, Qt::AnchorLeft, item, Qt::AnchorRight, data); - data->refreshSizeHints(0); // 0 = effectiveSpacing, will not be used + data->refreshSizeHints(); data = new AnchorData; addAnchor_helper(item, Qt::AnchorTop, item, Qt::AnchorBottom, data); - data->refreshSizeHints(0); // 0 = effectiveSpacing, will not be used + data->refreshSizeHints(); } /*! @@ -1399,14 +1377,14 @@ void QGraphicsAnchorLayoutPrivate::createCenterAnchors( addAnchor_helper(item, firstEdge, item, centerEdge, data); data->isCenterAnchor = true; data->dependency = AnchorData::Master; - data->refreshSizeHints(0); + data->refreshSizeHints(); data = new AnchorData; c->variables.insert(data, -1.0); addAnchor_helper(item, centerEdge, item, lastEdge, data); data->isCenterAnchor = true; data->dependency = AnchorData::Slave; - data->refreshSizeHints(0); + data->refreshSizeHints(); itemCenterConstraints[orientation].append(c); @@ -1473,7 +1451,7 @@ void QGraphicsAnchorLayoutPrivate::removeCenterAnchors( // Create the new anchor that should substitute the left-center-right anchors. AnchorData *data = new AnchorData; addAnchor_helper(item, firstEdge, item, lastEdge, data); - data->refreshSizeHints(0); + data->refreshSizeHints(); // Remove old anchors removeAnchor_helper(first, center); @@ -1995,12 +1973,8 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs( static bool simplificationEnabled = qgetenv("QT_ANCHORLAYOUT_NO_SIMPLIFICATION").isEmpty(); - // Reset the nominal sizes of each anchor based on the current item sizes. - if (!refreshAllSizeHints(orientation)) { - qWarning("QGraphicsAnchorLayout: anchor setup is not feasible."); - graphHasConflicts[orientation] = true; - return; - } + // Reset the nominal sizes of each anchor based on the current item sizes + refreshAllSizeHints(orientation); // Simplify the graph if (simplificationEnabled && !simplifyGraph(orientation)) { @@ -2169,29 +2143,19 @@ bool QGraphicsAnchorLayoutPrivate::calculateNonTrunk(const QList &g = graph[orientation]; QList > vertices = g.connections(); QLayoutStyleInfo styleInf = styleInfo(); for (int i = 0; i < vertices.count(); ++i) { - AnchorData *data = g.edgeData(vertices.at(i).first, vertices.at(i).second);; - Q_ASSERT(data->from && data->to); - - // During the traversal we check the feasibility of the complex anchors. - if (!data->refreshSizeHints(&styleInf)) - return false; + AnchorData *data = g.edgeData(vertices.at(i).first, vertices.at(i).second); + data->refreshSizeHints(&styleInf); } - - return true; } /*! diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h index fd82dd9..2b365fb 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h @@ -131,7 +131,7 @@ struct AnchorData : public QSimplexVariable { dependency(Independent) {} virtual void updateChildrenSizes() {} - virtual bool refreshSizeHints(const QLayoutStyleInfo *styleInfo); + void refreshSizeHints(const QLayoutStyleInfo *styleInfo = 0); virtual ~AnchorData() {} @@ -197,9 +197,7 @@ struct SequentialAnchorData : public AnchorData } virtual void updateChildrenSizes(); - virtual bool refreshSizeHints(const QLayoutStyleInfo *styleInfo); - - bool refreshSizeHints_helper(const QLayoutStyleInfo *styleInfo, bool refreshChildren = true); + void calculateSizeHints(); QVector m_children; // list of vertices in the sequence QVector m_edges; // keep the list of edges too. @@ -226,9 +224,7 @@ struct ParallelAnchorData : public AnchorData } virtual void updateChildrenSizes(); - virtual bool refreshSizeHints(const QLayoutStyleInfo *styleInfo); - - bool refreshSizeHints_helper(const QLayoutStyleInfo *styleInfo, bool refreshChildren = true); + bool calculateSizeHints(); AnchorData* firstEdge; AnchorData* secondEdge; @@ -483,7 +479,7 @@ public: const QList &variables); // Support functions for calculateGraph() - bool refreshAllSizeHints(Orientation orientation); + void refreshAllSizeHints(Orientation orientation); void findPaths(Orientation orientation); void constraintsFromPaths(Orientation orientation); void updateAnchorSizes(Orientation orientation); -- cgit v0.12 From 2b243d590fcd6ce0c94fbf8adb1a4bd19b1c4685 Mon Sep 17 00:00:00 2001 From: Janne Koskinen Date: Fri, 13 Nov 2009 10:32:02 +0200 Subject: Highlighted text colour correction for s60style Changed s60style HighlightedText to pickup the correct colour from S60 themes. Task-number: QTBUG-5709 Reviewed-by: Sami Merila --- src/gui/styles/qs60style.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index 9179237..a204ebc 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -668,7 +668,7 @@ void QS60StylePrivate::setThemePalette(QPalette *palette) const s60Color(QS60StyleEnums::CL_QsnTextColors, 55, 0)); palette->setColor(QPalette::BrightText, palette->color(QPalette::WindowText).lighter()); palette->setColor(QPalette::HighlightedText, - s60Color(QS60StyleEnums::CL_QsnTextColors, 10, 0)); + s60Color(QS60StyleEnums::CL_QsnTextColors, 24, 0)); palette->setColor(QPalette::Link, s60Color(QS60StyleEnums::CL_QsnHighlightColors, 3, 0)); palette->setColor(QPalette::LinkVisited, palette->color(QPalette::Link).darker()); -- cgit v0.12 From f79ecb7db2f26078541de6c31661fba76e12c9c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan-Arve=20S=C3=A6ther?= Date: Fri, 13 Nov 2009 09:53:27 +0100 Subject: Compile fix Solaris: "sun" is defined to 1 on Solaris :) --- examples/graphicsview/weatheranchorlayout/main.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/examples/graphicsview/weatheranchorlayout/main.cpp b/examples/graphicsview/weatheranchorlayout/main.cpp index 9002828..3ccde50 100644 --- a/examples/graphicsview/weatheranchorlayout/main.cpp +++ b/examples/graphicsview/weatheranchorlayout/main.cpp @@ -188,7 +188,7 @@ int main(int argc, char **argv) #ifdef DEBUG_MODE QGraphicsProxyWidget *title = createItem("Title"); QGraphicsProxyWidget *place = createItem("Place"); - QGraphicsProxyWidget *sun = createItem("Sun"); + QGraphicsProxyWidget *sunnyWeather = createItem("Sun"); QGraphicsProxyWidget *details = createItem("Details"); QGraphicsProxyWidget *tabbar = createItem("Tabbar"); #else @@ -196,7 +196,7 @@ int main(int argc, char **argv) PixmapWidget *title = new PixmapWidget(QPixmap(":/images/title.jpg")); PlaceWidget *place = new PlaceWidget(QPixmap(":/images/place.jpg")); PixmapWidget *details = new PixmapWidget(QPixmap(":/images/5days.jpg")); - PixmapWidget *sun = new PixmapWidget(QPixmap(":/images/weather-few-clouds.png")); + PixmapWidget *sunnyWeather = new PixmapWidget(QPixmap(":/images/weather-few-clouds.png")); PixmapWidget *tabbar = new PixmapWidget(QPixmap(":/images/tabbar.jpg")); #endif @@ -215,9 +215,9 @@ int main(int argc, char **argv) tabbar->setPreferredSize(QSizeF(70, 24)); tabbar->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); - sun->setPreferredSize(QSizeF(128, 97)); - sun->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); - sun->setZValue(9999); + sunnyWeather->setPreferredSize(QSizeF(128, 97)); + sunnyWeather->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); + sunnyWeather->setZValue(9999); // start anchor layout QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout; @@ -238,8 +238,8 @@ int main(int argc, char **argv) anchor = l->addAnchor(place, Qt::AnchorBottom, l, Qt::AnchorBottom); anchor->setSpacing(12); - anchor = l->addAnchor(sun, Qt::AnchorTop, title, Qt::AnchorTop); - anchor = l->addAnchor(sun, Qt::AnchorBottom, l, Qt::AnchorVerticalCenter); + anchor = l->addAnchor(sunnyWeather, Qt::AnchorTop, title, Qt::AnchorTop); + anchor = l->addAnchor(sunnyWeather, Qt::AnchorBottom, l, Qt::AnchorVerticalCenter); anchor = l->addAnchor(tabbar, Qt::AnchorTop, title, Qt::AnchorBottom); anchor->setSpacing(5); @@ -257,8 +257,8 @@ int main(int argc, char **argv) anchor = l->addAnchor(place, Qt::AnchorRight, details, Qt::AnchorLeft); anchor->setSpacing(35); - anchor = l->addAnchor(sun, Qt::AnchorLeft, place, Qt::AnchorHorizontalCenter); - anchor = l->addAnchor(sun, Qt::AnchorRight, l, Qt::AnchorHorizontalCenter); + anchor = l->addAnchor(sunnyWeather, Qt::AnchorLeft, place, Qt::AnchorHorizontalCenter); + anchor = l->addAnchor(sunnyWeather, Qt::AnchorRight, l, Qt::AnchorHorizontalCenter); anchor = l->addAnchor(tabbar, Qt::AnchorHorizontalCenter, details, Qt::AnchorHorizontalCenter); anchor = l->addAnchor(details, Qt::AnchorRight, l, Qt::AnchorRight); -- cgit v0.12 From baf18674870cc86db12cb44a28dd5480cc04ea8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan-Arve=20S=C3=A6ther?= Date: Fri, 13 Nov 2009 09:55:43 +0100 Subject: Clean up example (remove unused ifdef). --- examples/graphicsview/weatheranchorlayout/main.cpp | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/examples/graphicsview/weatheranchorlayout/main.cpp b/examples/graphicsview/weatheranchorlayout/main.cpp index 3ccde50..d835ae3 100644 --- a/examples/graphicsview/weatheranchorlayout/main.cpp +++ b/examples/graphicsview/weatheranchorlayout/main.cpp @@ -185,20 +185,12 @@ int main(int argc, char **argv) QGraphicsScene scene; scene.setSceneRect(0, 0, 800, 480); -#ifdef DEBUG_MODE - QGraphicsProxyWidget *title = createItem("Title"); - QGraphicsProxyWidget *place = createItem("Place"); - QGraphicsProxyWidget *sunnyWeather = createItem("Sun"); - QGraphicsProxyWidget *details = createItem("Details"); - QGraphicsProxyWidget *tabbar = createItem("Tabbar"); -#else - // pixmaps widgets - PixmapWidget *title = new PixmapWidget(QPixmap(":/images/title.jpg")); - PlaceWidget *place = new PlaceWidget(QPixmap(":/images/place.jpg")); - PixmapWidget *details = new PixmapWidget(QPixmap(":/images/5days.jpg")); - PixmapWidget *sunnyWeather = new PixmapWidget(QPixmap(":/images/weather-few-clouds.png")); - PixmapWidget *tabbar = new PixmapWidget(QPixmap(":/images/tabbar.jpg")); -#endif + // pixmaps widgets + PixmapWidget *title = new PixmapWidget(QPixmap(":/images/title.jpg")); + PlaceWidget *place = new PlaceWidget(QPixmap(":/images/place.jpg")); + PixmapWidget *details = new PixmapWidget(QPixmap(":/images/5days.jpg")); + PixmapWidget *sunnyWeather = new PixmapWidget(QPixmap(":/images/weather-few-clouds.png")); + PixmapWidget *tabbar = new PixmapWidget(QPixmap(":/images/tabbar.jpg")); // setup sizes -- cgit v0.12 From 671fb279defa0a97c38c28dded767f58c67f9dac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Nilsen?= Date: Thu, 12 Nov 2009 16:33:42 +0100 Subject: Fixes QGraphicsWidget: paint() being called before polish(). The problem is that we request an update() before we schedules a polish event in QGraphicsScene::addItems, which means paint() is being called before polishEvent(). We could try to swap the order in addItems, but that doesn't give us any guarantee that polish is delivered before update (since we have no control over what's happening from outside graphics view). A better solution is to always make sure we don't have unpolished items before we draw. Auto-test included. Task-number: QTBUG-4979 Reviewed-by: Andreas --- src/gui/graphicsview/qgraphicsscene.cpp | 8 +++++++ tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp | 27 ++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp index 13f31b8..5b0643d 100644 --- a/src/gui/graphicsview/qgraphicsscene.cpp +++ b/src/gui/graphicsview/qgraphicsscene.cpp @@ -4551,6 +4551,10 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte void QGraphicsScenePrivate::drawItems(QPainter *painter, const QTransform *const viewTransform, QRegion *exposedRegion, QWidget *widget) { + // Make sure we don't have unpolished items before we draw. + if (!unpolishedItems.isEmpty()) + _q_polishItems(); + QRectF exposedSceneRect; if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) { exposedSceneRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1); @@ -5077,6 +5081,10 @@ void QGraphicsScene::drawItems(QPainter *painter, const QStyleOptionGraphicsItem options[], QWidget *widget) { Q_D(QGraphicsScene); + // Make sure we don't have unpolished items before we draw. + if (!d->unpolishedItems.isEmpty()) + d->_q_polishItems(); + QTransform viewTransform = painter->worldTransform(); Q_UNUSED(options); diff --git a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp index 6b5ad09..829e55c 100644 --- a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp +++ b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp @@ -160,6 +160,7 @@ private slots: void widgetSendsGeometryChanges(); void respectHFW(); void addChildInpolishEvent(); + void polishEvent(); // Task fixes void task236127_bspTreeIndexFails(); @@ -2768,6 +2769,32 @@ void tst_QGraphicsWidget::addChildInpolishEvent() QCOMPARE(PolishWidget::numberOfPolish, 2); } +void tst_QGraphicsWidget::polishEvent() +{ + class MyGraphicsWidget : public QGraphicsWidget + { public: + void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) + { events << QEvent::Paint; } + void polishEvent() + { events << QEvent::Polish; } + QList events; + }; + + QGraphicsScene scene; + + MyGraphicsWidget *widget = new MyGraphicsWidget; + scene.addItem(widget); + + QGraphicsView view(&scene); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Make sure the item is painted. + QTRY_VERIFY(widget->events.contains(QEvent::Paint)); + + // Make sure the item got polish before paint. + QCOMPARE(widget->events.at(0), QEvent::Polish); +} QTEST_MAIN(tst_QGraphicsWidget) #include "tst_qgraphicswidget.moc" -- cgit v0.12 From f5c5cc585cef8d2d2f77e7d83d7a07c6d70f0d09 Mon Sep 17 00:00:00 2001 From: Olivier Goffart Date: Fri, 13 Nov 2009 10:08:26 +0100 Subject: Fixed: QCalendarWidget::showNextMonth() followed by a click on the navigation button causes it to go to the first possible month QCalendarWidget::setCurrentPage did not set the current index on the model. This is required in order to get QCalendarWidgetPrivate::getCurrentDate working. (and this is used by the calendar widget to navigate) This intentionaly do not check if the date is inside the minimumDate or maximumDate range. This was possible before, and the autotests tests that behaviour. Task-number: QTBUG-4058 Reviewed-by: Prasanth Ullattil --- src/gui/widgets/qcalendarwidget.cpp | 14 +++++ tests/auto/qcalendarwidget/tst_qcalendarwidget.cpp | 70 ++++++++++++++++++++++ 2 files changed, 84 insertions(+) diff --git a/src/gui/widgets/qcalendarwidget.cpp b/src/gui/widgets/qcalendarwidget.cpp index 08ed7f6..ee536ee 100644 --- a/src/gui/widgets/qcalendarwidget.cpp +++ b/src/gui/widgets/qcalendarwidget.cpp @@ -2297,7 +2297,21 @@ int QCalendarWidget::monthShown() const void QCalendarWidget::setCurrentPage(int year, int month) { Q_D(QCalendarWidget); + QDate currentDate = d->getCurrentDate(); + int day = currentDate.day(); + int daysInMonths = QDate(year, month, 1).daysInMonth(); + if (day > daysInMonths) + day = daysInMonths; + d->showMonth(year, month); + + QDate newDate(year, month, day); + int row = -1, col = -1; + d->m_model->cellForDate(newDate, &row, &col); + if (row != -1 && col != -1) { + d->m_view->selectionModel()->setCurrentIndex(d->m_model->index(row, col), + QItemSelectionModel::NoUpdate); + } } /*! diff --git a/tests/auto/qcalendarwidget/tst_qcalendarwidget.cpp b/tests/auto/qcalendarwidget/tst_qcalendarwidget.cpp index 381f46f..a57c1d6 100644 --- a/tests/auto/qcalendarwidget/tst_qcalendarwidget.cpp +++ b/tests/auto/qcalendarwidget/tst_qcalendarwidget.cpp @@ -75,6 +75,8 @@ private slots: void resetTextFormat(); void setWeekdayFormat(); + void showPrevNext_data(); + void showPrevNext(); }; // Testing get/set functions @@ -293,5 +295,73 @@ void tst_QCalendarWidget::cleanup() { } + +typedef void (QCalendarWidget::*ShowFunc)(); +Q_DECLARE_METATYPE(ShowFunc) + +void tst_QCalendarWidget::showPrevNext_data() +{ + QTest::addColumn("function"); + QTest::addColumn("dateOrigin"); + QTest::addColumn("expectedDate"); + + QTest::newRow("showNextMonth") << &QCalendarWidget::showNextMonth << QDate(1984,7,30) << QDate(1984,8,30); + QTest::newRow("showPrevMonth") << &QCalendarWidget::showPreviousMonth << QDate(1984,7,30) << QDate(1984,6,30); + QTest::newRow("showNextYear") << &QCalendarWidget::showNextYear << QDate(1984,7,30) << QDate(1985,7,30); + QTest::newRow("showPrevYear") << &QCalendarWidget::showPreviousYear << QDate(1984,7,30) << QDate(1983,7,30); + + QTest::newRow("showNextMonth limit") << &QCalendarWidget::showNextMonth << QDate(2007,12,4) << QDate(2008,1,4); + QTest::newRow("showPreviousMonth limit") << &QCalendarWidget::showPreviousMonth << QDate(2006,1,23) << QDate(2005,12,23); + + QTest::newRow("showNextMonth now") << &QCalendarWidget::showNextMonth << QDate() << QDate::currentDate().addMonths(1); + QTest::newRow("showNextYear now") << &QCalendarWidget::showNextYear << QDate() << QDate::currentDate().addYears(1); + QTest::newRow("showPrevieousMonth now") << &QCalendarWidget::showPreviousMonth << QDate() << QDate::currentDate().addMonths(-1); + QTest::newRow("showPreviousYear now") << &QCalendarWidget::showPreviousYear << QDate() << QDate::currentDate().addYears(-1); + + QTest::newRow("showToday now") << &QCalendarWidget::showToday << QDate(2000,1,31) << QDate::currentDate(); + QTest::newRow("showNextMonth 31") << &QCalendarWidget::showNextMonth << QDate(2000,1,31) << QDate(2000,2,28); + QTest::newRow("selectedDate") << &QCalendarWidget::showSelectedDate << QDate(2008,2,29) << QDate(2008,2,29); + +} + +void tst_QCalendarWidget::showPrevNext() +{ + QFETCH(ShowFunc, function); + QFETCH(QDate, dateOrigin); + QFETCH(QDate, expectedDate); + + QCalendarWidget calWidget; + calWidget.show(); + QTest::qWaitForWindowShown(&calWidget); + if(!dateOrigin.isNull()) { + calWidget.setSelectedDate(dateOrigin); + calWidget.setCurrentPage(dateOrigin.year(), dateOrigin.month()); + + QCOMPARE(calWidget.yearShown(), dateOrigin.year()); + QCOMPARE(calWidget.monthShown(), dateOrigin.month()); + } else { + QCOMPARE(calWidget.yearShown(), QDate::currentDate().year()); + QCOMPARE(calWidget.monthShown(), QDate::currentDate().month()); + } + + (calWidget.*function)(); + + QCOMPARE(calWidget.yearShown(), expectedDate.year()); + QCOMPARE(calWidget.monthShown(), expectedDate.month()); + + // QTBUG-4058 + QTest::qWait(20); + QToolButton *button = qFindChild(&calWidget, "qt_calendar_prevmonth"); + QTest::mouseClick(button, Qt::LeftButton); + expectedDate = expectedDate.addMonths(-1); + QCOMPARE(calWidget.yearShown(), expectedDate.year()); + QCOMPARE(calWidget.monthShown(), expectedDate.month()); + + if(!dateOrigin.isNull()) { + //the selectedDate should not have changed + QCOMPARE(calWidget.selectedDate(), dateOrigin); + } +} + QTEST_MAIN(tst_QCalendarWidget) #include "tst_qcalendarwidget.moc" -- cgit v0.12 From e6be9c88bc98481936fcba7fa1cfb4e255f6e30b Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Fri, 13 Nov 2009 10:58:15 +0100 Subject: Early return for allowMove within a parent QModelIndex If this is not done, the climbing ancestors later in the method uses srcParent.row() as pos causing failure depending on which rows are being moved, and what the row of the parent is. Merge-request: 2072 Reviewed-by: Olivier Goffart --- src/corelib/kernel/qabstractitemmodel.cpp | 6 +-- .../qabstractitemmodel/tst_qabstractitemmodel.cpp | 63 +++++++++++++++------- 2 files changed, 47 insertions(+), 22 deletions(-) diff --git a/src/corelib/kernel/qabstractitemmodel.cpp b/src/corelib/kernel/qabstractitemmodel.cpp index 8e2273d..10a61ca 100644 --- a/src/corelib/kernel/qabstractitemmodel.cpp +++ b/src/corelib/kernel/qabstractitemmodel.cpp @@ -2475,10 +2475,8 @@ void QAbstractItemModel::endRemoveRows() bool QAbstractItemModelPrivate::allowMove(const QModelIndex &srcParent, int start, int end, const QModelIndex &destinationParent, int destinationStart, Qt::Orientation orientation) { // Don't move the range within itself. - if ( ( destinationParent == srcParent ) - && ( destinationStart >= start ) - && ( destinationStart <= end + 1) ) - return false; + if (destinationParent == srcParent) + return !(destinationStart >= start && destinationStart <= end + 1); QModelIndex destinationAncestor = destinationParent; int pos = (Qt::Vertical == orientation) ? destinationAncestor.row() : destinationAncestor.column(); diff --git a/tests/auto/qabstractitemmodel/tst_qabstractitemmodel.cpp b/tests/auto/qabstractitemmodel/tst_qabstractitemmodel.cpp index bdc31af..413419d 100644 --- a/tests/auto/qabstractitemmodel/tst_qabstractitemmodel.cpp +++ b/tests/auto/qabstractitemmodel/tst_qabstractitemmodel.cpp @@ -865,15 +865,22 @@ void tst_QAbstractItemModel::testMoveSameParentDown_data() QTest::addColumn("startRow"); QTest::addColumn("endRow"); QTest::addColumn("destRow"); + // We can't put the actual parent index for the move in here because m_model is not defined until init() is run. + QTest::addColumn("topLevel"); // Move from the start to the middle - QTest::newRow("move01") << 0 << 2 << 8; + QTest::newRow("move01") << 0 << 2 << 8 << true; // Move from the start to the end - QTest::newRow("move02") << 0 << 2 << 10; + QTest::newRow("move02") << 0 << 2 << 10 << true; // Move from the middle to the middle - QTest::newRow("move03") << 3 << 5 << 8; + QTest::newRow("move03") << 3 << 5 << 8 << true; // Move from the middle to the end - QTest::newRow("move04") << 3 << 5 << 10; + QTest::newRow("move04") << 3 << 5 << 10 << true; + + QTest::newRow("move05") << 0 << 2 << 8 << false; + QTest::newRow("move06") << 0 << 2 << 10 << false; + QTest::newRow("move07") << 3 << 5 << 8 << false; + QTest::newRow("move08") << 3 << 5 << 10 << false; } void tst_QAbstractItemModel::testMoveSameParentDown() @@ -881,6 +888,9 @@ void tst_QAbstractItemModel::testMoveSameParentDown() QFETCH( int, startRow); QFETCH( int, endRow); QFETCH( int, destRow); + QFETCH( bool, topLevel); + + QModelIndex moveParent = topLevel ? QModelIndex() : m_model->index(5, 0); QList persistentList; QModelIndexList indexList; @@ -913,33 +923,37 @@ void tst_QAbstractItemModel::testMoveSameParentDown() ModelMoveCommand *moveCommand = new ModelMoveCommand(m_model, this); moveCommand->setNumCols(4); + if (!topLevel) + moveCommand->setAncestorRowNumbers(QList() << 5); moveCommand->setStartRow(startRow); moveCommand->setEndRow(endRow); moveCommand->setDestRow(destRow); + if (!topLevel) + moveCommand->setDestAncestors(QList() << 5); moveCommand->doCommand(); QVariantList beforeSignal = beforeSpy.takeAt(0); QVariantList afterSignal = afterSpy.takeAt(0); QCOMPARE(beforeSignal.size(), 5); - QCOMPARE(beforeSignal.at(0).value(), QModelIndex()); + QCOMPARE(beforeSignal.at(0).value(), moveParent); QCOMPARE(beforeSignal.at(1).toInt(), startRow); QCOMPARE(beforeSignal.at(2).toInt(), endRow); - QCOMPARE(beforeSignal.at(3).value(), QModelIndex()); + QCOMPARE(beforeSignal.at(3).value(), moveParent); QCOMPARE(beforeSignal.at(4).toInt(), destRow); QCOMPARE(afterSignal.size(), 5); - QCOMPARE(afterSignal.at(0).value(), QModelIndex()); + QCOMPARE(afterSignal.at(0).value(), moveParent); QCOMPARE(afterSignal.at(1).toInt(), startRow); QCOMPARE(afterSignal.at(2).toInt(), endRow); - QCOMPARE(afterSignal.at(3).value(), QModelIndex()); + QCOMPARE(afterSignal.at(3).value(), moveParent); QCOMPARE(afterSignal.at(4).toInt(), destRow); for (int i = 0; i < indexList.size(); i++) { QModelIndex idx = indexList.at(i); QModelIndex persistentIndex = persistentList.at(i); - if (idx.parent() == QModelIndex()) + if (idx.parent() == moveParent) { int row = idx.row(); if ( row >= startRow) @@ -976,15 +990,21 @@ void tst_QAbstractItemModel::testMoveSameParentUp_data() QTest::addColumn("startRow"); QTest::addColumn("endRow"); QTest::addColumn("destRow"); + QTest::addColumn("topLevel"); // Move from the middle to the start - QTest::newRow("move01") << 5 << 7 << 0; + QTest::newRow("move01") << 5 << 7 << 0 << true; // Move from the end to the start - QTest::newRow("move02") << 8 << 9 << 0; + QTest::newRow("move02") << 8 << 9 << 0 << true; // Move from the middle to the middle - QTest::newRow("move03") << 5 << 7 << 2; + QTest::newRow("move03") << 5 << 7 << 2 << true; // Move from the end to the middle - QTest::newRow("move04") << 8 << 9 << 5; + QTest::newRow("move04") << 8 << 9 << 5 << true; + + QTest::newRow("move05") << 5 << 7 << 0 << false; + QTest::newRow("move06") << 8 << 9 << 0 << false; + QTest::newRow("move07") << 5 << 7 << 2 << false; + QTest::newRow("move08") << 8 << 9 << 5 << false; } void tst_QAbstractItemModel::testMoveSameParentUp() @@ -993,6 +1013,9 @@ void tst_QAbstractItemModel::testMoveSameParentUp() QFETCH( int, startRow); QFETCH( int, endRow); QFETCH( int, destRow); + QFETCH( bool, topLevel); + + QModelIndex moveParent = topLevel ? QModelIndex() : m_model->index(5, 0); QList persistentList; QModelIndexList indexList; @@ -1026,26 +1049,30 @@ void tst_QAbstractItemModel::testMoveSameParentUp() ModelMoveCommand *moveCommand = new ModelMoveCommand(m_model, this); moveCommand->setNumCols(4); + if (!topLevel) + moveCommand->setAncestorRowNumbers(QList() << 5); moveCommand->setStartRow(startRow); moveCommand->setEndRow(endRow); moveCommand->setDestRow(destRow); + if (!topLevel) + moveCommand->setDestAncestors(QList() << 5); moveCommand->doCommand(); QVariantList beforeSignal = beforeSpy.takeAt(0); QVariantList afterSignal = afterSpy.takeAt(0); QCOMPARE(beforeSignal.size(), 5); - QCOMPARE(beforeSignal.at(0).value(), QModelIndex()); + QCOMPARE(beforeSignal.at(0).value(), moveParent); QCOMPARE(beforeSignal.at(1).toInt(), startRow); QCOMPARE(beforeSignal.at(2).toInt(), endRow); - QCOMPARE(beforeSignal.at(3).value(), QModelIndex()); + QCOMPARE(beforeSignal.at(3).value(), moveParent); QCOMPARE(beforeSignal.at(4).toInt(), destRow); QCOMPARE(afterSignal.size(), 5); - QCOMPARE(afterSignal.at(0).value(), QModelIndex()); + QCOMPARE(afterSignal.at(0).value(), moveParent); QCOMPARE(afterSignal.at(1).toInt(), startRow); QCOMPARE(afterSignal.at(2).toInt(), endRow); - QCOMPARE(afterSignal.at(3).value(), QModelIndex()); + QCOMPARE(afterSignal.at(3).value(), moveParent); QCOMPARE(afterSignal.at(4).toInt(), destRow); @@ -1053,7 +1080,7 @@ void tst_QAbstractItemModel::testMoveSameParentUp() { QModelIndex idx = indexList.at(i); QModelIndex persistentIndex = persistentList.at(i); - if (idx.parent() == QModelIndex()) + if (idx.parent() == moveParent) { int row = idx.row(); if ( row >= destRow) -- cgit v0.12 From 60d2ab05c350f866f942a35f341f455015fdb800 Mon Sep 17 00:00:00 2001 From: Jos van den Oever Date: Thu, 1 Oct 2009 18:49:27 +0200 Subject: Speed up QTextFormatCollection::indexForFormat QTextFormatCollection currently has two problems: - looking for the index of a QTextFormat is linear, this can take 25% cpu when loading large documents in kword - the hash function for QTextFormat is inadequate. Not all values are treated specially. E.g. each QBrush instance has the same hash value at the moment. These patches speed up loading of a large text document in KWord from 9 to 7 seconds. This fixes this by using QMultiHash to group the QTextFormat instances by hash and only loop through that list when looking up values. It also improves the hash function for QTextFormat. Merge-request: 1623 Reviewed-by: Olivier Goffart --- src/gui/text/qtextformat.cpp | 76 +++++++++++++++++++++++++++++++++----------- src/gui/text/qtextformat_p.h | 4 +-- 2 files changed, 59 insertions(+), 21 deletions(-) diff --git a/src/gui/text/qtextformat.cpp b/src/gui/text/qtextformat.cpp index d05d9e5..deda39f 100644 --- a/src/gui/text/qtextformat.cpp +++ b/src/gui/text/qtextformat.cpp @@ -265,21 +265,55 @@ private: friend QDataStream &operator>>(QDataStream &, QTextFormat &); }; -static uint variantHash(const QVariant &variant) +// this is only safe if sizeof(int) == sizeof(float) +static inline uint hash(float d) { - switch (variant.userType()) { - case QVariant::Invalid: return 0; - case QVariant::Bool: return variant.toBool(); - case QVariant::Int: return variant.toInt(); - case QMetaType::Float: return static_cast(variant.toFloat()); - case QVariant::Double: return static_cast(variant.toDouble()); + return reinterpret_cast(d); +} + +static inline uint hash(const QColor &color) +{ + return (color.isValid()) ? color.rgba() : 0x234109; +} + +static inline uint hash(const QPen &pen) +{ + return hash(pen.color()) + hash(pen.widthF()); +} + +static inline uint hash(const QBrush &brush) +{ + return hash(brush.color()) + (brush.style() << 3); +} + +static inline uint variantHash(const QVariant &variant) +{ + // simple and fast hash functions to differentiate between type and value + switch (variant.userType()) { // sorted by occurrence frequency case QVariant::String: return qHash(variant.toString()); - case QVariant::Color: return qHash(qvariant_cast(variant).rgb()); + case QVariant::Double: return hash(variant.toDouble()); + case QVariant::Int: return 0x811890 + variant.toInt(); + case QVariant::Brush: + return 0x01010101 + hash(qvariant_cast(variant)); + case QVariant::Bool: return 0x371818 + variant.toBool(); + case QVariant::Pen: return 0x02020202 + hash(qvariant_cast(variant)); + case QVariant::List: + return 0x8377 + qvariant_cast(variant).count(); + case QVariant::Color: return hash(qvariant_cast(variant)); + case QVariant::TextLength: + return 0x377 + hash(qvariant_cast(variant).rawValue()); + case QMetaType::Float: return hash(variant.toFloat()); + case QVariant::Invalid: return 0; default: break; } return qHash(variant.typeName()); } +static inline int getHash(const QTextFormatPrivate *d, int format) +{ + return (d ? d->hash() : 0) + format; +} + uint QTextFormatPrivate::recalcHash() const { hashValue = 0; @@ -3033,13 +3067,15 @@ QTextFormatCollection::~QTextFormatCollection() int QTextFormatCollection::indexForFormat(const QTextFormat &format) { - uint hash = format.d ? format.d->hash() : 0; - if (hashes.contains(hash)) { - for (int i = 0; i < formats.size(); ++i) { - if (formats.at(i) == format) - return i; + uint hash = getHash(format.d, format.format_type); + QMultiHash::const_iterator i = hashes.find(hash); + while (i != hashes.end() && i.key() == hash) { + if (formats.value(i.value()) == format) { + return i.value(); } + ++i; } + int idx = formats.size(); formats.append(format); @@ -3049,7 +3085,7 @@ int QTextFormatCollection::indexForFormat(const QTextFormat &format) f.d = new QTextFormatPrivate; f.d->resolveFont(defaultFnt); - hashes.insert(hash); + hashes.insert(hash, idx); } QT_CATCH(...) { formats.pop_back(); @@ -3060,11 +3096,13 @@ int QTextFormatCollection::indexForFormat(const QTextFormat &format) bool QTextFormatCollection::hasFormatCached(const QTextFormat &format) const { - uint hash = format.d ? format.d->hash() : 0; - if (hashes.contains(hash)) { - for (int i = 0; i < formats.size(); ++i) - if (formats.at(i) == format) - return true; + uint hash = getHash(format.d, format.format_type); + QMultiHash::const_iterator i = hashes.find(hash); + while (i != hashes.end() && i.key() == hash) { + if (formats.value(i.value()) == format) { + return true; + } + ++i; } return false; } diff --git a/src/gui/text/qtextformat_p.h b/src/gui/text/qtextformat_p.h index c796343..73ca0ce 100644 --- a/src/gui/text/qtextformat_p.h +++ b/src/gui/text/qtextformat_p.h @@ -55,7 +55,7 @@ #include "QtGui/qtextformat.h" #include "QtCore/qvector.h" -#include "QtCore/qset.h" +#include "QtCore/qhash.h" QT_BEGIN_NAMESPACE @@ -97,7 +97,7 @@ public: FormatVector formats; QVector objFormats; - QSet hashes; + QMultiHash hashes; inline QFont defaultFont() const { return defaultFnt; } void setDefaultFont(const QFont &f); -- cgit v0.12 From aeac586476a6e47c7a8a6aa2121bfe39a29d8458 Mon Sep 17 00:00:00 2001 From: Thiago Macieira Date: Fri, 8 May 2009 20:42:44 +0200 Subject: Reorganize the qatomic_armv6.h file to receive the RVCT inline assembly. Move the *Relaxed, *Acquire and *Release functions (which are simply forwarding calls to the *Ordered version) to the bottom of the file. Reviewed-By: Shane Kearns --- src/corelib/arch/qatomic_armv6.h | 171 ++++++++++++++++++++------------------- 1 file changed, 90 insertions(+), 81 deletions(-) diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h index 6862638..6eb9a7b 100644 --- a/src/corelib/arch/qatomic_armv6.h +++ b/src/corelib/arch/qatomic_armv6.h @@ -101,6 +101,8 @@ template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() { return false; } +#ifdef !Q_CC_RVCT + inline bool QBasicAtomicInt::ref() { register int newValue; @@ -155,21 +157,6 @@ inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) return result == 0; } -inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) { register int originalValue; @@ -188,21 +175,6 @@ inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) return originalValue; } -inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) -{ - return fetchAndStoreOrdered(newValue); -} - inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) { register int originalValue; @@ -224,21 +196,6 @@ inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) return originalValue; } -inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) -{ - return fetchAndAddOrdered(valueToAdd); -} - -inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) -{ - return fetchAndAddOrdered(valueToAdd); -} - -inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) -{ - return fetchAndAddOrdered(valueToAdd); -} - template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) { @@ -259,24 +216,6 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValu } template -Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -template -Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -template -Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) -{ - return testAndSetOrdered(expectedValue, newValue); -} - -template Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) { register T *originalValue; @@ -296,24 +235,6 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) } template -Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -template -Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -template -Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) -{ - return fetchAndStoreOrdered(newValue); -} - -template Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) { register T *originalValue; @@ -335,6 +256,94 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueTo return originalValue; } +#else +// This is Q_CC_RVCT + +#endif + +// common code + +inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + template Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddRelaxed(qptrdiff valueToAdd) { -- cgit v0.12 From 43c607383697ab506f9eb0d491ec6348f939e53d Mon Sep 17 00:00:00 2001 From: Thiago Macieira Date: Fri, 8 May 2009 20:45:24 +0200 Subject: Add the ARMv6 inline assembly code for compiling with RVCT. This is basically a copy & paste of the GCC inline assembly above, switched to the RVCT inline assembly model (which is actually easier to write and understand). I verified that this code compiles and assembles as expected. The output generated by RVCT is pretty much on the mark. However, I have not executed this code yet to see if it performs as expected. To be noted: - when expanding the inline template code, RVCT may be tempted to switch your entire function to ARM mode. Should we add __attribute__((noinline)) to prevent that? - There's no equivalent to GCC inline assembler's clobber, especially of "memory". Also, there's no "volatile" qualifier to the assembly. Does the compiler know it can't reorder the code? Does it know it shouldn't trust the value of the memory after this? My test indicates the code is fine... Reviewed-By: Shane Kearns --- src/corelib/arch/qatomic_armv6.h | 132 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h index 6eb9a7b..28655df 100644 --- a/src/corelib/arch/qatomic_armv6.h +++ b/src/corelib/arch/qatomic_armv6.h @@ -259,6 +259,138 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueTo #else // This is Q_CC_RVCT +// RVCT inline assembly documentation: +// http://www.keil.com/support/man/docs/armcc/armcc_chdcffdb.htm +// RVCT embedded assembly documentation: +// http://www.keil.com/support/man/docs/armcc/armcc_chddbeib.htm + +// save our pragma state and switch to ARM mode +#pragma push +#pragma arm + +inline bool QBasicAtomicInt::ref() +{ + register int newValue; + register int result; + retry: + __asm { + ldrex newValue, [&_q_value] + add newValue, newValue, #1 + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return newValue != 0; +} + +inline bool QBasicAtomicInt::deref() +{ + register int newValue; + register int result; + retry: + __asm { + ldrex newValue, [&_q_value] + sub newValue, newValue, #1 + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return newValue != 0; +} + +inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) +{ + register int result; + retry: + __asm { + ldrex result, [&_q_value] + eors result, result, expectedValue + strexeq result, newValue, [&_q_value] + teqeq result, #1 + beq retry + } + return result == 0; +} + +inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +{ + register int originalValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) +{ + register int originalValue; + register int newValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + add newValue, originalValue, valueToAdd + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) +{ + register T *result; + retry: + __asm { + ldrex result, [&_q_value] + eors result, result, expectedValue + strexeq result, newValue, [&_q_value] + teqeq result, #1 + beq retry + } + return result == 0; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) +{ + register T *originalValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) +{ + register T *originalValue; + register T *newValue; + register int result; + retry: + __asm { + ldrex originalValue, [&_q_value] + add newValue, originalValue, valueToAdd * sizeof(T) + strex result, newValue, [&_q_value] + teq result, #0 + bne retry + } + return originalValue; +} + +// go back to the previous pragma state (probably Thumb mode) +#pragma pop #endif // common code -- cgit v0.12 From a53bbbf81ce2dbce143ebc08fd91418e51a44588 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Wed, 4 Nov 2009 22:26:00 +0100 Subject: Binary compatibility of Symbian ARMv5 and ARMv6 builds Use ARMv6 atomics where available Use OS atomics otherwise Integrate ARMV6 atomics to Symbian builds Use compiler defined macros to detect if ARMv6 instructions are available This defines the QT_HAVE_ARMV6 macro, replacing the way it was defined by the Symbian build system previously in qpainting.pri. qatomic_symbian now uses qatomic_arm or qatomic_armv6 automatically Port armv6 atomics to implement generic atomics interface The inline atomics are not inlined when we build for thumb using RVCT. So there is no performance improvement of using the "inline" versions vs a shared version called through a function call. The generic atomics interface is good for binary compatibility, as the same symbols are exported in all versions now. Changed the fallback generic atomics implementation from the unix one to a symbian specific one using RFastLock (identical code to the windows generic atomics, except for RFastLock replaces Win32 CRITICAL_SECTION) Note: GCCE atomics still need porting Tell git to ignore .lst listing files (produced by sbs/abld listing) ARMv6 support for GCCE compiler and fallback implementation using OS When building corelib with GCCE and -march=armv6, QT_HAVE_ARMV6 will be defined. This patch adds copies of the asm functions in GCC syntax. When building for the Symbian emulator, or ARMv5, then Symbian OS atomic functions are used as a fallback - these are more efficient than the unix atomics, and don't require data import (which the ARMv5 atomics use, but the OS loader doesn't support fully) Symbian OS functions are always used for QBasicAtomicInt::ref / deref, because these are faster than the generic function in all cases. They are machine coded for ARMv6, and are used internally by RFastLock. Reviewed-By: axis Reviewed-By: Brad --- .gitignore | 1 + src/corelib/arch/armv6/qatomic_generic_armv6.cpp | 260 +++++++++++++++++++++++ src/corelib/arch/qatomic_armv6.h | 3 +- src/corelib/arch/qatomic_symbian.h | 240 ++++++++++++++++++++- src/corelib/arch/symbian/arch.pri | 2 +- src/corelib/arch/symbian/qatomic_symbian.cpp | 104 +++++++-- src/corelib/global/qglobal.h | 7 +- src/gui/painting/painting.pri | 1 - src/s60installs/eabi/QtCoreu.def | 8 +- 9 files changed, 587 insertions(+), 39 deletions(-) create mode 100644 src/corelib/arch/armv6/qatomic_generic_armv6.cpp diff --git a/.gitignore b/.gitignore index feb1ea4..33c9b7c 100644 --- a/.gitignore +++ b/.gitignore @@ -191,6 +191,7 @@ plugin_commonU.def *.qtplugin *.sis *.sisx +*.lst # Generated by abldfast.bat from devtools. .abldsteps.* diff --git a/src/corelib/arch/armv6/qatomic_generic_armv6.cpp b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp new file mode 100644 index 0000000..3078662 --- /dev/null +++ b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp @@ -0,0 +1,260 @@ +/**************************************************************************** +** +** Copyright (C) 2009 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$ +** +** This file implements the generic atomics interface using ARMv6 assembly +** instructions. It is more efficent than the inline versions when Qt is +** built for the THUMB instruction set, as the required instructions are +** only available in ARM state. +****************************************************************************/ + +#include + +#ifdef QT_HAVE_ARMV6 + +QT_BEGIN_NAMESPACE + +QT_USE_NAMESPACE + +#ifdef Q_CC_RVCT +#pragma push +#pragma arm +Q_CORE_EXPORT asm +bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue) +{ + CODE32 + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue +retry_testAndSetOrdered + LDREX r3,[r0] //r3 = *_q_value + EORS r3,r3,r1 //if (r3 == expectedValue) { + STREXEQ r3,r2,[r0] //*_q_value = newvalue, r3 = error + TEQEQ r3,#1 //if error + BEQ retry_testAndSetOrdered //then goto retry } + RSBS r0,r3,#1 //return (r3 == 0) + MOVCC r0,#0 + BX r14 +} + +Q_CORE_EXPORT asm +int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue) +{ + CODE32 +//R0 = _q_value +//R1 = newValue +retry_fetchAndStoreOrdered + LDREX r3,[r0] //r3 = *_q_value + STREX r2,r1,[r0] //*_q_value = newValue, r2 = error + TEQ r2,#0 //if error + BNE retry_fetchAndStoreOrdered //then goto retry + MOV r0,r3 //return r3 + BX r14 +} + +Q_CORE_EXPORT asm +int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd) +{ + CODE32 + //R0 = _q_value + //R1 = valueToAdd + STMDB sp!,{r12,lr} +retry_fetchAndAddOrdered + LDREX r2,[r0] //r2 = *_q_value + ADD r3,r2,r1 //r3 = r2 + r1 + STREX r12,r3,[r0] //*_q_value = r3, r12 = error + TEQ r12,#0 //if error + BNE retry_fetchAndAddOrdered //then retry + MOV r0,r2 //return r2 + LDMIA sp!,{r12,pc} +} + +Q_CORE_EXPORT asm +bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value, + void *expectedValue, + void *newValue) +{ + CODE32 + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue +retryPointer_testAndSetOrdered + LDREX r3,[r0] //r3 = *_q_value + EORS r3,r3,r1 //if (r3 == expectedValue) { + STREXEQ r3,r2,[r0] //*_q_value = newvalue, r3 = error + TEQEQ r3,#1 //if error + BEQ retryPointer_testAndSetOrdered //then goto retry } + RSBS r0,r3,#1 //return (r3 == 0) + MOVCC r0,#0 + BX r14 +} + +Q_CORE_EXPORT asm +void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue) +{ + CODE32 + //R0 = _q_value + //R1 = newValue +retryPointer_fetchAndStoreOrdered + LDREX r3,[r0] //r3 = *_q_value + STREX r2,r1,[r0] //*_q_value = newValue, r2 = error + TEQ r2,#0 //if error + BNE retryPointer_fetchAndStoreOrdered //then goto retry + MOV r0,r3 //return r3 + BX r14 +} + +Q_CORE_EXPORT asm +void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd) +{ + CODE32 + //R0 = _q_value + //R1 = valueToAdd + STMDB sp!,{r12,lr} +retryPointer_fetchAndAddOrdered + LDREX r2,[r0] //r2 = *_q_value + ADD r3,r2,r1 //r3 = r2 + r1 + STREX r12,r3,[r0] //*_q_value = r3, r12 = error + TEQ r12,#0 //if error + BNE retryPointer_fetchAndAddOrdered //then retry + MOV r0,r2 //return r2 + LDMIA sp!,{r12,pc} +} + +#pragma pop +#elif defined (Q_CC_GCCE) +Q_CORE_EXPORT __declspec( naked ) +bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue) +{ + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue + asm("retry_testAndSetOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" EORS r3,r3,r1"); //if (r3 == expectedValue) { + asm(" STREXEQ r3,r2,[r0]"); //*_q_value = newvalue, r3 = error + asm(" TEQEQ r3,#1"); //if error + asm(" BEQ retry_testAndSetOrdered"); //then goto retry } + asm(" RSBS r0,r3,#1"); //return (r3 == 0) + asm(" MOVCC r0,#0"); + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue) +{ +//R0 = _q_value +//R1 = newValue + asm("retry_fetchAndStoreOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" STREX r2,r1,[r0]"); //*_q_value = newValue, r2 = error + asm(" TEQ r2,#0"); //if error + asm(" BNE retry_fetchAndStoreOrdered"); //then goto retry + asm(" MOV r0,r3"); //return r3 + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd) +{ + //R0 = _q_value + //R1 = valueToAdd + asm(" STMDB sp!,{r12,lr}"); + asm("retry_fetchAndAddOrdered:"); + asm(" LDREX r2,[r0]"); //r2 = *_q_value + asm(" ADD r3,r2,r1 "); //r3 = r2 + r1 + asm(" STREX r12,r3,[r0]"); //*_q_value = r3, r12 = error + asm(" TEQ r12,#0"); //if error + asm(" BNE retry_fetchAndAddOrdered"); //then retry + asm(" MOV r0,r2"); //return r2 + asm(" LDMIA sp!,{r12,pc}"); +} + +Q_CORE_EXPORT __declspec( naked ) +bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value, + void *expectedValue, + void *newValue) +{ + //R0 = _q_value + //R1 = expectedValue + //R2 = newValue + asm("retryPointer_testAndSetOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" EORS r3,r3,r1"); //if (r3 == expectedValue) { + asm(" STREXEQ r3,r2,[r0]"); //*_q_value = newvalue, r3 = error + asm(" TEQEQ r3,#1"); //if error + asm(" BEQ retryPointer_testAndSetOrdered"); //then goto retry } + asm(" RSBS r0,r3,#1"); //return (r3 == 0) + asm(" MOVCC r0,#0"); + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue) +{ + //R0 = _q_value + //R1 = newValue + asm("retryPointer_fetchAndStoreOrdered:"); + asm(" LDREX r3,[r0]"); //r3 = *_q_value + asm(" STREX r2,r1,[r0]"); //*_q_value = newValue, r2 = error + asm(" TEQ r2,#0"); //if error + asm(" BNE retryPointer_fetchAndStoreOrdered"); //then goto retry + asm(" MOV r0,r3"); //return r3 + asm(" BX r14"); +} + +Q_CORE_EXPORT __declspec( naked ) +void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd) +{ + //R0 = _q_value + //R1 = valueToAdd + asm(" STMDB sp!,{r12,lr}"); + asm("retryPointer_fetchAndAddOrdered:"); + asm(" LDREX r2,[r0]"); //r2 = *_q_value + asm(" ADD r3,r2,r1"); //r3 = r2 + r1 + asm(" STREX r12,r3,[r0]"); //*_q_value = r3, r12 = error + asm(" TEQ r12,#0"); //if error + asm(" BNE retryPointer_fetchAndAddOrdered"); //then retry + asm(" MOV r0,r2"); //return r2 + asm(" LDMIA sp!,{r12,pc}"); +} +#else +#error unknown arm compiler +#endif +QT_END_NAMESPACE +#endif diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h index 28655df..1e9f0c4 100644 --- a/src/corelib/arch/qatomic_armv6.h +++ b/src/corelib/arch/qatomic_armv6.h @@ -45,7 +45,6 @@ QT_BEGIN_HEADER QT_BEGIN_NAMESPACE - #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE inline bool QBasicAtomicInt::isReferenceCountingNative() @@ -101,7 +100,7 @@ template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() { return false; } -#ifdef !Q_CC_RVCT +#ifndef Q_CC_RVCT inline bool QBasicAtomicInt::ref() { diff --git a/src/corelib/arch/qatomic_symbian.h b/src/corelib/arch/qatomic_symbian.h index 3721aca..571f628 100644 --- a/src/corelib/arch/qatomic_symbian.h +++ b/src/corelib/arch/qatomic_symbian.h @@ -42,12 +42,8 @@ #ifndef QATOMIC_SYMBIAN_H #define QATOMIC_SYMBIAN_H -#if defined(Q_CC_RVCT) -# define QT_NO_ARM_EABI -# include -#elif defined(Q_CC_NOKIAX86) || defined(Q_CC_GCCE) -# include -#endif +#include +#include QT_BEGIN_HEADER @@ -55,7 +51,237 @@ QT_BEGIN_NAMESPACE QT_MODULE(Core) -// Empty, but needed to avoid warnings +#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isReferenceCountingNative() +{ return false; } +inline bool QBasicAtomicInt::isReferenceCountingWaitFree() +{ return false; } + +#define Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isTestAndSetNative() +{ return false; } +inline bool QBasicAtomicInt::isTestAndSetWaitFree() +{ return false; } + +#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isFetchAndStoreNative() +{ return false; } +inline bool QBasicAtomicInt::isFetchAndStoreWaitFree() +{ return false; } + +#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE + +inline bool QBasicAtomicInt::isFetchAndAddNative() +{ return false; } +inline bool QBasicAtomicInt::isFetchAndAddWaitFree() +{ return false; } + +#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_NOT_NATIVE + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetNative() +{ return false; } +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetWaitFree() +{ return false; } + +#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_NOT_NATIVE + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreNative() +{ return false; } +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreWaitFree() +{ return false; } + +#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_NOT_NATIVE + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddNative() +{ return false; } +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() +{ return false; } + +Q_CORE_EXPORT bool QBasicAtomicInt_testAndSetOrdered(volatile int *, int, int); +Q_CORE_EXPORT int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *, int); +Q_CORE_EXPORT int QBasicAtomicInt_fetchAndAddOrdered(volatile int *, int); + +Q_CORE_EXPORT bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *, void *, void *); +Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *, void *); +Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *, qptrdiff); + +// Reference counting + +//LockedInc and LockedDec are machine coded for ARMv6 (and future proof) +inline bool QBasicAtomicInt::ref() +{ + int original = User::LockedInc((TInt&)_q_value); + return original != -1; +} + +inline bool QBasicAtomicInt::deref() +{ + int original = User::LockedDec((TInt&)_q_value); + return original != 1; +} + +// Test and set for integers + +inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) +{ + return QBasicAtomicInt_testAndSetOrdered(&_q_value, expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +// Fetch and store for integers + +inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +{ + return QBasicAtomicInt_fetchAndStoreOrdered(&_q_value, newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +// Fetch and add for integers + +inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) +{ + return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +// Test and set for pointers + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) +{ + union { T * volatile * typed; void * volatile * voidp; } pointer; + pointer.typed = &_q_value; + return QBasicAtomicPointer_testAndSetOrdered(pointer.voidp, expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +Q_INLINE_TEMPLATE bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +// Fetch and store for pointers + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) +{ + union { T * volatile * typed; void * volatile * voidp; } pointer; + union { T *typed; void *voidp; } returnValue; + pointer.typed = &_q_value; + returnValue.voidp = QBasicAtomicPointer_fetchAndStoreOrdered(pointer.voidp, newValue); + return returnValue.typed; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +// Fetch and add for pointers + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) +{ + union { T * volatile *typed; void * volatile *voidp; } pointer; + union { T *typed; void *voidp; } returnValue; + pointer.typed = &_q_value; + returnValue.voidp = QBasicAtomicPointer_fetchAndAddOrdered(pointer.voidp, valueToAdd * sizeof(T)); + return returnValue.typed; +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddRelaxed(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddAcquire(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +Q_INLINE_TEMPLATE T *QBasicAtomicPointer::fetchAndAddRelease(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} QT_END_NAMESPACE diff --git a/src/corelib/arch/symbian/arch.pri b/src/corelib/arch/symbian/arch.pri index deb94b1..3ef1c9e 100644 --- a/src/corelib/arch/symbian/arch.pri +++ b/src/corelib/arch/symbian/arch.pri @@ -2,4 +2,4 @@ # Symbian architecture # SOURCES += $$QT_ARCH_CPP/qatomic_symbian.cpp \ - $$QT_ARCH_CPP/../generic/qatomic_generic_unix.cpp + $$QT_ARCH_CPP/../armv6/qatomic_generic_armv6.cpp diff --git a/src/corelib/arch/symbian/qatomic_symbian.cpp b/src/corelib/arch/symbian/qatomic_symbian.cpp index 8f02155..2ab5ae9 100644 --- a/src/corelib/arch/symbian/qatomic_symbian.cpp +++ b/src/corelib/arch/symbian/qatomic_symbian.cpp @@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE // This way we can report on heap cells and handles that are really not owned by anything which still exists. // This information can be used to detect whether memory leaks are happening, particularly if these numbers grow as the app is used more. // This code is placed here as it happens to make it the very last static to be destroyed in a Qt app. The -// reason assumed is that this file appears before any other file declaring static data in the generated +// reason assumed is that this file appears before any other file declaring static data in the generated // Symbian MMP file. This particular file was chosen as it is the earliest symbian specific file. struct QSymbianPrintExitInfo { @@ -77,37 +77,95 @@ struct QSymbianPrintExitInfo TInt initThreadHandleCount; } symbian_printExitInfo; -QT_END_NAMESPACE +//For ARMv6, the generic atomics are machine coded +#ifndef QT_HAVE_ARMV6 +class QCriticalSection +{ +public: + QCriticalSection() { fastlock.CreateLocal(); } + ~QCriticalSection() { fastlock.Close(); } + void lock() { fastlock.Wait(); } + void unlock() { fastlock.Signal(); } -#if defined(Q_CC_RVCT) +private: + RFastLock fastlock; +}; -#include "../arm/qatomic_arm.cpp" +QCriticalSection qAtomicCriticalSection; -QT_BEGIN_NAMESPACE +Q_CORE_EXPORT +bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue) +{ + bool returnValue = false; + qAtomicCriticalSection.lock(); + if (*_q_value == expectedValue) { + *_q_value = newValue; + returnValue = true; + } + qAtomicCriticalSection.unlock(); + return returnValue; +} -Q_CORE_EXPORT __asm char q_atomic_swp(volatile char *ptr, char newval) +Q_CORE_EXPORT +int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue) { - add r2, pc, #0 - bx r2 - arm - swpb r2,r1,[r0] - mov r0, r2 - bx lr - thumb + int returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value = newValue; + qAtomicCriticalSection.unlock(); + return returnValue; } -Q_CORE_EXPORT __asm int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +Q_CORE_EXPORT +int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd) { - add r2, pc, #0 - bx r2 - arm - swp r2,r1,[r0] - mov r0, r2 - bx lr - thumb + int returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value += valueToAdd; + qAtomicCriticalSection.unlock(); + return returnValue; } -QT_END_NAMESPACE +Q_CORE_EXPORT +bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value, + void *expectedValue, + void *newValue) +{ + bool returnValue = false; + qAtomicCriticalSection.lock(); + if (*_q_value == expectedValue) { + *_q_value = newValue; + returnValue = true; + } + qAtomicCriticalSection.unlock(); + return returnValue; +} -#endif // Q_CC_RVCT +Q_CORE_EXPORT +void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue) +{ + void *returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value = newValue; + qAtomicCriticalSection.unlock(); + return returnValue; +} + +Q_CORE_EXPORT +void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd) +{ + void *returnValue; + qAtomicCriticalSection.lock(); + returnValue = *_q_value; + *_q_value = reinterpret_cast(returnValue) + valueToAdd; + qAtomicCriticalSection.unlock(); + return returnValue; +} + +#endif // QT_HAVE_ARMV6 + +QT_END_NAMESPACE diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h index d113e02..9558256 100644 --- a/src/corelib/global/qglobal.h +++ b/src/corelib/global/qglobal.h @@ -437,13 +437,18 @@ namespace QT_NAMESPACE {} #elif defined(__GCCE__) # define Q_CC_GCCE # define QT_VISIBILITY_AVAILABLE +# if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) +# define QT_HAVE_ARMV6 +# endif /* ARM Realview Compiler Suite RVCT compiler also defines __EDG__ and __GNUC__ (if --gnu flag is given), so check for it before that */ #elif defined(__ARMCC__) || defined(__CC_ARM) # define Q_CC_RVCT - +# if __TARGET_ARCH_ARM >= 6 +# define QT_HAVE_ARMV6 +# endif #elif defined(__GNUC__) # define Q_CC_GNU # define Q_C_CALLBACKS diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri index c35c33a..628a109 100644 --- a/src/gui/painting/painting.pri +++ b/src/gui/painting/painting.pri @@ -370,7 +370,6 @@ symbian { SOURCES += painting/qwindowsurface_s60.cpp armccIfdefBlock = \ "$${LITERAL_HASH}if defined(ARMV6)" \ - "MACRO QT_HAVE_ARMV6" \ "SOURCEPATH painting" \ "SOURCE qblendfunctions_armv6_rvct.s" \ "SOURCE qdrawhelper_armv6_rvct.s" \ diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index faf8b1e..17693ea 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -13,7 +13,7 @@ EXPORTS _Z11qt_int_sqrtj @ 12 NONAME _Z12noforcepointR11QTextStream @ 13 NONAME _Z12qSharedBuildv @ 14 NONAME - _Z12q_atomic_swpPVcc @ 15 NONAME + _Z12q_atomic_swpPVcc @ 15 NONAME ABSENT _Z12qt_s60GetRFsv @ 16 NONAME _Z13lowercasebaseR11QTextStream @ 17 NONAME _Z13qErrnoWarningPKcz @ 18 NONAME @@ -24,7 +24,7 @@ EXPORTS _Z15lowercasedigitsR11QTextStream @ 23 NONAME _Z15qAddPostRoutinePFvvE @ 24 NONAME _Z15qInitResourceIOv @ 25 NONAME - _Z15qt_atomic_yieldPi @ 26 NONAME + _Z15qt_atomic_yieldPi @ 26 NONAME ABSENT _Z15qt_error_stringi @ 27 NONAME _Z15uppercasedigitsR11QTextStream @ 28 NONAME _Z16qt_QString2HBufCRK7QString @ 29 NONAME @@ -706,7 +706,7 @@ EXPORTS _ZN15QAnimationGroupD0Ev @ 705 NONAME _ZN15QAnimationGroupD1Ev @ 706 NONAME _ZN15QAnimationGroupD2Ev @ 707 NONAME - _ZN15QBasicAtomicInt20fetchAndStoreOrderedEi @ 708 NONAME + _ZN15QBasicAtomicInt20fetchAndStoreOrderedEi @ 708 NONAME ABSENT _ZN15QDateTimeParser11parseFormatERK7QString @ 709 NONAME _ZN15QLinkedListData11shared_nullE @ 710 NONAME DATA 20 _ZN15QObjectUserDataD0Ev @ 711 NONAME @@ -3566,7 +3566,7 @@ EXPORTS inflateSync @ 3565 NONAME inflateSyncPoint @ 3566 NONAME qMetaTypeGuiHelper @ 3567 NONAME DATA 4 - q_atomic_lock @ 3568 NONAME DATA 1 + q_atomic_lock @ 3568 NONAME DATA 1 ABSENT qt_addObject @ 3569 NONAME qt_global_mutexpool @ 3570 NONAME DATA 4 qt_locale_initialized @ 3571 NONAME DATA 1 -- cgit v0.12 From 99c42254480fb147b0aaa01458300bae4472e3d8 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Fri, 6 Nov 2009 13:44:04 +0100 Subject: Fix functions that return whether atomics are natives following review comments Reviewed-By: Brad --- src/corelib/arch/qatomic_symbian.h | 31 ++++++-------- src/corelib/arch/symbian/qatomic_symbian.cpp | 63 ++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 18 deletions(-) diff --git a/src/corelib/arch/qatomic_symbian.h b/src/corelib/arch/qatomic_symbian.h index 571f628..92f6ef9 100644 --- a/src/corelib/arch/qatomic_symbian.h +++ b/src/corelib/arch/qatomic_symbian.h @@ -51,57 +51,52 @@ QT_BEGIN_NAMESPACE QT_MODULE(Core) -#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE +#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isReferenceCountingNative() -{ return false; } inline bool QBasicAtomicInt::isReferenceCountingWaitFree() { return false; } -#define Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE +#define Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isTestAndSetNative() -{ return false; } inline bool QBasicAtomicInt::isTestAndSetWaitFree() { return false; } -#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE +#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isFetchAndStoreNative() -{ return false; } inline bool QBasicAtomicInt::isFetchAndStoreWaitFree() { return false; } -#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE +#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE -inline bool QBasicAtomicInt::isFetchAndAddNative() -{ return false; } inline bool QBasicAtomicInt::isFetchAndAddWaitFree() { return false; } -#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_NOT_NATIVE +#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_SOMETIMES_NATIVE +Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative(); template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetNative() -{ return false; } +{ return QBasicAtomicPointer_isTestAndSetNative(); } template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isTestAndSetWaitFree() { return false; } -#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_NOT_NATIVE +#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_SOMETIMES_NATIVE +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative(); template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreNative() -{ return false; } +{ return QBasicAtomicPointer_isFetchAndStoreNative(); } template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndStoreWaitFree() { return false; } -#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_NOT_NATIVE +#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_SOMETIMES_NATIVE +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative(); template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddNative() -{ return false; } +{ return QBasicAtomicPointer_isFetchAndAddNative(); } template Q_INLINE_TEMPLATE bool QBasicAtomicPointer::isFetchAndAddWaitFree() { return false; } diff --git a/src/corelib/arch/symbian/qatomic_symbian.cpp b/src/corelib/arch/symbian/qatomic_symbian.cpp index 2ab5ae9..91b49c7 100644 --- a/src/corelib/arch/symbian/qatomic_symbian.cpp +++ b/src/corelib/arch/symbian/qatomic_symbian.cpp @@ -77,6 +77,69 @@ struct QSymbianPrintExitInfo TInt initThreadHandleCount; } symbian_printExitInfo; +Q_CORE_EXPORT bool QBasicAtomicInt::isReferenceCountingNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicInt::isTestAndSetNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndStoreNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndAddNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + +Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative() +{ +#ifdef QT_HAVE_ARMV6 + return true; +#else + return false; +#endif +} + //For ARMv6, the generic atomics are machine coded #ifndef QT_HAVE_ARMV6 -- cgit v0.12 From 0a07ca79318ba1b735ce0b3a208e471e4a24e1f2 Mon Sep 17 00:00:00 2001 From: Shane Kearns Date: Thu, 12 Nov 2009 19:21:25 +0100 Subject: Fix corelib def files for the new atomics implementation 4.6.0 has the wrong atomics implementation for symbian, as the team branch was not merged before the freeze. This updates the def files to match the implementation on the team branch so that it can be cherry-picked. Task-number: QTBUG-5752 Reviewed-by: Iain --- src/s60installs/bwins/QtCoreu.def | 3 +++ src/s60installs/eabi/QtCoreu.def | 7 +++++++ 2 files changed, 10 insertions(+) diff --git a/src/s60installs/bwins/QtCoreu.def b/src/s60installs/bwins/QtCoreu.def index 146d47e..1218b75 100644 --- a/src/s60installs/bwins/QtCoreu.def +++ b/src/s60installs/bwins/QtCoreu.def @@ -4384,4 +4384,7 @@ EXPORTS ?staticMetaObject@QAbstractTableModel@@2UQMetaObject@@B @ 4383 NONAME ; struct QMetaObject const QAbstractTableModel::staticMetaObject ?staticMetaObject@QFile@@2UQMetaObject@@B @ 4384 NONAME ; struct QMetaObject const QFile::staticMetaObject ?staticMetaObject@QHistoryState@@2UQMetaObject@@B @ 4385 NONAME ; struct QMetaObject const QHistoryState::staticMetaObject + ?QBasicAtomicPointer_isFetchAndAddNative@@YA_NXZ @ 4386 NONAME ; bool QBasicAtomicPointer_isFetchAndAddNative(void) + ?QBasicAtomicPointer_isFetchAndStoreNative@@YA_NXZ @ 4387 NONAME ; bool QBasicAtomicPointer_isFetchAndStoreNative(void) + ?QBasicAtomicPointer_isTestAndSetNative@@YA_NXZ @ 4388 NONAME ; bool QBasicAtomicPointer_isTestAndSetNative(void) diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def index 17693ea..99be68e 100644 --- a/src/s60installs/eabi/QtCoreu.def +++ b/src/s60installs/eabi/QtCoreu.def @@ -3612,4 +3612,11 @@ EXPORTS _ZNK13QStateMachine10isAnimatedEv @ 3611 NONAME _ZNK18QAbstractAnimation15currentLoopTimeEv @ 3612 NONAME _ZNK7QRegExp12captureCountEv @ 3613 NONAME + _Z38QBasicAtomicPointer_isTestAndSetNativev @ 3614 NONAME + _Z39QBasicAtomicPointer_isFetchAndAddNativev @ 3615 NONAME + _Z41QBasicAtomicPointer_isFetchAndStoreNativev @ 3616 NONAME + _ZN15QBasicAtomicInt18isTestAndSetNativeEv @ 3617 NONAME + _ZN15QBasicAtomicInt19isFetchAndAddNativeEv @ 3618 NONAME + _ZN15QBasicAtomicInt21isFetchAndStoreNativeEv @ 3619 NONAME + _ZN15QBasicAtomicInt25isReferenceCountingNativeEv @ 3620 NONAME -- cgit v0.12 From ee8e0fc9f32a84bd1e1673c9756044d62ecaebf5 Mon Sep 17 00:00:00 2001 From: Miikka Heikkinen Date: Fri, 13 Nov 2009 13:19:56 +0200 Subject: Fixed maximized dialogs losing maximized status on orientation switch If maximized dialog had minimum size that didn't fully fit to the screen, it lost its maximized status when orientation was switched, because of the logic that assumed that if a window is resized, it must no longer be maximized. Skipped this assumption for cases where resize occurs because enforcement of the minimum size of the window. Task-number: QTBUG-4671 Reviewed-by: Janne Anttila Reviewed-by: Sami Merila --- src/gui/kernel/qwidget_s60.cpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp index 504a538..1acdfda 100644 --- a/src/gui/kernel/qwidget_s60.cpp +++ b/src/gui/kernel/qwidget_s60.cpp @@ -213,6 +213,15 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove) if ((q->windowType() == Qt::Desktop)) return; + + QPoint oldPos(q->pos()); + QSize oldSize(q->size()); + QRect oldGeom(data.crect); + + // Lose maximized status if deliberate resize + if (w != oldSize.width() || h != oldSize.height()) + data.window_state &= ~Qt::WindowMaximized; + if (extra) { // any size restrictions? w = qMin(w,extra->maxw); h = qMin(h,extra->maxh); @@ -228,17 +237,10 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove) data.window_state = s; } - QPoint oldPos(q->pos()); - QSize oldSize(q->size()); - QRect oldGeom(data.crect); - bool isResize = w != oldSize.width() || h != oldSize.height(); if (!isMove && !isResize) return; - if (isResize) - data.window_state &= ~Qt::WindowMaximized; - if (q->isWindow()) { if (w == 0 || h == 0) { q->setAttribute(Qt::WA_OutsideWSRange, true); -- cgit v0.12 From aa784453478ebff299a27eec1683001d2e5084bc Mon Sep 17 00:00:00 2001 From: Olivier Goffart Date: Fri, 13 Nov 2009 13:22:41 +0100 Subject: Fix QAbstractSlider test Commit 46a3e518b3070c changed the behaviour of a wheel event of a different orientation. It works now no matter where the event was. Reviewed-by: Denis Reviewed-by: Thierry --- tests/auto/qabstractslider/tst_qabstractslider.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/auto/qabstractslider/tst_qabstractslider.cpp b/tests/auto/qabstractslider/tst_qabstractslider.cpp index d9574df..ee1ba19 100644 --- a/tests/auto/qabstractslider/tst_qabstractslider.cpp +++ b/tests/auto/qabstractslider/tst_qabstractslider.cpp @@ -742,11 +742,9 @@ void tst_QAbstractSlider::wheelEvent_data() << 1 // delta << int(Qt::Horizontal) // orientation of slider << int(Qt::Vertical) // orientation of wheel - << 0 // expected position after + << 1 // expected position after << QPoint(1,1); - // Scrolling in a slider of a different orientation than the wheel works - // if the mouse pointer is within the widget's rect QTest::newRow("Different orientation2")<< 0 // initial position << 0 // minimum << 100 // maximum -- cgit v0.12 From 0f236d91fbca19838a71df025446725fea2ca87a Mon Sep 17 00:00:00 2001 From: Jason McDonald Date: Fri, 13 Nov 2009 22:53:32 +1000 Subject: Fix broken merge of changes file. Reviewed-by: Trust Me --- dist/changes-4.6.0 | 4 ---- 1 file changed, 4 deletions(-) diff --git a/dist/changes-4.6.0 b/dist/changes-4.6.0 index 7c97aa5..eaacdae 100644 --- a/dist/changes-4.6.0 +++ b/dist/changes-4.6.0 @@ -15,10 +15,6 @@ Qt Bug Tracker: http://bugreports.qt.nokia.com Task Tracker: http://qt.nokia.com/developer/task-tracker Merge Request: http://qt.gitorious.org -QTBUG-1234 - Qt Bug Tracker: http://bugreports.qt.nokia.com -MR#1234 - Merge Request: http://qt.gitorious.org -123456 - Task Tracker: http://qt.nokia.com/developer/task-tracker - **************************************************************************** * General * **************************************************************************** -- cgit v0.12 From aff0df17051c4f251c86bc4d7929930e39514742 Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Fri, 13 Nov 2009 13:22:41 +0100 Subject: Fixed stroking of discontinuous paths with the GL2 engine. Since the stroke is rendered as a triangle strip, zero area triangles must be inserted in order to have gaps in the stroke. This is achieved by duplicating vertices before and after each gap. It was already done for open subpaths. This commit fixes gaps between closed subpaths. Task-number: QTBUG-5736 Reviewed-by: Gunnar --- src/opengl/gl2paintengineex/qtriangulatingstroker.cpp | 3 +++ src/opengl/gl2paintengineex/qtriangulatingstroker_p.h | 4 ---- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp index 1163eba..206104f 100644 --- a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp +++ b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp @@ -61,6 +61,9 @@ void QTriangulatingStroker::endCapOrJoinClosed(const qreal *start, const qreal * } else { endCap(cur); } + int count = m_vertices.size(); + m_vertices.add(m_vertices.at(count-2)); + m_vertices.add(m_vertices.at(count-1)); } diff --git a/src/opengl/gl2paintengineex/qtriangulatingstroker_p.h b/src/opengl/gl2paintengineex/qtriangulatingstroker_p.h index defa3f1..a0117d5 100644 --- a/src/opengl/gl2paintengineex/qtriangulatingstroker_p.h +++ b/src/opengl/gl2paintengineex/qtriangulatingstroker_p.h @@ -188,10 +188,6 @@ inline void QTriangulatingStroker::endCap(const qreal *pts) break; default: break; // to shut gcc up... } - - int count = m_vertices.size(); - m_vertices.add(m_vertices.at(count-2)); - m_vertices.add(m_vertices.at(count-1)); } -- cgit v0.12 From d324a151a45fa30ff3cb139ce009a1ba20122c7e Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Fri, 13 Nov 2009 14:00:12 +0100 Subject: Fixing and adding autotests for QTreeWidget Reviewed-By: ogoffart --- tests/auto/qtreewidget/tst_qtreewidget.cpp | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/tests/auto/qtreewidget/tst_qtreewidget.cpp b/tests/auto/qtreewidget/tst_qtreewidget.cpp index 6defd7b..621072c 100644 --- a/tests/auto/qtreewidget/tst_qtreewidget.cpp +++ b/tests/auto/qtreewidget/tst_qtreewidget.cpp @@ -167,6 +167,7 @@ private slots: void setCurrentItemExpandsParent(); void task239150_editorWidth(); void setTextUpdate(); + void taskQTBUG2844_visualItemRect(); public slots: void itemSelectionChanged(); @@ -601,9 +602,9 @@ void tst_QTreeWidget::setItemHidden() testWidget->scrollToItem(child); QVERIFY(testWidget->visualItemRect(parent).isValid() - && testWidget->viewport()->rect().contains(testWidget->visualItemRect(parent))); + && testWidget->viewport()->rect().intersects(testWidget->visualItemRect(parent))); QVERIFY(testWidget->visualItemRect(child).isValid() - && testWidget->viewport()->rect().contains(testWidget->visualItemRect(child))); + && testWidget->viewport()->rect().intersects(testWidget->visualItemRect(child))); QVERIFY(!testWidget->isItemHidden(parent)); QVERIFY(!testWidget->isItemHidden(child)); @@ -611,9 +612,9 @@ void tst_QTreeWidget::setItemHidden() testWidget->setItemHidden(parent, true); QVERIFY(!(testWidget->visualItemRect(parent).isValid() - && testWidget->viewport()->rect().contains(testWidget->visualItemRect(parent)))); + && testWidget->viewport()->rect().intersects(testWidget->visualItemRect(parent)))); QVERIFY(!(testWidget->visualItemRect(child).isValid() - && testWidget->viewport()->rect().contains(testWidget->visualItemRect(child)))); + && testWidget->viewport()->rect().intersects(testWidget->visualItemRect(child)))); QVERIFY(testWidget->isItemHidden(parent)); QVERIFY(!testWidget->isItemHidden(child)); @@ -3271,6 +3272,25 @@ void tst_QTreeWidget::setTextUpdate() QTRY_VERIFY(delegate.numPaints > 0); } +void tst_QTreeWidget::taskQTBUG2844_visualItemRect() +{ + CustomTreeWidget tree; + tree.resize(150, 100); + tree.setColumnCount(3); + QTreeWidgetItem item(&tree); + + QRect itemRect = tree.visualItemRect(&item); + + QRect rectCol0 = tree.visualRect(tree.indexFromItem(&item, 0)); + QRect rectCol1 = tree.visualRect(tree.indexFromItem(&item, 1)); + QRect rectCol2 = tree.visualRect(tree.indexFromItem(&item, 2)); + + QCOMPARE(tree.visualItemRect(&item), rectCol0 | rectCol2); + tree.setColumnHidden(2, true); + QCOMPARE(tree.visualItemRect(&item), rectCol0 | rectCol1); +} + + QTEST_MAIN(tst_QTreeWidget) -- cgit v0.12 From d0edd9b3d6ee5dba8e9a23d0fb9aaab74924d2ad Mon Sep 17 00:00:00 2001 From: Tom Cooksey Date: Wed, 11 Nov 2009 12:25:56 +0100 Subject: Add mkspec for Maemo 5 & 6 Reviewed-By: Robert Griebl Reviewed-By: Thiago Macieira --- mkspecs/linux-g++-maemo/qmake.conf | 28 ++++++++++++++++++++++ mkspecs/linux-g++-maemo/qplatformdefs.h | 42 +++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+) create mode 100644 mkspecs/linux-g++-maemo/qmake.conf create mode 100644 mkspecs/linux-g++-maemo/qplatformdefs.h diff --git a/mkspecs/linux-g++-maemo/qmake.conf b/mkspecs/linux-g++-maemo/qmake.conf new file mode 100644 index 0000000..067d857 --- /dev/null +++ b/mkspecs/linux-g++-maemo/qmake.conf @@ -0,0 +1,28 @@ +# +# qmake configuration for Maemo 5 & 6 +# + +MAKEFILE_GENERATOR = UNIX +TEMPLATE = app +CONFIG += qt warn_on release incremental link_prl +QT += core gui +QMAKE_INCREMENTAL_STYLE = sublib + +include(../common/g++.conf) +include(../common/linux.conf) + +# Work round scratchbox not having standard paths in it's default search path +QMAKE_LFLAGS += -Wl,-rpath-link=/lib +QMAKE_LFLAGS += -Wl,-rpath-link=/usr/lib + +# Override the default lib/include directories for scratchbox: +QMAKE_INCDIR_X11 = /usr/include/X11 +QMAKE_INCDIR_OPENGL = /usr/include +QMAKE_LIBDIR_X11 = /usr/lib +QMAKE_LIBDIR_OPENGL = /usr/lib + +# Work round PowerVR SGX 1.3 driver bug with glScissor & FBOs: +DEFINES += QT_GL_NO_SCISSOR_TEST + + +load(qt_config) diff --git a/mkspecs/linux-g++-maemo/qplatformdefs.h b/mkspecs/linux-g++-maemo/qplatformdefs.h new file mode 100644 index 0000000..857eaf3 --- /dev/null +++ b/mkspecs/linux-g++-maemo/qplatformdefs.h @@ -0,0 +1,42 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qmake spec 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 "../linux-g++/qplatformdefs.h" -- cgit v0.12 From c95acfda6aae0dcf4285bb759a271598bb2dccea Mon Sep 17 00:00:00 2001 From: Tom Cooksey Date: Wed, 11 Nov 2009 12:32:04 +0100 Subject: Generate debug symbols in release mode on Maemo Reviewed-By: Stefano Pironato --- mkspecs/linux-g++-maemo/qmake.conf | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/mkspecs/linux-g++-maemo/qmake.conf b/mkspecs/linux-g++-maemo/qmake.conf index 067d857..2195329 100644 --- a/mkspecs/linux-g++-maemo/qmake.conf +++ b/mkspecs/linux-g++-maemo/qmake.conf @@ -21,6 +21,10 @@ QMAKE_INCDIR_OPENGL = /usr/include QMAKE_LIBDIR_X11 = /usr/lib QMAKE_LIBDIR_OPENGL = /usr/lib +# We still need to generate debug symbols in release mode to put into the *-dbg packages: +QMAKE_CFLAGS_RELEASE += -g +QMAKE_CXXFLAGS_RELEASE += -g + # Work round PowerVR SGX 1.3 driver bug with glScissor & FBOs: DEFINES += QT_GL_NO_SCISSOR_TEST -- cgit v0.12 From c9211c691b370332b9165a9d80f03220789c1d53 Mon Sep 17 00:00:00 2001 From: Tom Cooksey Date: Wed, 11 Nov 2009 13:43:55 +0100 Subject: Disable optimisations which break stack traces on Maemo The -O2 mode enables omit-frame-pointer & optimize-sibling-calls, which can break stack traces. So, even in release mode, disable these optimisations so that we can at least still get a backtrace when a Qt application dies. Reviewed-By: Stefano Pironato --- mkspecs/linux-g++-maemo/qmake.conf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mkspecs/linux-g++-maemo/qmake.conf b/mkspecs/linux-g++-maemo/qmake.conf index 2195329..c39ba2c 100644 --- a/mkspecs/linux-g++-maemo/qmake.conf +++ b/mkspecs/linux-g++-maemo/qmake.conf @@ -22,8 +22,8 @@ QMAKE_LIBDIR_X11 = /usr/lib QMAKE_LIBDIR_OPENGL = /usr/lib # We still need to generate debug symbols in release mode to put into the *-dbg packages: -QMAKE_CFLAGS_RELEASE += -g -QMAKE_CXXFLAGS_RELEASE += -g +QMAKE_CFLAGS_RELEASE += -g -fno-omit-frame-pointer -fno-optimize-sibling-calls +QMAKE_CXXFLAGS_RELEASE += -g -fno-omit-frame-pointer -fno-optimize-sibling-calls # Work round PowerVR SGX 1.3 driver bug with glScissor & FBOs: DEFINES += QT_GL_NO_SCISSOR_TEST -- cgit v0.12 From 0c6255485dd2c59bfbb307583f2efe4dec8605cf Mon Sep 17 00:00:00 2001 From: ninerider Date: Fri, 13 Nov 2009 14:32:24 +0100 Subject: Cursor motion related tests disabled for windows ce. When calling cursor function, Windows CE responds with: This function is not supported on this system. Reviewed-by: Joerg --- tests/auto/qcombobox/tst_qcombobox.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/auto/qcombobox/tst_qcombobox.cpp b/tests/auto/qcombobox/tst_qcombobox.cpp index cc59b62..e903ab5 100644 --- a/tests/auto/qcombobox/tst_qcombobox.cpp +++ b/tests/auto/qcombobox/tst_qcombobox.cpp @@ -2479,6 +2479,10 @@ void tst_QComboBox::keyBoardNavigationWithMouse() QCOMPARE(combo.currentText(), QLatin1String("0")); +#ifdef Q_OS_WINCE + QSKIP("When calling cursor function, Windows CE responds with: This function is not supported on this system.", SkipAll); +#endif + QCursor::setPos(combo.view()->mapToGlobal(combo.view()->rect().center())); QTest::qWait(200); -- cgit v0.12 From 520ef13479e42b3eb1af96104fdad831905c53c2 Mon Sep 17 00:00:00 2001 From: ninerider Date: Fri, 13 Nov 2009 14:35:34 +0100 Subject: ChangeWindowTitle skipped for Windows CE Test fails on Windows CE due to QWorkspace state handling. As this class is obsolete, skipping this test resonable. The problem is added to the watch list for Windows CE in case it reappears. Reviewed-by: Joerg --- tests/auto/qworkspace/tst_qworkspace.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/auto/qworkspace/tst_qworkspace.cpp b/tests/auto/qworkspace/tst_qworkspace.cpp index c1fe3e0..35f8a4d 100644 --- a/tests/auto/qworkspace/tst_qworkspace.cpp +++ b/tests/auto/qworkspace/tst_qworkspace.cpp @@ -426,6 +426,9 @@ void tst_QWorkspace::showWindows() void tst_QWorkspace::changeWindowTitle() { +#ifdef Q_OS_WINCE + QSKIP( "Test fails on Windows CE due to QWorkspace state handling", SkipAll); +#endif const QString mwc( "MainWindow's Caption" ); const QString mwc2( "MainWindow's New Caption" ); const QString wc( "Widget's Caption" ); -- cgit v0.12 From aefd76b0052cd36ed7f890dd4b91f38873bec251 Mon Sep 17 00:00:00 2001 From: Olivier Goffart Date: Fri, 13 Nov 2009 15:00:25 +0100 Subject: QItemSelectionModel: fixed selection not kept when layout change and everything is selected The arbitrary number in commit 8a7700ffb5e4959e78 was not big enough. People still complains Task-number: QTBUG-5671 Reviewed-by: Thierry --- src/gui/itemviews/qitemselectionmodel.cpp | 5 +- .../tst_qitemselectionmodel.cpp | 65 ++++++++++++++++++++-- 2 files changed, 62 insertions(+), 8 deletions(-) diff --git a/src/gui/itemviews/qitemselectionmodel.cpp b/src/gui/itemviews/qitemselectionmodel.cpp index c6e02a6..2e4a602 100644 --- a/src/gui/itemviews/qitemselectionmodel.cpp +++ b/src/gui/itemviews/qitemselectionmodel.cpp @@ -730,13 +730,14 @@ void QItemSelectionModelPrivate::_q_layoutAboutToBeChanged() savedPersistentIndexes.clear(); savedPersistentCurrentIndexes.clear(); - // special case for when all indexes are selected + // optimisation for when all indexes are selected + // (only if there is lots of items (1000) because this is not entirely correct) if (ranges.isEmpty() && currentSelection.count() == 1) { QItemSelectionRange range = currentSelection.first(); QModelIndex parent = range.parent(); tableRowCount = model->rowCount(parent); tableColCount = model->columnCount(parent); - if (tableRowCount * tableColCount > 100 + if (tableRowCount * tableColCount > 1000 && range.top() == 0 && range.left() == 0 && range.bottom() == tableRowCount - 1 diff --git a/tests/auto/qitemselectionmodel/tst_qitemselectionmodel.cpp b/tests/auto/qitemselectionmodel/tst_qitemselectionmodel.cpp index 77c259c..269afbd 100644 --- a/tests/auto/qitemselectionmodel/tst_qitemselectionmodel.cpp +++ b/tests/auto/qitemselectionmodel/tst_qitemselectionmodel.cpp @@ -92,6 +92,7 @@ private slots: void task252069_rowIntersectsSelection(); void task232634_childrenDeselectionSignal(); void task260134_layoutChangedWithAllSelected(); + void QTBUG5671_layoutChangedWithAllSelected(); private: QAbstractItemModel *model; @@ -2025,24 +2026,24 @@ void tst_QItemSelectionModel::task220420_selectedIndexes() class QtTestTableModel: public QAbstractTableModel { Q_OBJECT - + public: QtTestTableModel(int rows = 0, int columns = 0, QObject *parent = 0) : QAbstractTableModel(parent), row_count(rows), column_count(columns) {} - + int rowCount(const QModelIndex& = QModelIndex()) const { return row_count; } int columnCount(const QModelIndex& = QModelIndex()) const { return column_count; } bool isEditable(const QModelIndex &) const { return true; } - + QVariant data(const QModelIndex &idx, int role) const { if (role == Qt::DisplayRole || role == Qt::EditRole) return QString("[%1,%2]").arg(idx.row()).arg(idx.column()); return QVariant(); } - + int row_count; int column_count; friend class tst_QItemSelectionModel; @@ -2055,7 +2056,7 @@ void tst_QItemSelectionModel::task240734_layoutChanged() QItemSelectionModel selectionModel(&model); selectionModel.select(model.index(0,0), QItemSelectionModel::Select); QCOMPARE(selectionModel.selectedIndexes().count() , 1); - + emit model.layoutAboutToBeChanged(); model.row_count = 5; emit model.layoutChanged(); @@ -2107,7 +2108,7 @@ void tst_QItemSelectionModel::merge_data() << QItemSelection(model->index(2, 2) , model->index(3, 4)) << int(QItemSelectionModel::Deselect) << QItemSelection(model->index(2, 1) , model->index(3, 1)); - + QItemSelection r1(model->index(2, 1) , model->index(3, 1)); r1.select(model->index(2, 4) , model->index(3, 4)); QTest::newRow("Toggle") @@ -2274,5 +2275,57 @@ void tst_QItemSelectionModel::task260134_layoutChangedWithAllSelected() } +void tst_QItemSelectionModel::QTBUG5671_layoutChangedWithAllSelected() +{ + struct MyFilterModel : public QSortFilterProxyModel + { // Override sort filter proxy to remove even numbered rows. + bool filtering; + virtual bool filterAcceptsRow( int source_row, const QModelIndex& source_parent ) const + { + return !filtering || !( source_row & 1 ); + } + }; + + //same as task260134_layoutChangedWithAllSelected but with a sightly bigger model + + enum { cNumRows=30, cNumCols=20 }; + + QStandardItemModel model(cNumRows, cNumCols); + MyFilterModel proxy; + proxy.filtering = true; + proxy.setSourceModel(&model); + QItemSelectionModel selection(&proxy); + + // Populate the tree view. + for (unsigned int i = 0; i < cNumCols; i++) + model.setHeaderData( i, Qt::Horizontal, QString::fromLatin1("Column %1").arg(i)); + + for (unsigned int r = 0; r < cNumRows; r++) { + for (unsigned int c = 0; c < cNumCols; c++) { + model.setData(model.index(r, c, QModelIndex()), + QString::fromLatin1("r:%1/c:%2").arg(r, c)); + } + } + + + QCOMPARE(model.rowCount(), int(cNumRows)); + QCOMPARE(proxy.rowCount(), int(cNumRows/2)); + + selection.select( QItemSelection(proxy.index(0,0), proxy.index(proxy.rowCount() - 1, proxy.columnCount() - 1)), QItemSelectionModel::Select); + + QList indexList; + foreach(const QModelIndex &id, selection.selectedIndexes()) + indexList << id; + + proxy.filtering = false; + proxy.invalidate(); + QCOMPARE(proxy.rowCount(), int(cNumRows)); + + //let's check the selection hasn't changed + QCOMPARE(selection.selectedIndexes().count(), indexList.count()); + foreach(QPersistentModelIndex index, indexList) + QVERIFY(selection.isSelected(index)); +} + QTEST_MAIN(tst_QItemSelectionModel) #include "tst_qitemselectionmodel.moc" -- cgit v0.12 From 3a48a44f39a39126a9065f9b349b8906662f07b6 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Fri, 13 Nov 2009 16:16:05 +0100 Subject: Fixed dockwidget autotest on X11 --- tests/auto/qdockwidget/tst_qdockwidget.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/auto/qdockwidget/tst_qdockwidget.cpp b/tests/auto/qdockwidget/tst_qdockwidget.cpp index c9a7f1c..8f72e39 100644 --- a/tests/auto/qdockwidget/tst_qdockwidget.cpp +++ b/tests/auto/qdockwidget/tst_qdockwidget.cpp @@ -50,6 +50,7 @@ #include #include #include +#include "private/qdockwidget_p.h" bool hasFeature(QDockWidget *dockwidget, QDockWidget::DockWidgetFeature feature) { return (dockwidget->features() & feature) == feature; } @@ -865,7 +866,9 @@ void tst_QDockWidget::taskQTBUG_1665_closableChanged() dock.show(); QTest::qWaitForWindowShown(&dock); - if (dock.windowFlags() & Qt::FramelessWindowHint) + QDockWidgetLayout *l = qobject_cast(dock.layout()); + + if (l && !l->nativeWindowDeco()) QSKIP("this machine doesn't support native dock widget", SkipAll); QVERIFY(dock.windowFlags() & Qt::WindowCloseButtonHint); -- cgit v0.12 From 099d6efe275511f18b0bc0002ac8cedd193139cd Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Fri, 13 Nov 2009 17:00:45 +0100 Subject: Fixed stroking of cosmetic dashed pens with the GL2 paint engine. Also fixed square caps which in some cases were extruded in the wrong direction. Task-number: QTBUG-5736 Reviewed-by: Trond --- src/opengl/gl2paintengineex/qtriangulatingstroker.cpp | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp index 206104f..1478b09 100644 --- a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp +++ b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp @@ -147,7 +147,6 @@ void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen) bool endsAtStart = startPts[0] == *(endPts-2) && startPts[1] == *(endPts-1); - Qt::PenCapStyle cap = m_cap_style; if (endsAtStart || path.hasImplicitClose()) m_cap_style = Qt::FlatCap; moveTo(pts); @@ -169,7 +168,7 @@ void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen) switch (*types) { case QPainterPath::MoveToElement: { if (pts != path.points()) - endCapOrJoinClosed(startPts, pts, path.hasImplicitClose(), endsAtStart); + endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); startPts = pts; int end = (endPts - pts) / 2; @@ -247,8 +246,6 @@ void QTriangulatingStroker::cubicTo(const qreal *pts) m_nvy = vy; } - - static void qdashprocessor_moveTo(qreal x, qreal y, void *data) { ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::MoveToElement, x, y); @@ -282,12 +279,12 @@ void QDashedStrokeProcessor::process(const QVectorPath &path, const QPen &pen) m_points.reset(); m_types.reset(); - qreal width = pen.width(); + qreal width = qpen_widthf(pen); if (width == 0) width = 1; m_dash_stroker.setDashPattern(pen.dashPattern()); - m_dash_stroker.setStrokeWidth(width); + m_dash_stroker.setStrokeWidth(pen.isCosmetic() ? width * m_inv_scale : width); m_dash_stroker.setMiterLimit(pen.miterLimit()); qreal curvyness = sqrt(width) * m_inv_scale / 8; -- cgit v0.12 From cbdfc6c2f761af6248355bf9bf71ac011d48b14b Mon Sep 17 00:00:00 2001 From: Thiago Macieira Date: Fri, 13 Nov 2009 17:09:06 +0100 Subject: Fix Qt file header, as spotted by tst_headers. Reviewed-By: Trust Me --- tools/assistant/lib/qhelp_global.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/assistant/lib/qhelp_global.cpp b/tools/assistant/lib/qhelp_global.cpp index 980de27..749d2c9 100644 --- a/tools/assistant/lib/qhelp_global.cpp +++ b/tools/assistant/lib/qhelp_global.cpp @@ -4,7 +4,7 @@ ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** -** This file is part of the Qt Assistant. +** This file is part of the Qt Assistant of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage -- cgit v0.12 From 379cea3cfdccf5a880241ca707ffc37170cb3736 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Fri, 13 Nov 2009 17:44:03 +0100 Subject: Fixed a regression in mainwindow that would not restore correctly The size of the dockwidgets would be ignored. Reviewed-by: ogoffart --- src/gui/widgets/qdockarealayout.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/gui/widgets/qdockarealayout.cpp b/src/gui/widgets/qdockarealayout.cpp index 953edab..07914b2 100644 --- a/src/gui/widgets/qdockarealayout.cpp +++ b/src/gui/widgets/qdockarealayout.cpp @@ -1931,9 +1931,6 @@ bool QDockAreaLayoutInfo::restoreState(QDataStream &stream, QList item_list.append(item); } else { QDockAreaLayoutItem item(new QDockWidgetItem(widget)); - if (!testing) { - item_list.append(item); - } if (flags & StateFlagFloating) { bool drawer = false; #ifdef Q_WS_MAC // drawer support @@ -1971,11 +1968,13 @@ bool QDockAreaLayoutInfo::restoreState(QDataStream &stream, QList if (!testing) { widget->setVisible(flags & StateFlagVisible); + item_list.append(item); } } else { int dummy; stream >> item.pos >> item.size >> dummy >> dummy; if (!testing) { + item_list.append(item); widget->setFloating(false); widget->setVisible(flags & StateFlagVisible); emit widget->dockLocationChanged(toDockWidgetArea(dockPos)); -- cgit v0.12 From d7abb14d1f4b8d5cca31ff9ec004eef7bf4cb9a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan-Arve=20S=C3=A6ther?= Date: Fri, 13 Nov 2009 18:14:09 +0100 Subject: Remove warning. (Forgot to commit this together with my previous commits) --- src/gui/graphicsview/qgraphicsanchorlayout.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/graphicsview/qgraphicsanchorlayout.h b/src/gui/graphicsview/qgraphicsanchorlayout.h index 1a0c458..063639e 100644 --- a/src/gui/graphicsview/qgraphicsanchorlayout.h +++ b/src/gui/graphicsview/qgraphicsanchorlayout.h @@ -76,7 +76,7 @@ private: Q_DECLARE_PRIVATE(QGraphicsAnchor) friend class QGraphicsAnchorLayoutPrivate; - friend class AnchorData; + friend struct AnchorData; }; class Q_GUI_EXPORT QGraphicsAnchorLayout : public QGraphicsLayout -- cgit v0.12 From bb818bf70cef00bbdcafaac1bf017575baeab8dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan-Arve=20S=C3=A6ther?= Date: Fri, 13 Nov 2009 18:17:32 +0100 Subject: Make it clear that the two semi-floating widget should overflow. --- examples/graphicsview/anchorlayout/main.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/graphicsview/anchorlayout/main.cpp b/examples/graphicsview/anchorlayout/main.cpp index 3e19f18..f898d1d 100644 --- a/examples/graphicsview/anchorlayout/main.cpp +++ b/examples/graphicsview/anchorlayout/main.cpp @@ -76,8 +76,8 @@ int main(int argc, char **argv) QGraphicsProxyWidget *c = createItem(minSize, prefSize, maxSize, "C"); QGraphicsProxyWidget *d = createItem(minSize, prefSize, maxSize, "D"); QGraphicsProxyWidget *e = createItem(minSize, prefSize, maxSize, "E"); - QGraphicsProxyWidget *f = createItem(QSizeF(30, 50), QSizeF(150, 50), maxSize, "F"); - QGraphicsProxyWidget *g = createItem(QSizeF(30, 50), QSizeF(30, 100), maxSize, "G"); + QGraphicsProxyWidget *f = createItem(QSizeF(30, 50), QSizeF(150, 50), maxSize, "F (overflow)"); + QGraphicsProxyWidget *g = createItem(QSizeF(30, 50), QSizeF(30, 100), maxSize, "G (overflow)"); QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout; l->setSpacing(0); -- cgit v0.12 From 0e74cc3e1a05147a8ae9c1c4be7c9f836da1acf3 Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Mon, 16 Nov 2009 08:04:46 +1000 Subject: Make isSharing() reset to false when context no longer sharing The documentation for QGLContext::isSharing() indicates that the function returns true only when the context is sharing. However, previously the sharing flag would stay on if the context was created as sharing but is no longer sharing. Task-number: QTBUG-5578 Reviewed-by: Sarah Smith --- src/opengl/qgl.cpp | 2 +- src/opengl/qgl_p.h | 1 + tests/auto/qgl/tst_qgl.cpp | 5 +++++ 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp index 8063fc8..f8a2ea4 100644 --- a/src/opengl/qgl.cpp +++ b/src/opengl/qgl.cpp @@ -3030,7 +3030,7 @@ void QGLContext::setValid(bool valid) bool QGLContext::isSharing() const { Q_D(const QGLContext); - return d->sharing; + return d->group->isSharing(); } QGLFormat QGLContext::format() const diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h index 9a17c67..45b2942 100644 --- a/src/opengl/qgl_p.h +++ b/src/opengl/qgl_p.h @@ -233,6 +233,7 @@ public: QGLExtensionFuncs &extensionFuncs() {return m_extensionFuncs;} const QGLContext *context() const {return m_context;} + bool isSharing() const { return m_shares.size() >= 2; } void addGuard(QGLSharedResourceGuard *guard); void removeGuard(QGLSharedResourceGuard *guard); diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp index ccb08c3..5dc072d 100644 --- a/tests/auto/qgl/tst_qgl.cpp +++ b/tests/auto/qgl/tst_qgl.cpp @@ -1842,6 +1842,7 @@ void tst_QGL::shareRegister() QVERIFY(qt_shared_test()->value(glw1->context()) == res1); // Create another context that shares with the first. + QVERIFY(!glw1->isSharing()); QGLWidget *glw2 = new QGLWidget(0, glw1); if (!glw2->isSharing()) { delete glw2; @@ -1880,6 +1881,7 @@ void tst_QGL::shareRegister() // Create a third context, not sharing with the others. QGLWidget *glw3 = new QGLWidget(); + QVERIFY(!glw3->isSharing()); // Create a guard on the standalone context. QGLSharedResourceGuard guard3(glw3->context()); @@ -1928,6 +1930,9 @@ void tst_QGL::shareRegister() // Delete the first context. delete glw1; + // The second context should no longer register as sharing. + QVERIFY(!glw2->isSharing()); + // The first context's resource should transfer to the second context. QCOMPARE(tst_QGLResource::deletions, 0); QVERIFY(qt_shared_test()->value(glw2->context()) == res1); -- cgit v0.12 From b2d5f886b36b4f4d317024db7cfd6668e2895cd4 Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Mon, 16 Nov 2009 08:38:59 +1000 Subject: Make pbuffers example compile under OpenGL/ES 1.1 Reviewed-by: Sarah Smith --- examples/opengl/pbuffers/glwidget.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/examples/opengl/pbuffers/glwidget.cpp b/examples/opengl/pbuffers/glwidget.cpp index 56ba65b..d843a73 100644 --- a/examples/opengl/pbuffers/glwidget.cpp +++ b/examples/opengl/pbuffers/glwidget.cpp @@ -175,7 +175,11 @@ void GLWidget::perspectiveProjection() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); +#ifdef QT_OPENGL_ES + glFrustumf(-aspect, +aspect, -1.0, +1.0, 4.0, 15.0); +#else glFrustum(-aspect, +aspect, -1.0, +1.0, 4.0, 15.0); +#endif glMatrixMode(GL_MODELVIEW); } @@ -183,7 +187,11 @@ void GLWidget::orthographicProjection() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); +#ifdef QT_OPENGL_ES + glOrthof(-1.0, +1.0, -1.0, +1.0, -90.0, +90.0); +#else glOrtho(-1.0, +1.0, -1.0, +1.0, -90.0, +90.0); +#endif glMatrixMode(GL_MODELVIEW); } -- cgit v0.12 From cc6befac3780a34eefb4e02e2a4fd6266d454242 Mon Sep 17 00:00:00 2001 From: Martin Jones Date: Mon, 16 Nov 2009 16:33:51 +1000 Subject: Install Qt declarative (if available) and QmlPatterns on S60 Reviewed-by: Warwick Allison --- src/s60installs/qt.iby | 2 ++ src/s60installs/s60installs.pro | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/src/s60installs/qt.iby b/src/s60installs/qt.iby index bc69dce..41eb562 100644 --- a/src/s60installs/qt.iby +++ b/src/s60installs/qt.iby @@ -57,6 +57,8 @@ file=ABI_DIR\BUILD_DIR\QtTest.dll SHARED_LIB_DIR\QtTest.dll PAG file=ABI_DIR\BUILD_DIR\QtWebKit.dll SHARED_LIB_DIR\QtWebKit.dll PAGED file=ABI_DIR\BUILD_DIR\phonon.dll SHARED_LIB_DIR\phonon.dll PAGED file=ABI_DIR\BUILD_DIR\QtMultimedia.dll SHARED_LIB_DIR\QtMultimedia.dll PAGED +file=ABI_DIR\BUILD_DIR\QtXmlPatterns.dll SHARED_LIB_DIR\QtXmlPatterns.dll PAGED +file=ABI_DIR\BUILD_DIR\QtDeclarative.dll SHARED_LIB_DIR\QtDeclarative.dll PAGED // imageformats file=ABI_DIR\BUILD_DIR\qgif.dll SHARED_LIB_DIR\qgif.dll PAGED diff --git a/src/s60installs/s60installs.pro b/src/s60installs/s60installs.pro index 90c9f27..2d9c489 100644 --- a/src/s60installs/s60installs.pro +++ b/src/s60installs/s60installs.pro @@ -101,6 +101,10 @@ symbian: { qtlibraries.sources += QtXmlPatterns.dll } + contains(QT_CONFIG, declarative): { + qtlibraries.sources += QtDeclarative.dll + } + contains(QT_CONFIG, webkit): { qtlibraries.sources += QtWebKit.dll } -- cgit v0.12 From b84208e523354abf68904d0d494ab41015b19408 Mon Sep 17 00:00:00 2001 From: stefan thomasson Date: Mon, 16 Nov 2009 17:21:13 +1000 Subject: Fixed false positives in bic autotest Adding QRegion::QRegionData, tagMENUITEMINFOA, tagMENUITEMINFOW, tagENHMETAHEADER to the class blacklist Merge-request: 2085 Reviewed-by: Rohan McGovern --- tests/auto/bic/tst_bic.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/auto/bic/tst_bic.cpp b/tests/auto/bic/tst_bic.cpp index 8c6056e..b7c79cf 100644 --- a/tests/auto/bic/tst_bic.cpp +++ b/tests/auto/bic/tst_bic.cpp @@ -96,6 +96,9 @@ tst_Bic::tst_Bic() /* QtOpenGL includes qt_windows.h, and some SDKs dont have these structs present */ bic.addBlacklistedClass(QLatin1String("tagTITLEBARINFO")); + bic.addBlacklistedClass(QLatin1String("tagMENUITEMINFOA")); + bic.addBlacklistedClass(QLatin1String("tagMENUITEMINFOW")); + bic.addBlacklistedClass(QLatin1String("tagENHMETAHEADER")); /* some bug in gcc also reported template instanciations */ bic.addBlacklistedClass(QLatin1String("QTypeInfo<*>")); @@ -115,6 +118,7 @@ tst_Bic::tst_Bic() bic.addBlacklistedClass(QLatin1String("QObjectData")); bic.addBlacklistedClass(QLatin1String("QAtomic")); bic.addBlacklistedClass(QLatin1String("QBasicAtomic")); + bic.addBlacklistedClass(QLatin1String("QRegion::QRegionData")); /* Jambi-related classes in Designer */ bic.addBlacklistedClass(QLatin1String("QDesignerLanguageExtension")); -- cgit v0.12