/* -*- 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_wasm_strip.h>

#include <com/sun/star/deployment/ui/PackageManagerDialog.hpp>

#include <com/sun/star/drawing/ModuleDispatcher.hpp>

#include <com/sun/star/frame/Desktop.hpp>

#include <com/sun/star/frame/DispatchResultEvent.hpp>

#include <com/sun/star/frame/DispatchResultState.hpp>

#include <com/sun/star/frame/DispatchHelper.hpp>

#include <com/sun/star/frame/UnknownModuleException.hpp>

#include <com/sun/star/frame/XLayoutManager.hpp>

#include <com/sun/star/frame/XSynchronousFrameLoader.hpp>

#include <com/sun/star/embed/EmbedStates.hpp>

#include <com/sun/star/embed/XEmbeddedObject.hpp>

#include <com/sun/star/util/XModifiable.hpp>

#include <com/sun/star/sdbc/DriverManager.hpp>

#include <com/sun/star/text/ModuleDispatcher.hpp>

#include <com/sun/star/task/OfficeRestartManager.hpp>

#include <com/sun/star/task/XInteractionHandler.hpp>

#include <com/sun/star/ui/dialogs/AddressBookSourcePilot.hpp>

#include <com/sun/star/ui/UIElementType.hpp>

#include <com/sun/star/ui/XUIElement.hpp>

#include <com/sun/star/uno/Reference.hxx>

#include <com/sun/star/util/XCloseable.hpp>

#include <com/sun/star/util/CloseVetoException.hpp>

#include <org/freedesktop/PackageKit/SyncDbusSessionHelper.hpp>

#include <comphelper/dispatchcommand.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/namedvaluecollection.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertysequence.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/sequence.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <svtools/addresstemplate.hxx>

#include <svtools/restartdialog.hxx>

#include <svtools/colorcfg.hxx>

#include <svl/visitem.hxx>

#include <unotools/configmgr.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <vcl/weld/DialogController.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <svl/intitem.hxx>

#include <svl/eitem.hxx>

#include <svl/stritem.hxx>

#include <basic/sbstar.hxx>

#include <basic/basrdll.hxx>

#include <basic/sberrors.hxx>

#include <tools/debug.hxx>

#include <vcl/help.hxx>

#include <sal/log.hxx>

#include <osl/file.hxx>

#include <vcl/EnumContext.hxx>

#include <vcl/themecolors.hxx>

#include <vcl/svapp.hxx>

#include <unotools/moduleoptions.hxx>

#include <unotools/securityoptions.hxx>

#include <rtl/bootstrap.hxx>

#include <com/sun/star/frame/ModuleManager.hpp>

#include <com/sun/star/frame/XModel3.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <sfx2/AdditionsDialogHelper.hxx>

#include <sfx2/app.hxx>

#include <sfx2/request.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/minfitem.hxx>

#include <sfx2/msg.hxx>

#include <sfx2/objface.hxx>

#include <sfx2/objsh.hxx>

#include <sfx2/viewsh.hxx>

#include <sfx2/docfac.hxx>

#include <sfx2/strings.hrc>

#include <sfx2/sfxresid.hxx>

#include <appdata.hxx>

#include <sfx2/viewfrm.hxx>

#include <sfx2/sfxdlg.hxx>

#include <sfx2/sfxsids.hrc>

#include <sorgitm.hxx>

#include <sfx2/sfxhelp.hxx>

#include <sfx2/zoomitem.hxx>

#include <sfx2/templatedlg.hxx>

#include <sfx2/notebookbar/SfxNotebookBar.hxx>

#include <sfx2/sidebar/SidebarController.hxx>

#include <sfx2/safemode.hxx>

#include <sfx2/sfxuno.hxx>

#include <DevelopmentToolDockingWindow.hxx>

#include <comphelper/types.hxx>

#include <officecfg/Office/Common.hxx>

#include <officecfg/Setup.hxx>

#include <unotools/confignode.hxx>

#include <memory>

#include <openuriexternally.hxx>

#include "getbasctlfunction.hxx"

using namespace ::com::sun::star;

using namespace ::com::sun::star::beans;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::frame;

using namespace ::com::sun::star::container;

using namespace ::com::sun::star::util;

using namespace ::com::sun::star::lang;

using namespace ::com::sun::star::ui;

namespace

{

    OUString lcl_getAppName( vcl::EnumContext::Application eApp )

    {

        switch ( eApp )

        {

            case vcl::EnumContext::Application::Writer:

                return u"Writer"_ustr;

            case vcl::EnumContext::Application::Calc:

                return u"Calc"_ustr;

            case vcl::EnumContext::Application::Impress:

                return u"Impress"_ustr;

            case vcl::EnumContext::Application::Draw:

                return u"Draw"_ustr;

            case vcl::EnumContext::Application::Formula:

                return u"Formula"_ustr;

            case vcl::EnumContext::Application::Base:

                return u"Base"_ustr;

            default:

                return OUString();

        }

    }

    // lp#527938, debian#602953, fdo#33266, i#105408

    bool lcl_isBaseAvailable()

    {

        try

        {

            // if we get css::sdbc::DriverManager, libsdbc2 is there

            // and the bibliography is assumed to work

            return css::sdbc::DriverManager::create(comphelper::getProcessComponentContext()).is();

        }

        catch (const Exception &)

        {

            TOOLS_INFO_EXCEPTION("sfx.appl", "assuming Base to be missing");

            return false;

        }

    }

    void lcl_tryLoadBibliography()

    {

        // lp#527938, debian#602953, fdo#33266, i#105408

        // make sure we actually can instantiate services from base first

        if(!lcl_isBaseAvailable())

        {

            if (officecfg::Office::Common::PackageKit::EnableBaseInstallation::get())

            {

                try

                {

                    using namespace org::freedesktop::PackageKit;

                    using namespace svtools;

                    Reference< XSyncDbusSessionHelper > xSyncDbusSessionHelper(SyncDbusSessionHelper::create(comphelper::getProcessComponentContext()));

                    Sequence< OUString > vPackages { u"libreoffice-base"_ustr };

                    xSyncDbusSessionHelper->InstallPackageNames(vPackages, OUString());

                    // I'll be back (hopefully)!

                    SolarMutexGuard aGuard;

                    executeRestartDialog(comphelper::getProcessComponentContext(), nullptr, RESTART_REASON_BIBLIOGRAPHY_INSTALL);

                }

                catch (const Exception &)

                {

                    TOOLS_INFO_EXCEPTION("sfx.appl", "trying to install LibreOffice Base");

                }

            }

            return;

        }

        try // fdo#48775

        {

            SfxStringItem aURL(SID_FILE_NAME, u".component:Bibliography/View1"_ustr);

            SfxStringItem aRef(SID_REFERER, u"private:user"_ustr);

            SfxStringItem aTarget(SID_TARGETNAME, u"_blank"_ustr);

            if (const SfxViewFrame* pViewFrame = SfxViewFrame::Current())

            {

                pViewFrame->GetDispatcher()->ExecuteList(SID_OPENDOC,

                        SfxCallMode::ASYNCHRON, { &aURL, &aRef, &aTarget });

            }

        }

        catch (const Exception &)

        {

            TOOLS_INFO_EXCEPTION( "sfx.appl", "trying to load bibliography database");

        }

    }

    void lcl_disableActiveEmbeddedObjects(const SfxObjectShell* pObjSh)

    {

        if (!pObjSh)

            return;

        comphelper::EmbeddedObjectContainer& rContainer = pObjSh->getEmbeddedObjectContainer();

        if (!rContainer.HasEmbeddedObjects())

            return;

        const uno::Sequence<OUString> aNames = rContainer.GetObjectNames();

        for (const auto& rName : aNames)

        {

            uno::Reference<embed::XEmbeddedObject> xEmbeddedObj

                = rContainer.GetEmbeddedObject(rName);

            if (!xEmbeddedObj.is())

                continue;

            try

            {

                if (xEmbeddedObj->getCurrentState() != embed::EmbedStates::LOADED)

                {

                    xEmbeddedObj->changeState(embed::EmbedStates::LOADED);

                }

            }

            catch (const uno::Exception&)

            {

            }

        }

    }

}

/// Find the correct location of the document (CREDITS.fodt, etc.), and return

/// it in rURL if found.

static bool checkURL( const char *pName, const char *pExt, OUString &rURL )

{

    using namespace osl;

    DirectoryItem aDirItem;

#ifdef MACOSX

    rURL = "$BRAND_BASE_DIR/Resources/" + OUString::createFromAscii( pName ) +

           OUString::createFromAscii( pExt );

#else

    rURL = "$BRAND_BASE_DIR/" + OUString::createFromAscii( pName ) +

           OUString::createFromAscii( pExt );

#endif

    rtl::Bootstrap::expandMacros( rURL );

    if (!rURL.isEmpty())

        return DirectoryItem::get( rURL, aDirItem ) == DirectoryItem::E_None;

    else

        return false;

}

/// Displays CREDITS or LICENSE in any of the available version

static void showDocument( const char* pBaseName )

{

    try {

        Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );

        auto args(::comphelper::InitPropertySequence({

            {"ViewOnly",    Any(true)},

            {"ReadOnly",    Any(true)}

        }));

        OUString aURL;

        if ( checkURL ( pBaseName, ".fodt", aURL ) ||

             checkURL ( pBaseName, ".html", aURL ) ||

             checkURL ( pBaseName, "", aURL ) ) {

            xDesktop->loadComponentFromURL( aURL, u"_blank"_ustr, 0, args );

        }

    } catch (const css::uno::Exception &) {

    }

}

namespace

{

    Reference<XFrame> GetRequestFrame(const SfxRequest& rReq)

    {

        const SfxItemSet* pArgs = rReq.GetInternalArgs_Impl();

        const SfxUnoFrameItem* pItem = nullptr;

        Reference <XFrame> xFrame;

        if (pArgs && (pItem = pArgs->GetItemIfSet(SID_FILLFRAME, false)))

        {

            xFrame = pItem->GetFrame();

        }

        return xFrame;

    }

    Reference<XFrame> GetDocFrame(const SfxRequest& rReq)

    {

        const SfxFrameItem* pFrameItem = rReq.GetArg<SfxFrameItem>(SID_DOCFRAME);

        SfxFrame* pFrame = pFrameItem ? pFrameItem->GetFrame() : nullptr;

        return pFrame ? pFrame->GetFrameInterface() : nullptr;

    }

    class LicenseDialog : public weld::GenericDialogController

    {

    public:

        LicenseDialog(weld::Window* pParent)

            : GenericDialogController(pParent, u"sfx/ui/licensedialog.ui"_ustr,  u"LicenseDialog"_ustr)

        {

        }

        virtual short run() override

        {

            short nRet = GenericDialogController::run();

            if (nRet == RET_OK)

                showDocument("LICENSE");

            return nRet;

        }

    };

    class SafeModeQueryDialog : public weld::MessageDialogController

    {

    public:

        SafeModeQueryDialog(weld::Window* pParent)

            : MessageDialogController(pParent, u"sfx/ui/safemodequerydialog.ui"_ustr, u"SafeModeQueryDialog"_ustr)

        {

        }

        virtual short run() override

        {

            short nRet = MessageDialogController::run();

            if (nRet == RET_OK)

            {

                sfx2::SafeMode::putFlag();

                const uno::Reference< uno::XComponentContext >& xContext = comphelper::getProcessComponentContext();

                css::task::OfficeRestartManager::get(xContext)->requestRestart(

                    css::uno::Reference< css::task::XInteractionHandler >());

            }

            return nRet;

        }

    };

}

weld::Window* SfxRequest::GetFrameWeld() const

{

    const SfxItemSet* pIntArgs = GetInternalArgs_Impl();

    const SfxUnoAnyItem* pItem = nullptr;

    if (pIntArgs && (pItem = pIntArgs->GetItemIfSet(SID_DIALOG_PARENT, false)))

    {

        Reference<awt::XWindow> xWindow;

        pItem->GetValue() >>= xWindow;

        return Application::GetFrameWeld(xWindow);

    }

    Reference<XFrame> xFrame(GetRequestFrame(*this));

    if (!xFrame)

        xFrame = GetDocFrame(*this);

    if (!xFrame)

    {

        SAL_WARN("sfx.appl", "no parent for dialogs");

        return nullptr;

    }

    return Application::GetFrameWeld(xFrame->getContainerWindow());

}

void SfxApplication::MiscExec_Impl( SfxRequest& rReq )

{

    const bool bIsLOK = comphelper::LibreOfficeKit::isActive();

    static svtools::EditableColorConfig aEditableConfig;

    static bool aColorConfigInitialized = false;

    if (!aColorConfigInitialized && bIsLOK)

    {

        // preload color schemes

        aEditableConfig.LoadScheme("Light");

        aEditableConfig.LoadScheme("Dark");

        aColorConfigInitialized = true;

    }

    bool bDone = false;

    switch ( rReq.GetSlot() )

    {

        case SID_SETOPTIONS:

        {

            if( rReq.GetArgs() )

                SetOptions( *rReq.GetArgs() );

            break;

        }

        case SID_QUITAPP:

        case SID_LOGOUT:

        {

            // protect against reentrant calls and avoid closing the same files in parallel

            if (pImpl->bInQuit || pImpl->bClosingDocs)

                return;

            if ( rReq.GetSlot() == SID_LOGOUT )

            {

                for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();

                    pObjSh; pObjSh = SfxObjectShell::GetNext( *pObjSh ) )

                {

                    if ( !pObjSh->IsModified() )

                        continue;

                    SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pObjSh );

                    if ( !pFrame || !pFrame->GetWindow().IsReallyVisible() )

                        continue;

                    if (pObjSh->PrepareClose())

                        pObjSh->SetModified( false );

                    else

                        return;

                }

                SfxStringItem aNameItem( SID_FILE_NAME, u"vnd.sun.star.cmd:logout"_ustr );

                SfxStringItem aReferer( SID_REFERER, u"private/user"_ustr );

                pImpl->pAppDispat->ExecuteList(SID_OPENDOC,

                        SfxCallMode::SLOT, { &aNameItem, &aReferer });

                return;

            }

            // try from nested requests again after 100ms

            if( Application::GetDispatchLevel() > 1 )

            {

                /* Don't save the request for closing the application and try it later

                   again. This is an UI bound functionality ... and the user will  try it again

                   if the dialog is closed. But we should not close the application automatically

                   if this dialog is closed by the user ...

                   So we ignore this request now and wait for a new user decision.

                */

                SAL_INFO("sfx.appl", "QueryExit => sal_False, DispatchLevel == " << Application::GetDispatchLevel() );

                return;

            }

            // block reentrant calls

            pImpl->bInQuit = true;

            Reference < XDesktop2 > xDesktop = Desktop::create ( ::comphelper::getProcessComponentContext() );

            rReq.ForgetAllArgs();

            // if terminate() failed, pImpl->bInQuit will now be sal_False, allowing further calls of SID_QUITAPP

            bool bTerminated = xDesktop->terminate();

            if (!bTerminated)

                // if terminate() was successful, SfxApplication is now dead!

                pImpl->bInQuit = false;

            // Set return value, terminate if possible

            rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), bTerminated ) );

            return;

        }

        case SID_CONFIG:

        case SID_TOOLBOXOPTIONS:

        case SID_CONFIGSTATUSBAR:

        case SID_CONFIGMENU:

        case SID_CONFIGACCEL:

        case SID_CONFIGEVENT:

        {

            SfxAbstractDialogFactory* pFact =

                SfxAbstractDialogFactory::Create();

            const SfxStringItem* pStringItem = rReq.GetArg(SID_CONFIG);

            SfxItemSet aSet(SfxItemSet::makeFixedSfxItemSet<SID_CONFIG, SID_CONFIG, SID_MACROINFO, SID_MACROINFO>( GetPool() ));

            // SID_CONFIG property will determine the default page shown

            if ( pStringItem )

            {

                aSet.Put( SfxStringItem(

                    SID_CONFIG, pStringItem->GetValue() ) );

            }

            else if (rReq.GetSlot() == SID_CONFIGEVENT)

            {

                aSet.Put( SfxStringItem(

                    SID_CONFIG, u"private:resource/event/"_ustr ) );

            }

            else if (rReq.GetSlot() == SID_TOOLBOXOPTIONS)

            {

                aSet.Put( SfxStringItem(

                    SID_CONFIG, u"private:resource/toolbar/"_ustr ) );

            }

#if HAVE_FEATURE_SCRIPTING

            // Preselect a macro in the 'keyboard' page

            if (auto const item = rReq.GetArg(SID_MACROINFO)) {

                aSet.Put(*item);

            }

#endif

            Reference <XFrame> xFrame(GetRequestFrame(rReq));

            ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateCustomizeTabDialog(rReq.GetFrameWeld(),

                &aSet, xFrame ));

            const short nRet = pDlg->Execute();

            if ( nRet )

                bDone = true;

            break;

        }

        case SID_CLOSEDOCS:

        {

            // protect against reentrant calls and avoid closing the same files in parallel

            if (pImpl->bInQuit || pImpl->bClosingDocs)

                return;

            pImpl->bClosingDocs = true;

            // closed all status for all visible frames

            bool bClosedAll = true;

            // Iterate over all documents and close them

            for (SfxObjectShell *pObjSh = SfxObjectShell::GetFirst(); pObjSh;)

            {

                SfxObjectShell* pNxtObjSh = SfxObjectShell::GetNext(*pObjSh);

                // can close immediately

                if (!pObjSh->IsModified())

                {

                    // don't close the last remaining frame for close dispatch

                    if (pNxtObjSh || !bClosedAll)

                        pObjSh->DoClose();

                }

                else

                {

                    // skip invisible frames when asking user to close

                    SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pObjSh);

                    if (pFrame && pFrame->GetWindow().IsReallyVisible())

                    {

                        // asks user to close

                        if (pObjSh->PrepareClose())

                        {

                            pObjSh->SetModified(false);

                            // get next pointer again after asking user since it can become invalid pointer from being manually closed by user

                            // don't close the last remaining frame for close dispatch

                            if ((pNxtObjSh = SfxObjectShell::GetNext(*pObjSh)) || !bClosedAll)

                                pObjSh->DoClose();

                        }

                        // user disagrees to close

                        else

                        {

                            bClosedAll = false;

                            // get next pointer again after asking user since it can become invalid pointer from being manually closed by user

                            pNxtObjSh = SfxObjectShell::GetNext(*pObjSh);

                        }

                    }

                }

                pObjSh = pNxtObjSh;

            }

            pImpl->bClosingDocs = false;

            // close dispatch status

            bool bDispatchOk = true;

            // open backing window

            if (bClosedAll)

            {

                // don't use pViewFrame = SfxViewFrame::Current() as dispatch won't load sometimes

                SfxObjectShell* pObjSh = SfxObjectShell::GetFirst();

                SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst(pObjSh);

                if (pViewFrame)

                {

                    Reference<XFrame> xCurrentFrame = pViewFrame->GetFrame().GetFrameInterface();

                    if (xCurrentFrame.is())

                    {

                        uno::Reference<frame::XDispatchProvider> xProvider(xCurrentFrame, uno::UNO_QUERY);

                        if (xProvider.is())

                        {

                            uno::Reference<frame::XDispatchHelper> xDispatcher

                                = frame::DispatchHelper::create(::comphelper::getProcessComponentContext());

                            // use .uno:CloseDoc to be able to close windows of the same document

                            css::uno::Any aResult =

                                xDispatcher->executeDispatch(xProvider,

                                                             u".uno:CloseDoc"_ustr,

                                                             u"_self"_ustr,

                                                             0,

                                                             uno::Sequence<beans::PropertyValue>());

                            css::frame::DispatchResultEvent aEvent;

                            bDispatchOk = (aResult >>= aEvent) && (aEvent.State == frame::DispatchResultState::SUCCESS);

                        }

                    }

                }

            }

            // terminate the application if the dispatch fails or

            // if there is no visible frame left after the command is run (e.g user manually closes the document again that was already cancelled for closing)

            if (!bDispatchOk || (!bClosedAll && !SfxObjectShell::GetFirst()))

            {

                SfxRequest aReq(SID_QUITAPP, SfxCallMode::SLOT, GetPool());

                MiscExec_Impl(aReq);

            }

            rReq.SetReturnValue(SfxBoolItem(0, bDispatchOk));

            bDone = true;

            break;

        }

        case SID_SAVEDOCS:

        {

            bool bOK = true;

            for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();

                  pObjSh;

                  pObjSh = SfxObjectShell::GetNext( *pObjSh ) )

            {

                SfxRequest aReq( SID_SAVEDOC, SfxCallMode::SLOT, pObjSh->GetPool() );

                if ( pObjSh->IsModified() && !pObjSh->isSaveLocked() )

                {

                    pObjSh->ExecuteSlot( aReq );

                    const SfxBoolItem* pItem(dynamic_cast<const SfxBoolItem*>(aReq.GetReturnValue().getItem()));

                    if ( !pItem || !pItem->GetValue() )

                        bOK = false;

                }

            }

            rReq.SetReturnValue( SfxBoolItem( 0, bOK ) );

            rReq.Done();

            break;

        }

        case SID_SEND_FEEDBACK:

        {

            OUString module = SfxHelp::GetCurrentModuleIdentifier();

            OUString sURL(officecfg::Office::Common::Menus::SendFeedbackURL::get() + //officecfg/registry/data/org/openoffice/Office/Common.xcu => https://hub.libreoffice.org/send-feedback/

                "?LOversion=" + utl::ConfigManager::getAboutBoxProductVersion() +

                "&LOlocale=" + utl::ConfigManager::getUILocale() +

                "&LOmodule=" + module.subView(module.lastIndexOf('.') + 1 )  );

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

        case SID_Q_AND_A:

        {

            // Askbot has URL's normalized to languages, not locales

            // Get language from locale: ll or lll or ll-CC or lll-CC

            OUString sURL(officecfg::Office::Common::Menus::QA_URL::get() + //https://hub.libreoffice.org/forum/

                "?LOlocale=" + utl::ConfigManager::getUILocale());

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

        case SID_DOCUMENTATION:

        {

            // Open documentation page based on locales

            OUString sURL(officecfg::Office::Common::Menus::DocumentationURL::get() + //https://hub.libreoffice.org/documentation/

                "?LOlocale=" + utl::ConfigManager::getUILocale());

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

#if !ENABLE_WASM_STRIP_PINGUSER

        case SID_GETINVOLVED:

        {

            // Open get involved/join us page based on locales

            OUString sURL(officecfg::Office::Common::Menus::GetInvolvedURL::get() + //https://hub.libreoffice.org/joinus/

                "?LOlocale=" + utl::ConfigManager::getUILocale());

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

        case SID_DONATION:

        {

            // Open donation page based on language + script (BCP47) with language as fall back.

            OUString aLang = LanguageTag(utl::ConfigManager::getUILocale()).getLanguage();

            OUString aBcp47 = LanguageTag(utl::ConfigManager::getUILocale()).getBcp47();

            OUString sURL(officecfg::Office::Common::Menus::DonationURL::get() + //https://hub.libreoffice.org/donation/

                "?BCP47=" + aBcp47 + "&LOlang=" + aLang );

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

        case SID_WHATSNEW:

        {

            // Open release notes depending on version and locale

            OUString sURL(officecfg::Office::Common::Menus::ReleaseNotesURL::get() + //https://hub.libreoffice.org/ReleaseNotes/

                "?LOvers=" + utl::ConfigManager::getProductVersion() +

                "&LOlocale=" + LanguageTag(utl::ConfigManager::getUILocale()).getBcp47() );

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

        case SID_CREDITS:

        {

            OUString sURL(officecfg::Office::Common::Menus::CreditsURL::get());

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

        break;

        case SID_HYPHENATIONMISSING:

        {

            // Open wiki page about hyphenation

            OUString sURL(officecfg::Office::Common::Menus::HyphenationMissingURL::get() + //https://hub.libreoffice.org/HyphenationMissing/

                "?LOlocale=" + utl::ConfigManager::getUILocale());

            sfx2::openUriExternally(sURL, false, rReq.GetFrameWeld());

            break;

        }

#endif

        case SID_SHOW_LICENSE:

        {

            LicenseDialog aDialog(rReq.GetFrameWeld());

            aDialog.run();

            break;

        }

        case SID_SHOW_CREDITS:

        {

            showDocument( "CREDITS" );

            break;

        }

        case FN_CHANGE_THEME:

        {

            const SfxStringItem* pNewThemeArg = rReq.GetArg(FN_PARAM_NEW_THEME);

            OUString sSchemeName = ThemeColors::GetThemeColors().GetThemeName();

            AppearanceMode eAppearnceMode = MiscSettings::GetAppColorMode();

            if (!pNewThemeArg)

            {

                // we do not override custom themes if the unocommand was triggered from the UI

                // by clicking on a toolbar/notebookbar button for example.

                if (!ThemeColors::IsCustomTheme(sSchemeName))

                {

                    bool bChangeToLightTheme = eAppearnceMode == AppearanceMode::DARK

                                               || (eAppearnceMode == AppearanceMode::AUTO

                                                   && MiscSettings::GetUseDarkMode());

                    // note that a theme and an appearance mode are not orthogonal anymore, for

                    // "Custom Themes", appearance mode is AUTO, for the "Automatic", "Light" and

                    // "Dark" default themes, it's AUTO, LIGHT & DARK respectively.

                    if (bChangeToLightTheme)

                    {

                        sSchemeName = svtools::LIGHT_COLOR_SCHEME;

                        eAppearnceMode = AppearanceMode::LIGHT;

                    }

                    else

                    {

                        sSchemeName = svtools::DARK_COLOR_SCHEME;

                        eAppearnceMode = AppearanceMode::DARK;

                    }

                }

            }

            else

                sSchemeName = pNewThemeArg->GetValue();

            aEditableConfig.LoadScheme(sSchemeName);

            MiscSettings::SetAppColorMode(eAppearnceMode);

            // kit explicitly ignores changes to the global color scheme, except for the current ViewShell,

            // so an attempted change to the same global color scheme when the now current ViewShell ignored

            // the last change requires re-sending the change. In which case individual shells will have to

            // decide if this color-scheme change is a change from their perspective to avoid unnecessary

            // invalidations.

            if (!pNewThemeArg || bIsLOK || aEditableConfig.GetCurrentSchemeName() != sSchemeName)

            {

                if (bIsLOK)

                    aEditableConfig.SetCurrentSchemeName(sSchemeName);

                else

                    aEditableConfig.LoadScheme(sSchemeName);

            }

            Invalidate(FN_CHANGE_THEME);

            break;

        }

        case FN_INVERT_BACKGROUND:

        {

            const SfxStringItem* pNewThemeArg = rReq.GetArg(FN_PARAM_NEW_THEME);

            svtools::EditableColorConfig aColorConfig;

            ::Color aDefLightColor = svtools::ColorConfig::GetDefaultColor(svtools::DOCCOLOR, 0);

            ::Color aDefDarkColor = svtools::ColorConfig::GetDefaultColor(svtools::DOCCOLOR, 1);

            OUString aNewTheme;

            if (!pNewThemeArg) {

                ::Color aCurrentColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;

                if (aCurrentColor == aDefLightColor) {

                    aNewTheme = OUString("Dark");

                } else {

                    aNewTheme = OUString("Light");

                }

            } else {

                aNewTheme = pNewThemeArg->GetValue();

            }

            svtools::ColorConfigValue aValue;

            if(aNewTheme == "Dark")

                aValue.nColor = aDefDarkColor;

            else

                aValue.nColor = aDefLightColor;

            aColorConfig.SetColorValue(svtools::DOCCOLOR, aValue);

            break;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_HELPINDEX:

        {

            Help* pHelp = Application::GetHelp();

            if ( pHelp )

            {

                pHelp->Start(u".uno:HelpIndex"_ustr, rReq.GetFrameWeld()); // show start page

                bDone = true;

            }

            break;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_HELPTIPS:

        {

            // Evaluate Parameter

            const SfxBoolItem* pOnItem = rReq.GetArg(SID_HELPTIPS);

            bool bOn = pOnItem

                            ? pOnItem->GetValue()

                            : !Help::IsQuickHelpEnabled();

            if ( bOn )

                Help::EnableQuickHelp();

            else

                Help::DisableQuickHelp();

            auto xChanges = comphelper::ConfigurationChanges::create();

            officecfg::Office::Common::Help::Tip::set(bOn, xChanges);

            xChanges->commit();

            Invalidate(SID_HELPTIPS);

            bDone = true;

            // Record if possible

            if ( !rReq.IsAPI() )

                rReq.AppendItem( SfxBoolItem( SID_HELPTIPS, bOn) );

            break;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_EXTENDEDHELP:

        {

            Help::StartExtHelp();

            break;

        }

        case SID_HELPBALLOONS:

        {

            // Evaluate Parameter

            const SfxBoolItem* pOnItem = rReq.GetArg(SID_HELPBALLOONS);

            bool bOn = pOnItem

                            ? pOnItem->GetValue()

                            : !Help::IsBalloonHelpEnabled();

            if ( bOn )

                Help::EnableBalloonHelp();

            else

                Help::DisableBalloonHelp();

            auto xChanges = comphelper::ConfigurationChanges::create();

            officecfg::Office::Common::Help::ExtendedTip::set(bOn, xChanges);

            xChanges->commit();

            Invalidate(SID_HELPBALLOONS);

            bDone = true;

            // Record if possible

            if ( !rReq.IsAPI() )

                rReq.AppendItem( SfxBoolItem( SID_HELPBALLOONS, bOn) );

            break;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#if !ENABLE_WASM_STRIP_PINGUSER

        case SID_TIPOFTHEDAY:

        {

            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();

            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateTipOfTheDayDialog(rReq.GetFrameWeld()));

            pDlg->StartExecuteAsync(nullptr);

            bDone = true;

            break;

        }

#endif

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_WIDGET_TEST_DIALOG:

        {

            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();

            VclPtr<VclAbstractDialog> pDlg(pFact->CreateWidgetTestDialog(rReq.GetFrameWeld()));

            pDlg->StartExecuteAsync([pDlg](sal_Int32 /*nResult*/){

                pDlg->disposeOnce();

            });

            bDone = true;

            break;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_ABOUT:

        {

            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();

            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateAboutDialog(rReq.GetFrameWeld()));

            pDlg->StartExecuteAsync(nullptr);

            bDone = true;

            break;

        }

        case SID_EXTENSION_MANAGER:

        {

            css::uno::Reference<css::awt::XWindow> xParent;

            if (weld::Window* pWindow = rReq.GetFrameWeld())

                xParent = pWindow->GetXWindow();

            Reference<ui::dialogs::XAsynchronousExecutableDialog> xDialog(

                css::deployment::ui::PackageManagerDialog::create(

                    comphelper::getProcessComponentContext(), xParent, OUString()));

            assert(xDialog.is());