vcl/qt5/QtFrame.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <QtFrame.hxx>
  21 #include <QtFrame.moc>
  22
  23 #include <QtData.hxx>
  24 #include <QtDragAndDrop.hxx>
  25 #include <QtFontFace.hxx>
  26 #include <QtGraphics.hxx>
  27 #include <QtInstance.hxx>
  28 #include <QtMainWindow.hxx>
  29 #include <QtMenu.hxx>
  30 #include <QtSvpGraphics.hxx>
  31 #include <QtSystem.hxx>
  32 #include <QtTools.hxx>
  33 #include <QtTransferable.hxx>
  34 #if CHECK_ANY_QT_USING_X11
  35 #include <QtX11Support.hxx>
  36 #endif
  37
  38 #include <QtCore/QMimeData>
  39 #include <QtCore/QPoint>
  40 #include <QtCore/QSize>
  41 #include <QtCore/QThread>
  42 #include <QtGui/QDragMoveEvent>
  43 #include <QtGui/QDropEvent>
  44 #include <QtGui/QIcon>
  45 #include <QtGui/QWindow>
  46 #include <QtGui/QScreen>
  47 #include <QtWidgets/QStyle>
  48 #include <QtWidgets/QToolTip>
  49 #include <QtWidgets/QApplication>
  50 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
  51 #include <QtWidgets/QDesktopWidget>
  52 #endif
  53 #include <QtWidgets/QMenuBar>
  54 #include <QtWidgets/QMainWindow>
  55 #if CHECK_QT5_USING_X11
  56 #include <QtX11Extras/QX11Info>
  57 #endif
  58
  59 #include <window.h>
  60 #include <vcl/syswin.hxx>
  61
  62 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
  63
  64 #include <cairo.h>
  65 #include <headless/svpgdi.hxx>
  66
  67 #include <unx/fontmanager.hxx>
  68
  69 #if CHECK_QT5_USING_X11 && QT5_HAVE_XCB_ICCCM
  70 static bool g_bNeedsWmHintsWindowGroup = true;
  71 #endif
  72
  73 static void SvpDamageHandler(void* handle, sal_Int32 nExtentsX, sal_Int32 nExtentsY,
  74                              sal_Int32 nExtentsWidth, sal_Int32 nExtentsHeight)
  75 {
  76     QtFrame* pThis = static_cast<QtFrame*>(handle);
  77     pThis->Damage(nExtentsX, nExtentsY, nExtentsWidth, nExtentsHeight);
  78 }
  79
  80 namespace
  81 {
  82 sal_Int32 screenNumber(const QScreen* pScreen)
  83 {
  84     const QList<QScreen*> screens = QApplication::screens();
  85
  86     sal_Int32 nScreen = 0;
  87     bool bFound = false;
  88     for (const QScreen* pCurScreen : screens)
  89     {
  90         if (pScreen == pCurScreen)
  91         {
  92             bFound = true;
  93             break;
  94         }
  95         nScreen++;
  96     }
  97
  98     return bFound ? nScreen : -1;
  99 }
 100 }
 101
 102 QtFrame::QtFrame(QtFrame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo)
 103     : m_pTopLevel(nullptr)
 104     , m_bUseCairo(bUseCairo)
 105     , m_bNullRegion(true)
 106     , m_bGraphicsInUse(false)
 107     , m_ePointerStyle(PointerStyle::Arrow)
 108     , m_pDragSource(nullptr)
 109     , m_pDropTarget(nullptr)
 110     , m_bInDrag(false)
 111     , m_bDefaultSize(true)
 112     , m_bDefaultPos(true)
 113     , m_bFullScreen(false)
 114     , m_bFullScreenSpanAll(false)
 115 #if CHECK_ANY_QT_USING_X11
 116     , m_nKeyModifiers(ModKeyFlags::NONE)
 117 #endif
 118     , m_nInputLanguage(LANGUAGE_DONTKNOW)
 119 {
 120     QtInstance* pInst = GetQtInstance();
 121     pInst->insertFrame(this);
 122
 123     m_aDamageHandler.handle = this;
 124     m_aDamageHandler.damaged = ::SvpDamageHandler;
 125
 126     if (nStyle & SalFrameStyleFlags::DEFAULT) // ensure default style
 127     {
 128         nStyle |= SalFrameStyleFlags::MOVEABLE | SalFrameStyleFlags::SIZEABLE
 129                   | SalFrameStyleFlags::CLOSEABLE;
 130         nStyle &= ~SalFrameStyleFlags::FLOAT;
 131     }
 132
 133     m_nStyle = nStyle;
 134     m_pParent = pParent;
 135
 136     Qt::WindowFlags aWinFlags(Qt::Widget);
 137     if (!(nStyle & SalFrameStyleFlags::SYSTEMCHILD))
 138     {
 139         if (nStyle & SalFrameStyleFlags::INTRO)
 140             aWinFlags = Qt::SplashScreen;
 141         // floating toolbars are frameless tool windows
 142         // + they must be able to receive keyboard focus
 143         else if ((nStyle & SalFrameStyleFlags::FLOAT)
 144                  && (nStyle & SalFrameStyleFlags::OWNERDRAWDECORATION))
 145             aWinFlags = Qt::Tool | Qt::FramelessWindowHint;
 146         else if (nStyle & SalFrameStyleFlags::TOOLTIP)
 147             aWinFlags = Qt::ToolTip;
 148         // Can't use Qt::Popup, because it grabs the input focus and generates a focus-out event,
 149         // instantly auto-closing the LO's editable ComboBox popup.
 150         // On X11, the alternative Qt::Window | Qt::FramelessWindowHint | Qt::BypassWindowManagerHint
 151         // seems to work well enough, but at least on Wayland and WASM, this results in problems.
 152         // So while using Qt::ToolTip, the popups are wrongly advertised via accessibility, at least
 153         // the GUI seems to work on all platforms... what a mess.
 154         else if (isPopup())
 155             aWinFlags = Qt::ToolTip | Qt::FramelessWindowHint;
 156         else if (nStyle & SalFrameStyleFlags::TOOLWINDOW)
 157             aWinFlags = Qt::Tool;
 158         // top level windows can't be transient in Qt, so make them dialogs, if they have a parent. At least
 159         // the plasma shell relies on this setting to skip dialogs in the window list. And Qt Xcb will just
 160         // set transient for the types Dialog, Sheet, Tool, SplashScreen, ToolTip, Drawer and Popup.
 161         else if (nStyle & SalFrameStyleFlags::DIALOG || m_pParent)
 162             aWinFlags = Qt::Dialog;
 163         else
 164             aWinFlags = Qt::Window;
 165     }
 166
 167     if (aWinFlags == Qt::Window)
 168     {
 169         m_pTopLevel = new QtMainWindow(*this, aWinFlags);
 170         m_pQWidget = new QtWidget(*this);
 171         m_pTopLevel->setCentralWidget(m_pQWidget);
 172         m_pTopLevel->setFocusProxy(m_pQWidget);
 173     }
 174     else
 175     {
 176         m_pQWidget = new QtWidget(*this, aWinFlags);
 177         // from Qt's POV the popup window doesn't have the input focus, so we must force tooltips...
 178         if (isPopup())
 179             m_pQWidget->setAttribute(Qt::WA_AlwaysShowToolTips);
 180     }
 181
 182     FillSystemEnvData(m_aSystemData, reinterpret_cast<sal_IntPtr>(this), m_pQWidget);
 183
 184     QWindow* pChildWindow = windowHandle();
 185     connect(pChildWindow, &QWindow::screenChanged, this, &QtFrame::screenChanged);
 186
 187     if (pParent && !(pParent->m_nStyle & SalFrameStyleFlags::PLUG))
 188     {
 189         QWindow* pParentWindow = pParent->windowHandle();
 190         if (pParentWindow && pChildWindow && (pParentWindow != pChildWindow))
 191             pChildWindow->setTransientParent(pParentWindow);
 192     }
 193
 194     SetIcon(SV_ICON_ID_OFFICE);
 195
 196     fixICCCMwindowGroup();
 197 }
 198
 199 void QtFrame::screenChanged(QScreen*) { m_pQWidget->fakeResize(); }
 200
 201 void QtFrame::FillSystemEnvData(SystemEnvData& rData, sal_IntPtr pWindow, QWidget* pWidget)
 202 {
 203     assert(rData.platform == SystemEnvData::Platform::Invalid);
 204     assert(rData.toolkit == SystemEnvData::Toolkit::Invalid);
 205     if (QGuiApplication::platformName() == "wayland")
 206         rData.platform = SystemEnvData::Platform::Wayland;
 207     else if (QGuiApplication::platformName() == "xcb")
 208         rData.platform = SystemEnvData::Platform::Xcb;
 209     else if (QGuiApplication::platformName() == "wasm")
 210         rData.platform = SystemEnvData::Platform::WASM;
 211     else
 212     {
 213         // maybe add a SystemEnvData::Platform::Unsupported to avoid special cases and not abort?
 214         SAL_WARN("vcl.qt",
 215                  "Unsupported qt VCL platform: " << toOUString(QGuiApplication::platformName()));
 216         std::abort();
 217     }
 218
 219     rData.toolkit = SystemEnvData::Toolkit::Qt;
 220     rData.aShellWindow = pWindow;
 221     rData.pWidget = pWidget;
 222 }
 223
 224 void QtFrame::fixICCCMwindowGroup()
 225 {
 226 #if CHECK_QT5_USING_X11 && QT5_HAVE_XCB_ICCCM
 227     if (!g_bNeedsWmHintsWindowGroup)
 228         return;
 229     g_bNeedsWmHintsWindowGroup = false;
 230
 231     assert(m_aSystemData.platform != SystemEnvData::Platform::Invalid);
 232     if (m_aSystemData.platform != SystemEnvData::Platform::Xcb)
 233         return;
 234
 235     g_bNeedsWmHintsWindowGroup = QtX11Support::fixICCCMwindowGroup(asChild()->winId());
 236 #else
 237     (void)this; // avoid loplugin:staticmethods
 238 #endif
 239 }
 240
 241 QtFrame::~QtFrame()
 242 {
 243     QtInstance* pInst = GetQtInstance();
 244     pInst->eraseFrame(this);
 245     delete asChild();
 246     m_aSystemData.aShellWindow = 0;
 247 }
 248
 249 void QtFrame::Damage(sal_Int32 nExtentsX, sal_Int32 nExtentsY, sal_Int32 nExtentsWidth,
 250                      sal_Int32 nExtentsHeight) const
 251 {
 252     m_pQWidget->update(scaledQRect(QRect(nExtentsX, nExtentsY, nExtentsWidth, nExtentsHeight),
 253                                    1 / devicePixelRatioF()));
 254 }
 255
 256 SalGraphics* QtFrame::AcquireGraphics()
 257 {
 258     if (m_bGraphicsInUse)
 259         return nullptr;
 260
 261     m_bGraphicsInUse = true;
 262
 263     if (m_bUseCairo)
 264     {
 265         if (!m_pSvpGraphics)
 266         {
 267             QSize aSize = m_pQWidget->size() * devicePixelRatioF();
 268             m_pSvpGraphics.reset(new QtSvpGraphics(this));
 269             m_pSurface.reset(
 270                 cairo_image_surface_create(CAIRO_FORMAT_ARGB32, aSize.width(), aSize.height()));
 271             m_pSvpGraphics->setSurface(m_pSurface.get(),
 272                                        basegfx::B2IVector(aSize.width(), aSize.height()));
 273             cairo_surface_set_user_data(m_pSurface.get(), QtSvpGraphics::getDamageKey(),
 274                                         &m_aDamageHandler, nullptr);
 275         }
 276         return m_pSvpGraphics.get();
 277     }
 278     else
 279     {
 280         if (!m_pQtGraphics)
 281         {
 282             m_pQtGraphics.reset(new QtGraphics(this));
 283             m_pQImage.reset(
 284                 new QImage(m_pQWidget->size() * devicePixelRatioF(), Qt_DefaultFormat32));
 285             m_pQImage->fill(Qt::transparent);
 286             m_pQtGraphics->ChangeQImage(m_pQImage.get());
 287         }
 288         return m_pQtGraphics.get();
 289     }
 290 }
 291
 292 void QtFrame::ReleaseGraphics(SalGraphics* pSalGraph)
 293 {
 294     (void)pSalGraph;
 295     if (m_bUseCairo)
 296         assert(pSalGraph == m_pSvpGraphics.get());
 297     else
 298         assert(pSalGraph == m_pQtGraphics.get());
 299     m_bGraphicsInUse = false;
 300 }
 301
 302 bool QtFrame::PostEvent(std::unique_ptr<ImplSVEvent> pData)
 303 {
 304     QtInstance* pInst = GetQtInstance();
 305     pInst->PostEvent(this, pData.release(), SalEvent::UserEvent);
 306     return true;
 307 }
 308
 309 QWidget* QtFrame::asChild() const
 310 {
 311     if (m_pTopLevel)
 312         return m_pTopLevel;
 313     return m_pQWidget;
 314 }
 315
 316 qreal QtFrame::devicePixelRatioF() const { return asChild()->devicePixelRatioF(); }
 317
 318 bool QtFrame::isWindow() const { return asChild()->isWindow(); }
 319
 320 QWindow* QtFrame::windowHandle() const
 321 {
 322     // set attribute 'Qt::WA_NativeWindow' first to make sure a window handle actually exists
 323     QWidget* pChild = asChild();
 324     assert(pChild->window() == pChild);
 325     switch (m_aSystemData.platform)
 326     {
 327         case SystemEnvData::Platform::Wayland:
 328         case SystemEnvData::Platform::Xcb:
 329             pChild->setAttribute(Qt::WA_NativeWindow);
 330             break;
 331         case SystemEnvData::Platform::WASM:
 332             // no idea, why Qt::WA_NativeWindow breaks the menubar for EMSCRIPTEN
 333             break;
 334         case SystemEnvData::Platform::Invalid:
 335             std::abort();
 336             break;
 337     }
 338     return pChild->windowHandle();
 339 }
 340
 341 QScreen* QtFrame::screen() const
 342 {
 343 #if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
 344     return asChild()->screen();
 345 #else
 346     // QWidget::screen only available from Qt 5.14 on, call windowHandle(),
 347     // with the indirect result that mouse move events on Wayland will not be
 348     // emitted reliably, s. QTBUG-75766
 349     QWindow* const pWindow = windowHandle();
 350     return pWindow ? pWindow->screen() : nullptr;
 351 #endif
 352 }
 353
 354 bool QtFrame::isMinimized() const { return asChild()->isMinimized(); }
 355
 356 bool QtFrame::isMaximized() const { return asChild()->isMaximized(); }
 357
 358 void QtFrame::SetWindowStateImpl(Qt::WindowStates eState)
 359 {
 360     return asChild()->setWindowState(eState);
 361 }
 362
 363 void QtFrame::SetTitle(const OUString& rTitle)
 364 {
 365     m_pQWidget->window()->setWindowTitle(toQString(rTitle));
 366 }
 367
 368 void QtFrame::SetIcon(sal_uInt16 nIcon)
 369 {
 370     if (m_nStyle
 371             & (SalFrameStyleFlags::PLUG | SalFrameStyleFlags::SYSTEMCHILD
 372                | SalFrameStyleFlags::FLOAT | SalFrameStyleFlags::INTRO
 373                | SalFrameStyleFlags::OWNERDRAWDECORATION)
 374         || !isWindow())
 375         return;
 376
 377     QString appicon;
 378
 379     if (nIcon == SV_ICON_ID_TEXT)
 380         appicon = "libreoffice-writer";
 381     else if (nIcon == SV_ICON_ID_SPREADSHEET)
 382         appicon = "libreoffice-calc";
 383     else if (nIcon == SV_ICON_ID_DRAWING)
 384         appicon = "libreoffice-draw";
 385     else if (nIcon == SV_ICON_ID_PRESENTATION)
 386         appicon = "libreoffice-impress";
 387     else if (nIcon == SV_ICON_ID_DATABASE)
 388         appicon = "libreoffice-base";
 389     else if (nIcon == SV_ICON_ID_FORMULA)
 390         appicon = "libreoffice-math";
 391     else
 392         appicon = "libreoffice-startcenter";
 393
 394     QIcon aIcon = QIcon::fromTheme(appicon);
 395     m_pQWidget->window()->setWindowIcon(aIcon);
 396 }
 397
 398 void QtFrame::SetMenu(SalMenu*) {}
 399
 400 void QtFrame::SetExtendedFrameStyle(SalExtStyle /*nExtStyle*/) { /* not needed */}
 401
 402 void QtFrame::Show(bool bVisible, bool bNoActivate)
 403 {
 404     assert(m_pQWidget);
 405     if (bVisible == asChild()->isVisible())
 406         return;
 407
 408     auto* pSalInst(GetQtInstance());
 409     assert(pSalInst);
 410
 411     if (!bVisible) // hide
 412     {
 413         pSalInst->RunInMainThread([this]() { asChild()->setVisible(false); });
 414         return;
 415     }
 416
 417     // show
 418     SetDefaultSize();
 419
 420     pSalInst->RunInMainThread([this, bNoActivate]() {
 421         QWidget* const pChild = asChild();
 422         pChild->setVisible(true);
 423         pChild->raise();
 424         if (!bNoActivate)
 425         {
 426             pChild->activateWindow();
 427             pChild->setFocus();
 428         }
 429     });
 430 }
 431
 432 void QtFrame::SetMinClientSize(tools::Long nWidth, tools::Long nHeight)
 433 {
 434     if (!isChild())
 435     {
 436         const qreal fRatio = devicePixelRatioF();
 437         asChild()->setMinimumSize(round(nWidth / fRatio), round(nHeight / fRatio));
 438     }
 439 }
 440
 441 void QtFrame::SetMaxClientSize(tools::Long nWidth, tools::Long nHeight)
 442 {
 443     if (!isChild())
 444     {
 445         const qreal fRatio = devicePixelRatioF();
 446         asChild()->setMaximumSize(round(nWidth / fRatio), round(nHeight / fRatio));
 447     }
 448 }
 449
 450 int QtFrame::menuBarOffset() const
 451 {
 452     QtMainWindow* pTopLevel = m_pParent->GetTopLevelWindow();
 453     if (pTopLevel && pTopLevel->menuBar() && pTopLevel->menuBar()->isVisible())
 454         return round(pTopLevel->menuBar()->geometry().height() * devicePixelRatioF());
 455     return 0;
 456 }
 457
 458 void QtFrame::SetDefaultPos()
 459 {
 460     if (!m_bDefaultPos)
 461         return;
 462
 463     // center on parent
 464     if (m_pParent)
 465     {
 466         const qreal fRatio = devicePixelRatioF();
 467         QWidget* const pParentWin = m_pParent->asChild()->window();
 468         QWidget* const pChildWin = asChild()->window();
 469         QPoint aPos = (pParentWin->rect().center() - pChildWin->rect().center()) * fRatio;
 470         aPos.ry() -= menuBarOffset();
 471         SetPosSize(aPos.x(), aPos.y(), 0, 0, SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y);
 472         assert(!m_bDefaultPos);
 473     }
 474     else
 475         m_bDefaultPos = false;
 476 }
 477
 478 Size QtFrame::CalcDefaultSize()
 479 {
 480     assert(isWindow());
 481
 482     Size aSize;
 483     if (!m_bFullScreen)
 484     {
 485         const QScreen* pScreen = screen();
 486         if (!pScreen)
 487             pScreen = QGuiApplication::screens().at(0);
 488         aSize = bestmaxFrameSizeForScreenSize(toSize(pScreen->size()));
 489     }
 490     else
 491     {
 492         if (!m_bFullScreenSpanAll)
 493         {
 494             aSize = toSize(QGuiApplication::screens().at(maGeometry.screen())->size());
 495         }
 496         else
 497         {
 498 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
 499             QScreen* pScreen = QGuiApplication::screenAt(QPoint(0, 0));
 500 #else
 501             // QGuiApplication::screenAt was added in Qt 5.10, use deprecated QDesktopWidget
 502             int nLeftScreen = QApplication::desktop()->screenNumber(QPoint(0, 0));
 503             QScreen* pScreen = QGuiApplication::screens()[nLeftScreen];
 504 #endif
 505             aSize = toSize(pScreen->availableVirtualGeometry().size());
 506         }
 507     }
 508
 509     return aSize;
 510 }
 511
 512 void QtFrame::SetDefaultSize()
 513 {
 514     if (!m_bDefaultSize)
 515         return;
 516
 517     Size aDefSize = CalcDefaultSize();
 518     SetPosSize(0, 0, aDefSize.Width(), aDefSize.Height(),
 519                SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT);
 520     assert(!m_bDefaultSize);
 521 }
 522
 523 void QtFrame::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
 524                          sal_uInt16 nFlags)
 525 {
 526     if (!isWindow() || isChild(true, false))
 527         return;
 528
 529     if (nFlags & (SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT))
 530     {
 531         if (isChild(false) || !m_pQWidget->isMaximized())
 532         {
 533             if (!(nFlags & SAL_FRAME_POSSIZE_WIDTH))
 534                 nWidth = maGeometry.width();
 535             else if (!(nFlags & SAL_FRAME_POSSIZE_HEIGHT))
 536                 nHeight = maGeometry.height();
 537
 538             if (nWidth > 0 && nHeight > 0)
 539             {
 540                 m_bDefaultSize = false;
 541                 const int nNewWidth = round(nWidth / devicePixelRatioF());
 542                 const int nNewHeight = round(nHeight / devicePixelRatioF());
 543                 if (m_nStyle & SalFrameStyleFlags::SIZEABLE)
 544                     asChild()->resize(nNewWidth, nNewHeight);
 545                 else
 546                     asChild()->setFixedSize(nNewWidth, nNewHeight);
 547             }
 548
 549             // assume the resize happened
 550             // needed for calculations and will eventually be corrected by events
 551             if (nWidth > 0)
 552                 maGeometry.setWidth(nWidth);
 553             if (nHeight > 0)
 554                 maGeometry.setHeight(nHeight);
 555         }
 556     }
 557
 558     if (!(nFlags & (SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y)))
 559     {
 560         if (nFlags & (SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT))
 561             SetDefaultPos();
 562         return;
 563     }
 564
 565     if (m_pParent)
 566     {
 567         const SalFrameGeometry& aParentGeometry = m_pParent->maGeometry;
 568         if (QGuiApplication::isRightToLeft())
 569             nX = aParentGeometry.x() + aParentGeometry.width() - nX - maGeometry.width() - 1;
 570         else
 571             nX += aParentGeometry.x();
 572         nY += aParentGeometry.y() + menuBarOffset();
 573     }
 574
 575     if (!(nFlags & SAL_FRAME_POSSIZE_X))
 576         nX = maGeometry.x();
 577     else if (!(nFlags & SAL_FRAME_POSSIZE_Y))
 578         nY = maGeometry.y();
 579
 580     // assume the reposition happened
 581     // needed for calculations and will eventually be corrected by events later
 582     maGeometry.setPos({ nX, nY });
 583
 584     m_bDefaultPos = false;
 585     asChild()->move(round(nX / devicePixelRatioF()), round(nY / devicePixelRatioF()));
 586 }
 587
 588 void QtFrame::GetClientSize(tools::Long& rWidth, tools::Long& rHeight)
 589 {
 590     rWidth = round(m_pQWidget->width() * devicePixelRatioF());
 591     rHeight = round(m_pQWidget->height() * devicePixelRatioF());
 592 }
 593
 594 void QtFrame::GetWorkArea(tools::Rectangle& rRect)
 595 {
 596     if (!isWindow())
 597         return;
 598     QScreen* pScreen = screen();
 599     if (!pScreen)
 600         return;
 601
 602     QSize aSize = pScreen->availableVirtualSize() * devicePixelRatioF();
 603     rRect = tools::Rectangle(0, 0, aSize.width(), aSize.height());
 604 }
 605
 606 SalFrame* QtFrame::GetParent() const { return m_pParent; }
 607
 608 void QtFrame::SetModal(bool bModal)
 609 {
 610     if (!isWindow() || asChild()->isModal() == bModal)
 611         return;
 612
 613     auto* pSalInst(GetQtInstance());
 614     assert(pSalInst);
 615     pSalInst->RunInMainThread([this, bModal]() {
 616
 617         QWidget* const pChild = asChild();
 618         const bool bWasVisible = pChild->isVisible();
 619
 620         // modality change is only effective if the window is hidden
 621         if (bWasVisible)
 622         {
 623             pChild->hide();
 624             if (QGuiApplication::platformName() == "xcb")
 625             {
 626                 SAL_WARN("vcl.qt", "SetModal called after Show - apply delay");
 627                 // tdf#152979 give QXcbConnection some time to avoid
 628                 // "qt.qpa.xcb: internal error:  void QXcbWindow::setNetWmStateOnUnmappedWindow() called on mapped window"
 629                 QThread::msleep(100);
 630             }
 631         }
 632
 633         pChild->setWindowModality(bModal ? Qt::WindowModal : Qt::NonModal);
 634
 635         if (bWasVisible)
 636             pChild->show();
 637     });
 638 }
 639
 640 bool QtFrame::GetModal() const { return isWindow() && windowHandle()->isModal(); }
 641
 642 void QtFrame::SetWindowState(const vcl::WindowData* pState)
 643 {
 644     if (!isWindow() || !pState || isChild(true, false))
 645         return;
 646
 647     const vcl::WindowDataMask nMaxGeometryMask
 648         = vcl::WindowDataMask::PosSize | vcl::WindowDataMask::MaximizedX
 649           | vcl::WindowDataMask::MaximizedY | vcl::WindowDataMask::MaximizedWidth
 650           | vcl::WindowDataMask::MaximizedHeight;
 651
 652     if ((pState->mask() & vcl::WindowDataMask::State)
 653         && (pState->state() & vcl::WindowState::Maximized) && !isMaximized()
 654         && (pState->mask() & nMaxGeometryMask) == nMaxGeometryMask)
 655     {
 656         const qreal fRatio = devicePixelRatioF();
 657         QWidget* const pChild = asChild();
 658         pChild->resize(ceil(pState->width() / fRatio), ceil(pState->height() / fRatio));
 659         pChild->move(ceil(pState->x() / fRatio), ceil(pState->y() / fRatio));
 660         SetWindowStateImpl(Qt::WindowMaximized);
 661     }
 662     else if (pState->mask() & vcl::WindowDataMask::PosSize)
 663     {
 664         sal_uInt16 nPosSizeFlags = 0;
 665         if (pState->mask() & vcl::WindowDataMask::X)
 666             nPosSizeFlags |= SAL_FRAME_POSSIZE_X;
 667         if (pState->mask() & vcl::WindowDataMask::Y)
 668             nPosSizeFlags |= SAL_FRAME_POSSIZE_Y;
 669         if (pState->mask() & vcl::WindowDataMask::Width)
 670             nPosSizeFlags |= SAL_FRAME_POSSIZE_WIDTH;
 671         if (pState->mask() & vcl::WindowDataMask::Height)
 672             nPosSizeFlags |= SAL_FRAME_POSSIZE_HEIGHT;
 673         SetPosSize(pState->x(), pState->y(), pState->width(), pState->height(), nPosSizeFlags);
 674     }
 675     else if (pState->mask() & vcl::WindowDataMask::State && !isChild())
 676     {
 677         if (pState->state() & vcl::WindowState::Maximized)
 678             SetWindowStateImpl(Qt::WindowMaximized);
 679         else if (pState->state() & vcl::WindowState::Minimized)
 680             SetWindowStateImpl(Qt::WindowMinimized);
 681         else
 682             SetWindowStateImpl(Qt::WindowNoState);
 683     }
 684 }
 685
 686 bool QtFrame::GetWindowState(vcl::WindowData* pState)
 687 {
 688     pState->setState(vcl::WindowState::Normal);
 689     pState->setMask(vcl::WindowDataMask::State);
 690     if (isMinimized())
 691         pState->rState() |= vcl::WindowState::Minimized;
 692     else if (isMaximized())
 693         pState->rState() |= vcl::WindowState::Maximized;
 694     else
 695     {
 696         // we want the frame position and the client area size
 697         QRect rect = scaledQRect({ asChild()->pos(), asChild()->size() }, devicePixelRatioF());
 698         pState->setPosSize(toRectangle(rect));
 699         pState->rMask() |= vcl::WindowDataMask::PosSize;
 700     }
 701
 702     return true;
 703 }
 704
 705 void QtFrame::ShowFullScreen(bool bFullScreen, sal_Int32 nScreen)
 706 {
 707     // only top-level windows can go fullscreen
 708     assert(m_pTopLevel);
 709
 710     if (m_bFullScreen == bFullScreen)
 711         return;
 712
 713     m_bFullScreen = bFullScreen;
 714     m_bFullScreenSpanAll = m_bFullScreen && (nScreen < 0);
 715
 716     // show it if it isn't shown yet
 717     if (!isWindow())
 718         m_pTopLevel->show();
 719
 720     if (m_bFullScreen)
 721     {
 722         m_aRestoreGeometry = m_pTopLevel->geometry();
 723         m_nRestoreScreen = maGeometry.screen();
 724         SetScreenNumber(m_bFullScreenSpanAll ? m_nRestoreScreen : nScreen);
 725         if (!m_bFullScreenSpanAll)
 726             windowHandle()->showFullScreen();
 727         else
 728             windowHandle()->showNormal();
 729     }
 730     else
 731     {
 732         SetScreenNumber(m_nRestoreScreen);
 733         windowHandle()->showNormal();
 734         m_pTopLevel->setGeometry(m_aRestoreGeometry);
 735     }
 736 }
 737
 738 void QtFrame::StartPresentation(bool bStart)
 739 {
 740 #if CHECK_ANY_QT_USING_X11
 741     // meh - so there's no Qt platform independent solution
 742     // https://forum.qt.io/topic/38504/solved-qdialog-in-fullscreen-disable-os-screensaver
 743     assert(m_aSystemData.platform != SystemEnvData::Platform::Invalid);
 744     unsigned int nRootWindow(0);
 745     std::optional<Display*> aDisplay;
 746
 747 #if CHECK_QT5_USING_X11
 748     if (QX11Info::isPlatformX11())
 749     {
 750         nRootWindow = QX11Info::appRootWindow();
 751         aDisplay = QX11Info::display();
 752     }
 753 #endif
 754
 755     m_SessionManagerInhibitor.inhibit(bStart, u"presentation", APPLICATION_INHIBIT_IDLE,
 756                                       nRootWindow, aDisplay);
 757 #else
 758     Q_UNUSED(bStart)
 759 #endif
 760 }
 761
 762 void QtFrame::SetAlwaysOnTop(bool bOnTop)
 763 {
 764     QWidget* const pWidget = asChild();
 765     const Qt::WindowFlags flags = pWidget->windowFlags();
 766     if (bOnTop)
 767         pWidget->setWindowFlags(flags | Qt::CustomizeWindowHint | Qt::WindowStaysOnTopHint);
 768     else
 769         pWidget->setWindowFlags(flags & ~(Qt::CustomizeWindowHint | Qt::WindowStaysOnTopHint));
 770 }
 771
 772 void QtFrame::ToTop(SalFrameToTop nFlags)
 773 {
 774     QWidget* const pWidget = asChild();
 775     if (isWindow() && !(nFlags & SalFrameToTop::GrabFocusOnly))
 776         pWidget->raise();
 777     if ((nFlags & SalFrameToTop::RestoreWhenMin) || (nFlags & SalFrameToTop::ForegroundTask))
 778     {
 779         if (nFlags & SalFrameToTop::RestoreWhenMin)
 780             pWidget->setWindowState(pWidget->windowState() & ~Qt::WindowMinimized);
 781         pWidget->activateWindow();
 782     }
 783     else if ((nFlags & SalFrameToTop::GrabFocus) || (nFlags & SalFrameToTop::GrabFocusOnly))
 784     {
 785         if (!(nFlags & SalFrameToTop::GrabFocusOnly))
 786             pWidget->activateWindow();
 787         pWidget->setFocus(Qt::OtherFocusReason);
 788     }
 789 }
 790
 791 void QtFrame::SetPointer(PointerStyle ePointerStyle)
 792 {
 793     if (ePointerStyle == m_ePointerStyle)
 794         return;
 795     m_ePointerStyle = ePointerStyle;
 796
 797     m_pQWidget->setCursor(GetQtData()->getCursor(ePointerStyle));
 798 }
 799
 800 void QtFrame::CaptureMouse(bool bMouse)
 801 {
 802     static const char* pEnv = getenv("SAL_NO_MOUSEGRABS");
 803     if (pEnv && *pEnv)
 804         return;
 805
 806     if (bMouse)
 807         m_pQWidget->grabMouse();
 808     else
 809         m_pQWidget->releaseMouse();
 810 }
 811
 812 void QtFrame::SetPointerPos(tools::Long nX, tools::Long nY)
 813 {
 814     // some cursor already exists (and it has m_ePointerStyle shape)
 815     // so here we just reposition it
 816     QCursor::setPos(m_pQWidget->mapToGlobal(QPoint(nX, nY) / devicePixelRatioF()));
 817 }
 818
 819 void QtFrame::Flush()
 820 {
 821     // was: QGuiApplication::sync();
 822     // but FIXME it causes too many issues, figure out sth better
 823
 824     // unclear if we need to also flush cairo surface - gtk3 backend
 825     // does not do it. QPainter in QtWidget::paintEvent() is
 826     // destroyed, so that state should be safely flushed.
 827 }
 828
 829 bool QtFrame::ShowTooltip(const OUString& rText, const tools::Rectangle& rHelpArea)
 830 {
 831     QRect aHelpArea(toQRect(rHelpArea));
 832     if (QGuiApplication::isRightToLeft())
 833         aHelpArea.moveLeft(maGeometry.width() - aHelpArea.width() - aHelpArea.left() - 1);
 834     m_aTooltipText = rText;
 835     m_aTooltipArea = aHelpArea;
 836     return true;
 837 }
 838
 839 void QtFrame::SetInputContext(SalInputContext* pContext)
 840 {
 841     if (!pContext)
 842         return;
 843
 844     if (!(pContext->mnOptions & InputContextFlags::Text))
 845         return;
 846
 847     m_pQWidget->setAttribute(Qt::WA_InputMethodEnabled);
 848 }
 849
 850 void QtFrame::EndExtTextInput(EndExtTextInputFlags /*nFlags*/)
 851 {
 852     if (m_pQWidget)
 853         m_pQWidget->endExtTextInput();
 854 }
 855
 856 OUString QtFrame::GetKeyName(sal_uInt16 nKeyCode)
 857 {
 858     vcl::KeyCode vclKeyCode(nKeyCode);
 859     int nCode = vclKeyCode.GetCode();
 860     int nRetCode = 0;
 861
 862     if (nCode >= KEY_0 && nCode <= KEY_9)
 863         nRetCode = (nCode - KEY_0) + Qt::Key_0;
 864     else if (nCode >= KEY_A && nCode <= KEY_Z)
 865         nRetCode = (nCode - KEY_A) + Qt::Key_A;
 866     else if (nCode >= KEY_F1 && nCode <= KEY_F26)
 867         nRetCode = (nCode - KEY_F1) + Qt::Key_F1;
 868     else
 869     {
 870         switch (nCode)
 871         {
 872             case KEY_DOWN:
 873                 nRetCode = Qt::Key_Down;
 874                 break;
 875             case KEY_UP:
 876                 nRetCode = Qt::Key_Up;
 877                 break;
 878             case KEY_LEFT:
 879                 nRetCode = Qt::Key_Left;
 880                 break;
 881             case KEY_RIGHT:
 882                 nRetCode = Qt::Key_Right;
 883                 break;
 884             case KEY_HOME:
 885                 nRetCode = Qt::Key_Home;
 886                 break;
 887             case KEY_END:
 888                 nRetCode = Qt::Key_End;
 889                 break;
 890             case KEY_PAGEUP:
 891                 nRetCode = Qt::Key_PageUp;
 892                 break;
 893             case KEY_PAGEDOWN:
 894                 nRetCode = Qt::Key_PageDown;
 895                 break;
 896             case KEY_RETURN:
 897                 nRetCode = Qt::Key_Return;
 898                 break;
 899             case KEY_ESCAPE:
 900                 nRetCode = Qt::Key_Escape;
 901                 break;
 902             case KEY_TAB:
 903                 nRetCode = Qt::Key_Tab;
 904                 break;
 905             case KEY_BACKSPACE:
 906                 nRetCode = Qt::Key_Backspace;
 907                 break;
 908             case KEY_SPACE:
 909                 nRetCode = Qt::Key_Space;
 910                 break;
 911             case KEY_INSERT:
 912                 nRetCode = Qt::Key_Insert;
 913                 break;
 914             case KEY_DELETE:
 915                 nRetCode = Qt::Key_Delete;
 916                 break;
 917             case KEY_ADD:
 918                 nRetCode = Qt::Key_Plus;
 919                 break;
 920             case KEY_SUBTRACT:
 921                 nRetCode = Qt::Key_Minus;
 922                 break;
 923             case KEY_MULTIPLY:
 924                 nRetCode = Qt::Key_Asterisk;
 925                 break;
 926             case KEY_DIVIDE:
 927                 nRetCode = Qt::Key_Slash;
 928                 break;
 929             case KEY_POINT:
 930                 nRetCode = Qt::Key_Period;
 931                 break;
 932             case KEY_COMMA:
 933                 nRetCode = Qt::Key_Comma;
 934                 break;
 935             case KEY_LESS:
 936                 nRetCode = Qt::Key_Less;
 937                 break;
 938             case KEY_GREATER:
 939                 nRetCode = Qt::Key_Greater;
 940                 break;
 941             case KEY_EQUAL:
 942                 nRetCode = Qt::Key_Equal;
 943                 break;
 944             case KEY_FIND:
 945                 nRetCode = Qt::Key_Find;
 946                 break;
 947             case KEY_CONTEXTMENU:
 948                 nRetCode = Qt::Key_Menu;
 949                 break;
 950             case KEY_HELP:
 951                 nRetCode = Qt::Key_Help;
 952                 break;
 953             case KEY_UNDO:
 954                 nRetCode = Qt::Key_Undo;
 955                 break;
 956             case KEY_REPEAT:
 957                 nRetCode = Qt::Key_Redo;
 958                 break;
 959             case KEY_TILDE:
 960                 nRetCode = Qt::Key_AsciiTilde;
 961                 break;
 962             case KEY_QUOTELEFT:
 963                 nRetCode = Qt::Key_QuoteLeft;
 964                 break;
 965             case KEY_BRACKETLEFT:
 966                 nRetCode = Qt::Key_BracketLeft;
 967                 break;
 968             case KEY_BRACKETRIGHT:
 969                 nRetCode = Qt::Key_BracketRight;
 970                 break;
 971             case KEY_COLON:
 972                 nRetCode = Qt::Key_Colon;
 973                 break;
 974             case KEY_SEMICOLON:
 975                 nRetCode = Qt::Key_Semicolon;
 976                 break;
 977
 978             // Special cases
 979             case KEY_COPY:
 980                 nRetCode = Qt::Key_Copy;
 981                 break;
 982             case KEY_CUT:
 983                 nRetCode = Qt::Key_Cut;
 984                 break;
 985             case KEY_PASTE:
 986                 nRetCode = Qt::Key_Paste;
 987                 break;
 988             case KEY_OPEN:
 989                 nRetCode = Qt::Key_Open;
 990                 break;
 991         }
 992     }
 993
 994     if (vclKeyCode.IsShift())
 995         nRetCode += Qt::SHIFT;
 996     if (vclKeyCode.IsMod1())
 997         nRetCode += Qt::CTRL;
 998     if (vclKeyCode.IsMod2())
 999         nRetCode += Qt::ALT;
1000
1001     QKeySequence keySeq(nRetCode);
1002     OUString sKeyName = toOUString(keySeq.toString());
1003
1004     return sKeyName;
1005 }
1006
1007 bool QtFrame::MapUnicodeToKeyCode(sal_Unicode /*aUnicode*/, LanguageType /*aLangType*/,
1008                                   vcl::KeyCode& /*rKeyCode*/)
1009 {
1010     // not supported yet
1011     return false;
1012 }
1013
1014 LanguageType QtFrame::GetInputLanguage() { return m_nInputLanguage; }
1015
1016 void QtFrame::setInputLanguage(LanguageType nInputLanguage)
1017 {
1018     if (nInputLanguage == m_nInputLanguage)
1019         return;
1020     m_nInputLanguage = nInputLanguage;
1021     CallCallback(SalEvent::InputLanguageChange, nullptr);
1022 }
1023
1024 static Color toColor(const QColor& rColor)
1025 {
1026     return Color(rColor.red(), rColor.green(), rColor.blue());
1027 }
1028
1029 static bool toVclFont(const QFont& rQFont, const css::lang::Locale& rLocale, vcl::Font& rVclFont)
1030 {
1031     psp::FastPrintFontInfo aInfo;
1032     QFontInfo qFontInfo(rQFont);
1033
1034     OUString sFamilyName = toOUString(rQFont.family());
1035     aInfo.m_aFamilyName = sFamilyName;
1036     aInfo.m_eItalic = QtFontFace::toFontItalic(qFontInfo.style());
1037     aInfo.m_eWeight = QtFontFace::toFontWeight(qFontInfo.weight());
1038     aInfo.m_eWidth = QtFontFace::toFontWidth(rQFont.stretch());
1039
1040     psp::PrintFontManager::get().matchFont(aInfo, rLocale);
1041     SAL_INFO("vcl.qt", "font match result for '"
1042                            << sFamilyName << "': "
1043                            << (aInfo.m_nID != 0 ? OUString::Concat("'") + aInfo.m_aFamilyName + "'"
1044                                                 : OUString("failed")));
1045
1046     if (aInfo.m_nID == 0)
1047         return false;
1048
1049     int nPointHeight = qFontInfo.pointSize();
1050     if (nPointHeight <= 0)
1051         nPointHeight = rQFont.pointSize();
1052
1053     vcl::Font aFont(aInfo.m_aFamilyName, Size(0, nPointHeight));
1054     if (aInfo.m_eWeight != WEIGHT_DONTKNOW)
1055         aFont.SetWeight(aInfo.m_eWeight);
1056     if (aInfo.m_eWidth != WIDTH_DONTKNOW)
1057         aFont.SetWidthType(aInfo.m_eWidth);
1058     if (aInfo.m_eItalic != ITALIC_DONTKNOW)
1059         aFont.SetItalic(aInfo.m_eItalic);
1060     if (aInfo.m_ePitch != PITCH_DONTKNOW)
1061         aFont.SetPitch(aInfo.m_ePitch);
1062
1063     rVclFont = aFont;
1064     return true;
1065 }
1066
1067 void QtFrame::UpdateSettings(AllSettings& rSettings)
1068 {
1069     if (QtData::noNativeControls())
1070         return;
1071
1072     StyleSettings style(rSettings.GetStyleSettings());
1073     const css::lang::Locale aLocale = rSettings.GetUILanguageTag().getLocale();
1074
1075     // General settings
1076     QPalette pal = QApplication::palette();
1077
1078     style.SetToolbarIconSize(ToolbarIconSize::Large);
1079
1080     Color aFore = toColor(pal.color(QPalette::Active, QPalette::WindowText));
1081     Color aBack = toColor(pal.color(QPalette::Active, QPalette::Window));
1082     Color aText = toColor(pal.color(QPalette::Active, QPalette::Text));
1083     Color aBase = toColor(pal.color(QPalette::Active, QPalette::Base));
1084     Color aButn = toColor(pal.color(QPalette::Active, QPalette::ButtonText));
1085     Color aMid = toColor(pal.color(QPalette::Active, QPalette::Mid));
1086     Color aHigh = toColor(pal.color(QPalette::Active, QPalette::Highlight));
1087     Color aHighText = toColor(pal.color(QPalette::Active, QPalette::HighlightedText));
1088     Color aLink = toColor(pal.color(QPalette::Active, QPalette::Link));
1089     Color aVisitedLink = toColor(pal.color(QPalette::Active, QPalette::LinkVisited));
1090
1091     style.SetSkipDisabledInMenus(true);
1092
1093     // Foreground
1094     style.SetRadioCheckTextColor(aFore);
1095     style.SetLabelTextColor(aFore);
1096     style.SetDialogTextColor(aFore);
1097     style.SetGroupTextColor(aFore);
1098
1099     // Text
1100     style.SetFieldTextColor(aText);
1101     style.SetFieldRolloverTextColor(aText);
1102     style.SetListBoxWindowTextColor(aText);
1103     style.SetWindowTextColor(aText);
1104     style.SetToolTextColor(aText);
1105
1106     // Base
1107     style.SetFieldColor(aBase);
1108     style.SetWindowColor(aBase);
1109     style.SetActiveTabColor(aBase);
1110     style.SetListBoxWindowBackgroundColor(aBase);
1111     style.SetAlternatingRowColor(toColor(pal.color(QPalette::Active, QPalette::AlternateBase)));
1112
1113     // Buttons
1114     style.SetDefaultButtonTextColor(aButn);
1115     style.SetButtonTextColor(aButn);
1116     style.SetDefaultActionButtonTextColor(aButn);
1117     style.SetActionButtonTextColor(aButn);
1118     style.SetFlatButtonTextColor(aButn);
1119     style.SetDefaultButtonRolloverTextColor(aButn);
1120     style.SetButtonRolloverTextColor(aButn);
1121     style.SetDefaultActionButtonRolloverTextColor(aButn);
1122     style.SetActionButtonRolloverTextColor(aButn);
1123     style.SetFlatButtonRolloverTextColor(aButn);
1124     style.SetDefaultButtonPressedRolloverTextColor(aButn);
1125     style.SetButtonPressedRolloverTextColor(aButn);
1126     style.SetDefaultActionButtonPressedRolloverTextColor(aButn);
1127     style.SetActionButtonPressedRolloverTextColor(aButn);
1128     style.SetFlatButtonPressedRolloverTextColor(aButn);
1129
1130     // Tabs
1131     style.SetTabTextColor(aButn);
1132     style.SetTabRolloverTextColor(aButn);
1133     style.SetTabHighlightTextColor(aButn);
1134
1135     // Disable color
1136     style.SetDisableColor(toColor(pal.color(QPalette::Disabled, QPalette::WindowText)));
1137
1138     // Background
1139     style.BatchSetBackgrounds(aBack);
1140     style.SetInactiveTabColor(aBack);
1141
1142     // Workspace
1143     style.SetWorkspaceColor(aMid);
1144
1145     // Selection
1146     // https://invent.kde.org/plasma/plasma-workspace/-/merge_requests/305
1147     style.SetAccentColor(aHigh);
1148     style.SetHighlightColor(aHigh);
1149     style.SetHighlightTextColor(aHighText);
1150     style.SetListBoxWindowHighlightColor(aHigh);
1151     style.SetListBoxWindowHighlightTextColor(aHighText);
1152     style.SetActiveColor(aHigh);
1153     style.SetActiveTextColor(aHighText);
1154
1155     // Links
1156     style.SetLinkColor(aLink);
1157     style.SetVisitedLinkColor(aVisitedLink);
1158
1159     // Tooltip
1160     style.SetHelpColor(toColor(QToolTip::palette().color(QPalette::Active, QPalette::ToolTipBase)));
1161     style.SetHelpTextColor(
1162         toColor(QToolTip::palette().color(QPalette::Active, QPalette::ToolTipText)));
1163
1164     // Menu
1165     std::unique_ptr<QMenuBar> pMenuBar = std::make_unique<QMenuBar>();
1166     QPalette qMenuCG = pMenuBar->palette();
1167
1168     // Menu text and background color, theme specific
1169     Color aMenuFore = toColor(qMenuCG.color(QPalette::WindowText));
1170     Color aMenuBack = toColor(qMenuCG.color(QPalette::Window));
1171
1172     style.SetMenuTextColor(aMenuFore);
1173     style.SetMenuBarTextColor(style.GetPersonaMenuBarTextColor().value_or(aMenuFore));
1174     style.SetMenuColor(aMenuBack);
1175     style.SetMenuBarColor(aMenuBack);
1176     style.SetMenuHighlightColor(toColor(qMenuCG.color(QPalette::Highlight)));
1177     style.SetMenuHighlightTextColor(toColor(qMenuCG.color(QPalette::HighlightedText)));
1178
1179     // set special menubar highlight text color
1180     if (QApplication::style()->inherits("HighContrastStyle"))
1181         ImplGetSVData()->maNWFData.maMenuBarHighlightTextColor
1182             = toColor(qMenuCG.color(QPalette::HighlightedText));
1183     else
1184         ImplGetSVData()->maNWFData.maMenuBarHighlightTextColor = aMenuFore;
1185
1186     // set menubar rollover color
1187     if (pMenuBar->style()->styleHint(QStyle::SH_MenuBar_MouseTracking))
1188     {
1189         style.SetMenuBarRolloverColor(toColor(qMenuCG.color(QPalette::Highlight)));
1190         style.SetMenuBarRolloverTextColor(ImplGetSVData()->maNWFData.maMenuBarHighlightTextColor);
1191     }
1192     else
1193     {
1194         style.SetMenuBarRolloverColor(aMenuBack);
1195         style.SetMenuBarRolloverTextColor(aMenuFore);
1196     }
1197     style.SetMenuBarHighlightTextColor(style.GetMenuHighlightTextColor());
1198
1199     // Default fonts
1200     vcl::Font aFont;
1201     if (toVclFont(QApplication::font(), aLocale, aFont))
1202     {
1203         style.BatchSetFonts(aFont, aFont);
1204         aFont.SetWeight(WEIGHT_BOLD);
1205         style.SetTitleFont(aFont);
1206         style.SetFloatTitleFont(aFont);
1207     }
1208
1209     // Tooltip font
1210     if (toVclFont(QToolTip::font(), aLocale, aFont))
1211         style.SetHelpFont(aFont);
1212
1213     // Menu bar font
1214     if (toVclFont(pMenuBar->font(), aLocale, aFont))
1215         style.SetMenuFont(aFont);
1216
1217     // Icon theme
1218     style.SetPreferredIconTheme(toOUString(QIcon::themeName()));
1219
1220     // Scroll bar size
1221     style.SetScrollBarSize(QApplication::style()->pixelMetric(QStyle::PM_ScrollBarExtent));
1222     style.SetMinThumbSize(QApplication::style()->pixelMetric(QStyle::PM_ScrollBarSliderMin));
1223
1224     // These colors are used for the ruler text and marks
1225     style.SetShadowColor(toColor(pal.color(QPalette::Disabled, QPalette::WindowText)));
1226     style.SetDarkShadowColor(toColor(pal.color(QPalette::Inactive, QPalette::WindowText)));
1227
1228     // Cursor blink interval
1229     int nFlashTime = QApplication::cursorFlashTime();
1230     style.SetCursorBlinkTime(nFlashTime != 0 ? nFlashTime / 2 : STYLE_CURSOR_NOBLINKTIME);
1231
1232     rSettings.SetStyleSettings(style);
1233 }
1234
1235 void QtFrame::Beep() { QApplication::beep(); }
1236
1237 SalFrame::SalPointerState QtFrame::GetPointerState()
1238 {
1239     SalPointerState aState;
1240     aState.maPos = toPoint(QCursor::pos() * devicePixelRatioF());
1241     aState.maPos.Move(-maGeometry.x(), -maGeometry.y());
1242     aState.mnState = GetMouseModCode(QGuiApplication::mouseButtons())
1243                      | GetKeyModCode(QGuiApplication::keyboardModifiers());
1244     return aState;
1245 }
1246
1247 KeyIndicatorState QtFrame::GetIndicatorState() { return KeyIndicatorState(); }
1248
1249 void QtFrame::SimulateKeyPress(sal_uInt16 nKeyCode)
1250 {
1251     SAL_WARN("vcl.qt", "missing simulate keypress " << nKeyCode);
1252 }
1253
1254 // don't set QWidget parents; this breaks popups on Wayland, like the LO ComboBox or ColorPicker!
1255 void QtFrame::SetParent(SalFrame* pNewParent) { m_pParent = static_cast<QtFrame*>(pNewParent); }
1256
1257 void QtFrame::SetPluginParent(SystemParentData* /*pNewParent*/)
1258 {
1259     //FIXME: no SetPluginParent impl. for qt5
1260 }
1261
1262 void QtFrame::ResetClipRegion() { m_bNullRegion = true; }
1263
1264 void QtFrame::BeginSetClipRegion(sal_uInt32)
1265 {
1266     m_aRegion = QRegion(QRect(QPoint(0, 0), m_pQWidget->size()));
1267 }
1268
1269 void QtFrame::UnionClipRegion(tools::Long nX, tools::Long nY, tools::Long nWidth,
1270                               tools::Long nHeight)
1271 {
1272     m_aRegion
1273         = m_aRegion.united(scaledQRect(QRect(nX, nY, nWidth, nHeight), 1 / devicePixelRatioF()));
1274 }
1275
1276 void QtFrame::EndSetClipRegion() { m_bNullRegion = false; }
1277
1278 void QtFrame::SetScreenNumber(unsigned int nScreen)
1279 {
1280     if (!isWindow())
1281         return;
1282
1283     QWindow* const pWindow = windowHandle();
1284     if (!pWindow)
1285         return;
1286
1287     QList<QScreen*> screens = QApplication::screens();
1288     if (static_cast<int>(nScreen) < screens.size() || m_bFullScreenSpanAll)
1289     {
1290         QRect screenGeo;
1291
1292         if (!m_bFullScreenSpanAll)
1293         {
1294             screenGeo = QGuiApplication::screens().at(nScreen)->geometry();
1295             pWindow->setScreen(QApplication::screens()[nScreen]);
1296         }
1297         else // special case: fullscreen over all available screens
1298         {
1299             assert(m_bFullScreen);
1300             // left-most screen
1301 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
1302             QScreen* pScreen = QGuiApplication::screenAt(QPoint(0, 0));
1303 #else
1304             // QGuiApplication::screenAt was added in Qt 5.10, use deprecated QDesktopWidget
1305             int nLeftScreen = QApplication::desktop()->screenNumber(QPoint(0, 0));
1306             QScreen* pScreen = QGuiApplication::screens()[nLeftScreen];
1307 #endif
1308             // entire virtual desktop
1309             screenGeo = pScreen->availableVirtualGeometry();
1310             pWindow->setScreen(pScreen);
1311             pWindow->setGeometry(screenGeo);
1312             nScreen = screenNumber(pScreen);
1313         }
1314
1315         // setScreen by itself has no effect, explicitly move the widget to
1316         // the new screen
1317         asChild()->move(screenGeo.topLeft());
1318     }
1319     else
1320     {
1321         // index outta bounds, use primary screen
1322         QScreen* primaryScreen = QApplication::primaryScreen();
1323         pWindow->setScreen(primaryScreen);
1324         nScreen = static_cast<sal_uInt32>(screenNumber(primaryScreen));
1325     }
1326
1327     maGeometry.setScreen(nScreen);
1328 }
1329
1330 void QtFrame::SetApplicationID(const OUString& rWMClass)
1331 {
1332 #if CHECK_QT5_USING_X11
1333     assert(m_aSystemData.platform != SystemEnvData::Platform::Invalid);
1334     if (m_aSystemData.platform != SystemEnvData::Platform::Xcb || !m_pTopLevel)
1335         return;
1336
1337     QtX11Support::setApplicationID(m_pTopLevel->winId(), rWMClass);
1338 #else
1339     Q_UNUSED(rWMClass);
1340 #endif
1341 }
1342
1343 void QtFrame::ResolveWindowHandle(SystemEnvData& rData) const
1344 {
1345     if (!rData.pWidget)
1346         return;
1347     assert(rData.platform != SystemEnvData::Platform::Invalid);
1348     if (rData.platform != SystemEnvData::Platform::Wayland)
1349         rData.SetWindowHandle(static_cast<QWidget*>(rData.pWidget)->winId());
1350 }
1351
1352 // Drag'n'drop foo
1353
1354 void QtFrame::registerDragSource(QtDragSource* pDragSource)
1355 {
1356     assert(!m_pDragSource);
1357     m_pDragSource = pDragSource;
1358 }
1359
1360 void QtFrame::deregisterDragSource(QtDragSource const* pDragSource)
1361 {
1362     assert(m_pDragSource == pDragSource);
1363     (void)pDragSource;
1364     m_pDragSource = nullptr;
1365 }
1366
1367 void QtFrame::registerDropTarget(QtDropTarget* pDropTarget)
1368 {
1369     assert(!m_pDropTarget);
1370     m_pDropTarget = pDropTarget;
1371     m_pQWidget->setAcceptDrops(true);
1372 }
1373
1374 void QtFrame::deregisterDropTarget(QtDropTarget const* pDropTarget)
1375 {
1376     assert(m_pDropTarget == pDropTarget);
1377     (void)pDropTarget;
1378     m_pDropTarget = nullptr;
1379 }
1380
1381 static css::uno::Reference<css::datatransfer::XTransferable>
1382 lcl_getXTransferable(const QMimeData* pMimeData)
1383 {
1384     css::uno::Reference<css::datatransfer::XTransferable> xTransferable;
1385     const QtMimeData* pQtMimeData = dynamic_cast<const QtMimeData*>(pMimeData);
1386     if (!pQtMimeData)
1387         xTransferable = new QtDnDTransferable(pMimeData);
1388     else
1389         xTransferable = pQtMimeData->xTransferable();
1390     return xTransferable;
1391 }
1392
1393 static sal_Int8 lcl_getUserDropAction(const QDropEvent* pEvent, const sal_Int8 nSourceActions,
1394                                       const QMimeData* pMimeData)
1395 {
1396 // we completely ignore all proposals by the Qt event, as they don't
1397 // match at all with the preferred LO DnD actions.
1398 // check the key modifiers to detect a user-overridden DnD action
1399 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
1400     const Qt::KeyboardModifiers eKeyMod = pEvent->modifiers();
1401 #else
1402     const Qt::KeyboardModifiers eKeyMod = pEvent->keyboardModifiers();
1403 #endif
1404     sal_Int8 nUserDropAction = 0;
1405     if ((eKeyMod & Qt::ShiftModifier) && !(eKeyMod & Qt::ControlModifier))
1406         nUserDropAction = css::datatransfer::dnd::DNDConstants::ACTION_MOVE;
1407     else if ((eKeyMod & Qt::ControlModifier) && !(eKeyMod & Qt::ShiftModifier))
1408         nUserDropAction = css::datatransfer::dnd::DNDConstants::ACTION_COPY;
1409     else if ((eKeyMod & Qt::ShiftModifier) && (eKeyMod & Qt::ControlModifier))
1410         nUserDropAction = css::datatransfer::dnd::DNDConstants::ACTION_LINK;
1411     nUserDropAction &= nSourceActions;
1412
1413     // select the default DnD action, if there isn't a user preference
1414     if (0 == nUserDropAction)
1415     {
1416         // default LO internal action is move, but default external action is copy
1417         nUserDropAction = dynamic_cast<const QtMimeData*>(pMimeData)
1418                               ? css::datatransfer::dnd::DNDConstants::ACTION_MOVE
1419                               : css::datatransfer::dnd::DNDConstants::ACTION_COPY;
1420         nUserDropAction &= nSourceActions;
1421
1422         // if the default doesn't match any allowed source action, fall back to the
1423         // preferred of all allowed source actions
1424         if (0 == nUserDropAction)
1425             nUserDropAction = toVclDropAction(getPreferredDropAction(nSourceActions));
1426
1427         // this is "our" preference, but actually we would even prefer any default,
1428         // if there is any
1429         nUserDropAction |= css::datatransfer::dnd::DNDConstants::ACTION_DEFAULT;
1430     }
1431     return nUserDropAction;
1432 }
1433
1434 void QtFrame::handleDragMove(QDragMoveEvent* pEvent)
1435 {
1436     assert(m_pDropTarget);
1437
1438     // prepare our suggested drop action for the drop target
1439     const sal_Int8 nSourceActions = toVclDropActions(pEvent->possibleActions());
1440     const QMimeData* pMimeData = pEvent->mimeData();
1441     const sal_Int8 nUserDropAction = lcl_getUserDropAction(pEvent, nSourceActions, pMimeData);
1442
1443 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
1444     const Point aPos = toPoint(pEvent->position().toPoint() * devicePixelRatioF());
1445 #else
1446     const Point aPos = toPoint(pEvent->pos() * devicePixelRatioF());
1447 #endif
1448
1449     css::datatransfer::dnd::DropTargetDragEnterEvent aEvent;
1450     aEvent.Source = static_cast<css::datatransfer::dnd::XDropTarget*>(m_pDropTarget);
1451     aEvent.Context = static_cast<css::datatransfer::dnd::XDropTargetDragContext*>(m_pDropTarget);
1452     aEvent.LocationX = aPos.X();
1453     aEvent.LocationY = aPos.Y();
1454     aEvent.DropAction = nUserDropAction;
1455     aEvent.SourceActions = nSourceActions;
1456
1457     // ask the drop target to accept our drop action
1458     if (!m_bInDrag)
1459     {
1460         aEvent.SupportedDataFlavors = lcl_getXTransferable(pMimeData)->getTransferDataFlavors();
1461         m_pDropTarget->fire_dragEnter(aEvent);
1462         m_bInDrag = true;
1463     }
1464     else
1465         m_pDropTarget->fire_dragOver(aEvent);
1466
1467     // the drop target accepted our drop action => inform Qt
1468     if (m_pDropTarget->proposedDropAction() != 0)
1469     {
1470         pEvent->setDropAction(getPreferredDropAction(m_pDropTarget->proposedDropAction()));
1471         pEvent->accept();
1472     }
1473     else // or maybe someone else likes it?
1474         pEvent->ignore();
1475 }
1476
1477 void QtFrame::handleDrop(QDropEvent* pEvent)
1478 {
1479     assert(m_pDropTarget);
1480
1481     // prepare our suggested drop action for the drop target
1482     const sal_Int8 nSourceActions = toVclDropActions(pEvent->possibleActions());
1483     const sal_Int8 nUserDropAction
1484         = lcl_getUserDropAction(pEvent, nSourceActions, pEvent->mimeData());
1485
1486 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
1487     const Point aPos = toPoint(pEvent->position().toPoint() * devicePixelRatioF());
1488 #else
1489     const Point aPos = toPoint(pEvent->pos() * devicePixelRatioF());
1490 #endif
1491
1492     css::datatransfer::dnd::DropTargetDropEvent aEvent;
1493     aEvent.Source = static_cast<css::datatransfer::dnd::XDropTarget*>(m_pDropTarget);
1494     aEvent.Context = static_cast<css::datatransfer::dnd::XDropTargetDropContext*>(m_pDropTarget);
1495     aEvent.LocationX = aPos.X();
1496     aEvent.LocationY = aPos.Y();
1497     aEvent.SourceActions = nSourceActions;
1498     aEvent.DropAction = nUserDropAction;
1499     aEvent.Transferable = lcl_getXTransferable(pEvent->mimeData());
1500
1501     // ask the drop target to accept our drop action
1502     m_pDropTarget->fire_drop(aEvent);
1503     m_bInDrag = false;
1504
1505     const bool bDropSuccessful = m_pDropTarget->dropSuccessful();
1506     const sal_Int8 nDropAction = m_pDropTarget->proposedDropAction();
1507
1508     // inform the drag source of the drag-origin frame of the drop result
1509     if (pEvent->source())
1510     {
1511         QtWidget* pWidget = dynamic_cast<QtWidget*>(pEvent->source());
1512         assert(pWidget); // AFAIK there shouldn't be any non-Qt5Widget as source in LO itself
1513         if (pWidget)
1514             pWidget->frame().m_pDragSource->fire_dragEnd(nDropAction, bDropSuccessful);
1515     }
1516
1517     // the drop target accepted our drop action => inform Qt
1518     if (bDropSuccessful)
1519     {
1520         pEvent->setDropAction(getPreferredDropAction(nDropAction));
1521         pEvent->accept();
1522     }
1523     else // or maybe someone else likes it?
1524         pEvent->ignore();
1525 }
1526
1527 void QtFrame::handleDragLeave()
1528 {
1529     css::datatransfer::dnd::DropTargetEvent aEvent;
1530     aEvent.Source = static_cast<css::datatransfer::dnd::XDropTarget*>(m_pDropTarget);
1531     m_pDropTarget->fire_dragExit(aEvent);
1532     m_bInDrag = false;
1533 }
1534
1535 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */