Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1786 insertions, 0 deletions

diff --git a/vcl/source/app/svapp.cxx b/vcl/source/app/svapp.cxx
new file mode 100644
index 0000000000..e1e12dbc3e
--- /dev/null
+++ b/vcl/source/app/svapp.cxx
@@ -0,0 +1,1786 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+#include <config_version.h>
+
+#include <osl/file.hxx>
+#include <osl/thread.hxx>
+#include <osl/module.hxx>
+#include <rtl/ustrbuf.hxx>
+
+#include <sal/log.hxx>
+
+#include <tools/debug.hxx>
+#include <tools/time.hxx>
+#include <tools/stream.hxx>
+#include <tools/json_writer.hxx>
+
+#include <unotools/configmgr.hxx>
+#include <unotools/resmgr.hxx>
+#include <unotools/syslocale.hxx>
+#include <unotools/syslocaleoptions.hxx>
+
+#include <vcl/toolkit/dialog.hxx>
+#include <vcl/dialoghelper.hxx>
+#include <vcl/lok.hxx>
+#include <vcl/toolkit/floatwin.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/keycod.hxx>
+#include <vcl/event.hxx>
+#include <vcl/vclevent.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/wrkwin.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/cvtgrf.hxx>
+#include <vcl/toolkit/unowrap.hxx>
+#include <vcl/timer.hxx>
+#include <vcl/scheduler.hxx>
+#include <vcl/skia/SkiaHelper.hxx>
+
+#include <salinst.hxx>
+#include <graphic/Manager.hxx>
+#include <salframe.hxx>
+#include <salsys.hxx>
+#include <svdata.hxx>
+#include <displayconnectiondispatch.hxx>
+#include <window.h>
+#include <accmgr.hxx>
+#include <strings.hrc>
+#include <strings.hxx>
+#if OSL_DEBUG_LEVEL > 0
+#include <schedulerimpl.hxx>
+#endif
+
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/awt/XToolkit.hpp>
+#include <comphelper/lok.hxx>
+#include <comphelper/threadpool.hxx>
+#include <comphelper/solarmutex.hxx>
+#include <osl/process.h>
+
+#ifdef DBG_UTIL
+#include <svl/poolitem.hxx>
+#include <svl/itemset.hxx>
+#include <svl/itempool.hxx>
+#endif
+
+#include <cassert>
+#include <limits>
+#include <string_view>
+#include <utility>
+#include <thread>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+namespace {
+void InitSettings(ImplSVData* pSVData);
+}
+
+// keycodes handled internally by VCL
+vcl::KeyCode const ReservedKeys[]
+{
+                vcl::KeyCode(KEY_F1,0)                  ,
+                vcl::KeyCode(KEY_F1,KEY_SHIFT)          ,
+                vcl::KeyCode(KEY_F1,KEY_MOD1)           ,
+                vcl::KeyCode(KEY_F2,KEY_SHIFT)          ,
+                vcl::KeyCode(KEY_F4,KEY_MOD1)           ,
+                vcl::KeyCode(KEY_F4,KEY_MOD2)           ,
+                vcl::KeyCode(KEY_F4,KEY_MOD1|KEY_MOD2)  ,
+                vcl::KeyCode(KEY_F6,0)                  ,
+                vcl::KeyCode(KEY_F6,KEY_MOD1)           ,
+                vcl::KeyCode(KEY_F6,KEY_SHIFT)          ,
+                vcl::KeyCode(KEY_F6,KEY_MOD1|KEY_SHIFT) ,
+                vcl::KeyCode(KEY_F10,0)
+#ifdef UNX
+                ,
+                vcl::KeyCode(KEY_1,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_2,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_3,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_4,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_5,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_6,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_7,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_8,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_9,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_0,KEY_SHIFT|KEY_MOD1),
+                vcl::KeyCode(KEY_ADD,KEY_SHIFT|KEY_MOD1)
+#endif
+};
+
+extern "C" {
+    typedef UnoWrapperBase* (*FN_TkCreateUnoWrapper)();
+}
+
+struct ImplPostEventData
+{
+    VclPtr<vcl::Window> mpWin;
+    ImplSVEvent *   mnEventId;
+    MouseEvent      maMouseEvent;
+    VclEventId      mnEvent;
+    KeyEvent        maKeyEvent;
+    GestureEventPan maGestureEvent;
+
+    ImplPostEventData(VclEventId nEvent, vcl::Window* pWin, const KeyEvent& rKeyEvent)
+        : mpWin(pWin)
+        , mnEventId(nullptr)
+        , mnEvent(nEvent)
+        , maKeyEvent(rKeyEvent)
+    {}
+    ImplPostEventData(VclEventId nEvent, vcl::Window* pWin, const MouseEvent& rMouseEvent)
+        : mpWin(pWin)
+        , mnEventId(nullptr)
+        , maMouseEvent(rMouseEvent)
+        , mnEvent(nEvent)
+    {}
+    ImplPostEventData(VclEventId nEvent, vcl::Window* pWin, const GestureEventPan& rGestureEvent)
+        : mpWin(pWin)
+        , mnEventId(nullptr)
+        , mnEvent(nEvent)
+        , maGestureEvent(rGestureEvent)
+    {}
+};
+
+Application* GetpApp()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if ( !pSVData )
+        return nullptr;
+    return pSVData->mpApp;
+}
+
+Application::Application()
+{
+    // useful for themes at least, perhaps extensions too
+    OUString aVar("LIBO_VERSION"), aValue(LIBO_VERSION_DOTTED);
+    osl_setEnvironment(aVar.pData, aValue.pData);
+
+    ImplGetSVData()->mpApp = this;
+    m_pCallbackData = nullptr;
+    m_pCallback = nullptr;
+}
+
+Application::~Application()
+{
+    ImplDeInitSVData();
+    ImplGetSVData()->mpApp = nullptr;
+#ifdef DBG_UTIL
+    // Due to
+    //   svx/source/dialog/framelinkarray.cxx
+    //   class Cell final : public SfxPoolItem
+    //   const Cell OBJ_CELL_NONE;
+    // being a static held SfxPoolItem which is not yet de-initialized here
+    // number often is (1), even higher with other modules loaded (like 5).
+    // These get de-allocated reliably in module-deinitializations, so this
+    // is no memory loss. These counters are more to be able to have an eye
+    // on amounts of SfxPoolItems used during office usage and to be able to
+    // detect if an error in future changes may lead to memory losses - these
+    // would show in dramatically higher numbers then immediately
+    SAL_INFO("vcl.items", "ITEM: " << getAllocatedSfxPoolItemCount() << " SfxPoolItems still allocated at shutdown");
+    SAL_INFO("vcl.items", "ITEM: " << getUsedSfxPoolItemCount() << " SfxPoolItems were incarnated during runtime");
+
+    // Same mechanism for SfxItemSet(s)
+    SAL_INFO("vcl.items", "ITEM: " << getAllocatedSfxItemSetCount() << " SfxItemSets still allocated at shutdown");
+    SAL_INFO("vcl.items", "ITEM: " << getUsedSfxItemSetCount() << " SfxItemSets were incarnated during runtime");
+
+    // Same mechanism for PoolItemHolder(s)
+    SAL_INFO("vcl.items", "ITEM: " << getAllocatedSfxPoolItemHolderCount() << " SfxPoolItemHolders still allocated at shutdown");
+    SAL_INFO("vcl.items", "ITEM: " << getUsedSfxPoolItemHolderCount() << " SfxPoolItemHolders were incarnated during runtime");
+
+    // Same mechanism for SfxPoolItem(s)directly put to a Pool
+    SAL_INFO("vcl.items", "ITEM: " << getRemainingDirectlyPooledSfxPoolItemCount() << " SfxPoolItems still directly put in Pool at shutdown (deleted @Pool destruction)");
+    SAL_INFO("vcl.items", "ITEM: " << getAllDirectlyPooledSfxPoolItemCount() << " SfxPoolItems directly put in Pool");
+
+    // Additional call to list still incarnated SfxPoolItems (under 'svl.items')
+    listAllocatedSfxPoolItems();
+
+#endif
+}
+
+int Application::Main()
+{
+    SAL_WARN("vcl", "Application is a base class and should be overridden.");
+    return EXIT_SUCCESS;
+}
+
+bool Application::QueryExit()
+{
+    WorkWindow* pAppWin = ImplGetSVData()->maFrameData.mpAppWin;
+
+    // call the close handler of the application window
+    if ( pAppWin )
+        return pAppWin->Close();
+    else
+        return true;
+}
+
+void Application::Shutdown()
+{
+}
+
+void Application::Init()
+{
+}
+
+void Application::InitFinished()
+{
+}
+
+void Application::DeInit()
+{
+}
+
+sal_uInt16 Application::GetCommandLineParamCount()
+{
+    return static_cast<sal_uInt16>(osl_getCommandArgCount());
+}
+
+OUString Application::GetCommandLineParam( sal_uInt16 nParam )
+{
+    OUString aParam;
+    osl_getCommandArg( nParam, &aParam.pData );
+    return aParam;
+}
+
+OUString Application::GetAppFileName()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    SAL_WARN_IF( !pSVData->maAppData.mxAppFileName, "vcl", "AppFileName should be set to something after SVMain!" );
+    if ( pSVData->maAppData.mxAppFileName )
+        return *pSVData->maAppData.mxAppFileName;
+
+    /*
+     *  provide a fallback for people without initialized vcl here (like setup
+     *  in responsefile mode)
+     */
+    OUString aAppFileName;
+    OUString aExeFileName;
+    osl_getExecutableFile(&aExeFileName.pData);
+
+    // convert path to native file format
+    osl::FileBase::getSystemPathFromFileURL(aExeFileName, aAppFileName);
+
+    return aAppFileName;
+}
+
+void Application::Exception( ExceptionCategory nCategory )
+{
+    switch ( nCategory )
+    {
+        // System has precedence (so do nothing)
+        case ExceptionCategory::System:
+        case ExceptionCategory::UserInterface:
+            break;
+        default:
+            Abort("Unknown Error");
+            break;
+    }
+}
+
+void Application::Abort( const OUString& rErrorText )
+{
+    //HACK: Dump core iff --norestore command line argument is given (assuming
+    // this process is run by developers who are interested in cores, vs. end
+    // users who are not):
+#if OSL_DEBUG_LEVEL > 0
+    bool dumpCore = true;
+#else
+    bool dumpCore = false;
+    sal_uInt16 n = GetCommandLineParamCount();
+    for (sal_uInt16 i = 0; i != n; ++i) {
+        if (GetCommandLineParam(i) == "--norestore") {
+            dumpCore = true;
+            break;
+        }
+    }
+#endif
+
+    SalAbort( rErrorText, dumpCore );
+}
+
+size_t Application::GetReservedKeyCodeCount()
+{
+    return SAL_N_ELEMENTS(ReservedKeys);
+}
+
+const vcl::KeyCode* Application::GetReservedKeyCode( size_t i )
+{
+    if( i >= GetReservedKeyCodeCount() )
+        return nullptr;
+    else
+        return &ReservedKeys[i];
+}
+
+void Application::notifyWindow(vcl::LOKWindowId /*nLOKWindowId*/,
+                               const OUString& /*rAction*/,
+                               const std::vector<vcl::LOKPayloadItem>& /*rPayload = std::vector<LOKPayloadItem>()*/) const
+{
+    SAL_WARN("vcl", "Invoked not implemented method: Application::notifyWindow");
+}
+
+void Application::libreOfficeKitViewCallback(int nType, const OString& pPayload) const
+{
+    if (!comphelper::LibreOfficeKit::isActive())
+        return;
+
+    if (m_pCallback)
+    {
+        m_pCallback(nType, pPayload.getStr(), m_pCallbackData);
+    }
+}
+
+void Application::notifyInvalidation(tools::Rectangle const* /*pRect*/) const
+{
+}
+
+void Application::Execute()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.mbInAppExecute = true;
+    pSVData->maAppData.mbAppQuit = false;
+
+    int nExitCode = 0;
+    if (!pSVData->mpDefInst->DoExecute(nExitCode))
+    {
+        if (Application::IsOnSystemEventLoop())
+        {
+            SAL_WARN("vcl.schedule", "Can't omit DoExecute when running on system event loop!");
+            std::abort();
+        }
+        while (!pSVData->maAppData.mbAppQuit)
+            Application::Yield();
+    }
+
+    pSVData->maAppData.mbInAppExecute = false;
+
+    GetpApp()->Shutdown();
+}
+
+static bool ImplYield(bool i_bWait, bool i_bAllEvents)
+{
+    ImplSVData* pSVData = ImplGetSVData();
+
+    SAL_INFO("vcl.schedule", "Enter ImplYield: " << (i_bWait ? "wait" : "no wait") <<
+             ": " << (i_bAllEvents ? "all events" : "one event"));
+
+    // there's a data race here on WNT only because ImplYield may be
+    // called without SolarMutex; but the only remaining use of mnDispatchLevel
+    // is in OSX specific code
+    pSVData->maAppData.mnDispatchLevel++;
+
+    // do not wait for events if application was already quit; in that
+    // case only dispatch events already available
+    bool bProcessedEvent = pSVData->mpDefInst->DoYield(
+            i_bWait && !pSVData->maAppData.mbAppQuit, i_bAllEvents );
+
+    pSVData->maAppData.mnDispatchLevel--;
+
+    DBG_TESTSOLARMUTEX(); // must be locked on return from Yield
+
+    SAL_INFO("vcl.schedule", "Leave ImplYield with return " << bProcessedEvent );
+    return bProcessedEvent;
+}
+
+bool Application::Reschedule( bool i_bAllEvents )
+{
+    static const bool bAbort = Application::IsOnSystemEventLoop();
+    if (bAbort)
+    {
+        SAL_WARN("vcl.schedule", "Application::Reschedule(" << i_bAllEvents << ")");
+        std::abort();
+    }
+    return ImplYield(false, i_bAllEvents);
+}
+
+bool Application::IsOnSystemEventLoop()
+{
+    return ImplGetSVData()->maAppData.m_bUseSystemLoop;
+}
+
+void Scheduler::ProcessEventsToIdle()
+{
+    int nSanity = 1;
+    while (ImplYield(false, true))
+    {
+        if (0 == ++nSanity % 1000)
+        {
+            SAL_WARN("vcl.schedule", "ProcessEventsToIdle: " << nSanity);
+        }
+    }
+#if OSL_DEBUG_LEVEL > 0
+    // If we yield from a non-main thread we just can guarantee that all idle
+    // events were processed at some point, but our check can't prevent further
+    // processing in the main thread, which may add new events, so skip it.
+    const ImplSVData* pSVData = ImplGetSVData();
+    if ( !pSVData->mpDefInst->IsMainThread() )
+        return;
+    for (int nTaskPriority = 0; nTaskPriority < PRIO_COUNT; ++nTaskPriority)
+    {
+        const ImplSchedulerData* pSchedulerData = pSVData->maSchedCtx.mpFirstSchedulerData[nTaskPriority];
+        while (pSchedulerData)
+        {
+            assert(!pSchedulerData->mbInScheduler);
+            if (pSchedulerData->mpTask)
+            {
+                Idle *pIdle = dynamic_cast<Idle*>(pSchedulerData->mpTask);
+                if (pIdle && pIdle->IsActive())
+                {
+                    SAL_WARN("vcl.schedule",
+                             "Unprocessed Idle: "
+                                 << pIdle << " "
+                                 << (pIdle->GetDebugName() ? pIdle->GetDebugName() : "(nullptr)"));
+                }
+            }
+            pSchedulerData = pSchedulerData->mpNext;
+        }
+    }
+#endif
+}
+
+extern "C" {
+/// used by unit tests that test only via the LOK API
+SAL_DLLPUBLIC_EXPORT void unit_lok_process_events_to_idle()
+{
+    const SolarMutexGuard aGuard;
+    Scheduler::ProcessEventsToIdle();
+}
+}
+
+void Application::Yield()
+{
+    static const bool bAbort = Application::IsOnSystemEventLoop();
+    if (bAbort)
+    {
+        SAL_WARN("vcl.schedule", "Application::Yield()");
+        std::abort();
+    }
+    ImplYield(true, false);
+}
+
+IMPL_STATIC_LINK_NOARG( ImplSVAppData, ImplQuitMsg, void*, void )
+{
+    assert(ImplGetSVData()->maAppData.mbAppQuit);
+    ImplGetSVData()->mpDefInst->DoQuit();
+}
+
+void Application::Quit()
+{
+    ImplGetSVData()->maAppData.mbAppQuit = true;
+    Application::PostUserEvent( LINK( nullptr, ImplSVAppData, ImplQuitMsg ) );
+}
+
+comphelper::SolarMutex& Application::GetSolarMutex()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return *(pSVData->mpDefInst->GetYieldMutex());
+}
+
+bool Application::IsMainThread()
+{
+    return ImplGetSVData()->mnMainThreadId == osl::Thread::getCurrentIdentifier();
+}
+
+sal_uInt32 Application::ReleaseSolarMutex()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return pSVData->mpDefInst->ReleaseYieldMutexAll();
+}
+
+void Application::AcquireSolarMutex( sal_uInt32 nCount )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->mpDefInst->AcquireYieldMutex( nCount );
+}
+
+bool Application::IsInMain()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return pSVData && pSVData->maAppData.mbInAppMain;
+}
+
+bool Application::IsInExecute()
+{
+    return ImplGetSVData()->maAppData.mbInAppExecute;
+}
+
+bool Application::IsQuit()
+{
+    return ImplGetSVData()->maAppData.mbAppQuit;
+}
+
+bool Application::IsInModalMode()
+{
+    return (ImplGetSVData()->maAppData.mnModalMode != 0);
+}
+
+sal_uInt16 Application::GetDispatchLevel()
+{
+    return ImplGetSVData()->maAppData.mnDispatchLevel;
+}
+
+bool Application::AnyInput( VclInputFlags nType )
+{
+    return ImplGetSVData()->mpDefInst->AnyInput( nType );
+}
+
+sal_uInt64 Application::GetLastInputInterval()
+{
+    return (tools::Time::GetSystemTicks()-ImplGetSVData()->maAppData.mnLastInputTime);
+}
+
+bool Application::IsUICaptured()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+
+    // If mouse was captured, or if in tracking- or in select-mode of a floatingwindow (e.g. menus
+    // or pulldown toolboxes) another window should be created
+    // D&D active !!!
+    return pSVData->mpWinData->mpCaptureWin || pSVData->mpWinData->mpTrackWin
+           || pSVData->mpWinData->mpFirstFloat || nImplSysDialog;
+}
+
+void Application::OverrideSystemSettings( AllSettings& /*rSettings*/ )
+{
+}
+
+void Application::MergeSystemSettings( AllSettings& rSettings )
+{
+    vcl::Window* pWindow = ImplGetSVData()->maFrameData.mpFirstFrame;
+    if( ! pWindow )
+        pWindow = ImplGetDefaultWindow();
+    if( pWindow )
+    {
+        ImplSVData* pSVData = ImplGetSVData();
+        if ( !pSVData->maAppData.mbSettingsInit )
+        {
+            // side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
+            pWindow->ImplUpdateGlobalSettings( *pSVData->maAppData.mxSettings );
+            pSVData->maAppData.mbSettingsInit = true;
+        }
+        // side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
+        pWindow->ImplUpdateGlobalSettings( rSettings, false );
+    }
+}
+
+void Application::SetSettings( const AllSettings& rSettings )
+{
+    const SolarMutexGuard aGuard;
+
+    ImplSVData* pSVData = ImplGetSVData();
+    if ( !pSVData->maAppData.mxSettings )
+    {
+        InitSettings(pSVData);
+        *pSVData->maAppData.mxSettings = rSettings;
+    }
+    else
+    {
+        AllSettings aOldSettings = *pSVData->maAppData.mxSettings;
+        if (aOldSettings.GetUILanguageTag().getLanguageType() != rSettings.GetUILanguageTag().getLanguageType() &&
+                pSVData->mbResLocaleSet)
+        {
+            pSVData->mbResLocaleSet = false;
+        }
+        *pSVData->maAppData.mxSettings = rSettings;
+        AllSettingsFlags nChangeFlags = aOldSettings.GetChangeFlags( *pSVData->maAppData.mxSettings );
+        if ( bool(nChangeFlags) )
+        {
+            DataChangedEvent aDCEvt( DataChangedEventType::SETTINGS, &aOldSettings, nChangeFlags );
+
+            // notify data change handler
+            ImplCallEventListenersApplicationDataChanged( &aDCEvt);
+
+            // Update all windows
+            vcl::Window* pFirstFrame = pSVData->maFrameData.mpFirstFrame;
+            // Reset data that needs to be re-calculated
+            tools::Long nOldDPIX = 0;
+            tools::Long nOldDPIY = 0;
+            if ( pFirstFrame )
+            {
+                nOldDPIX = pFirstFrame->GetOutDev()->GetDPIX();
+                nOldDPIY = pFirstFrame->GetOutDev()->GetDPIY();
+                vcl::Window::ImplInitAppFontData(pFirstFrame);
+            }
+            vcl::Window* pFrame = pFirstFrame;
+            while ( pFrame )
+            {
+                // call UpdateSettings from ClientWindow in order to prevent updating data twice
+                vcl::Window* pClientWin = pFrame;
+                while ( pClientWin->ImplGetClientWindow() )
+                    pClientWin = pClientWin->ImplGetClientWindow();
+                pClientWin->UpdateSettings( rSettings, true );
+
+                vcl::Window* pTempWin = pFrame->mpWindowImpl->mpFrameData->mpFirstOverlap;
+                while ( pTempWin )
+                {
+                    // call UpdateSettings from ClientWindow in order to prevent updating data twice
+                    pClientWin = pTempWin;
+                    while ( pClientWin->ImplGetClientWindow() )
+                        pClientWin = pClientWin->ImplGetClientWindow();
+                    pClientWin->UpdateSettings( rSettings, true );
+                    pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
+                }
+
+                pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
+            }
+
+            // if DPI resolution for screen output was changed set the new resolution for all
+            // screen compatible VirDev's
+            pFirstFrame = pSVData->maFrameData.mpFirstFrame;
+            if ( pFirstFrame )
+            {
+                if ( (pFirstFrame->GetOutDev()->GetDPIX() != nOldDPIX) ||
+                     (pFirstFrame->GetOutDev()->GetDPIY() != nOldDPIY) )
+                {
+                    VirtualDevice* pVirDev = pSVData->maGDIData.mpFirstVirDev;
+                    while ( pVirDev )
+                    {
+                        if ( pVirDev->mbScreenComp &&
+                             (pVirDev->GetDPIX() == nOldDPIX) &&
+                             (pVirDev->GetDPIY() == nOldDPIY) )
+                        {
+                            pVirDev->SetDPIX( pFirstFrame->GetOutDev()->GetDPIX() );
+                            pVirDev->SetDPIY( pFirstFrame->GetOutDev()->GetDPIY() );
+                            if ( pVirDev->IsMapModeEnabled() )
+                            {
+                                MapMode aMapMode = pVirDev->GetMapMode();
+                                pVirDev->SetMapMode();
+                                pVirDev->SetMapMode( aMapMode );
+                            }
+                        }
+
+                        pVirDev = pVirDev->mpNext;
+                    }
+                }
+            }
+        }
+    }
+}
+
+const AllSettings& Application::GetSettings()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if ( !pSVData->maAppData.mxSettings )
+    {
+        InitSettings(pSVData);
+    }
+
+    return *(pSVData->maAppData.mxSettings);
+}
+
+namespace {
+
+void InitSettings(ImplSVData* pSVData)
+{
+    assert(!pSVData->maAppData.mxSettings && "initialization should not happen twice!");
+
+    pSVData->maAppData.mxSettings.emplace();
+    if (!utl::ConfigManager::IsFuzzing())
+    {
+        pSVData->maAppData.mpCfgListener = new LocaleConfigurationListener;
+        pSVData->maAppData.mxSettings->GetSysLocale().GetOptions().AddListener( pSVData->maAppData.mpCfgListener );
+    }
+}
+
+}
+
+void Application::NotifyAllWindows( DataChangedEvent& rDCEvt )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    vcl::Window* pFrame = pSVData->maFrameData.mpFirstFrame;
+    while ( pFrame )
+    {
+        pFrame->NotifyAllChildren( rDCEvt );
+
+        vcl::Window* pSysWin = pFrame->mpWindowImpl->mpFrameData->mpFirstOverlap;
+        while ( pSysWin )
+        {
+            pSysWin->NotifyAllChildren( rDCEvt );
+            pSysWin = pSysWin->mpWindowImpl->mpNextOverlap;
+        }
+
+        pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
+    }
+}
+
+void Application::ImplCallEventListenersApplicationDataChanged( void* pData )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    VclWindowEvent aEvent( nullptr, VclEventId::ApplicationDataChanged, pData );
+
+    pSVData->maAppData.maEventListeners.Call( aEvent );
+}
+
+void Application::ImplCallEventListeners( VclSimpleEvent& rEvent )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.maEventListeners.Call( rEvent );
+}
+
+void Application::AddEventListener( const Link<VclSimpleEvent&,void>& rEventListener )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.maEventListeners.addListener( rEventListener );
+}
+
+void Application::RemoveEventListener( const Link<VclSimpleEvent&,void>& rEventListener )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.maEventListeners.removeListener( rEventListener );
+}
+
+void Application::AddKeyListener( const Link<VclWindowEvent&,bool>& rKeyListener )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.maKeyListeners.push_back( rKeyListener );
+}
+
+void Application::RemoveKeyListener( const Link<VclWindowEvent&,bool>& rKeyListener )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    auto & rVec = pSVData->maAppData.maKeyListeners;
+    std::erase(rVec, rKeyListener);
+}
+
+bool Application::HandleKey( VclEventId nEvent, vcl::Window *pWin, KeyEvent* pKeyEvent )
+{
+    // let listeners process the key event
+    VclWindowEvent aEvent( pWin, nEvent, static_cast<void *>(pKeyEvent) );
+
+    ImplSVData* pSVData = ImplGetSVData();
+
+    if ( pSVData->maAppData.maKeyListeners.empty() )
+        return false;
+
+    bool bProcessed = false;
+    // Copy the list, because this can be destroyed when calling a Link...
+    std::vector<Link<VclWindowEvent&,bool>> aCopy( pSVData->maAppData.maKeyListeners );
+    for ( const Link<VclWindowEvent&,bool>& rLink : aCopy )
+    {
+        if( rLink.Call( aEvent ) )
+        {
+            bProcessed = true;
+            break;
+        }
+    }
+    return bProcessed;
+}
+
+ImplSVEvent * Application::PostKeyEvent( VclEventId nEvent, vcl::Window *pWin, KeyEvent const * pKeyEvent )
+{
+    const SolarMutexGuard aGuard;
+    ImplSVEvent * nEventId = nullptr;
+
+    if( pWin && pKeyEvent )
+    {
+        std::unique_ptr<ImplPostEventData> pPostEventData(new ImplPostEventData( nEvent, pWin, *pKeyEvent ));
+
+        nEventId = PostUserEvent(
+                       LINK( nullptr, Application, PostEventHandler ),
+                       pPostEventData.get() );
+
+        if( nEventId )
+        {
+            pPostEventData->mnEventId = nEventId;
+            ImplGetSVData()->maAppData.maPostedEventList.emplace_back( pWin, pPostEventData.release() );
+        }
+    }
+
+    return nEventId;
+}
+
+ImplSVEvent* Application::PostGestureEvent(VclEventId nEvent, vcl::Window* pWin,
+                                           GestureEventPan const * pGestureEvent)
+{
+    const SolarMutexGuard aGuard;
+    ImplSVEvent * nEventId = nullptr;
+
+    if (pWin && pGestureEvent)
+    {
+        Point aTransformedPosition(pGestureEvent->mnX, pGestureEvent->mnY);
+
+        aTransformedPosition.AdjustX(pWin->GetOutOffXPixel());
+        aTransformedPosition.AdjustY(pWin->GetOutOffYPixel());
+
+        const GestureEventPan aGestureEvent(
+            sal_Int32(aTransformedPosition.X()),
+            sal_Int32(aTransformedPosition.Y()),
+            pGestureEvent->meEventType,
+            pGestureEvent->mnOffset,
+            pGestureEvent->meOrientation
+        );
+
+        std::unique_ptr<ImplPostEventData> pPostEventData(new ImplPostEventData(nEvent, pWin, aGestureEvent));
+
+        nEventId = PostUserEvent(
+                       LINK( nullptr, Application, PostEventHandler ),
+                       pPostEventData.get());
+
+        if (nEventId)
+        {
+            pPostEventData->mnEventId = nEventId;
+            ImplGetSVData()->maAppData.maPostedEventList.emplace_back(pWin, pPostEventData.release());
+        }
+    }
+
+    return nEventId;
+}
+
+bool Application::LOKHandleMouseEvent(VclEventId nEvent, vcl::Window* pWindow, const MouseEvent* pEvent)
+{
+    bool bSuccess = false;
+    SalMouseEvent aMouseEvent;
+
+    if (!pWindow)
+        return false;
+
+    if (!pEvent)
+        return false;
+
+    aMouseEvent.mnTime = tools::Time::GetSystemTicks();
+    aMouseEvent.mnX = pEvent->GetPosPixel().X();
+    aMouseEvent.mnY = pEvent->GetPosPixel().Y();
+    aMouseEvent.mnCode = pEvent->GetButtons() | pEvent->GetModifier();
+
+    switch (nEvent)
+    {
+        case VclEventId::WindowMouseMove:
+            aMouseEvent.mnButton = 0;
+            bSuccess = ImplLOKHandleMouseEvent(pWindow, NotifyEventType::MOUSEMOVE, false,
+                                               aMouseEvent.mnX, aMouseEvent.mnY,
+                                               aMouseEvent.mnTime, aMouseEvent.mnCode,
+                                               ImplGetMouseMoveMode(&aMouseEvent),
+                                               pEvent->GetClicks());
+        break;
+
+        case VclEventId::WindowMouseButtonDown:
+            aMouseEvent.mnButton = pEvent->GetButtons();
+            bSuccess = ImplLOKHandleMouseEvent(pWindow, NotifyEventType::MOUSEBUTTONDOWN, false,
+                                               aMouseEvent.mnX, aMouseEvent.mnY,
+                                               aMouseEvent.mnTime,
+#ifdef MACOSX
+                                               aMouseEvent.mnButton |
+                                               (aMouseEvent.mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3)),
+#else
+                                               aMouseEvent.mnButton |
+                                               (aMouseEvent.mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)),
+#endif
+                                               ImplGetMouseButtonMode(&aMouseEvent),
+                                               pEvent->GetClicks());
+            break;
+
+        case VclEventId::WindowMouseButtonUp:
+            aMouseEvent.mnButton = pEvent->GetButtons();
+            bSuccess = ImplLOKHandleMouseEvent(pWindow, NotifyEventType::MOUSEBUTTONUP, false,
+                                               aMouseEvent.mnX, aMouseEvent.mnY,
+                                               aMouseEvent.mnTime,
+#ifdef MACOSX
+                                               aMouseEvent.mnButton |
+                                               (aMouseEvent.mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3)),
+#else
+                                               aMouseEvent.mnButton |
+                                               (aMouseEvent.mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)),
+#endif
+                                               ImplGetMouseButtonMode(&aMouseEvent),
+                                               pEvent->GetClicks());
+            break;
+
+        default:
+            SAL_WARN( "vcl.layout", "Application::HandleMouseEvent unknown event (" << static_cast<int>(nEvent) << ")" );
+            break;
+    }
+
+    return bSuccess;
+}
+
+
+ImplSVEvent* Application::PostMouseEvent( VclEventId nEvent, vcl::Window *pWin, MouseEvent const * pMouseEvent )
+{
+    const SolarMutexGuard aGuard;
+    ImplSVEvent * nEventId = nullptr;
+
+    if( pWin && pMouseEvent )
+    {
+        Point aTransformedPos( pMouseEvent->GetPosPixel() );
+
+        // LOK uses (0, 0) as the origin of all windows; don't offset.
+        if (!comphelper::LibreOfficeKit::isActive())
+        {
+            aTransformedPos.AdjustX(pWin->GetOutOffXPixel());
+            aTransformedPos.AdjustY(pWin->GetOutOffYPixel());
+        }
+
+        const MouseEvent aTransformedEvent( aTransformedPos, pMouseEvent->GetClicks(), pMouseEvent->GetMode(),
+                                            pMouseEvent->GetButtons(), pMouseEvent->GetModifier() );
+
+        std::unique_ptr<ImplPostEventData> pPostEventData(new ImplPostEventData( nEvent, pWin, aTransformedEvent ));
+
+        nEventId = PostUserEvent(
+                       LINK( nullptr, Application, PostEventHandler ),
+                       pPostEventData.get() );
+
+        if( nEventId )
+        {
+            pPostEventData->mnEventId = nEventId;
+            ImplGetSVData()->maAppData.maPostedEventList.emplace_back( pWin, pPostEventData.release() );
+        }
+    }
+
+    return nEventId;
+}
+
+
+IMPL_STATIC_LINK( Application, PostEventHandler, void*, pCallData, void )
+{
+    const SolarMutexGuard aGuard;
+    ImplPostEventData*  pData = static_cast< ImplPostEventData * >( pCallData );
+    const void*         pEventData;
+    SalEvent            nEvent;
+    ImplSVEvent * const nEventId = pData->mnEventId;
+
+    switch( pData->mnEvent )
+    {
+        case VclEventId::WindowMouseMove:
+            nEvent = SalEvent::ExternalMouseMove;
+            pEventData = &pData->maMouseEvent;
+        break;
+
+        case VclEventId::WindowMouseButtonDown:
+            nEvent = SalEvent::ExternalMouseButtonDown;
+            pEventData = &pData->maMouseEvent;
+        break;
+
+        case VclEventId::WindowMouseButtonUp:
+            nEvent = SalEvent::ExternalMouseButtonUp;
+            pEventData = &pData->maMouseEvent;
+        break;
+
+        case VclEventId::WindowKeyInput:
+            nEvent = SalEvent::ExternalKeyInput;
+            pEventData = &pData->maKeyEvent;
+        break;
+
+        case VclEventId::WindowKeyUp:
+            nEvent = SalEvent::ExternalKeyUp;
+            pEventData = &pData->maKeyEvent;
+        break;
+
+        case VclEventId::WindowGestureEvent:
+            nEvent = SalEvent::ExternalGesture;
+            pEventData = &pData->maGestureEvent;
+        break;
+
+        default:
+            nEvent = SalEvent::NONE;
+            pEventData = nullptr;
+        break;
+    }
+
+    if( pData->mpWin && pData->mpWin->mpWindowImpl->mpFrameWindow && pEventData )
+        ImplWindowFrameProc( pData->mpWin->mpWindowImpl->mpFrameWindow.get(), nEvent, pEventData );
+
+    // remove this event from list of posted events, watch for destruction of internal data
+    auto svdata = ImplGetSVData();
+    ::std::vector< ImplPostEventPair >::iterator aIter( svdata->maAppData.maPostedEventList.begin() );
+
+    while( aIter != svdata->maAppData.maPostedEventList.end() )
+    {
+        if( nEventId == (*aIter).second->mnEventId )
+        {
+            delete (*aIter).second;
+            aIter = svdata->maAppData.maPostedEventList.erase( aIter );
+        }
+        else
+            ++aIter;
+    }
+}
+
+void Application::RemoveMouseAndKeyEvents( vcl::Window* pWin )
+{
+    const SolarMutexGuard aGuard;
+
+    // remove all events for specific window, watch for destruction of internal data
+    auto svdata = ImplGetSVData();
+    ::std::vector< ImplPostEventPair >::iterator aIter( svdata->maAppData.maPostedEventList.begin() );
+
+    while( aIter != svdata->maAppData.maPostedEventList.end() )
+    {
+        if( pWin == (*aIter).first )
+        {
+            if( (*aIter).second->mnEventId )
+                RemoveUserEvent( (*aIter).second->mnEventId );
+
+            delete (*aIter).second;
+            aIter = svdata->maAppData.maPostedEventList.erase( aIter );
+        }
+        else
+            ++aIter;
+    }
+}
+
+ImplSVEvent * Application::PostUserEvent( const Link<void*,void>& rLink, void* pCaller,
+                                          bool bReferenceLink )
+{
+    vcl::Window* pDefWindow = ImplGetDefaultWindow();
+    if ( pDefWindow == nullptr )
+        return nullptr;
+
+    std::unique_ptr<ImplSVEvent> pSVEvent(new ImplSVEvent);
+    pSVEvent->mpData    = pCaller;
+    pSVEvent->maLink    = rLink;
+    pSVEvent->mpWindow  = nullptr;
+    pSVEvent->mbCall    = true;
+    if (bReferenceLink)
+    {
+        SolarMutexGuard aGuard;
+        pSVEvent->mpInstanceRef = static_cast<vcl::Window *>(rLink.GetInstance());
+    }
+
+    auto pTmpEvent = pSVEvent.get();
+    if (!pDefWindow->ImplGetFrame()->PostEvent( std::move(pSVEvent) ))
+        return nullptr;
+    return pTmpEvent;
+}
+
+void Application::RemoveUserEvent( ImplSVEvent * nUserEvent )
+{
+    if(nUserEvent)
+    {
+        SAL_WARN_IF( nUserEvent->mpWindow, "vcl",
+                    "Application::RemoveUserEvent(): Event is send to a window" );
+        SAL_WARN_IF( !nUserEvent->mbCall, "vcl",
+                    "Application::RemoveUserEvent(): Event is already removed" );
+
+        nUserEvent->mpWindow.clear();
+        nUserEvent->mpInstanceRef.clear();
+        nUserEvent->mbCall = false;
+    }
+}
+
+vcl::Window* Application::GetFocusWindow()
+{
+    return ImplGetSVData()->mpWinData->mpFocusWin;
+}
+
+OutputDevice* Application::GetDefaultDevice()
+{
+    vcl::Window* pWindow = ImplGetDefaultWindow();
+    if (pWindow != nullptr)
+    {
+        return pWindow->GetOutDev();
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+basegfx::SystemDependentDataManager& Application::GetSystemDependentDataManager()
+{
+    return ImplGetSystemDependentDataManager();
+}
+
+vcl::Window* Application::GetFirstTopLevelWindow()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return pSVData->maFrameData.mpFirstFrame;
+}
+
+vcl::Window* Application::GetNextTopLevelWindow( vcl::Window const * pWindow )
+{
+    return pWindow->mpWindowImpl->mpFrameData->mpNextFrame;
+}
+
+tools::Long    Application::GetTopWindowCount()
+{
+    tools::Long nRet = 0;
+    ImplSVData* pSVData = ImplGetSVData();
+    vcl::Window *pWin = pSVData ? pSVData->maFrameData.mpFirstFrame.get() : nullptr;
+    while( pWin )
+    {
+        if( pWin->ImplGetWindow()->IsTopWindow() )
+            nRet++;
+        pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
+    }
+    return nRet;
+}
+
+vcl::Window* Application::GetTopWindow( tools::Long nIndex )
+{
+    tools::Long nIdx = 0;
+    ImplSVData* pSVData = ImplGetSVData();
+    vcl::Window *pWin = pSVData ? pSVData->maFrameData.mpFirstFrame.get() : nullptr;
+    while( pWin )
+    {
+        if( pWin->ImplGetWindow()->IsTopWindow() )
+        {
+            if( nIdx == nIndex )
+                return pWin->ImplGetWindow();
+            else
+                nIdx++;
+        }
+        pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
+    }
+    return nullptr;
+}
+
+vcl::Window* Application::GetActiveTopWindow()
+{
+    vcl::Window *pWin = ImplGetSVData()->mpWinData->mpFocusWin;
+    while( pWin )
+    {
+        if( pWin->IsTopWindow() )
+            return pWin;
+        pWin = pWin->mpWindowImpl->mpParent;
+    }
+    return nullptr;
+}
+
+void Application::SetAppName( const OUString& rUniqueName )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.mxAppName = rUniqueName;
+}
+
+OUString Application::GetAppName()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if ( pSVData->maAppData.mxAppName )
+        return *(pSVData->maAppData.mxAppName);
+    else
+        return OUString();
+}
+
+enum {hwAll=0, hwEnv=1, hwUI=2};
+
+static OUString Localize(TranslateId aId, const bool bLocalize)
+{
+    if (bLocalize)
+        return VclResId(aId);
+    else
+        return Translate::get(aId, Translate::Create("vcl", LanguageTag("en-US")));
+}
+
+OUString Application::GetOSVersion()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    OUString aVersion;
+    if (pSVData && pSVData->mpDefInst)
+        aVersion = pSVData->mpDefInst->getOSVersion();
+    else
+        aVersion = "-";
+    return aVersion;
+}
+
+OUString Application::GetHWOSConfInfo(const int bSelection, const bool bLocalize)
+{
+    OUStringBuffer aDetails;
+
+    const auto appendDetails = [&aDetails](std::u16string_view sep, auto&& val) {
+        if (!aDetails.isEmpty() && !sep.empty())
+            aDetails.append(sep);
+        aDetails.append(std::move(val));
+    };
+
+    if (bSelection != hwUI) {
+        appendDetails(u"; ", Localize(SV_APP_CPUTHREADS, bLocalize)
+                                + OUString::number(std::thread::hardware_concurrency()));
+
+        OUString aVersion = GetOSVersion();
+
+        appendDetails(u"; ", Localize(SV_APP_OSVERSION, bLocalize) + aVersion);
+    }
+
+    if (bSelection != hwEnv) {
+        appendDetails(u"; ", Localize(SV_APP_UIRENDER, bLocalize));
+#if HAVE_FEATURE_SKIA
+        if ( SkiaHelper::isVCLSkiaEnabled() )
+        {
+            switch(SkiaHelper::renderMethodToUse())
+            {
+                case SkiaHelper::RenderVulkan:
+                    appendDetails(u"", Localize(SV_APP_SKIA_VULKAN, bLocalize));
+                    break;
+                case SkiaHelper::RenderMetal:
+                    appendDetails(u"", Localize(SV_APP_SKIA_METAL, bLocalize));
+                    break;
+                case SkiaHelper::RenderRaster:
+                    appendDetails(u"", Localize(SV_APP_SKIA_RASTER, bLocalize));
+                    break;
+            }
+        }
+        else
+#endif
+            appendDetails(u"", Localize(SV_APP_DEFAULT, bLocalize));
+
+#if (defined LINUX || defined _WIN32 || defined MACOSX || defined __FreeBSD__ || defined EMSCRIPTEN)
+        appendDetails(u"; ", SV_APP_VCLBACKEND + GetToolkitName());
+#endif
+    }
+
+    return aDetails.makeStringAndClear();
+}
+
+void Application::SetDisplayName( const OUString& rName )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->maAppData.mxDisplayName = rName;
+}
+
+OUString Application::GetDisplayName()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if ( pSVData->maAppData.mxDisplayName )
+        return *(pSVData->maAppData.mxDisplayName);
+    else if (pSVData->maFrameData.mpAppWin)
+        return pSVData->maFrameData.mpAppWin->GetText();
+    else
+        return OUString();
+}
+
+unsigned int Application::GetScreenCount()
+{
+    SalSystem* pSys = ImplGetSalSystem();
+    return pSys ? pSys->GetDisplayScreenCount() : 0;
+}
+
+unsigned int Application::GetDisplayBuiltInScreen()
+{
+    SalSystem* pSys = ImplGetSalSystem();
+    return pSys ? pSys->GetDisplayBuiltInScreen() : 0;
+}
+
+unsigned int Application::GetDisplayExternalScreen()
+{
+    // This is really unpleasant, in theory we could have multiple
+    // external displays etc.
+    int nExternal(0);
+    switch (GetDisplayBuiltInScreen())
+    {
+    case 0:
+        nExternal = 1;
+        break;
+    case 1:
+        nExternal = 0;
+        break;
+    default:
+        // When the built-in display is neither 0 nor 1
+        // then place the full-screen presentation on the
+        // first available screen.
+        nExternal = 0;
+        break;
+    }
+    return nExternal;
+}
+
+AbsoluteScreenPixelRectangle Application::GetScreenPosSizePixel( unsigned int nScreen )
+{
+    SalSystem* pSys = ImplGetSalSystem();
+    if (!pSys)
+    {
+        SAL_WARN("vcl", "Requesting screen size/pos for screen #" << nScreen << " failed");
+        assert(false);
+        return AbsoluteScreenPixelRectangle();
+    }
+    AbsoluteScreenPixelRectangle aRect = pSys->GetDisplayScreenPosSizePixel(nScreen);
+    if (aRect.GetHeight() == 0)
+        SAL_WARN("vcl", "Requesting screen size/pos for screen #" << nScreen << " returned 0 height.");
+    return aRect;
+}
+
+namespace {
+tools::Long calcDistSquare( const AbsoluteScreenPixelPoint& i_rPoint, const AbsoluteScreenPixelRectangle& i_rRect )
+{
+    const AbsoluteScreenPixelPoint aRectCenter( (i_rRect.Left() + i_rRect.Right())/2,
+                       (i_rRect.Top() + i_rRect.Bottom())/ 2 );
+    const tools::Long nDX = aRectCenter.X() - i_rPoint.X();
+    const tools::Long nDY = aRectCenter.Y() - i_rPoint.Y();
+    return nDX*nDX + nDY*nDY;
+}
+}
+
+unsigned int Application::GetBestScreen( const AbsoluteScreenPixelRectangle& i_rRect )
+{
+    const unsigned int nScreens = GetScreenCount();
+    unsigned int nBestMatchScreen = 0;
+    unsigned long nOverlap = 0;
+    for( unsigned int i = 0; i < nScreens; i++ )
+    {
+        const AbsoluteScreenPixelRectangle aCurScreenRect( GetScreenPosSizePixel( i ) );
+        // if a screen contains the rectangle completely it is obviously the best screen
+        if( aCurScreenRect.Contains( i_rRect ) )
+            return i;
+        // next the screen which contains most of the area of the rect is the best
+        AbsoluteScreenPixelRectangle aIntersection( aCurScreenRect.GetIntersection( i_rRect ) );
+        if( ! aIntersection.IsEmpty() )
+        {
+            const unsigned long nCurOverlap( aIntersection.GetWidth() * aIntersection.GetHeight() );
+            if( nCurOverlap > nOverlap )
+            {
+                nOverlap = nCurOverlap;
+                nBestMatchScreen = i;
+            }
+        }
+    }
+    if( nOverlap > 0 )
+        return nBestMatchScreen;
+
+    // finally the screen which center is nearest to the rect is the best
+    const AbsoluteScreenPixelPoint aCenter( (i_rRect.Left() + i_rRect.Right())/2,
+                         (i_rRect.Top() + i_rRect.Bottom())/2 );
+    tools::Long nDist = std::numeric_limits<tools::Long>::max();
+    for( unsigned int i = 0; i < nScreens; i++ )
+    {
+        const AbsoluteScreenPixelRectangle aCurScreenRect( GetScreenPosSizePixel( i ) );
+        const tools::Long nCurDist( calcDistSquare( aCenter, aCurScreenRect ) );
+        if( nCurDist < nDist )
+        {
+            nBestMatchScreen = i;
+            nDist = nCurDist;
+        }
+    }
+    return nBestMatchScreen;
+}
+
+bool Application::InsertAccel( Accelerator* pAccel )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+
+    if ( !pSVData->maAppData.mpAccelMgr )
+        pSVData->maAppData.mpAccelMgr = new ImplAccelManager();
+    return pSVData->maAppData.mpAccelMgr->InsertAccel( pAccel );
+}
+
+void Application::RemoveAccel( Accelerator const * pAccel )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+
+    if ( pSVData->maAppData.mpAccelMgr )
+        pSVData->maAppData.mpAccelMgr->RemoveAccel( pAccel );
+}
+
+void Application::SetHelp( Help* pHelp )
+{
+    ImplGetSVData()->maAppData.mpHelp = pHelp;
+}
+
+void Application::UpdateMainThread()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if (pSVData && pSVData->mpDefInst)
+        pSVData->mpDefInst->updateMainThread();
+}
+
+Help* Application::GetHelp()
+{
+    return ImplGetSVData()->maAppData.mpHelp;
+}
+
+OUString Application::GetToolkitName()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if ( pSVData->maAppData.mxToolkitName )
+        return *(pSVData->maAppData.mxToolkitName);
+    else
+        return OUString();
+}
+
+vcl::Window* Dialog::GetDefDialogParent()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    // find some useful dialog parent
+
+    // always use the topmost parent of the candidate
+    // window to avoid using dialogs or floaters
+    // as DefDialogParent
+
+    // current focus frame
+    vcl::Window *pWin = pSVData->mpWinData->mpFocusWin;
+    if (pWin && !pWin->IsMenuFloatingWindow())
+    {
+        while (pWin->mpWindowImpl && pWin->mpWindowImpl->mpParent)
+            pWin = pWin->mpWindowImpl->mpParent;
+
+        // check for corrupted window hierarchy, #122232#, may be we now crash somewhere else
+        if (!pWin->mpWindowImpl)
+        {
+            OSL_FAIL( "Window hierarchy corrupted!" );
+            pSVData->mpWinData->mpFocusWin = nullptr;   // avoid further access
+            return nullptr;
+        }
+
+        if ((pWin->mpWindowImpl->mnStyle & WB_INTROWIN) == 0)
+        {
+            return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
+        }
+    }
+
+    // last active application frame
+    pWin = pSVData->maFrameData.mpActiveApplicationFrame;
+    if (pWin)
+    {
+        return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
+    }
+
+    // first visible top window (may be totally wrong...)
+    pWin = pSVData->maFrameData.mpFirstFrame;
+    while (pWin)
+    {
+        if( pWin->ImplGetWindow()->IsTopWindow() &&
+            pWin->mpWindowImpl->mbReallyVisible &&
+            (pWin->mpWindowImpl->mnStyle & WB_INTROWIN) == 0
+        )
+        {
+            while( pWin->mpWindowImpl->mpParent )
+                pWin = pWin->mpWindowImpl->mpParent;
+            return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
+        }
+        pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
+    }
+
+    // use the desktop
+    return nullptr;
+}
+
+weld::Window* Application::GetDefDialogParent()
+{
+    vcl::Window* pWindow = Dialog::GetDefDialogParent();
+    return pWindow ? pWindow->GetFrameWeld() : nullptr;
+}
+
+DialogCancelMode Application::GetDialogCancelMode()
+{
+    return ImplGetSVData()->maAppData.meDialogCancel;
+}
+
+void Application::SetDialogCancelMode( DialogCancelMode mode )
+{
+    ImplGetSVData()->maAppData.meDialogCancel = mode;
+}
+
+bool Application::IsDialogCancelEnabled()
+{
+    return ImplGetSVData()->maAppData.meDialogCancel != DialogCancelMode::Off;
+}
+
+void Application::SetSystemWindowMode( SystemWindowFlags nMode )
+{
+    ImplGetSVData()->maAppData.mnSysWinMode = nMode;
+}
+
+SystemWindowFlags Application::GetSystemWindowMode()
+{
+    return ImplGetSVData()->maAppData.mnSysWinMode;
+}
+
+css::uno::Reference< css::awt::XToolkit > Application::GetVCLToolkit()
+{
+    css::uno::Reference< css::awt::XToolkit > xT;
+    UnoWrapperBase* pWrapper = UnoWrapperBase::GetUnoWrapper();
+    if ( pWrapper )
+        xT = pWrapper->GetVCLToolkit();
+    return xT;
+}
+
+#ifdef DISABLE_DYNLOADING
+
+extern "C" { UnoWrapperBase* CreateUnoWrapper(); }
+
+#else
+
+extern "C" { static void thisModule() {} }
+
+#endif
+
+UnoWrapperBase* UnoWrapperBase::GetUnoWrapper( bool bCreateIfNotExist )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    static bool bAlreadyTriedToCreate = false;
+    if ( !pSVData->mpUnoWrapper && bCreateIfNotExist && !bAlreadyTriedToCreate )
+    {
+#ifndef DISABLE_DYNLOADING
+        osl::Module aTkLib;
+        aTkLib.loadRelative(&thisModule, TK_DLL_NAME);
+        if (aTkLib.is())
+        {
+            FN_TkCreateUnoWrapper fnCreateWrapper = reinterpret_cast<FN_TkCreateUnoWrapper>(aTkLib.getFunctionSymbol("CreateUnoWrapper"));
+            if ( fnCreateWrapper )
+            {
+                pSVData->mpUnoWrapper = fnCreateWrapper();
+            }
+            aTkLib.release();
+        }
+        SAL_WARN_IF( !pSVData->mpUnoWrapper, "vcl", "UnoWrapper could not be created!" );
+#else
+        pSVData->mpUnoWrapper = CreateUnoWrapper();
+#endif
+        bAlreadyTriedToCreate = true;
+    }
+    return pSVData->mpUnoWrapper;
+}
+
+void UnoWrapperBase::SetUnoWrapper( UnoWrapperBase* pWrapper )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    SAL_WARN_IF( pSVData->mpUnoWrapper, "vcl", "SetUnoWrapper: Wrapper already exists" );
+    pSVData->mpUnoWrapper = pWrapper;
+}
+
+css::uno::Reference< css::awt::XDisplayConnection > Application::GetDisplayConnection()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+
+    if( !pSVData->mxDisplayConnection.is() )
+    {
+        pSVData->mxDisplayConnection.set( new vcl::DisplayConnectionDispatch );
+        pSVData->mxDisplayConnection->start();
+    }
+
+    return pSVData->mxDisplayConnection;
+}
+
+void Application::SetFilterHdl( const Link<ConvertData&,bool>& rLink )
+{
+    ImplGetSVData()->maGDIData.mxGrfConverter->SetFilterHdl( rLink );
+}
+
+const LocaleDataWrapper& Application::GetAppLocaleDataWrapper()
+{
+    return GetSettings().GetLocaleDataWrapper();
+}
+
+void Application::EnableHeadlessMode( bool dialogsAreFatal )
+{
+    DialogCancelMode eNewMode = dialogsAreFatal ? DialogCancelMode::Fatal : DialogCancelMode::Silent;
+    DialogCancelMode eOldMode = GetDialogCancelMode();
+    assert(eOldMode == DialogCancelMode::Off || GetDialogCancelMode() == eNewMode);
+    if (eOldMode != eNewMode)
+        SetDialogCancelMode( eNewMode );
+}
+
+bool Application::IsHeadlessModeEnabled()
+{
+    return IsDialogCancelEnabled() || comphelper::LibreOfficeKit::isActive();
+}
+
+void Application::EnableBitmapRendering()
+{
+    ImplGetSVData()->maAppData.mbRenderToBitmaps = true;
+}
+
+bool Application::IsBitmapRendering()
+{
+    return ImplGetSVData()->maAppData.mbRenderToBitmaps;
+}
+
+void Application::EnableConsoleOnly()
+{
+    EnableHeadlessMode(true);
+    EnableBitmapRendering();
+}
+
+static bool bSafeMode = false;
+
+bool Application::IsSafeModeEnabled()
+{
+    return bSafeMode;
+}
+
+void Application::EnableSafeMode()
+{
+    bSafeMode = true;
+}
+
+void Application::ShowNativeErrorBox(const OUString& sTitle  ,
+                                     const OUString& sMessage)
+{
+    int btn = ImplGetSalSystem()->ShowNativeMessageBox(
+            sTitle,
+            sMessage);
+    if (btn != SALSYSTEM_SHOWNATIVEMSGBOX_BTN_OK) {
+        SAL_WARN( "vcl", "ShowNativeMessageBox returned " << btn);
+    }
+}
+
+const OUString& Application::GetDesktopEnvironment()
+{
+    if (IsHeadlessModeEnabled())
+    {
+        static constexpr OUString aNone(u"none"_ustr);
+        return aNone;
+    }
+    else
+        return SalGetDesktopEnvironment();
+}
+
+void Application::AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType, const OUString& rDocumentService)
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    pSVData->mpDefInst->AddToRecentDocumentList(rFileUrl, rMimeType, rDocumentService);
+}
+
+bool InitAccessBridge()
+{
+// Disable MSAA bridge on UNIX
+#if defined UNX
+    return true;
+#else
+    bool bRet = ImplInitAccessBridge();
+
+    if( !bRet )
+    {
+        // disable accessibility if the user chooses to continue
+        AllSettings aSettings = Application::GetSettings();
+        MiscSettings aMisc = aSettings.GetMiscSettings();
+        aMisc.SetEnableATToolSupport( false );
+        aSettings.SetMiscSettings( aMisc );
+        Application::SetSettings( aSettings );
+    }
+    return bRet;
+#endif // !UNX
+}
+
+// MT: AppEvent was in oldsv.cxx, but is still needed...
+void Application::AppEvent( const ApplicationEvent& /*rAppEvent*/ )
+{
+}
+
+bool Application::hasNativeFileSelection()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return pSVData->mpDefInst->hasNativeFileSelection();
+}
+
+Reference< ui::dialogs::XFilePicker2 >
+Application::createFilePicker( const Reference< uno::XComponentContext >& xSM )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return pSVData->mpDefInst->createFilePicker( xSM );
+}
+
+Reference< ui::dialogs::XFolderPicker2 >
+Application::createFolderPicker( const Reference< uno::XComponentContext >& xSM )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    return pSVData->mpDefInst->createFolderPicker( xSM );
+}
+
+void Application::setDeInitHook(Link<LinkParamNone*,void> const & hook) {
+    ImplSVData * pSVData = ImplGetSVData();
+    assert(!pSVData->maDeInitHook.IsSet());
+    pSVData->maDeInitHook = hook;
+    // Fake this for VCLXToolkit ctor instantiated from
+    // postprocess/CppunitTest_services.mk:
+    pSVData->maAppData.mbInAppMain = true;
+}
+
+namespace vcl::lok {
+
+void registerPollCallbacks(
+    LibreOfficeKitPollCallback pPollCallback,
+    LibreOfficeKitWakeCallback pWakeCallback,
+    void *pData) {
+
+    ImplSVData * pSVData = ImplGetSVData();
+    if (pSVData)
+    {
+        pSVData->mpPollCallback = pPollCallback;
+        pSVData->mpWakeCallback = pWakeCallback;
+        pSVData->mpPollClosure = pData;
+    }
+}
+
+void unregisterPollCallbacks()
+{
+    ImplSVData * pSVData = ImplGetSVData();
+    if (!pSVData)
+        return;
+
+    // Not hyper-elegant - but in the case of Android & unipoll we need to detach
+    // this thread from the JVM's clutches to avoid a crash closing document
+    if (pSVData->mpPollClosure && pSVData->mpDefInst)
+        pSVData->mpDefInst->releaseMainThread();
+
+    // Just set mpPollClosure to null as that is what calling this means, that the callback data
+    // points to an object that no longer exists. In particular, don't set
+    // pSVData->mpPollCallback to nullptr as that is used to detect whether Unipoll is in use in
+    // isUnipoll().
+    pSVData->mpPollClosure = nullptr;
+}
+
+bool isUnipoll()
+{
+    ImplSVData * pSVData = ImplGetSVData();
+    return pSVData && pSVData->mpPollCallback != nullptr;
+}
+
+void numberOfViewsChanged(int count)
+{
+    if (count == 0)
+        return;
+    ImplSVData * pSVData = ImplGetSVData();
+    auto& rCache = pSVData->maGDIData.maScaleCache;
+    // Normally the cache size is set to 10, scale according to the number of users.
+    rCache.setMaxSize(count * 10);
+}
+
+void dumpState(rtl::OStringBuffer &rState)
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    if (!pSVData)
+        return;
+
+    rState.append("\nWindows:\t");
+    rState.append(static_cast<sal_Int32>(Application::GetTopWindowCount()));
+
+    vcl::Window *pWin = Application::GetFirstTopLevelWindow();
+    while (pWin)
+    {
+        tools::JsonWriter props;
+        pWin->DumpAsPropertyTree(props);
+
+        rState.append("\n\tWindow: ");
+        rState.append(props.finishAndGetAsOString());
+
+        pWin = Application::GetNextTopLevelWindow( pWin );
+    }
+
+    vcl::graphic::Manager::get().dumpState(rState);
+
+    pSVData->dumpState(rState);
+}
+
+void trimMemory(int nTarget)
+{
+    if (nTarget >= 1000)
+    {
+        ImplSVData* pSVData = ImplGetSVData();
+        if (!pSVData) // shutting down
+            return;
+        pSVData->dropCaches();
+        vcl::graphic::Manager::get().dropCache();
+        // TODO: ideally - free up any deeper dirtied thread stacks.
+        // comphelper::ThreadPool::getSharedOptimalPool().shutdown();
+    }
+    // else for now caches re-fill themselves as/when used.
+}
+
+} // namespace lok, namespace vcl
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */