And include qcore_mac_p.h where needed.
Task-number: QTBUG-99313
Change-Id: Idb1b005f1b5938e8cf329ae06ffaf0d249874db2
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
[ChangeLog][QtCore][Meta Objects] The QMetaObject::invokeMethod() taking
a method name by string, QMetaObject::newInstance(), and
QMetaMethod::invoke() now support more than 10 arguments.
[ChangeLog][QtCore][Meta Objects] The use of the Q_ARG and Q_RETURN_ARG
macros is now optional with QMetaObject::invokeMethod(),
QMetaObject::newInstance(), and QMetaMethod::invoke(): the type name
will be obtained from the C++ type (the same as QMetaType). The function
qReturnArg() can be used in place of the Q_RETURN_ARG macro. The macros
are still useful in rare conditions where the type was typedef'ed from
its original name.
Change-Id: I36b24183fbd041179f2ffffd17022a2b48c7639b
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Since Qt 6.0, QMetaType stores the name obtained from the C++ compiler,
which means we know a type like Qt::Alignment by its proper, full name
of QFlags<Qt::AlignmentFlag>. However, the meta object records only the
bare name of the enumeration, not the full flags.
Pick-to: 6.2 6.3 6.4
Fixes: QTBUG-105932
Fixes: QTBUG-96185
Change-Id: Ic6547f8247454b47baa8fffd170eab977e306377
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Type registration isn't necessary any more, unless you're trying to look
up a name back to ID or QMetaType object. It hasn't been since 6.0.
Drive-by update the example not to use deprecated API.
Drive-by remove the paragraph about requirements that aren't accurate
any more.
Pick-to: 6.4
Task-number: QTBUG-104858
Change-Id: Ic6547f8247454b47baa8fffd170eecb66719fa65
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Unifies our approach to calling CoInitializeEx and CoUninitialize,
removing a lot of boilerplate in the process, and also fixes a few
bugs where we would incorrectly balance our calls to CoInitializeEx
and CoUninitialize.
The optimistic approach of qfilesystemengine_win.cpp of calling
CoCreateInstance without initializing the COM library explicitly
has been removed, as calling CoInitializeEx should be a noop in
the situation where it's already been loaded.
Change-Id: I9e2ec101678c2ebb9946504b5e8034e58f1bb56a
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>
But not before ::fromValue, since that registers automatically.
Take the opportunity to add the \relates to the two streaming operators
to QDataStream, so the documentation shows up *somewhere* at all.
Pick-to: 6.4
Task-number: QTBUG-105469
Change-Id: Ic6547f8247454b47baa8fffd170eb8ffc31feb5d
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
For those, moc does know their type ID, and yet they may be still
forward-declared in the C++ side, so the meta object may have recorded a
null pointer in the metatype array.
Fixes: QTBUG-105832
Change-Id: Ic6547f8247454b47baa8fffd170dae07c0813dc7
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
For now just includes qfunctions_winrt_p.h
Once submodules have been moved over to qfunctions_win_p.h we can move
non-WinRT specific content from qfunctions_winrt_p.h to _win_p.h.
Change-Id: I467bb4991c67a8769b60b9cf9f26aa553c439b92
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>
We changed qTryMetaTypeInterfaceForType() so it does record void and
void* (see commit 2d0c31e7d9 and commit
3695b35dfc). By incrementing the revision
number, we make it possible to determine at runtime whether the new
information ought to be present.
We may add even more types (namely, non-const references) before 6.5.0
is out. For pointers, the restriction remains that the metatype is
recorded only if the pointer is a pointer to a complete type.
Change-Id: Ic6547f8247454b47baa8fffd170dad79b1a90f6b
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
The asyncify support in the event loop currently uses
EM_JS, which Emscripten does not support using from
side modules.
Change-Id: I5f961d9cd12f7b1b6cc1c2382b807a1da2918725
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
Reviewed-by: Mikołaj Boc <Mikolaj.Boc@qt.io>
Use correct text formatting; this ensures e.g. the decrement
operator isn't converted to an en dash in the docs. Apply
to increment operator docs also for consistency.
Task-number: QTBUG-105729
Change-Id: I5f126b90bc1d1b91d86e1f87c9b17a583841adb6
Reviewed-by: Topi Reiniö <topi.reinio@qt.io>
Inline the data members into the only remaining user (qdir.cpp) and
remove the class.
As a drive-by, fix the non-idiomatic use of QT_BUILD_CORE_LIB to mean
!QT_BOOTSTRAPPED and apply the guard consistently to the declaration,
too.
Pick-to: 6.4 6.3 6.2
Fixes: QTBUG-105747
Change-Id: If2c780dd96e2a2e331cabdc42fd920874e7737b0
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
The QObjectPrivate::declarativeData member is stored in a union with
currentChildBeingDeleted. The QObject destructor always sets the
currentChildBeingDeleted member of the union. It also sets the
isDeletingChildren bool, which is the only way to find out which union
member we can safely access.
While the QObject destructor is deleting children and isDeletingChildren
is set, we must not access the declarativeData member of the union.
Add a test case that initializes the function pointers for the
declarative handlers and constructs a situation where an object
emits a signal while it is destroying children.
Fixes: QTBUG-105286
Pick-to: 6.4 6.3 6.3.2 6.2 5.15
Change-Id: Iea5ba2f7843b6926a8d157be166e6044d98d6c02
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
For other modules that wrap invokeMethod and equivalent, like
qtwebchannel.
Task-number: QTBUG-105596
Change-Id: Ic6547f8247454b47baa8fffd170bbca806b04d8f
Reviewed-by: Arno Rehn <a.rehn@menlosystems.com>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
State the problem and suggest possible solutions for the
app developer.
Pick-to: 6.4
Change-Id: I0484c4eb31020ec0016005f43f910f32a319b850
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Emscripten's option for enabling asyncify (-sASYNCIFY) is a link-time
option, which means there is no requirement to have a separate asyncify
build, at least for static builds.
Replace the current QT_HAVE_EMSCRIPTEN_ASYNCIFY compile-time option
with a run-time option which checks if the asyncify API is available.
Keep support for configuring with "-device-option QT_EMSCRIPTEN_ASYNCIFY=1"
for backwards compatibility and for the use case where want asyncify
support to be on by default for a given Qt build.
Enable asyncify for the asyncify_exec example.
Pick-to: 6.4
Change-Id: I301fd7e2d3c0367532c886f4e34b23e1093646ad
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
The call to this function was behind a broken #define and
was never enabled. It also does not work, so remove it.
This means that calling processEvents() in a loop (as opposed
to calling exec()) most likely does not work either, which
is something we want to revisit.
Pick-to: 6.4
Change-Id: I90802a69d3a48e7f2b5d0b657d89452c09d9571a
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
The way the Qt 6.0 QMetaTypeInterface was designed, using a static
inline variable in a template, would normally require the linker and
dynamic linker to merge all copies and choose a single copy as the
official one. But because of hidden visibility and of Windows DLLs,
QMetaType already copes with multiple copies NOT getting merged. So we
may as well ask the linkers not to bother and use simpler, local
relocations to find those symbols.
They are all supposed to still be equivalent and it's an ODR violation
if they're not.
The Apple ld64 linker complains if you use this type of global
relocation:
ld: warning: direct access in function
[...]
to global weak symbol
'QtPrivate::QMetaTypeInterfaceWrapper<int>::metaType'
Fixes: QTBUG-93471
Pick-to: 6.3 6.4
Change-Id: Id0fb9ab0089845ee8843fffd16f98a10aa719434
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
QTranslator builds a list of "candidate" names in order to find out
the translation file to load. Part of the name comes from the UI
languages, as determined by the QLocale object passed to load()
(via QLocale::uiLanguages()).
On UNIX this list of languages is processed by adding a lowercase
version of each language. In other words, if the list is something
like:
{"en-Latn-US", "en-US", "en"}
then it is changed to contain:
{"en-Latn-US", "en-latn-us", "en-US", "en-us", "en"}
(The last element is not needlessly duplicated, since it's already
fully lowercase.)
I am not sure why this is done only on UNIX: the commit introducing
this behavior predates public history. If I have to take a guess, it's
done because the language is then used to assemble a file name that
QTranslator tries to open. On UNIX file names are case sensitive, so
if the translation file is called "translations_en_us.qm" it would
fail to load under a "en-US" locale (the "-" -> "_" processing is done
later).
But what about Windows? In principle, turning the names in lowercase
is not necessary as Windows' filesystem is case insensitive; a
translation file called "translations_en_us.qm" will still be loaded
if opened as "translations_en_US.qm"...
... *except* if the file is in the resource system! In that case,
filesystem access is still case sensitive, and will fail to load the
translation file (which instead would load just fine on UNIX).
Plug this silly cross-platform difference by also lowercasing on
Windows.
Change-Id: I2573721e33d9da08f60a5bb56e35e4553cbe4efe
Pick-to: 5.15 6.2 6.3 6.4
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@gmx.de>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Kai Koehne <kai.koehne@qt.io>
ownMethodIndex works for all kind of methods, also for constructors.
Therefore, remove the assertion there (that checks for non constructors)
and add a test in qtbase so it does not happen again.
The test broken by the assertion is in qtdeclarative:
tst_QJSEngine::newQMetaObject().
Also rename QMetaMethodPrivate::ownConstructorIndex() to
ownConstructorMethodIndex() as the previous naming implied that
ownMethodIndex() could not be used for constructors.
amends b73ab954df
Task-number: QTBUG-105360
Change-Id: I0244993ed79bee055645b5443f5d02e1c089a6c6
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The previous commit, b0e4d53b63, missed
this one. Same rationale as back then.
Pick-to: 6.4 6.3
Change-Id: Ibad4c130e0d61c64808275fa7b97b58ebd479acc
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
All versions down to Qt 6.2 require macOS 10.14 or iOS 13.
Pick-to: 6.2 6.3 6.4
Change-Id: I5048921ea5a149346a0fa84228227d9156004675
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
All versions down to 6.2 require at least Xcode 12, which ships with
the macOS 11 SDK, and iOS 14 SDK.
Pick-to: 6.4 6.3 6.2
Change-Id: I128321ec9e97b670b7c027f1233978e1b8856f88
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
QVarLengthArray checks for is_nothrow_move_constructible_v, though only
uses that information for its own noexceptness.
Pick-to: 6.4
Change-Id: I03c81e4da75fbe287d491843716d26e1acac8310
Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
This avoids having to rely on moc precalculating everything and getting
its sums right, as the main integer table only has a string index
(unlike my original 5.0 plan which would have stored the offset).
For example, for:
struct Object : QObject { Q_OBJECT signals: void changed(const QVariant &v); }
moc now generates:
struct qt_meta_stringdata_Object_t {};
static constexpr auto qt_meta_stringdata_Object = QtMocHelpers::stringData(
"Object",
"foobar",
"",
"v"
);
Notes on the implementation:
* the old code is retained because we need moc 6.5 to generate code
compatible with QtCore 6.2-6.4. It's marked for removal in Qt 6.9.
* the struct qt_meta_stringdata_%s_t remains because we need a
TU-specific type for QtPrivate::is_complete (via
qt_incomplete_metaTypeArray). This can be cleaned up.
* after this change, GDB complains while loading QtCore:
warning: internal error: string "StringData<long sequence of numbers>" failed to be canonicalized
but debugging does not appear to be impacted. It's just annoying
because it shows up when QtTest detects a crash too.
Change-Id: Id0fb9ab0089845ee8843fffd16f9d5493e9bd708
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Instead of having that function load those from memory. This allows us
to pass constant expressions in QVariant::Private s constructor
Change-Id: I3859764fed084846bcb0fffd17045ddd62553710
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
This means we can't do a tail-call from customConstruct when
PrivateShared is in use. But the case without that is still a tail-call.
Change-Id: I3859764fed084846bcb0fffd17045d144181ea84
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Even though it's calling a noexcept(false) constructor, we can declare
when it it won't throw and allow the caller to suppress its own
exception handling.
This necessitated splitting the Q_DECLARE_SHARED into its components
because fromValue<QVariant> uses QTypeInfo<QVariant>::isRelocatable.
Change-Id: I3859764fed084846bcb0fffd1704503aa4d3e535
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Group them by noexceptness and then organize each group logically. We
also don't need to #ifdef the constructors for the unavailable classes,
as they are forward-declared.
Change-Id: I6f936da6f6e84d649f70fffd17060903c78edf0f
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Simply cast from uint to qsizetype: All supported compilers will already
complain long before we reach an argument can that can represented by
unsigned int but not by qsizetype.
Change-Id: I455bde34db6b50ae9e017c7e2e811e22df926614
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
https://developercommunity.visualstudio.com/t/C:-constinit-for-an-optional-fails-if-/1406069
does not only affect constinit thread_local but also constinit in
general on MSVC compilers when C++20 is being used. So disable the
feature for these compilers in general for now.
This commit amends d9531593a2
Fixes: QTBUG-105234
Pick-to: 6.4
Change-Id: I1855f0857d85487895460fc7c56675fb864bfa73
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Microsoft recommends to use CoInitializeEx()
and SetWindowLongPtr()/GetWindowLongPtr() in new code.
Use COINIT_DISABLE_OLE1DDE to avoid overhead of
initializing and using obsolete technology.
Pick-to: 6.4
Change-Id: I9d16943e864d4487dd4f46fd9325579c298c52b9
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>
Pointer comparison is not sufficient on most platforms.
Change-Id: I6f936da6f6e84d649f70fffd1706f8b1f0654a1e
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The rewrites in a1c34d8bd0,
0f76e55bc4 and in commit
b73ab954df didn't do this right, though no
problem ended up happening. In particular, the constructor one failed to
check if there were even more parameters.
Change-Id: I6f936da6f6e84d649f70fffd1706f827ba635584
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Commit 3695b35dfc accounted for pointer to
other incomplete types, but pointer-to-void was missed. This caused an
inconsistency in the stored metatype for void*, which is a built-in type
(QMetaType::VoidStar) but no pointer was recorded.
The test in tst_moc hadn't been enabled because the functions in
questions weren't extracted by moc. That is fixed in this commit.
Change-Id: I6f936da6f6e84d649f70fffd1706f613517a75fb
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Previously, we were storing all binding-observers in a list, so that we
can later revisit them during the notification loop.
However, there is no point in doing that when the binding did not
actually change.
Pick-to: 6.4
Change-Id: I0b3343cc442eca2586c7c6a10c31d780f04730e6
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Problem description:
--------------------
Assume we have two properties, P1 and P2. Assume further that we assign
a binding to P2, so that it depends on P1. Let the binding additionally
capture some (non-QProperty) boolean, and only create the dependency to
P1 if the boolean is true.
The state afterwards is
P1:[p1vaue|firstObserver]
|
|
v
---[p2binding]
/
P2:[p2value|binding]
If the boolean is set to false, and P1 changes its value, we still
correctly re-evaluate the binding and update P2's value. However, during
binding evaluation we will notice that there is no further dependency
from P2 on P1, and remove its observer.
The state afterwards is
P1:[p1vaue|firstObserver=nullptr]
---[p2binding]
/
P2:[p2value|binding]
Then, during the notify phase, we traverse the observer's again,
starting from P1's firstObserver. Given that it is nullptr now, we never
reach P2's binding, and thus won't send a notification from it.
Fix:
----
We store a list of all visited binding-observers (in a QVarLengthArray,
to avoid allocations as long as possible). After the binding evaluation
phase, we then use that list to send notifications from every binding
that we visited. As we already have a list of all bindings, we no longer
need to recurse on binding-observes during the notification process;
instead, we only need to deal with static callbacks and ChangeHandlers.
The pre-existing notification logic is still kept for the grouped update
case, where we already have a list of all delayed properties, and should
therefore not encounter the same issue. Unifying its codepath with the
existing logic is left as an exercise for a later patch.
Fixes: QTBUG-105204
Task-number: QTBUG-104982
Pick-to: 6.4 6.3 6.2
Change-Id: I2951f7d9597f4da0b8560a64dfb834f7ad86e757
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
All of those are implicitly-shared Qt data types whose copy constructors
can't throw and have wide contracts (there aren't even any assertions
for validity in any of them). These are all types with a QVariant
implicit constructor, except for QCborValue, which is updated on this
list so QJsonValue (which has a QVariant constructor) is also
legitimately noexcept.
To ensure we haven't made a mistake, the Private constructor checks
again.
Change-Id: I3859764fed084846bcb0fffd17044d8319a45e1f
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Commit 2f0a625fd4 added noexcept for
these, but didn't verify that the operation itself was noexcept. And it
wasn't on 32-bit systems, because sizeof(void *) is only 4 bytes, making
QVariant and QVariant::Private a mere 12 bytes. That's insufficient for
QUuid and for almost all geometric types when qreal==double.
We can't use sizeof() in qvariant.h because most of those classes are
only forward-declared.
Change-Id: I6f936da6f6e84d649f70fffd1705ce948891d06a
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Until we've checked the stored meta type, we don't know what the Private
contains. We only formed a reference to said value, so we should be
safe, but why tempt it?
Change-Id: I6f936da6f6e84d649f70fffd1706095fc6228755
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@gmail.com>
So the compiler doesn't feel like it must emit these functions. They're
not used outside of qmetaobject.cpp.
Change-Id: I36b24183fbd041179f2ffffd170228c6e94b5f9b
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
We don't need to copy the candidate name into the QVarLengthArray buffer,
we just need that buffer for the parameters.
Change-Id: I36b24183fbd041179f2ffffd17021ba2fd2b8251
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Like in the previous commit, use QMetaMethodPrivate::invokeImpl() to
avoid having to reconstruct the method signature.
Change-Id: I36b24183fbd041179f2ffffd17021c7a0bfa48c0
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Use the QMetaMethodPrivate::invokeImpl() function we added in the last
commit, without recreating the method signature. Instead, only do a
comparison on the method name and allow invokeImpl() to decide whether
this method can be called with the given arguments. This will allow
invokeImpl() to have more flexibility in deciding if the arguments match,
using the stored metatype information.
Change-Id: I36b24183fbd041179f2ffffd17021a86484bfab6
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
This adds an internal method to QMetaMethodPrivate to do the work of
actually placing the call on a given meta method. This rewrite should
make the code clearer, but make no otherwise perceptible difference in
behavior.
The next commit will rewrite QMetaObject::invokeMethod to use this new,
internal function to avoid doing a lot of string allocations.
Change-Id: I36b24183fbd041179f2ffffd170219c0deaaf7f5
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The #ifdef wasn't necessary because destroy() had been using
__STDCPP_DEFAULT_NEW_ALIGNMENT__ without #if.
Change-Id: I3859764fed084846bcb0fffd17039570283d3eaf
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Instead of placing the error deep into IsPointerToTypeDerivedFromQObject
with a message about weird the sizes, move them closer to the front-end
so we get a proper error message like:
<stdin>:1:56: required from here
qmetatype.h:1131:45: error: static assertion failed: Meta Types must be fully defined
<stdin>:1:50: required from here
qmetatype.h:1132:29: error: static assertion failed: Meta Types cannot be non-const references or rvalue references.
<stdin>:1:56: required from here
qmetatype.h:1136:55: error: static assertion failed: Pointer Meta Types must either point to fully-defined types or be declared with Q_DECLARE_OPAQUE_POINTER(T *)
This does not apply to the meta type list stored in a meta object, as
meta method parameters may be opaque pointers or even forward-declared
only.
Change-Id: I36b24183fbd041179f2ffffd17025f10f38e04e6
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Namely, they shouldn't be supported. Even trying to create such a type
(as in QMetaType::fromType<int &>()) should fail, because for the
purposes of the meta type, they are not the same.
However, they were being registered in the meta objects' meta type list
as a mistake since commit cb43aaca11
("Introduce QMetaObject::metaType"), including for output parameters in
D-Bus remote objects' meta objects. despite the comment saying "type id
not available".
[ChangeLog][Potentially Source-incompatible Changes] Made meta types for
non-const references fail to compile. Previously, QMetaType::fromType
allowed this to compile, but returned the meta type for the base type,
which was incorrect. Const references are understood to be the same as
the base type.
[ChangeLog][Important Behavior Changes] The meta type for non-const
reference parameters in extracted methods (signals, slots, etc.) is no
longer available in QMetaMethod. This used to be the case in Qt 4.x and
5.x, but due to a mistake in Qt 6.0-6.3, QMetaMethod would incorrectly
report the base (non-reference) type. Additionally, both the reference
and the non-reference types may have been reported in different APIs.
Pick-to: 6.4
Change-Id: I36b24183fbd041179f2ffffd1702384d2b64a5f9
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
customConstruct has to do an additional check to ensure that
QVariant::fromValue(nullptr) returns null.
We can get rid of it by special casing nullptr_t in a fromValue overload
instead, reducing the amount of work that needs to happen at runtime.
Change-Id: I2aea6aecfee0a9404cbd78dbea01a1d5d3047ca0
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
QHash, QString, QByteArray, and QDateTime are explicitly noexcept, while
QList, QMap, and QModelIndex are implicitly noexcept because all their
members are explicitly nothrow-copyable.
There are a couple more Qt types that ought to be nothrow-copyable too,
like QBitArray and QUrl.
Change-Id: I3859764fed084846bcb0fffd17044b5ebb046ee9
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Make them all noexcept and ensure they are all passed by value.
Unfortunately for QRectF and QLineF, they're too big when qreal==double,
so QVariant needs to allocate memory itself. Strictly speaking, they're
too big for passing by value too, but the codegen is identical, so we
may as well. For Qt 7, enlarging QVariant::Private would be a good idea.
Change-Id: I3859764fed084846bcb0fffd17044ac379b3c1d2
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@gmail.com>
With very minor code style fixes. Moved up so they can be used in some
methods below.
Change-Id: I3859764fed084846bcb0fffd17044f8e61886e2c
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
They don't need to be in the header. They're still inline though.
Change-Id: I3859764fed084846bcb0fffd17044f49031feefc
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
And move it into the .cpp file, to hide the ugliness.
Change-Id: I3859764fed084846bcb0fffd17044729e361a42e
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
It's effectively the same and no one is using v_construct().
Change-Id: I3859764fed084846bcb0fffd1704470801c9e6e7
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
If the payload is trivially copyable and is using the internal space,
then it's already been copied by the copying of QVariant::Private. No
further work is needed.
Change-Id: I3859764fed084846bcb0fffd170446a4e474efb7
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
This suppresses a few duplicated checks that both QMetaType and QVariant
has (and QVariant's are stricter), and allows for customConstruct() to
perform a tail-call optimization, if it doesn't get inlined.
Change-Id: I3859764fed084846bcb0fffd1703a503ffb01f8f
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Avoids having to do work after QMetaType::construct() returns. That
can't get the tail-call optimization right now because it is a non-
inline non-static member function, so the QMetaType must be spilled to
the stack.
Change-Id: I3859764fed084846bcb0fffd1703a3ffc723f43f
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
In one of the three calls to customConstruct() -- QVariant::detach() --
we've already checked that the type is valid, so don't re-emit the
warning there.
Change-Id: I3859764fed084846bcb0fffd1703a3c7c0fb3164
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
We can implement the trivial {default,copy,move} construction outselves
inside qmetatype.cpp and qvariant.cpp, simplifying the QMetaType
interface object, removing up to three relocations per QMTI.
This adds the testing for QMetaType::isXxxConstructible and
isDestructible that couldn't be added before.
Change-Id: Ic44396b31ba04712aab3fffd16ff0a28f541d507
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Instead of duplicating the checks and methods that it already has.
Change-Id: I3859764fed084846bcb0fffd170355bf3dc597c8
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Unit tests will come after I've fixed the flags themselves. At this point,
they are wrong.
[ChangeLog][QtCore][QMetaType] Added isDefaultConstructible(),
isCopyConstructible(), isMoveConstructible() and isDestructible().
Change-Id: I3859764fed084846bcb0fffd170353109378e34c
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
This also rewrites QMetaType::id() on top of the helper, with the benefit
of calling a member static function, so QMetaType doesn't need to be
spilled onto the stack. In some upcoming changes I need to ensure that
QMetaTypes are registered so they can be found by name and I'd like to
have a dedicated function name for that, instead of calling .id().
Since I needed to add docs for the new function, I've updated for the
old one too.
[ChangeLog][QMetaType] Added QMetaType::registerType() and an overload
of qRegisterMetaType() taking QMetaType (the two functions do the same
thing). These two functions ensure a given QMetaType is registered with
the Qt global registry, so they can be found by name later. Using
qRegisterMetaType<T>() also accomplishes the same thing, but is slightly
better for completely generic code because it will avoid emitting the
registration for built-in types.
Change-Id: I3859764fed084846bcb0fffd170351d606034c22
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
It's not registered until an ID is assigned.
Pick-to: 6.4
Change-Id: I3859764fed084846bcb0fffd17034f5b369c5b4d
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Details: Added a note on how QProperty works in QML using BINDABLE keyword
Task-number: QTBUG-89166
Change-Id: Ib48dd26b0724f906efa65d14fbb75a8b97255b05
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
So long as you only ask us to copy it. Copying is mandatory, though.
I'll firm up the warning in a later commit, which may not get cherry-
picked as far back.
Pick-to: 6.2 6.3 6.4
Fixes: QTBUG-105140
Change-Id: I3859764fed084846bcb0fffd170432abf65dc197
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
If the metatype does not support copy and default construction, then it
it unsuitunsuitable for use in QMetaType. We cannot prevent users from
passing in such metatypes (as we have e.g. a ctor taking QMetaType), so
verify this in customConstruct, and make the variant invalid in that
case.
Pick-to: 6.2 6.3 6.4
Change-Id: Ib1f0149c8fb9a1cce0049fd0311980754cc85d1b
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
The doc comments were missing the classname, and therefore did not show
up in the correct places.
Pick-to: 6.4 6.3 6.2
Change-Id: I23a56356dcad862e2fe1f6f8c3da2f39852b80c7
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
They're ALWAYS const objects, though they also chock full of relocations
so they are never in read-only sections of memory (except maybe in final
executables that are position-dependent).
These are methods in a private sub-class of QVariant. No one outside of
QtCore (at least qtbase) should be using them directly. QVariant doesn't
have many friends (a bit anti-social); the one that matters is
qvariant_cast and that one does access QVariant::Private. This is not a
BC problem because QVariant::Private::type()'s signature is not
changing. In any case, QVariant's Q_CORE_EXPORT does not apply to
QVariant::Private anyway (see [1]).
[1] https://msvc.godbolt.org/z/r9cer8eWh
Pick-to: 6.3 6.4
Change-Id: I3859764fed084846bcb0fffd17035355f823dc8f
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
They must be outside the Qt namespace.
Pick-to: 6.4
Change-Id: I3859764fed084846bcb0fffd17030ebc62812e09
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Happens when we switch to protected visibility.
qjnihelpers.cpp:398:1: error: visibility does not match previous declaration
jni.h:1112:1: note: previous attribute is here
Change-Id: I3859764fed084846bcb0fffd17036098322e6b8d
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Do it in preparation for other changes around gadget type traits, for
porting qtdeclarative to the new API.
Change-Id: I91cd5aff81a678565cdf1b7e0b57f52bae8a1a80
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Deal with the case that the object gets deleted between a call to
moveToThread and the start of the thread by removing the object from the
list in that case.
Fixes: QTBUG-104014
Pick-to: 6.4
Change-Id: Ib249b6e8e8dfbc4d1332bb99a57fa9d3cff16465
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Allow specifying the Java class on which to set/get the field via its
corresponding C++ type, removing the need to explicitly provide the
Java type string.
Those were missing from a085a14d76, which
was noticed when porting QtConnectivity over to the new template APIs.
Pick-to: 6.4
Change-Id: I8f324c9fcc486b4c6c2f2b9051f7eca0cbec0e91
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
QMetaTypeInterfaceWrapper tries to find the metaObjectFunction using
the MetaObjectForType template. Using SFINAE, for a QObject, it should
resolve to a suitable specialization.
Such a specialization doesn't yet exist. It had to be created.
The following path returns nullptr for registered meta types:
auto metatype = QMetaType(typeId);
requestedTestType.metaObject() -> returns nullptr since a bad template
argument is fed to MetaObjectForType<T> in
QMetaTypeInterfaceWrapper<IneritingFromQObject>::metaType's static initializer.
Change-Id: I8b31c51e12cb19c333e00480b0177354b910ce1e
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
isRegistered naturally has the potential to run into unregistered
types; in that case, we should not print any warning.
Pick-to: 6.4 6.3 6.2
Change-Id: I060b23199ed1d41f67ebe656ed3c396094edffd4
Reviewed-by: Stefan Gehn <stefan.gehn@qt.io>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
It's needed in QtHttpServer.
[ChangeLog][QtCore][QDebug] Can now stream QMetaType.
[ChangeLog][QtCore][QMetaType] Can now be streamed through QDebug.
Change-Id: I974d77d678137715472a3907ab1e50ba2dbaa087
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This commit adds macros for declaring scoped native callbacks which are
in namespace or for example defined as static class member variables.
The existing macros don't allow this as they use QtJniMethods namespace
and the introduced callbacks' namespaces are not enclosed in that
namespace, yielding a compilation error.
Pick-to: 6.4
Change-Id: I754560bea7e9a1b57c2661d1ee7236e78db39ba1
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Partially reverts 06c2478
Even though these structs are not meant to be used anywhere outside
QObject, some special applications like Gammaray need them to get
details about connections.
Pick-to: 6.4
Fixes: QTBUG-104734
Change-Id: Ied73021e317cc6aed6192c229d9450ae48b6774c
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The manually defined native JNI function tables allow defining a name
that may be different from the actual function name; this name is then
used from the Java-side.
This can be useful to provide also as an option with the new
"unstringifying" macros which can help for example in porting code
to these new macros.
Pick-to: 6.4
Change-Id: Icfebfb351cb8dfb122795d20b37e2eac167a41bf
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
References to __declspec(dllimport) is not a constant expression on
Windows, so we can't have a direct reference to a staticMetaObject.
Commit 9b8493314d fixed the Q_OBJECT parent
link (added in 5.14, kicked in for 6.0 with the ABI break), but commit
656d6f2a9b added links for Q_GADGETs too
without taking the need for Windows DLLs into account.
This change is a no-op everywhere but Windows. On Windows, since we
store the pointer to the indirect getter function, now you may get non-
null pointers from QMetaObject::superClass().
Pick-to: 6.4
Change-Id: I6d3880c7d99d4fc494c8fffd16fab51aa255106e
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The presence of the mutable causes the const object to lose its
constness, so declaring as const wasn't helpful. But we can't drop the
const wholesale for MSVC right now because it mangles the variable's
type in the external name.
For all other compilers, we drop it for user-defined types, which is a
no-op but is semantically correct because QMetaType needs to modify
those objects. Aside from a few const_cast (marked with comments),
nothing else changes.
For types with built-in type IDs, however, the QMetaTypeInterface is now
fully const... or would be if it weren't full of relocations. It does
move the lot from the .data section to the .data.rel.ro section. After
this change, QtCore and QtGui have:
QtCore QtGui
.data.rel.ro 57 23
.data, exported 17 39
.data, private 94 193
sizeof(QtPrivate::QMetaTypeInterface) = 112 on 64-bit platforms
(but GCC issues ".align 32", so they effectively occupy 128 bytes)
Change-Id: Id0fb9ab0089845ee8843fffd16f9a35bfafebf77
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
This *should* make no difference in behavior, it just prevents the
instantiation of the QMetaTypeInterface and all the lambdas used in it
in every compilation unit, with a copy in every library. Now, a simple
function like:
QMetaType f() { return QMetaType::fromType<int>(); }
produces only a single function, with a reference into QtCore:
_Z1fv:
movq _ZN9QtPrivate25QMetaTypeInterfaceWrapperIiE8metaTypeE@GOTPCREL(%rip),%rax
ret
The code above *does* work on Windows, producing:
_Z1fv:
movq __imp__ZN9QtPrivate25QMetaTypeInterfaceWrapperIiE8metaTypeE(%rip), %rax
ret
However, it breaks the staticMetaObjects' metatype listing, because
getting the address of a __declspec(dllimport) variable is not a
constant expression (it lacks data relocations). So this is disabled on
Windows.
This change also broke the INTEGRITY build. I've simply disabled the
optimization there without attempting to understand why it fails.
Task-number: QTBUG-93471
Pick-to: 6.4
Change-Id: Id0fb9ab0089845ee8843fffd16f97748a00b4d64
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Even though QDoc accepted the \fn signature without a class scope,
the documentation does not end up on the class reference unless we
mark construct() as a member of QJniObject.
Pick-to: 6.4
Change-Id: Icae44f8eb24aa6b269242084479e735f2637c312
Reviewed-by: Luca Di Sera <luca.disera@qt.io>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
If a library declares a logging category that needs to be used
by clients (e.g. via inline methods, macros, etc.), then the
logging category function generated by Q_DECLARE_LOGGING_CATEGORY
has to be exported.
We've seen this problem with Q_NAMESPACE, Q_GADGET, etc.: these
macros also declare functions or objects that in some cases need to
be exported.
And precisely like Q_NAMESPACE, Q_GADGET, etc., people end up
relying on the implementation details of Q_DECLARE_LOGGING_CATEGORY
(specifically, what does it expand to) in order to place the
export directives in the right place.
Introduce a more robust solution and apply it around qtbase.
Cleanup some minor code as a drive-by (remove `extern` and useless
semicolons).
[ChangeLog][QtCore][QLoggingCategory] Added the
Q_DECLARE_EXPORTED_LOGGING_CATEGORY macro, in order to allow dynamic
libraries to declare a logging category that can be then used by
client code.
Change-Id: I18f40cc937cfe8277b8d62ebc824c27a0773de04
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Kai Koehne <kai.koehne@qt.io>
This allows us to simplify the explicit specialization of the
QMetaTypeInterface<void> explicit specialization, dropping the warning
push/pop, and remove an unnecessary explicit instantiation.
Pick-to: 6.3 6.4
Change-Id: Id0fb9ab0089845ee8843fffd16f9bdccf1965b95
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
It was introduced in commit d9f9bc9bad for
Qt 6.0 to avoid extern __declspec(dllexport), which MSVC doesn't like,
but was made obsolete by commit 77b99e8111
that removed the extern templates altogether for MSVC.
This change is NOT a no-op because Q_CORE_EXPORT expands to
Q_DECL_IMPORT which is __attribute__((visibility("default"))) on ELF
platforms. That's actually a good thing, because the symbol is not
defined in any library that is not called QtCore anyway. GCC and Linux
are also going towards properly requiring imported symbols to be
explicitly marked, which this is.
Task-number: QTBUG-93471
Pick-to: 6.3 6.4
Change-Id: Id0fb9ab0089845ee8843fffd16f99616883281e3
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Now that QStringConverter can handle non UTF encodings through ICU,
add a way to get a decoder for arbitrary HTML code.
Opposed to QStringConverter::encodingForHtml(), this method will
try to create a valid string decoder also for non unicode codecs.
Pick-to: 6.4
Change-Id: I343584da1b114396c744f482d9b433c9cedcc511
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Set it to nullptr on clear, and deal with possibly null bindingStatus.
Task-number: QTBUG-101177
Task-number: QTBUG-102403
Pick-to: 6.4
Change-Id: I66cb4d505a4f7b377dc90b45ac13834fca19d399
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Added for 6.4. Not extremely useful as long as the macros that allow
the declaration of new class and type strings also being documented.
Pick-to: 6.4
Change-Id: I9ee466fdd0aaccec1e627ceb313b5a5c17e3f3fa
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
Found by codespell
Pick-to: 6.4
Change-Id: Ie3e301a23830c773a2e9aff487c702a223d246eb
Reviewed-by: Nicholas Bennett <nicholas.bennett@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
They weren't flags. They were the version of Qt that was used in
compiling the application itself. The protection against rollback isn't
necessary any more, since qversiontagging.h, which applies to everything
and not just the main application binary. And using them to make
decisions on functionality or behavior is misguided (see previous
commit).
This commit does not deprecate the front-end classes' argument. In the
future, we may find some need for them.
Pick-to: 6.4
Change-Id: Ia4a094014ddb48cc9f6dfffd16f83a7b58ff95d3
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
It's not used for anything, so remove the temptation of trying to use it
to make decisions at runtime about a behavior. It's the wrong tool for
the job: it might tell you the version of Qt the *application* was
compiled against, but not the version any of the Qt-using libraries
were.
Pick-to: 6.4
Change-Id: I175efddd75f24ae59057fffd16f70b77dd87faf4
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
The assertion has the acquire fence at the wrong place:
- QThreadData::thread isn't dereferenced, so the acquire fence on its
load() isn't needed.
- QObjectPrivate::threadData, however, _is_ dereferenced, so an
acquire fence is needed; the relaxed load() is insufficient.
Swapping the loadAcquire() and the loadRelaxed() fixes both issues.
Pick-to: 6.4 6.3 6.2 5.15
Change-Id: Iee964490e93ebc323c188e616bf0d448f91fb2b5
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Add support for blocking sockets on secondary threads and on the main
thread with asyncify. This extends the support for websockify tunneled
TCP sockets, which was previously limited to async sockets on the main
thread.
Blocking sockets support is implemented by emulating select() on top
of emscripten's socket notification support. This is requires synchronization
between the blockee threads and the main thread, since we get socket
notification callbacks on the main thread. The synchronized state is held
in g_socketState where the main thread registers socket readiness state and
blocking threads register themselves.
Blocking using asyncify on the main thread is similar to blocking on
a secondary thread, with the exception that the main thread suspends
with qt_asyncify_suspend() instead of waiting on a wait condition.
Change-Id: Idb5a493644e1e6634057dc2f64f2e99e82e3c01e
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
We support blocking the event dispatcher thread in two cases:
- secondary threads: wait on a wait condition
- main thread: asyncify suspend
Create abstraction which implements both cases under a common API:
bool QEventDispatcherWasm::wait(int timeout)
void QEventDispatcherWasm::wakeUpDispatcherThread()
Make QEventDispatcherWasm::wakeUp() use the new API.
Also refactor the runOnMainThread functionality to provide several variants
- runAsync(fn): makes an async call on the main thread, from the main thread.
- runOnMainThread(fn): runs fn on the main thread, synchronously if
called from the main thread.
- runOnMainThreadAsync(fn): runs a fn on the main thread, always asynchronously
Change-Id: Ia6ac21a162e6b8ea2d71bacf6085beb9567588b5
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
Adding specialHTMLTargets to EXPORTED_RUNTIME_METHODS carries the
obligation to actually use it as well; failing to do so makes Emscripten
stop with a reference error on startup.
However, we can't guarantee that Qt will use it in all cases. The
current usage depends on QGuiApplication being used. Application code
could be using QCoreApplication, or no application object at all.
Detect if specialHTMLTargets is present instead, and then enable the code
paths which uses it if that's the case. This means that apps which want
to use e.g. multiple browser windows can opt into support by making sure
EXPORTED_RUNTIME_METHODS contains specialHTMLTargets.
Change-Id: I81105aa01946602fcf593f170e305d7dc9bad3be
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
The \value command supports a [since ...] parameter. We might as well
use it, to standardize how we document when enum members were added.
Change-Id: I68a101e8101f780d0e6607a63723aa1bd837bb56
Reviewed-by: Topi Reiniö <topi.reinio@qt.io>
As with method signatures, register class names using template function
specialization in the QtJniTypes namespace, and then declare C++ types
as JNI classes with a class name string. Such classes implicitly get
registered as JNI types as well.
Add a QJniObject construct method (since C++ constructors that are
templates cannot be explicitly instantiated with a type), and a
QJniEnvironment::findClass overload.
Add test coverage, also for the recently added macros for native
methods.
As a drive-by, change the name of the Q_JNI_DECLARE_NATIVE_METHOD
macro to Q_DECLARE_JNI_NATIVE_METHOD for consistency.
Change-Id: Ic19562d78da726f202b3bdf4e9354e8ad24d8bd9
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Useful for tests that request permissions and need to ensure these
are requested on behalf of the app itself, and not its parent process,
regardless of how it's invoked.
Change-Id: Iac493e95440a3a04df4fa466c1d700ba1233e393
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
Amends ba6c1d2785, which made
m_statusOrPendingObjects already atomic, but did not handle concurrent
deletion/push_back of the pendingObjects vector correctly.
We use the existing lock in QThreadPrivate to prevent data races.
Pick-to: 6.2 6.3
Fixes: QTBUG-101681
Change-Id: I0b440fee6ec270d762e6700a4fe74f28b19e75e8
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Add a template function that allows us to get the method signature
string from a free function, which are used as native callbacks methods
from Java.
Provide a macro that defines a signature object, and a JNINativeMethod
object based on it, in an internal namespace so that we don't pollute
the namespace with generated names.
Add another macro to get the generated JNINativeMethod object based on
the free function name.
Lastly, add overloads to QJniEnvironment::registerNativeMethods that
take a std::initializer_list of JNINativeMethods.
We can now declare a free function to be a JNI native method:
static bool callbackFromJava(JNIEnv *e, jobject /*thiz*/, jstring p1)
{
// ...
}
Q_JNI_DECLARE_NATIVE_METHOD(callbackFromJava);
and register it with the JNI environment like this:
QJniEnvironment jni;
jni.registerNativeMethods(clazz, {
Q_JNI_NATIVE_METHOD(callbackFromJava)
});
removing a significant amount of boiler plate code.
Change-Id: Ie4007b24125879fed3dae1f4d232b4aa95999b44
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
QMetaType can register a converter from a smart pointer class to
QObject *. The code tries to do so even if the smart pointer is
actually holding a pointer to a _const_ QObject
(e.g. shared_ptr<const QObject>), causing a compile error:
../src/qt5/qtbase/build/include/QtCore/../../../src/corelib/kernel/qmetatype.h:1208:32: error: invalid conversion from ‘const QObject*’ to ‘QObject*’ [-fpermissive]
1208 | return p.operator->();
| ~~~~~~~~~~~~^~
| |
| const QObject*
Disable the conversion if indeed the source is const qualified.
Change-Id: I9e9bc5992f74131e5cfd6ece9b83d4f26d370e92
Fixes: QTBUG-103741
Pick-to: 6.2 6.3
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Replace implicit conversions from QAtomicPointer<T> → T* with the
equivalent, but explicit, loadAcquire().
This is in preparation of deprecating the implicit QAtomic<T> ↔ T
conversions.
Change-Id: I6c8476a705c3996ef724dd63b58d9526d1a39af7
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The implicit conversion operator from QAtomicPointer<T> → T* performs
a loadAcquire().
In the cases of this patch, we're only comparing pointer values to
check whether QObject thread affinities are compatible, so relaxed
loads suffice.
Pick-to: 6.3
Change-Id: If19124778b4770d86baeaeb3c91214e47881b288
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>
The SIP configuration is not available through the NVRAM in all cases,
so we try to get it via the private syscall first, if we can, and then
skip the warning if we don't find it in NVRAM.
Pick-to: 6.2 6.3
Change-Id: I0866d06c329a3ac70bb1f23732d10aab13a4f9c1
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
Sometimes it is not desirable to include the libraries in the APK,
e.g. system and vendor apps could prefer having one set of libraries
installed on the device. If unbundled deployment is specified,
native libraries will not be included in the APK.
With unbundled deployment, optional arguments can be passed to
set the path to load the libraries on the device.
[ChangeLog][Android][Deployment Changes] Adds option for Unbundled
deployment, where native libraries are not packaged in the APK.
Task-number: QAA-771
Change-Id: Ica51ef83a24dad58c7586bf610a58abe21fc1100
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Includes fixes in indexed for loops that are either known to modify
the container under iteration, or else aren't known not to do it, so
were kept as indexed loops, instead of being ported to ranged ones.
Pick-to: 6.3 6.2
Task-number: QTBUG-103532
Change-Id: I7047b6127fbc4ac16ee113cfd6d1c71f2caba1e7
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
... fixing the int/qsizetype mismatches in the old code.
These loops trivially don't modify the container under iteration, so
using a ranged for loop is safe.
Pick-to: 6.3 6.2
Task-number: QTBUG-103532
Change-Id: I1c9e1bffceea0ada54007d313aebe2e688fa9122
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The unsigned return value was very un-Qt-ish, and, indeed,
tst_QCoreApplication just stored the result in ints.
Port to qsizetype, being the type of the expression that the function
calculates.
Task-number: QTBUG-103532
Change-Id: I95a81a686439b0686faad7a430adeaab66dc9e8d
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The only in-tree user outside QtCore is tst_QCoreApplication, guard
the (single) test function there with QT_BUILD_INTERNAL.
Change-Id: Ibc87ba76f2135cd8283acd75318f80a95e4b5c45
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
... in favor of including qabstracteventdispatcher_p.h, where needed.
Keeps the code DRY.
Change-Id: I5bee2e653cb29ffac2601ff03c952a4b3adbdb9c
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
We don't need to reload d->threadData, as we've already loaded it into
a register three lines above, so use the already-loaded value.
We don't care whether we might have read a different value the second
time around, because that would mean we had a race condition elsewhere
in the program (e.g. concurrent moveToThread() calls).
Pick-to: 6.3
Change-Id: I29a27ca23302288b5900ac6b45b8690a80e85680
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
We don't need an acquire fence for checking a pointer for nullness,
and we're not dereferencing the pointer later, so use a relaxed load
there.
Pick-to: 6.3
Change-Id: Id84e6fc50100f1bf6a4e33f89424f8b1cbb250cd
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
We dereference thisThreadData in the next line, at a point in time
where we haven't, yet, verified that it's this_thread's QThreadData,
so we need an acquire fence.
The alternative would be to re-arrange the code so that dereferencing
the pointer is delayed until after we verified it's this_thread's, but
that doesn't seem readily possible.
Even if it was easy, we'd first need to verify whether there are any
writes into QThreadData objects after they've been constructed, in
which case the acquire fence may be needed even in case it's 'ours'.
So just add the acquire fence.
Pick-to: 6.3 6.2 5.15
Change-Id: I468bc1f971bd87345bfcd6c13b7384bdf09d086a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Only qcoreapplication_p.h uses a QReadWriteLock (tanslationMutex), so
include it only there.
This include has caused QAtomicPointer<QReadWriteLockPrivate> to
percolate to the top-5 of template instantiation hogs when compiling
QtWidgets, as reported by Clang -ftime-trace.
This patch improves that, because qcoreapplication_p.h isn't part of
the PCH and is much less frequently included into QtWidgets TUs (68
instead of 142 times).
Pick-to: 6.3 6.2
Change-Id: I2518040d83a04e7cef0645d7f4bf641fb50f49ff
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Manipulating owning containers is costly at runtime, but also at
compile-time, so don't do it in inline functions, do it
out-of-line.
Removes the top-2 entries[1] in a Clang -ftime-trace QtWidget build.
[1] at the time of writing of this patch
Change-Id: I5da5030788b0d976a0ab7875f87ba3b51dbb1231
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
... out of QThreadData.
No-one except two functions in qobject.cpp uses the object, and its
creation is constinit, so there's no advantage to expose it to the
world as a QThreadData member.
Remove it from QThreadData, move the class' definition to the unnamed
namespace in qobject.cpp, ensure constinit'ability by letting the
language zero out the members (as opposed to an STL algorithm call),
declare it constinit thread_local static, and adapt the two users
(basically, removing the retrieval of QThreadData::current()).
Almost no effect on Clang, but saves ~400 bytes on optimized GCC 11.2
Linux AMD64 C++20 builds.
Change-Id: I22432d4ec5eb4ab59920656409b21768983fb4db
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This allows us to specialize JNI type signature templates for e.g. the
context object, which in Java signatures is "android/content/Context".
Introduce a Q_DECLARE_JNI_TYPE macro that takes care of the plumbing.
The types declared this way live in the QtJniTypes namespace, and
transparently convert from and to jobject. Since jobject is a typedef
to _jobject* we cannot create a subclass. Use a "Object" superclass
that we can provide a QJniObject constructor for so that we don't
require the QJniObject declaration to be able to use the macro.
The APIs in the QNativeInterface namespace doesn't provide source or
binary compatibility guarantees, so we can change the return types.
Change-Id: I4cf9fa734ec9a5550b6fddeb14ef0ffd72663f29
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Since we know at compile time whether the return type is an object type,
we can use 'if constexpr' and auto return type in the call(Static)Method
and get(Static)Field functions to call the object-type methods.
This makes the object-methods conceptually obsolete, but don't declare
them as deprecated as long as they are still used in submodules to avoid
warning floods and build failures in -Werror configurations.
Change-Id: Ic3019ed990a9252eefcb02cdb355f8a6ed6bc2ff
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Replace the current license disclaimer in files by
a SPDX-License-Identifier.
Files that have to be modified by hand are modified.
License files are organized under LICENSES directory.
Task-number: QTBUG-67283
Change-Id: Id880c92784c40f3bbde861c0d93f58151c18b9f1
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Jörg Bornemann <joerg.bornemann@qt.io>
This allows the compiler to deduce the template arguments based on the
provided method parameters, which we can then pass to the methodSignature
and fieldSignature helpers to generate the signature string completely at
compile time.
Since we can't partially specialize template member functions, replace
the specializations for void methods with compile-time-if branches in
the general templates.
This variadic template now prevents implicit conversion from the
LiteralStorage types to const char* signatures, so catch the case where
such a type ends up in the parameter list.
Due to overload resolution rules for constructors, we need to explicitly
disable the constructor if any of the arguments is a string literal type,
as we have to keep the old C-style variadic function working for such
calls.
Add variations that use the variadic templates to the unit tests.
Change-Id: I8734664b38bae932369462330a9a03302254c33c
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
They already nicely factored this error-only code from the normal path
of execution. All that was missing was for them to be marked as COLD,
so the compiler moves them out of the way even further, and optimizes
them for size, not speed.
TEXT size savings: ~400b on GCC 11.2 and ~500b on Clang 10 optimized
C++20 AMD64 Linux builds.
Pick-to: 6.3 6.2 5.15
Change-Id: I64a4123645855b4e34fbb0bc3304d144d7191a0d
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
During type normalization, we remove the struct, class and enum
keywords (see the skipStructClassOrEnum function). However, we only want
to do that for actual keywords, not for a name that happens to start
with e.g. "enum", as in "enumerationNameSpacce".
Adjust the MSVC check to still require no identifier character after the
keyword, while still allowing for some remaining characters.
Fixes: QTBUG-97813
Pick-to: 6.3 6.2
Change-Id: I82b873d02ff454cce4b75f2814a52a66f2268208
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
We don't support it any more. I don't think it has ever properly
compiled Qt 6 (and it's no longer working for me against GCC 12's
libstdc++ headers). If you report a bug against it, Intel support's
first question is if you can try instead the new Clang/LLVM-based oneAPI
C++ compiler.
So we support only that one, which identifies itself as Q_CC_CLANG.
Change-Id: I5ff8e16fcdcb4ffd9ab6fffd16eb57a092c8439e
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Value 220 is already used in the (poorly, but consistently) placed
GraphicsSceneLeave event type.
Change-Id: I2fd90645475a70380e43e906c5f8459b3119f22f
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
The `inline` keyword does not control inlining, as we all know (use
Q_ALWAYS_INLINE to force inlining, if required). However, it does
control the emission of the out-of-line copy of an inline function, if
the compiler did inline it where it got used: with the keyword, no copy
is required, which is our objective here.
Furthermore, we compile with -fvisibility-inlines-hidden with
GCC-compatible compilers (all but MSVC and Integrity's), which means
those functions will never be in the ABI of QtCore: they'll either have
been inlined with no out-of-line copy, or that out-of-line emission is
hidden.
Change-Id: If2e0f4b2190341ebaa31fffd16e31584561669f2
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
This prevents false-negatives and false-positives, as e.g. Clang
10.0.0 masks as GCC 4.2, so Q_CC_GNU is 402 on that
compiler. Depending on the test (Q_CC_GNU > NNN or Q_CC_GNU < NNN),
the result of the test is almost random.
Q_CC_<comp>_ONLY makes sure we match only GCC or MSVC, not bycatch
such as Clang or ICC.
Pick-to: 6.3 6.2 5.15
Change-Id: I4c550a11ecf85fc9a2216b330b69bd03d45b47e0
Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Introduce an internal QtJniTypes namespace with types that allow us to
concatenate string literals at compile time. This makes it possible to
generate arbitrary strings based on types, which we can then use as
signatures to JNI method calls.
Move some of the private members of QJniObject into the QtJniTypes
namespace for consistency, and to allow further template specialization
by user code to make other types and their JNI signature string known.
Remove the "Jni" prefix from names.
Use the compile-time generated string in QJniObject methods that created
the signature string at runtime, which involved a temporary memory
allocation.
Treat 'void' as a primitive type (with signature string 'V'), and
remove redundant template specializations.
Add a test case to verify the the strings are constructed correctly
at compile time.
Change-Id: I5e3895a97f7dc1b86961f7a7855b899d9203037d
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The os_log_create API documents that the logging subsystem will
maintain a global list of logs, and will return existing logs
for subsequent calls for the same category and subsystem, so
we don't need to maintain our own log.
This also avoids a crash were we would end up in the logging
backend during application shutdown, when destructor functions
run, for example via QLibraryStore::cleanup().
In this case local static such as our log cache had already been
destroyed, leading to use after free.
Pick-to: 6.2 6.3 5.15
Change-Id: I91abfef6c56f8ca6dd8d602ac83aa163ce3d6860
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Previously, a restart of QtActivity on Android would make the
application fail with a blank screen. That happened because the
QtActivity tried to reload the whole application and failed.
With this patch, the QtActivity detects if the application is restarting
by checking if QtNative and QtActivityDelegate are live and updates the
connections on those objects accordingly. It allows the application to
continue as before. In case that is not possible, the QtActivity will
restart the application.
Fixes: QTBUG-38971
Fixes: QTBUG-102298
Pick-to: 5.15 6.2 6.3
Change-Id: Id500d20b185d57b39d45d34eeaa99745a3c2b95b
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Convert various uses of Q_GLOBAL_STATIC_WITH_ARGS() to the less
verbose form the recent reworking makes possible.
Change-Id: I57820660b5d00d39bf54b5a08cb921ebaec57c7c
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Not every id is an NSObject, and even those that are are sometimes
passed around as id<SomeProtocol>, in which case we still want them
to have pretty debug descriptions.
Change-Id: I50a02cd8fb9d6a2cbde3c4aef81116033d10b72c
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This is a cherry modification of 5826a7ad921930393c84b790123f493e26d0685c
in 5.15 branch.
Fixes: QTBUG-102438
Pick-to: 6.3 6.2
Change-Id: I8bdb7cb2537c6df7bb1381871b3cc2446ff1d270
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
There's no advantage to them being inline: Absent de-virtualisation,
clone() is only supposed to be called through the vtable, and the copy
ctor is only supposed to be used in the implementation of clone().
And when the compiler de-virtualises, we don't want the code
duplication associated with inlining.
Enforce this by introducing new macros to hide the boilerplate.
This fixes missing out-of-line dtors in:
- QSinglePointEvent
- QApplicationStateChangeEvent
- QFutureCallOutEvent
Wrong covariant return in:
- QFutureCallOutEvent
And missing clone() reimplementations in:
- QCloseEvent
- QIconDragEvent
- QShowEvent
- QHideEvent
- QDragEnterEvent
- QDragLeaveEvent
While these don't carry extra data or members, a dynamic_cast of the
result of clone() as well as using the expected covariant return value
would fail:
QShowEvent *e = ~~~;
QShowEvent *e2 = e->clone(); // ERROR: converting QEvent* to QShowEvent*
Check that reimplementing clone() is binary compatible (covariant
returns may change the numerical pointer value returned, cf.
https://community.kde.org/Policies/Binary_Compatibility_Issues_With_C%2B%2B).
The copy-assignment operator stays inline for the time being, as the
goal is to = delete it in the future.
This patch covers, roughly, QtCore and QtGui.
[ChangeLog][QtGui][QEvent subclasses] Fixed missing clone()
reimplementations on QCloseEvent, QIconDragEvent, QShowEvent,
QHideEvent, QDragEnterEvent, and QDragLeaveEvent.
Task-number: QTBUG-45582
Task-number: QTBUG-97601
Change-Id: Ib8a0519dbe85a7a8da61050d48be338004dfa69a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
All of this connection management code is used only in QtCore and
mustn't be touched by other modules (not even qtdeclarative). So there's
no reason for it to be around and slow down the compilation time of
everything using QObjectPrivate.
Change-Id: If2e0f4b2190341ebaa31fffd16e31313f1b7020f
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Just to be pedantically correct, but also makes the construction code
slightly more readable.
Pick-to: 6.2 6.3
Change-Id: I29f1c141c0f7436393d9fffd16e2bbf0f361c024
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Disable copy and move SMFs and make the dtor protected. This requires
to restore the default ctor, which in turn also becomes protected,
because it needn't be public.
Found by clazy-copyable-polymorphic.
Pick-to: 6.3
Change-Id: Ibde8202e755f6de05cd8f9e92cf0f9cf19b4e19b
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This is needed for use in QHash and similar.
It's essentially the same as using the integer id, but typesafe
Change-Id: I9515b8e178c8f9828934cb0bb099cce5553ec393
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Since the class is exported, both ctors from source_location (std and
experimental) need to be in the DLL, otherwise a Qt built with C++20
(using std::source_location) may break C++17 users that, however, have
experimental::source_location (and therefore expect the DLL to export
it).
This is exactly the same issue we had with QPolygon and
QVector::begin() with and w/o QT_STRICT_ITERTORS, therefore the same
fix applies, with the difference that we don't need a separate TU here
to inject the missing symbols, because both versions can be
overloaded.
[ChangeLog][QtCore][QPropertyBindingSourceLocation] (Windows only)
Fixed a binary-incompatibility where source_location constructors were
missing in the ABI.
Pick-to: 6.3 6.2
Change-Id: I4a514565cceea5f92975eff3a3e936efa5f7d8da
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Android permissions query blocks Qt main thread. If the input method
was activated before the permissions query started, android would try
to invoke input method before returning back to permissions query.
This will cause a deadlock.
Fix the issue by moving the deadlock counter to Qt core and
incrementing the value before the permissions query. This will prevent
the input method queries to enter Qt main thread.
Fixes: QTBUG-99484
Pick-to: 6.2 6.3 6.3.0
Change-Id: I54ea59578880cde4095c26fa2a6a264c4dc1b7ff
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>
Use fromRawData() to create a QByteArray-as-a-view instead.
Pick-to: 6.3
Change-Id: Ic6083ec438bc089a6f11d7e4718eca72c0d51fe3
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The function-call operator of QGlobalStatic creates the payload object
unless is has already been deleted. When performing read-only
operations on the payload object, it's better to use
QGlobalStatic::exists() + the dereference operator instead, because
that prevents the creation of the payload just to find it empty.
Pick-to: 6.3
Change-Id: I367add516520d076412cbbc542ee7a3b6ea45c14
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Unlock the QReadLocker after we're done with the registry, before we
perform expensive operations such as I/O and QByteArrayList::join().
Pick-to: 6.3
Change-Id: I96549c517a2b4ffe34a70ea83f8c061ff9620795
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
MSVC 19 does not allow using constinit on thread_local objects of
non-trivial type:
https://developercommunity.visualstudio.com/t/C:-constinit-for-an-optional-fails-if-/1406069
Instead of revoking Q_CONSTINIT for that compiler or removing
Q_CONSTINIT from such variables, add a new macro for this situation,
so the constinit static assertion will still be checked on other
platforms.
Amends 32692667a6.
Change-Id: Ic2247768b0d64e0c01648cffc9532fe5bd4bbd5d
Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
Removed "explicit" keyword from constructors taking
(const char *, qsizetype) and (const char *, const char *).
Switched to using brace initialization for creating QLatin1StringView
in QtCore.
[ChangeLog][QtCore][QLatin1StringView] The (const char *, qsizetype)
and (const char *, const char *) constructors are no longer explicit.
Change-Id: I4f6760692e4df60fe4231e86a25f6ea03cd1bf82
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Still not complete. Just grepping for static and thread_local.
Task-number: QTBUG-100486
Change-Id: I90ca14e8db3a95590ecde5f89924cf6fcc9755a3
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
It expands to the first available of
- constinit (C++20)
- [[clang::require_constant_initialization]] (Clang)
- __constinit (GCC >= 10)
Use it around the code (on and near static QBasicAtomic; this patch
makes no attempt to find all statics in qtbase).
[ChangeLog][QtCore][QtGlobal] Added macro Q_CONSTINIT.
Fixes: QTBUG-100484
Change-Id: I11e0363a7acb3464476859d12ec7f94319d82be7
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
As a drive-by, did also minor refactorings/improvements.
Task-number: QTBUG-98434
Change-Id: I81964176ae2f07ea63674c96f47f9c6aa046854f
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Anton Kudryavtsev <antkudr@mail.ru>
Global functions need an associated header file/class/namespace to make
the documentation visible.
Remove QDoc comment tag (/*!) for an internal function.
Pick-to: 6.3
Task-number: QTBUG-99578
Change-Id: Id390d433d7e081fc90fa57a02097b6c37fa13bee
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Kai Koehne <kai.koehne@qt.io>
The QVariant(bool) is an extremely dangerous catch-all for all sorts of
things that may convert to bool, including arbitrary pointers. Delete
the corresponding constructor, in order to force users to use the
(correct) construction using fromValue, and/or to prevent bugs
altogether. This is technically speaking a SiC, but one of type A -- if
pointer to bool was intented, just do the conversion explicitly.
[ChangeLog][QtCore][QVariant] QVariant used to be constructible by raw
pointers through a conversion towards bool. This is now illegal. If such
a conversion is needed, users are advised to insert manual casts to
bool.
Change-Id: I1b1f81962259514e57d841246740e0f7050104e0
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
In some situation we want to notify even if the value didn't change.
Task-number: QTBUG-101771
Pick-to: 6.2 6.3
Change-Id: I7d82a9f6e0f7d5eb48065e3f428b814939181ea8
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
The last 32 timer that could overflow was not used anymore since Qt 5.9,
see also commit aaa3184f8d. This appends commit aaa3184f8d.
Pick-to: 6.3 6.2 5.15
Change-Id: If033a5fa7a58427bcbc643cc19fc73a8dd36a169
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This was lost when QtCore, QtGui and QtWidgets were split up. Restored
now via a virtual function on QObjectPrivate.
Chose to return std::string instead of QString or QByteArray because
its SSO is usually sufficient to hold these flag strings.
[ChangeLog][QtCore][QObject] Restored printing of Qt3-style
information from dumpObjectTree().
[ChangeLog][QtWidgets][QWidget] Restored printing of Qt3-style
information from QWidget::dumpObjectTree().
Fixes: QTBUG-101732
Change-Id: I39ff5728ea5f5abbdbf81b5d7e13b8d16b6ee8b7
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Unlike the Gui and Widgets pointers, the Core one wasn't needed,
because the only user can inline the variables contents.
Saves one relocation.
Pick-to: 6.3
Change-Id: Ib7535e1a29c5125eea55c66dad6d2d1de72f6bc1
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Forward declare more types in qvariant.h, and do the same for qdebug.h
(which will be removed from qvariant in a separate patch).
As we now only forward declare containers (e.g. QMap, QList, ...), code
which includes <QVariantMap>, <QVariantList>... breaks without further
adjustment: So far, those headers simply included qvariant.h. However,
by introducing new actual headers for those types and adjusting
sync.profile, we can avoid this issue.
To avoid breaking leaf modules and user code, we make the change opt-in:
Unless QT_LEAN_HEADERS is defined to a value of >= 1, we still
include the superfluous headers. We also set this macro in qtbase via
QT_EXTRA_INTERNAL_TARGET_DEFINES.
[ChangeLog][Potentially Source-Incompatible Changes] qvariant.h no
longer includes <QList>, <QMap>, <QHash>, <QVarLengthArray>, <QSet> and
<QObject>. Code that relied on transitive includes might need to
explicitly include those headers now. Notably, including <QVariant> (or
qvariant.h) is no longer sufficient when using QVariant(List|Map|Hash).
Using them now requires including respectively <QVariantList>,
<QVariantMap>, or <QVariantHash>. Alternatively, including <QVariant>
and the <QList>, <QMap> or <QHash> header also works.
[ChangeLog][Potentially Source-Incompatible Changes] qdebug.h no longer
includes <QSet>, <QHash>, <QVarLengthArray> and <QMap>. Code that relied
on transitive includes might need to explicitly include those headers
now.
Task-number: QTBUG-97601
Change-Id: I142e5de709ed0b305716369a3266389ab7fbbb71
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Add a new entry to the Call enum that can be used by dynamic meta
objects to encode their own metaCall variations.
Change-Id: I7890d11924ab99311b6f016ce97d2ab483c26d27
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
In no particular order:
- use the variable field width feature of QString::asprintf() to
generate the indentation implicitly, instead of fill()ing a
QByteArray with the desired number of spaces
- just default-construct 'flags', don't assign an empty string
- use qUtf16Printable() to avoid funneling UTF-16 data through 8-bit
encodings
- use a C++11 ranged for instead of a counted loop
- remove a pointless isEmpty() guard (the loop won't execute when the
children().isEmpty())
- avoid copying object->children() (returns by cref, so it's also ok
to stuff it directly into the ranged for loop).
Add a test.
Pick-to: 6.3
Change-Id: Ie7314713cb48de7e890cdee0760c0361dd24fd18
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Also remove left-over code paths related to it.
[ChangeLog][QtCore] QElapsedTimer::TickCounter enum is now
deprecated. Qt does not use the Windows API behind this
enum already since Qt 5.9, so it's fair to assume that
any code path relying on the enum is dead code.
Change-Id: I308fe23658835034774e2015a8ee64659102de56
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
We only support Windows versions that feature the PerformanceCounter
API (see also 48fd845c61).
Pick-to: 6.3 6.2 5.15
Task-number: QTBUG-84433
Change-Id: I477f9015ee8c87d31f859f529631f3a6b0215ae6
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
... while keeping the QString overload for users that pass actual
QStrings (e.g. QStringLiteral).
However, QString and QAnyStringView cannot be overloaded (they're
ambiguous for most arguments), so we need to make one of them a
Q_WEAK_OVERLOAD.
Normally, we'd make the new function weak and keep the old function
as-is, but, here, that would be beside the point, because all callers
would continue to resolve to the QString overload, and nothing would
call the QAnyStringView one.
So we really want the old function to be the Q_WEAK_OVERLOAD, so that
the QString overload is only selected when actual QStrings are
passed. That means we need to leave the old function in a compat build
(compiled in, but not visible in the public header). Since
Q_WEAK_OVERLOADs cannot be (easily) exported (they're templates), make
it call a private function (which can be, and is, exported).
Reviewers may questions whether one can overload
setObjectName() and
template <typename = void> setObjectName()
The answer is that we can, because templates mangle differently from
normal functions. We can even call the template function (with
explicit template arguments), as seen in removed_api.cpp.
This adapts the interface of the function to how most users use it:
They pass QLatin1String or just const char[]. Only very few passed
QStringLiteral, which, ignoring that fact that it produces a ton of
code for the temporary QString's destructor that's never executed,
would have been, and continues to be, the optimal way of passing data,
modulo plugin bugs (QTBUG-51602, QTBUG-49061).
[ChangeLog][QtCore][QObject] Added setObjectName() overload taking
QAnyStringView.
Fixes: QTBUG-101393
Change-Id: I1243545614754b4978d4c8641460980b6b293c1a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
... to centralize the creation of QObjectPrivate::extraData.
Change-Id: I04e97779ceb0168fa7660e77e0dab2ed3e1ad03e
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
QPlatformTextureList holds a QRhiTexture instead of GLuint. A
QPlatformBackingStore now optionally can own a QRhi and a
QRhiSwapChain for the associated window. Non-GL rendering must use
this QRhi everywhere, whereas GL (QOpenGLWidget) can choose to still
rely on resource sharing between contexts. A widget tells that it
wants QRhi and the desired configuration in a new virtual function in
QWidgetPrivate returning a QPlatformBackingStoreRhiConfig. This is
evaluated (among a top-level's all children) upon create() before
creating the repaint manager and the QWidgetWindow.
In QOpenGLWidget what do request is obvious: it will request an
OpenGL-based QRhi. QQuickWidget (or a potential future QRhiWidget)
will be more interesting: it needs to honor the standard Qt Quick
env.vars. and QQuickWindow APIs (or, in whatever way the user
configured the QRhiWidget), and so will set up the config struct
accordingly.
In addition, the rhiconfig and surface type is (re)evaluated when
(re)parenting a widget to a new tlw. If needed, this will now trigger
a destroy - create on the tlw. This should be be safe to do in
setParent. When multiple child widgets report an enabled rhiconfig,
the first one (the first child encountered) wins. So e.g. attempting
to have a QOpenGLWidget and a Vulkan-based QQuickWidget in the same
top-level window will fail one of the widgets (it likely won't
render).
RasterGLSurface is no longer used by widgets. Rather, the appropriate
surface type is chosen.
The rhi support in the backingstore is usable without widgets as well.
To make rhiFlush() functional, one needs to call setRhiConfig() after
creating the QBackingStore. (like QWidget does to top-level windows)
Most of the QT_NO_OPENGL ifdefs are eliminated all over the place.
Everything with QRhi is unconditional code at compile time, except the
actual initialization.
Having to plumb the widget tlw's shareContext (or, now, the QRhi)
through QWindowPrivate is no longer needed. The old approach does not
scale: to implement composeAndFlush (now rhiFlush) we need more than
just a QRhi object, and this way we no longer pollute everything
starting from the widget level (QWidget's topextra -> QWidgetWindow ->
QWindowPrivate) just to send data around.
The BackingStoreOpenGLSupport interface and the QtGui - QtOpenGL split
is all gone. Instead, there is a QBackingStoreDefaultCompositor in
QtGui which is what the default implementations of composeAndFlush and
toTexture call. (overriding composeAndFlush and co. f.ex. in eglfs
should continue working mostly as-is, apart from adapting to the
texture list changes and getting the native OpenGL texture id out of
the QRhiTexture)
As QQuickWidget is way too complicated to just port as-is, an rhi
manual test (rhiwidget) is introduced as a first step, in ordewr to
exercise a simple, custom render-to-texture widget that does something
using a (not necessarily OpenGL-backed) QRhi and acts as fully
functional QWidget (modeled after QOpenGLWidget). This can also form
the foundation of a potential future QRhiWidget.
It is also possible to force the QRhi-based flushing always,
regardless of the presence of render-to-texture widgets. To exercise
this, set the env.var. QT_WIDGETS_RHI=1. This picks a
platform-specific default, and can be overridden with
QT_WIDGETS_RHI_BACKEND. (in sync with Qt Quick) This can eventually be
extended to query the platform plugin as well to check if the platform
plugin prefers to always do flushes with a 3D API.
QOpenGLWidget should work like before from the user's perspective, while
internally it has to do some things differently to play nice and prevent
regressions with the new rendering architecture. To exercise this
better, the qopenglwidget example gets a new tab-based view (that could
perhaps replace the example's main window later on?). The openglwidget
manual test is made compatible with Qt 6, and gets a counterpart in form
of the dockedopenglwidget manual test, which is a modified version of
the cube example that features dock widgets. This is relevant in
particular because render-to-texture widgets within a QDockWidget has
its own specific quirks, with logic taking this into account, hence
testing is essential.
For existing applications there are two important consequences with
this patch in place:
- Once the rhi-based composition is enabled, it stays active for the
lifetime of the top-level window.
- Dynamically creating and parenting the first render-to-texture
widget to an already created tlw will destroy and recreate the tlw
(and the underlying window). The visible effects of this depend on the
platform. (e.g. the window may disappear and reappear on some,
whereas with other windowing systems it is not noticeable at all -
this is not really different from similar situtions with reparenting
or when moving windows between screens, so should be acceptable in
practice)
- On iOS raster windows are flushed with Metal (and rhi) from now on
(previously this was through OpenGL by making flush() call
composeAndFlush().
Change-Id: Id05bd0f7a26fa845f8b7ad8eedda3b0e78ab7a4e
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Factor common code into a separate macro to DRY.
The immediate paractical consequence is that we now have a way to
reliably get a const char[] from the SIGNAL or SLOT macros, e.g. for
storing in a QOffsetStringArray, without causing compile errors in
debug mode or running the danger of causing runtime initialization via
qFlagLocation, which is of limited value in this circumstance, anyway,
because qFlagLocation only stores the last two strings.
Pick-to: 6.3
Change-Id: I67401858e94eedc1200fdd08e695fd56d10f8560
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The -mno-direct-extern-access tells the compiler and linker that
references to symbols outside this ELF module mustn't be direct and must
instead always go through the GOT or PLT (the PLT can additionally be
disabled with -fno-plt). The ELF protected visibility tells the compiler
and linker that this symbol is present in the dynamic symbol table as an
export, but it cannot be interposed by another ELF module.
This option is required for user code to link properly to Qt, otherwise
they will get linker errors (assuming GNU binutils >= 2.39) or runtime
failures (glibc >= 2.35). Both versions of glibc and binutils are older
than GCC 12, so it's a safe assumption they are in use and downgrading
the toolchain or libc is not supported. Adding this option to the
compilation is assured for CMake and qmake-based projects.
For example, all accessess to QCoreApplication::self in QtCore, after
this change and with GCC 12 are relocation-free and direct:
000000000013ebf0 <QCoreApplicationPrivate::checkInstance(char const*)>:
13ebf0: cmpq $0x0,0x4f73d0(%rip) # 635fc8 <QCoreApplication::self>
13ebf8: setne %al
13ebfb: je a90fe <QCoreApplicationPrivate::checkInstance(char const*) [clone .cold]>
13ec01: ret
Meanwhile, accesses to the same variable in other modules are indirect
via the GOT:
66650: mov 0x876e1(%rip),%rax # edd38 <QCoreApplication::self@Qt_6>
66657: cmpq $0x0,(%rax)
This replaces the -Bsymbolic and -Bsymbolic-functions (broken)
functionality that Qt has been using or attempting to use since ~2006.
See https://gitlab.com/x86-psABIs/x86-64-ABI/-/issues/8#note_606975128
Change-Id: Iad4b0a3e5c06570b9f5f571b26ed564aa0811e47
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
QObject's cache the binding status pointer to avoid TLS lookups.
However, when an object is moved to a different thread, we need to
update the cached pointer (as the original thread might stop and thus no
longer exist, and to correctly allow setting up bindings in the object's
thread).
Fix this by also storing the binding status in QThreadPrivate and
updating the object's binding status when moved. This does only work
when the thread is already running, though. If it is not running, we
instead treat the QThreadPrivate's status pointer as a pointer to a
vector of pending objects. Once the QThread has been started, we check
if there are pending objects, and update them at this point.
Pick-to: 6.2 6.3
Fixes: QTBUG-101177
Change-Id: I0490bbbdc1a17cb5f85044ad6eb2e1a8c759d4b7
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
By changing it to unique_ptr.
Pick-to: 6.2 6.3
Change-Id: I91abb69445b537d4c95983ae735341882352b29d
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The array of metatypes should always contain at least one entry (for the
metatype of the current metaobject itself).
This prevents crashes in the case of a metaobject without meta-methods
and properties (as observed in Qt for Python).
Pick-to: 6.2 6.3
Change-Id: I7a6fb316eea48c4852b6f1c26e0a930aeba4c799
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
See script in qtbase/util/includeprivate for the rules.
Since these files are being touched anyway, I also ran the
updatecopyright.pl script too.
Change-Id: Ib056b47dde3341ef9a52ffff13ef677e471674b6
Reviewed-by: Marc Mutz <marc.mutz@qt.io>
Sona Kurazyan
Thiago Macieira
Konrad Kujawa
Mike Trahearn
Tor Arne Vestbø
Morten Sørvig
Paul Wicking
Marc Mutz
Volker Hilsheimer
Giuseppe D'Angelo
Sami Shalayel
Fabian Kosmale
Oliver Wolff
Yuhang Zhao
Laszlo Papp
Jaishree Vyas
Mikolaj Boc
Alexey Edelev
Allan Sandfeld Jensen
Ivan Solovev
Juha Vuolle
Waqar Ahmed
Topi Reinio
Lars Knoll
Kai Köhne
Edward Welbourne
Tinja Paavoseppä
Lucie Gérard
Michael Spork
Samuel Mira
Liang Qi
Mårten Nordheim
Jarkko Koivikko
Ulf Hermann
Marc Mutz
Laszlo Agocs