3#ifndef QQUICKPALETTEPROVIDERPRIVATEBASE_H
4#define QQUICKPALETTEPROVIDERPRIVATEBASE_H
17#include <QtQuick/private/qquickpalette_p.h>
18#include <QtQuick/private/qquickabstractpaletteprovider_p.h>
19#include <QtGui/qwindow.h>
20#include <QtQml/private/qlazilyallocated_p.h>
42template <
class I,
class Impl>
45 static_assert(std::is_base_of<QObject, I>{},
"The interface class must inherit QObject");
124 using PalettePtr = std::unique_ptr<QQuickPalette>;
125 using Self = QQuickPaletteProviderPrivateBase<I, Impl>;
127 void registerPalette(PalettePtr
palette);
136 const I *itemWithPalette()
const;
137 I *itemWithPalette();
144 PalettePtr m_palette;
147template<
class I,
class Impl>
150 if (!providesPalette()) {
153 const_cast<Self*
>(
this)->registerPalette(std::make_unique<QQuickPalette>());
154 Q_EMIT const_cast<Self*
>(
this)->itemWithPalette()->paletteCreated();
157 return paletteData();
160template<
class I,
class Impl>
164 qWarning(
"Palette cannot be null.");
168 if (providesPalette() && paletteData() ==
palette) {
169 qWarning(
"Self assignment makes no sense.");
176template<
class I,
class Impl>
179 if (isValidPalette(
p)) {
180 palette()->fromQPalette(
p->toQPalette());
184template<
class I,
class Impl>
187 paletteData()->reset();
190template<
class I,
class Impl>
196template<
class I,
class Impl>
202template <
class Window>
203inline constexpr bool isRootWindow() {
return std::is_base_of_v<QWindow, Window>; }
205template<
class I,
class Impl>
208 if constexpr (!isRootWindow<I>()) {
210 if (!providesPalette()) {
215 m_palette = std::move(
palette);
216 m_palette->setPaletteProvider(
this);
217 m_palette->inheritPalette(parentPalette(defaultPalette()));
219 setCurrentColorGroup();
224 I::connect(paletteData(), &
QQuickPalette::changed, itemWithPalette(), [
this]{ updateChildrenPalettes(toQPalette()); });
233 if constexpr (std::is_base_of_v<T, QQuickWindow>) {
234 return getPrivateImpl<QQuickWindowPrivate>(
item);
235 }
else if constexpr (std::is_base_of_v<T, QQuickItem>) {
236 return getPrivateImpl<QQuickItemPrivate>(
item);
242template<
class I,
class Impl>
245 if constexpr (!isRootWindow<I>()) {
246 if (
auto window = itemWithPalette()->window()) {
256template<
class I,
class Impl>
259 if constexpr (!isRootWindow<I>()) {
261 if (!std::is_base_of_v<QQuickPopup, I>) {
262 for (
auto parentItem = itemWithPalette()->parentItem(); parentItem;
263 parentItem = parentItem->parentItem()) {
266 if (parentItem &&
getPrivate(*parentItem)->providesPalette()) {
267 return getPrivate(*parentItem)->palette()->toQPalette();
272 if (
auto wp = windowPalette()) {
273 return wp->toQPalette();
277 return fallbackPalette;
283 if constexpr (isRootWindow<I>()) {
284 return item.contentItem();
285 }
else if constexpr (std::is_base_of_v<QQuickPopup, I>) {
292template<
class I,
class Impl>
295 if (providesPalette()) {
298 palette()->inheritPalette(parentPalette);
301 updateChildrenPalettes(parentPalette);
305template<
class I,
class Impl>
308 if constexpr (!isRootWindow<I>()) {
309 if (providesPalette()) {
310 const bool enabled = itemWithPalette()->isEnabled();
311 const auto window = itemWithPalette()->window();
319template<
class I,
class Impl>
322 if constexpr (std::is_same_v<QQuickWindow, I> && std::is_same_v<QQuickWindowPrivate, Impl>) {
329 Q_UNREACHABLE_RETURN();
331 if (
auto root =
rootItem(*itemWithPalette())) {
332 for (
auto &&
child : root->childItems()) {
334 getPrivate(*child)->inheritPalette(parentPalette);
341template<
class I,
class Impl>
346 if constexpr (!isRootWindow<I>()) {
348 I::connect(itemWithPalette(), &I::parentChanged,
349 itemWithPalette(), [
this]() { inheritPalette(parentPalette(defaultPalette())); });
350 I::connect(itemWithPalette(), &I::windowChanged,
351 itemWithPalette(), [
this]() { inheritPalette(parentPalette(defaultPalette())); });
352 I::connect(itemWithPalette(), &I::enabledChanged,
353 itemWithPalette(), [
this]() { setCurrentColorGroup(); });
357template<
class I,
class Impl>
360 static_assert(std::is_base_of<QObjectData, Impl>{},
361 "The Impl class must inherit QObjectData");
363 return static_cast<const I*
>(
static_cast<const Impl*
>(
this)->q_ptr);
366template<
class I,
class Impl>
369 return const_cast<I*
>(
const_cast<const Self*
>(
this)->itemWithPalette());
372template<
class I,
class Impl>
375 Q_ASSERT(m_palette);
return m_palette.get();
378template<
class I,
class Impl>
381 return palette()->toQPalette();
The QPalette class contains color groups for each widget state.
The QQuickItem class provides the most basic of all visual items in \l {Qt Quick}.
void inheritPalette(const QPalette &parentPalette)
virtual bool providesPalette() const
virtual void updateChildrenPalettes(const QPalette &parentPalette)
virtual QQuickPalette * palette() const
virtual ~QQuickPaletteProviderPrivateBase()=default
void setCurrentColorGroup()
virtual void resetPalette()
QPalette parentPalette(const QPalette &fallbackPalette) const override
QPalette defaultPalette() const override
virtual void setPalette(QQuickPalette *p)
Contains color groups for each QML item state. \inmodule QtQuick.
\qmltype Window \instantiates QQuickWindow \inqmlmodule QtQuick
Combined button and popup list for selecting options.
GLenum GLenum GLsizei const GLuint GLboolean enabled
const QQuickItem * rootItem(const I &item)
decltype(auto) getPrivate(T &item)
constexpr bool isRootWindow()
decltype(auto) getPrivateImpl(I &t)