KDDockWidgets API Documentation  1.4
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Pages
QWidgetAdapter_quick.cpp
Go to the documentation of this file.
1 /*
2  This file is part of KDDockWidgets.
3 
4  SPDX-FileCopyrightText: 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
5  Author: Sérgio Martins <sergio.martins@kdab.com>
6 
7  SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only
8 
9  Contact KDAB at <info@kdab.com> for commercial licensing options.
10 */
11 
21 #include "QWidgetAdapter.h"
22 #include "MainWindowBase.h"
23 
24 #include "../DockRegistry_p.h"
25 #include "../Utils_p.h"
26 #include "../FloatingWindow_p.h"
27 
28 #include <QResizeEvent>
29 #include <QMouseEvent>
30 #include <QQmlComponent>
31 #include <QQuickItem>
32 #include <QQmlEngine>
33 #include <QQuickView>
34 #include <QScopedValueRollback>
35 
36 using namespace KDDockWidgets;
37 
38 namespace KDDockWidgets {
39 
45 class MouseEventRedirector : public QObject
46 {
47  Q_OBJECT
48 public:
49  explicit MouseEventRedirector(QObject *eventSource, QObject *eventTarget)
50  : QObject(eventTarget)
51  , m_eventSource(eventSource)
52  , m_eventTarget(eventTarget)
53  {
54  eventSource->installEventFilter(this);
55 
56  // Each source can only have one MouseEventRedirector
57  auto oldRedirector = s_mouseEventRedirectors.take(eventSource);
58  if (oldRedirector) {
59  eventSource->removeEventFilter(oldRedirector);
60  oldRedirector->deleteLater();
61  }
62 
63  s_mouseEventRedirectors.insert(eventSource, this);
64  }
65 
66  static MouseEventRedirector *redirectorForSource(QObject *eventSource)
67  {
68  return s_mouseEventRedirectors.value(eventSource);
69  }
70 
71  ~MouseEventRedirector() override;
72 
73  bool eventFilter(QObject *source, QEvent *ev) override
74  {
75  QMouseEvent *me = mouseEvent(ev);
76  if (!me)
77  return false;
78 
79  // MouseArea.enable is different from Item.enabled. The former still lets the events
80  // go through event loops. So query MouseArea.enable here and bail out if false.
81  const QVariant v = source->property("enabled");
82  if (v.isValid() && !v.toBool())
83  return false;
84 
85  // Finally send the event
86  m_eventTarget->setProperty("cursorPosition", m_eventSource->property("cursorPosition"));
87  qApp->sendEvent(m_eventTarget, me);
88  m_eventTarget->setProperty("cursorPosition", CursorPosition_Undefined);
89 
90  return false;
91  }
92 
93  QObject *const m_eventSource;
94  QObject *const m_eventTarget;
95  static QHash<QObject *, MouseEventRedirector *> s_mouseEventRedirectors;
96 };
97 
98 QHash<QObject *, MouseEventRedirector *> MouseEventRedirector::s_mouseEventRedirectors = {};
99 
100 MouseEventRedirector::~MouseEventRedirector()
101 {
102  s_mouseEventRedirectors.remove(m_eventSource);
103 }
104 
105 }
106 
108 {
109  return flags & (Qt::Window | Qt::Tool);
110 }
111 
112 static QQuickItem *actualParentItem(QQuickItem *candidateParentItem, Qt::WindowFlags flags)
113 {
114  // When we have a top-level, such as FloatingWindow, we only want to set QObject parentship
115  // and not parentItem.
116  return flagsAreTopLevelFlags(flags) ? nullptr
117  : candidateParentItem;
118 }
119 
120 QWidgetAdapter::QWidgetAdapter(QQuickItem *parent, Qt::WindowFlags flags)
121  : QQuickItem(actualParentItem(parent, flags))
122  , m_windowFlags(flags)
123 {
124  if (parent && flagsAreTopLevelFlags(flags)) {
125  // See comment in actualParentItem(). We set only the QObject parent. Mimics QWidget behaviour
126  QObject::setParent(parent);
127  }
128 
129  connect(this, &QQuickItem::widthChanged, this, [this] {
130  onResize(size());
131  updateGeometry();
132  });
133 
134  connect(this, &QQuickItem::heightChanged, this, [this] {
135  if (!m_windowIsBeingDestroyed) { // If Window is being destroyed we don't bother
136  onResize(size());
137  updateGeometry();
138  }
139  });
140 
141  setSize(QSize(800, 800));
142 }
143 
144 QWidgetAdapter::~QWidgetAdapter()
145 {
146 }
147 
148 void QWidgetAdapter::raiseAndActivate()
149 {
150  if (QWindow *w = windowHandle()) {
151  w->raise();
152  w->requestActivate();
153  }
154 }
155 
156 void QWidgetAdapter::setWindowOpacity(qreal level)
157 {
158  if (QWindow *w = windowHandle())
159  w->setOpacity(level);
160 }
161 
162 bool QWidgetAdapter::onResize(QSize)
163 {
164  return false;
165 }
166 void QWidgetAdapter::onLayoutRequest()
167 {
168 }
169 void QWidgetAdapter::onMousePress()
170 {
171 }
172 void QWidgetAdapter::onMouseMove(QPoint)
173 {
174 }
175 void QWidgetAdapter::onMouseRelease()
176 {
177 }
178 void QWidgetAdapter::onCloseEvent(QCloseEvent *)
179 {
180 }
181 
182 void QWidgetAdapter::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data)
183 {
184  QQuickItem::itemChange(change, data);
185 
186  // Emulate the QWidget behaviour as QQuickItem doesn't receive some QEvents.
187  switch (change) {
188  case QQuickItem::ItemParentHasChanged: {
190  qApp->sendEvent(this, &ev); // Not calling event() directly, otherwise it would skip event filters
191  Q_EMIT parentChanged(this);
192  break;
193  }
194  case QQuickItem::ItemVisibleHasChanged: {
195  if (m_inSetParent) {
196  // Setting parent to nullptr will emit visible true in QtQuick
197  // which we don't want, as we're going to hide it (as we do with QtWidgets)
198  break;
199  }
200 
201  QEvent ev(isVisible() ? QEvent::Show : QEvent::Hide);
202  event(&ev);
203  break;
204  }
205  default:
206  break;
207  }
208 }
209 
210 void QWidgetAdapter::QQUICKITEMgeometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
211 {
212  // Send a few events manually, since QQuickItem doesn't do it for us.
213  QQuickItem::QQUICKITEMgeometryChanged(newGeometry, oldGeometry);
214 
215  // Not calling event() directly, otherwise it would skip event filters
216 
217  if (newGeometry.size() != oldGeometry.size()) {
219  qApp->sendEvent(this, &ev);
220  }
221 
222  if (newGeometry.topLeft() != oldGeometry.topLeft()) {
223  QEvent ev(QEvent::Move);
224  qApp->sendEvent(this, &ev);
225  }
226 
227  Q_EMIT itemGeometryChanged();
228 }
229 
230 void QWidgetAdapter::raise()
231 {
232  if (isTopLevel()) {
233  if (QWindow *w = windowHandle())
234  w->raise();
235  } else if (auto p = QQuickItem::parentItem()) {
236  // It's not a top-level, so just increase its Z-order
237  const auto siblings = p->childItems();
238  QQuickItem *last = siblings.last();
239  if (last != this)
240  stackAfter(last);
241  }
242 }
243 
244 QSize QWidgetAdapter::minimumSize() const
245 {
246  if (m_isWrapper) {
247  const auto children = childItems();
248  if (!children.isEmpty()) {
249  const QSize min = children.constFirst()->property("kddockwidgets_min_size").toSize();
250  return min.expandedTo(Layouting::Item::hardcodedMinimumSize);
251  }
252  }
253 
254  const QSize min = property("kddockwidgets_min_size").toSize();
255  return min.expandedTo(Layouting::Item::hardcodedMinimumSize);
256 }
257 
258 QSize QWidgetAdapter::maximumSize() const
259 {
260 
261  if (m_isWrapper) {
262  const auto children = childItems();
263  if (!children.isEmpty()) {
264  const QSize max = children.constFirst()->property("kddockwidgets_max_size").toSize();
265  return max.isEmpty() ? Layouting::Item::hardcodedMaximumSize
266  : max.boundedTo(Layouting::Item::hardcodedMaximumSize);
267  }
268  }
269 
270  const QSize max = property("kddockwidgets_max_size").toSize();
271  return max.isEmpty() ? Layouting::Item::hardcodedMaximumSize
272  : max.boundedTo(Layouting::Item::hardcodedMaximumSize);
273 }
274 
275 WId QWidgetAdapter::winId() const
276 {
277  if (QWindow *w = windowHandle())
278  return w->winId();
279 
280  return WId(-1);
281 }
282 
283 FloatingWindow *QWidgetAdapter::floatingWindow() const
284 {
285  if (auto fw = qobject_cast<FloatingWindow *>(window()))
286  return fw;
287 
288  return nullptr;
289 }
290 
291 QRect QWidgetAdapter::geometry() const
292 {
293  if (isTopLevel()) {
294  if (QWindow *w = windowHandle()) {
295  return w->geometry();
296  }
297  }
298 
299  return KDDockWidgets::Private::geometry(this);
300 }
301 
302 QRect QWidgetAdapter::rect() const
303 {
304  return QRectF(0, 0, width(), height()).toRect();
305 }
306 
307 QPoint QWidgetAdapter::pos() const
308 {
309  return geometry().topLeft();
310 }
311 
312 void QWidgetAdapter::show()
313 {
314  setVisible(true);
315 }
316 
317 void QWidgetAdapter::setFixedHeight(int height)
318 {
319  setHeight(height);
320 }
321 
322 void QWidgetAdapter::setFixedWidth(int width)
323 {
324  setWidth(width);
325 }
326 
327 void QWidgetAdapter::setGeometry(QRect rect)
328 {
329  setWidth(rect.width());
330  setHeight(rect.height());
331  move(rect.topLeft());
332 }
333 
334 QRect QWidgetAdapter::frameGeometry() const
335 {
336  if (QWindow *w = windowHandle())
337  return w->frameGeometry();
338 
339  return geometry();
340 }
341 
342 void QWidgetAdapter::grabMouse()
343 {
344  QQuickItem::grabMouse();
345 }
346 
347 void QWidgetAdapter::releaseMouse()
348 {
349  QQuickItem::ungrabMouse();
350 }
351 
352 void QWidgetAdapter::releaseKeyboard()
353 {
354  // Not needed apparently
355 }
356 
357 void QWidgetAdapter::setMinimumSize(QSize sz)
358 {
359  if (minimumSize() != sz) {
360  setProperty("kddockwidgets_min_size", sz);
361  updateGeometry();
362  }
363 }
364 
365 void QWidgetAdapter::setMaximumSize(QSize sz)
366 {
367  if (maximumSize() != sz) {
368  setProperty("kddockwidgets_max_size", sz);
369  updateGeometry();
370  }
371 }
372 
373 void QWidgetAdapter::setMaximumSize(int w, int h)
374 {
375  QWidgetAdapter::setMaximumSize(QSize(w, h));
376 }
377 
378 void QWidgetAdapter::setMinimumSize(int w, int h)
379 {
380  QWidgetAdapter::setMinimumSize(QSize(w, h));
381 }
382 
383 void QWidgetAdapter::updateGeometry()
384 {
385  Q_EMIT geometryUpdated();
386 }
387 
388 void QWidgetAdapter::resize(QSize sz)
389 {
390  setWidth(sz.width());
391  setHeight(sz.height());
392 }
393 
394 void QWidgetAdapter::resize(int w, int h)
395 {
396  resize({ w, h });
397 }
398 
399 bool QWidgetAdapter::isWindow() const
400 {
401  QQuickItem *parent = parentItem();
402  if (!parent)
403  return true;
404 
405  if (QQuickView *w = quickView()) {
406  if (parent == w->contentItem() || parent == w->rootObject())
407  return true;
408  }
409 
410  return false;
411 }
412 
413 bool QWidgetAdapter::isMaximized() const
414 {
415  if (QWindow *w = windowHandle())
416  return w->windowStates() & Qt::WindowMaximized;
417 
418  return false;
419 }
420 
421 bool KDDockWidgets::QWidgetAdapter::isActiveWindow() const
422 {
423  if (QWindow *w = windowHandle())
424  return w->isActive();
425 
426  return false;
427 }
428 
429 void QWidgetAdapter::showMaximized()
430 {
431  if (QWindow *w = windowHandle())
432  w->showMaximized();
433 }
434 
435 void QWidgetAdapter::showMinimized()
436 {
437  if (QWindow *w = windowHandle())
438  w->showMinimized();
439 }
440 
441 void QWidgetAdapter::showNormal()
442 {
443  if (QWindow *w = windowHandle())
444  w->showNormal();
445 }
446 
447 QQuickView *QWidgetAdapter::quickView() const
448 {
449  return qobject_cast<QQuickView *>(QQuickItem::window());
450 }
451 
452 QWindow *QWidgetAdapter::windowHandle() const
453 {
454  return QQuickItem::window();
455 }
456 
457 QWidgetAdapter *QWidgetAdapter::window() const
458 {
459  // We return the top-most QWidgetAdapter
460 
461  if (QWidgetAdapter *w = parentWidget(/*includeTransient =*/false))
462  return w->window();
463 
464  return const_cast<QWidgetAdapter *>(this);
465 }
466 
467 QWidgetAdapter *QWidgetAdapter::parentWidget(bool includeTransient) const
468 {
469  QQuickItem *p = parentItem();
470  while (p) {
471  if (auto qa = qobject_cast<QWidgetAdapter *>(p))
472  return qa;
473 
474  p = p->parentItem();
475  }
476 
477  if (includeTransient) {
478  if (QQuickView *w = quickView()) {
479  // Here we're mimicking QWidget::parentWidget(), which can return the transient parent of the QWindow.
480  MainWindowBase *mw = DockRegistry::self()->mainWindowForHandle(w->transientParent());
481  if (mw)
482  return mw;
483  }
484  }
485 
486 
487  return nullptr;
488 }
489 
490 QPoint QWidgetAdapter::mapToGlobal(QPoint pt) const
491 {
492  return QQuickItem::mapToGlobal(pt).toPoint();
493 }
494 
495 QPoint QWidgetAdapter::mapFromGlobal(QPoint pt) const
496 {
497  return QQuickItem::mapFromGlobal(pt).toPoint();
498 }
499 
500 QPoint QWidgetAdapter::mapTo(const QQuickItem *parent, QPoint pos) const
501 {
502  if (!parent)
503  return {};
504 
505  return parent->mapFromGlobal(QQuickItem::mapToGlobal(pos)).toPoint();
506 }
507 
508 bool QWidgetAdapter::testAttribute(Qt::WidgetAttribute attr) const
509 {
510  return m_widgetAttributes & attr;
511 }
512 
513 void QWidgetAdapter::setAttribute(Qt::WidgetAttribute attr, bool enable)
514 {
515  if (enable)
516  m_widgetAttributes |= attr;
517  else
518  m_widgetAttributes &= ~attr;
519 }
520 
521 void QWidgetAdapter::setWindowTitle(const QString &title)
522 {
523  if (QWindow *window = windowHandle())
524  window->setTitle(title);
525 }
526 
527 void QWidgetAdapter::setWindowIcon(const QIcon &icon)
528 {
529  if (QWindow *window = windowHandle())
530  window->setIcon(icon);
531 }
532 
533 bool QWidgetAdapter::close()
534 {
535  QCloseEvent ev;
536  onCloseEvent(&ev);
537 
538  if (ev.isAccepted()) {
539  setVisible(false);
540  return true;
541  }
542 
543  return false;
544 }
545 
546 QQuickItem *QWidgetAdapter::childAt(QPoint p) const
547 {
548  return QQuickItem::childAt(p.x(), p.y());
549 }
550 
551 void QWidgetAdapter::move(QPoint pt)
552 {
553  move(pt.x(), pt.y());
554 }
555 
556 void QWidgetAdapter::move(int x, int y)
557 {
558  if (isTopLevel()) {
559  if (QWindow *w = windowHandle()) {
560  w->setPosition(x, y);
561  return;
562  }
563  }
564 
565  setX(x);
566  setY(y);
567  setAttribute(Qt::WA_Moved);
568 }
569 
570 void QWidgetAdapter::setSize(QSize size)
571 {
572  QQuickItem::setSize(QSizeF(size));
573 }
574 
575 void QWidgetAdapter::setParent(QQuickItem *p)
576 {
577  {
578  QScopedValueRollback<bool> guard(m_inSetParent, true);
579 
580  QQuickItem::setParent(p);
581  QQuickItem::setParentItem(p);
582  }
583 
584  // Mimic QWidget::setParent(), hide widget when setting parent
585  if (!p)
586  setVisible(false);
587 }
588 
589 void QWidgetAdapter::activateWindow()
590 {
591  if (QWindow *w = windowHandle())
592  w->requestActivate();
593 }
594 
595 void QWidgetAdapter::setSizePolicy(QSizePolicy sp)
596 {
597  m_sizePolicy = sp;
598 }
599 
600 QSizePolicy QWidgetAdapter::sizePolicy() const
601 {
602  return m_sizePolicy;
603 }
604 
605 QSize QWidgetAdapter::sizeHint() const
606 {
607  return m_sizeHint;
608 }
609 
610 bool QWidgetAdapter::hasFocus() const
611 {
612  return hasActiveFocus();
613 }
614 
615 void QWidgetAdapter::setWindowFlag(int flag, bool enable)
616 {
617  Q_UNUSED(flag);
618  Q_UNUSED(enable);
619 }
620 
621 Qt::WindowFlags QWidgetAdapter::windowFlags() const
622 {
623  return m_windowFlags;
624 }
625 
627 QQuickItem *QWidgetAdapter::createItem(QQmlEngine *engine, const QString &filename)
628 {
629  QQmlComponent component(engine, filename);
630  QObject *obj = component.create();
631  if (!obj) {
632  qWarning() << Q_FUNC_INFO << component.errorString();
633  return nullptr;
634  }
635 
636  return qobject_cast<QQuickItem *>(obj);
637 }
638 
639 void QWidgetAdapter::makeItemFillParent(QQuickItem *item)
640 {
641  // This is equivalent to "anchors.fill: parent
642 
643  if (!item) {
644  qWarning() << Q_FUNC_INFO << "Invalid item";
645  return;
646  }
647 
648  QQuickItem *parentItem = item->parentItem();
649  if (!parentItem) {
650  qWarning() << Q_FUNC_INFO << "Invalid parentItem for" << item;
651  return;
652  }
653 
654  QObject *anchors = item->property("anchors").value<QObject *>();
655  if (!anchors) {
656  qWarning() << Q_FUNC_INFO << "Invalid anchors for" << item;
657  return;
658  }
659 
660  anchors->setProperty("fill", QVariant::fromValue(parentItem));
661 }
662 
663 void QWidgetAdapter::setFlag(Qt::WindowType f, bool on)
664 {
665  if (on) {
666  m_windowFlags |= f;
667  } else {
668  m_windowFlags &= ~f;
669  }
670 }
671 
672 Qt::FocusPolicy QWidgetAdapter::focusPolicy() const
673 {
674  return m_focusPolicy;
675 }
676 
677 void QWidgetAdapter::setFocusPolicy(Qt::FocusPolicy policy)
678 {
679  m_focusPolicy = policy;
680 }
681 
682 void QWidgetAdapter::setFocus(Qt::FocusReason reason)
683 {
684  QQuickItem::setFocus(true, reason);
685  forceActiveFocus(reason);
686 }
687 
688 void QWidgetAdapter::render(QPainter *)
689 {
690  qWarning() << Q_FUNC_INFO << "Implement me";
691 }
692 
693 void QWidgetAdapter::setMouseTracking(bool enabled)
694 {
695  m_mouseTrackingEnabled = enabled;
696 }
697 
698 bool QWidgetAdapter::event(QEvent *ev)
699 {
700  if (ev->type() == QEvent::Close)
701  onCloseEvent(static_cast<QCloseEvent *>(ev));
702 
703  return QQuickItem::event(ev);
704 }
705 
706 bool QWidgetAdapter::eventFilter(QObject *watched, QEvent *ev)
707 {
708  if (qobject_cast<QWindow *>(watched)) {
709  if (m_mouseTrackingEnabled) {
710  switch (ev->type()) {
711  case QEvent::MouseMove:
714  ev->ignore();
715  qApp->sendEvent(this, ev);
716  //qDebug() << "Mouse event" << ev;
717  if (ev->isAccepted())
718  return true;
719  break;
720  default:
721  break;
722  }
723  }
724  }
725 
726  return QQuickItem::eventFilter(watched, ev);
727 }
728 
729 void QWidgetAdapter::setWindowIsBeingDestroyed(bool is)
730 {
731  m_windowIsBeingDestroyed = is;
732 }
733 
734 void QWidgetAdapter::create()
735 {
736  // Nothing to do, for QtQuick ?
737 }
738 
739 QQuickItem *KDDockWidgets::Private::widgetForWindow(QWindow *window)
740 {
741  if (!window)
742  return nullptr;
743 
744  return window->property("kddockwidgets_qwidget").value<QQuickItem *>();
745 }
746 
747 void QWidgetAdapter::redirectMouseEvents(QObject *source)
748 {
749  if (auto existingRedirector = MouseEventRedirector::redirectorForSource(source)) {
750  if (existingRedirector->m_eventTarget == this) {
751  // Nothing to do. The specified event source is already redirecting to this instance
752  return;
753  }
754  }
755 
756  new MouseEventRedirector(source, this);
757 }
758 
759 void QWidgetAdapter::setIsWrapper()
760 {
761  m_isWrapper = true;
762 }
763 
764 bool QWidgetAdapter::isWrapper() const
765 {
766  return m_isWrapper;
767 }
768 
769 LayoutGuestWidget::~LayoutGuestWidget() = default;
770 
771 #include "QWidgetAdapter_quick.moc"
QObject::Q_OBJECT
Q_OBJECTQ_OBJECT
QObject::removeEventFilter
void removeEventFilter(QObject *obj)
QVariant::isValid
bool isValid() const const
QEvent::ParentChange
ParentChange
QRect::topLeft
QPoint topLeft() const const
QVariant::fromValue
QVariant fromValue(const T &value)
QRect
QRectF::toRect
QRect toRect() const const
QVariant::value
T value() const const
QSize::isEmpty
bool isEmpty() const const
actualParentItem
static QQuickItem * actualParentItem(QQuickItem *candidateParentItem, Qt::WindowFlags flags)
Definition: QWidgetAdapter_quick.cpp:112
QWindow
QRect::width
int width() const const
QSize
QPoint::x
int x() const const
QPoint::y
int y() const const
QSize::width
int width() const const
QPainter
KDDockWidgets::CursorPosition_Undefined
@ CursorPosition_Undefined
Definition: KDDockWidgets.h:239
QMouseEvent
MainWindowBase.h
The MainWindow base-class that's shared between QtWidgets and QtQuick stack.
QWidgetAdapter.h
Abstraction for supporting both QtWidgets and QtQuick.
Qt::WindowFlags
typedef WindowFlags
QSizePolicy
QCloseEvent
QObject
Qt::FocusReason
FocusReason
QSize::height
int height() const const
QRectF::topLeft
QPointF topLeft() const const
QString
QEvent::isAccepted
bool isAccepted() const const
QObject::installEventFilter
void installEventFilter(QObject *filterObj)
QSize::boundedTo
QSize boundedTo(const QSize &otherSize) const const
Qt::WindowMaximized
WindowMaximized
QIcon
QVariant::toBool
bool toBool() const const
QObject::setProperty
bool setProperty(const char *name, const QVariant &value)
QSize::expandedTo
QSize expandedTo(const QSize &otherSize) const const
QRect::height
int height() const const
QHash::remove
int remove(const Key &key)
QEvent::type
QEvent::Type type() const const
QEvent
QObject::setParent
void setParent(QObject *parent)
QSizeF
QEvent::ignore
void ignore()
QRectF
KDDockWidgets
Definition: Config.cpp:36
QScopedValueRollback
QRectF::size
QSizeF size() const const
KDDockWidgets::MainWindowBase
The MainWindow base-class. MainWindow and MainWindowBase are only split in two so we can share some c...
Definition: MainWindowBase.h:56
flagsAreTopLevelFlags
static bool flagsAreTopLevelFlags(Qt::WindowFlags flags)
Definition: QWidgetAdapter_quick.cpp:107
QVariant
Qt::FocusPolicy
FocusPolicy
QHash< QObject *, MouseEventRedirector * >
Qt::WidgetAttribute
WidgetAttribute
QPoint
QObject::property
QVariant property(const char *name) const const

© 2019-2021 Klarälvdalens Datakonsult AB (KDAB)
"The Qt, C++ and OpenGL Experts"
https://www.kdab.com/
KDDockWidgets
Advanced Dock Widget Framework for Qt
https://www.kdab.com/development-resources/qt-tools/kddockwidgets/
Generated on Mon Nov 15 2021 00:17:28 for KDDockWidgets API Documentation by doxygen 1.8.20