horok/libreoffice
1
0
Fork 0
Code Activity
libreoffice/cui/source/options/treeopt.cxx
Daniel Baumann 8e63e14cf6
Adding upstream version 4:25.2.3. 
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
2025-06-22 16:20:04 +02:00

2675 lines
100 KiB
C++
Raw Permalink Blame History

/* -*- 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 <memory>
#include <string_view>
#include <config_features.h>
#include <config_feature_opencl.h>
#include <config_feature_desktop.h>
#include <config_gpgme.h>
#include <officecfg/Office/Common.hxx>
#include <officecfg/Office/Writer.hxx>
#include <svx/dialogs.hrc>
#include <svx/svxids.hrc>
#include <treeopt.hrc>
#include <helpids.h>
#include "appearance.hxx"
#include "cfgchart.hxx"
#include "connpoolconfig.hxx"
#include "connpooloptions.hxx"
#include <cuioptgenrl.hxx>
#include <dbregister.hxx>
#include "dbregisterednamesconfig.hxx"
#include <dialmgr.hxx>
#include "fontsubs.hxx"
#include "optaccessibility.hxx"
#include <optasian.hxx>
#include "optchart.hxx"
#include "optctl.hxx"
#include "optfltr.hxx"
#include "optgdlg.hxx"
#include "opthtml.hxx"
#include "optinet2.hxx"
#include "optjava.hxx"
#include "optjsearch.hxx"
#include <optlingu.hxx>
#if HAVE_FEATURE_OPENCL
#include "optopencl.hxx"
#endif
#include <optpath.hxx>
#include "optsave.hxx"
#include "optupdt.hxx"
#include <treeopt.hxx>
#include "optbasic.hxx"
#include "optlanguagetool.hxx"
#include "optdeepl.hxx"
// include search util
#include <com/sun/star/util/SearchFlags.hpp>
#include <com/sun/star/util/SearchAlgorithms2.hpp>
#include <unotools/textsearch.hxx>
#include <com/sun/star/awt/XContainerWindowEventHandler.hpp>
#include <com/sun/star/awt/ContainerWindowProvider.hpp>
#include <com/sun/star/awt/XControl.hpp>
#include <com/sun/star/awt/PosSize.hpp>
#include <com/sun/star/frame/Desktop.hpp>
#include <com/sun/star/frame/ModuleManager.hpp>
#include <com/sun/star/frame/UnknownModuleException.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/linguistic2/LinguProperties.hpp>
#include <comphelper/getexpandeduri.hxx>
#include <comphelper/processfactory.hxx>
#include <editeng/langitem.hxx>
#include <editeng/optitems.hxx>
#include <editeng/unolingu.hxx>
#include <linguistic/misc.hxx>
#include <o3tl/deleter.hxx>
#include <officecfg/Office/OptionsDialog.hxx>
#include <sfx2/app.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/module.hxx>
#include <sfx2/printopt.hxx>
#include <sfx2/shell.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/viewfrm.hxx>
#include <svl/flagitem.hxx>
#include <svl/intitem.hxx>
#include <svl/cjkoptions.hxx>
#include <svl/ctloptions.hxx>
#include <svx/databaseregistrationui.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <tools/urlobj.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <unotools/configmgr.hxx>
#include <unotools/moduleoptions.hxx>
#include <unotools/optionsdlg.hxx>
#include <unotools/viewoptions.hxx>
#include <utility>
#include <vcl/help.hxx>
#include <vcl/svapp.hxx>
#include <vcl/weldutils.hxx>
#include <vcl/window.hxx>
#include <sal/log.hxx>
using namespace ::com::sun::star;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::linguistic2;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::util;
LastPageSaver* OfaTreeOptionsDialog::pLastPageSaver = nullptr;
// some stuff for easier changes for SvtViewOptions
constexpr OUString VIEWOPT_DATANAME = u"page data"_ustr;
static void SetViewOptUserItem( SvtViewOptions& rOpt, const OUString& rData )
{
rOpt.SetUserItem( VIEWOPT_DATANAME, Any( rData ) );
}
static OUString GetViewOptUserItem( const SvtViewOptions& rOpt )
{
Any aAny( rOpt.GetUserItem( VIEWOPT_DATANAME ) );
OUString aUserData;
aAny >>= aUserData;
return aUserData;
}
namespace {
struct ModuleToGroupNameMap_Impl
{
std::u16string_view m_pModule;
OUString m_sGroupName;
sal_uInt16 m_nNodeId;
};
}
static ModuleToGroupNameMap_Impl ModuleMap[] =
{
{ u"ProductName", OUString(), SID_GENERAL_OPTIONS },
{ u"LanguageSettings", OUString(), SID_LANGUAGE_OPTIONS },
{ u"Internet", OUString(), SID_INET_DLG },
{ u"LoadSave", OUString(), SID_FILTER_DLG },
{ u"Writer", OUString(), SID_SW_EDITOPTIONS },
{ u"WriterWeb", OUString(), SID_SW_ONLINEOPTIONS },
{ u"Math", OUString(), SID_SM_EDITOPTIONS },
{ u"Calc", OUString(), SID_SC_EDITOPTIONS },
{ u"Impress", OUString(), SID_SD_EDITOPTIONS },
{ u"Draw", OUString(), SID_SD_GRAPHIC_OPTIONS },
{ u"Charts", OUString(), SID_SCH_EDITOPTIONS },
{ u"Base", OUString(), SID_SB_STARBASEOPTIONS },
};
static void setGroupName( std::u16string_view rModule, const OUString& rGroupName )
{
for (ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
{
if ( rEntry.m_pModule == rModule )
{
rEntry.m_sGroupName = rGroupName;
break;
}
}
}
static OUString getGroupName( std::u16string_view rModule, bool bForced )
{
OUString sGroupName;
for (const ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
{
if ( rEntry.m_pModule == rModule )
{
sGroupName = rEntry.m_sGroupName;
break;
}
}
if ( sGroupName.isEmpty() && bForced )
{
if ( rModule == u"Writer" )
sGroupName = CuiResId(SID_SW_EDITOPTIONS_RES[0].first);
else if ( rModule == u"WriterWeb" )
sGroupName = CuiResId(SID_SW_ONLINEOPTIONS_RES[0].first);
else if ( rModule == u"Calc" )
sGroupName = CuiResId(SID_SC_EDITOPTIONS_RES[0].first);
else if ( rModule == u"Impress" )
sGroupName = CuiResId(SID_SD_EDITOPTIONS_RES[0].first);
else if ( rModule == u"Draw" )
sGroupName = CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[0].first);
else if ( rModule == u"Math" )
sGroupName = CuiResId(SID_SM_EDITOPTIONS_RES[0].first);
else if ( rModule == u"Base" )
sGroupName = CuiResId(SID_SB_STARBASEOPTIONS_RES[0].first);
}
return sGroupName;
}
static void deleteGroupNames()
{
for (ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
rEntry.m_sGroupName.clear();
}
static sal_uInt16 getGroupNodeId( std::u16string_view rModule )
{
sal_uInt16 nNodeId = 0xFFFF;
for (const ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
{
if ( rEntry.m_pModule == rModule )
{
nNodeId = rEntry.m_nNodeId;
break;
}
}
return nNodeId;
}
namespace {
bool MailMergeCfgIsEmailSupported()
{
std::optional<bool> b = officecfg::Office::Writer::MailMergeWizard::EMailSupported::get();
return b.has_value() && *b;
}
}
//typedef SfxTabPage* (*FNCreateTabPage)(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rAttrSet);
static std::unique_ptr<SfxTabPage> CreateGeneralTabPage(sal_uInt16 nId, weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
{
CreateTabPage fnCreate = nullptr;
switch(nId)
{
case RID_SFXPAGE_SAVE: fnCreate = &SvxSaveTabPage::Create; break;
case RID_SFXPAGE_PATH: fnCreate = &SvxPathTabPage::Create; break;
case RID_SFXPAGE_GENERAL: fnCreate = &SvxGeneralTabPage::Create; break;
case RID_SFXPAGE_PRINTOPTIONS: fnCreate = &SfxCommonPrintOptionsTabPage::Create; break;
case OFA_TP_LANGUAGES: fnCreate = &OfaLanguagesTabPage::Create; break;
case RID_SFXPAGE_LINGU: fnCreate = &SvxLinguTabPage::Create; break;
case OFA_TP_VIEW: fnCreate = &OfaViewTabPage::Create; break;
case OFA_TP_MISC: fnCreate = &OfaMiscTabPage::Create; break;
case RID_SVXPAGE_ASIAN_LAYOUT: fnCreate = &SvxAsianLayoutPage::Create; break;
case RID_SVX_FONT_SUBSTITUTION: fnCreate = &SvxFontSubstTabPage::Create; break;
case RID_SVXPAGE_INET_PROXY: fnCreate = &SvxProxyTabPage::Create; break;
case RID_SVXPAGE_INET_SECURITY: fnCreate = &SvxSecurityTabPage::Create; break;
case RID_SVXPAGE_INET_MAIL: fnCreate = &SvxEMailTabPage::Create; break;
#if HAVE_FEATURE_DESKTOP
case RID_SVXPAGE_APPEARANCE: fnCreate = &SvxAppearanceTabPage::Create; break;
#endif
case RID_OFAPAGE_HTMLOPT: fnCreate = &OfaHtmlTabPage::Create; break;
case SID_OPTFILTER_MSOFFICE: fnCreate = &OfaMSFilterTabPage::Create; break;
case RID_OFAPAGE_MSFILTEROPT2: fnCreate = &OfaMSFilterTabPage2::Create; break;
case RID_SVXPAGE_JSEARCH_OPTIONS: fnCreate = &SvxJSearchOptionsPage::Create ; break;
case SID_SB_CONNECTIONPOOLING: fnCreate = &::offapp::ConnectionPoolOptionsPage::Create; break;
case SID_SB_DBREGISTEROPTIONS: fnCreate = &svx::DbRegistrationOptionsPage::Create; break;
case RID_SVXPAGE_ACCESSIBILITYCONFIG: fnCreate = &SvxAccessibilityOptionsTabPage::Create; break;
case RID_SVXPAGE_OPTIONS_CTL: fnCreate = &SvxCTLOptionsPage::Create ; break;
case RID_SVXPAGE_LANGTOOL_OPTIONS: fnCreate = &OptLanguageToolTabPage::Create ; break;
case RID_SVXPAGE_DEEPL_OPTIONS: fnCreate = &OptDeeplTabPage::Create ; break;
case RID_SVXPAGE_OPTIONS_JAVA: fnCreate = &SvxJavaOptionsPage::Create ; break;
#if HAVE_FEATURE_OPENCL
case RID_SVXPAGE_OPENCL: fnCreate = &SvxOpenCLTabPage::Create ; break;
#endif
case RID_SVXPAGE_ONLINEUPDATE: fnCreate = &SvxOnlineUpdateTabPage::Create; break;
case RID_OPTPAGE_CHART_DEFCOLORS: fnCreate = &SvxDefaultColorOptPage::Create; break;
#if HAVE_FEATURE_SCRIPTING
case RID_SVXPAGE_BASICIDE_OPTIONS: fnCreate = &SvxBasicIDEOptionsPage::Create; break;
#endif
}
return fnCreate ? (*fnCreate)( pPage, pController, &rSet ) : nullptr;
}
namespace {
struct OptionsMapping_Impl
{
OUString m_aGroupName;
OUString m_aPageName;
sal_uInt16 m_nPageId;
};
}
constexpr OptionsMapping_Impl OptionsMap_Impl[]
{
// GROUP PAGE PAGE-ID
{ u"ProductName"_ustr, u""_ustr, SID_GENERAL_OPTIONS },
{ u"ProductName"_ustr, u"UserData"_ustr, RID_SFXPAGE_GENERAL },
{ u"ProductName"_ustr, u"General"_ustr, OFA_TP_MISC },
{ u"ProductName"_ustr, u"View"_ustr, OFA_TP_VIEW },
{ u"ProductName"_ustr, u"Print"_ustr, RID_SFXPAGE_PRINTOPTIONS },
{ u"ProductName"_ustr, u"Paths"_ustr, RID_SFXPAGE_PATH },
{ u"ProductName"_ustr, u"Fonts"_ustr, RID_SVX_FONT_SUBSTITUTION },
{ u"ProductName"_ustr, u"Security"_ustr, RID_SVXPAGE_INET_SECURITY },
{ u"ProductName"_ustr, u"Appearance"_ustr, RID_SVXPAGE_APPEARANCE },
{ u"ProductName"_ustr, u"Accessibility"_ustr, RID_SVXPAGE_ACCESSIBILITYCONFIG },
{ u"ProductName"_ustr, u"Java"_ustr, RID_SVXPAGE_OPTIONS_JAVA },
{ u"ProductName"_ustr, u"BasicIDEOptions"_ustr, RID_SVXPAGE_BASICIDE_OPTIONS },
{ u"ProductName"_ustr, u"OnlineUpdate"_ustr, RID_SVXPAGE_ONLINEUPDATE },
{ u"LanguageSettings"_ustr, u""_ustr, SID_LANGUAGE_OPTIONS },
{ u"LanguageSettings"_ustr, u"Languages"_ustr, OFA_TP_LANGUAGES },
{ u"LanguageSettings"_ustr, u"WritingAids"_ustr, RID_SFXPAGE_LINGU },
{ u"LanguageSettings"_ustr, u"SearchingInJapanese"_ustr, RID_SVXPAGE_JSEARCH_OPTIONS },
{ u"LanguageSettings"_ustr, u"AsianLayout"_ustr, RID_SVXPAGE_ASIAN_LAYOUT },
{ u"LanguageSettings"_ustr, u"ComplexTextLayout"_ustr, RID_SVXPAGE_OPTIONS_CTL },
{ u"Internet"_ustr, u""_ustr, SID_INET_DLG },
{ u"Internet"_ustr, u"Proxy"_ustr, RID_SVXPAGE_INET_PROXY },
{ u"Internet"_ustr, u"Email"_ustr, RID_SVXPAGE_INET_MAIL },
{ u"LoadSave"_ustr, u""_ustr, SID_FILTER_DLG },
{ u"LoadSave"_ustr, u"General"_ustr, RID_SFXPAGE_SAVE },
{ u"LoadSave"_ustr, u"VBAProperties"_ustr, SID_OPTFILTER_MSOFFICE },
{ u"LoadSave"_ustr, u"MicrosoftOffice"_ustr, RID_OFAPAGE_MSFILTEROPT2 },
{ u"LoadSave"_ustr, u"HTMLCompatibility"_ustr, RID_OFAPAGE_HTMLOPT },
{ u"Writer"_ustr, u""_ustr, SID_SW_EDITOPTIONS },
{ u"Writer"_ustr, u"General"_ustr, RID_SW_TP_OPTLOAD_PAGE },
{ u"Writer"_ustr, u"View"_ustr, RID_SW_TP_CONTENT_OPT },
{ u"Writer"_ustr, u"FormattingAids"_ustr, RID_SW_TP_OPTSHDWCRSR },
{ u"Writer"_ustr, u"Grid"_ustr, RID_SVXPAGE_GRID },
{ u"Writer"_ustr, u"BasicFontsWestern"_ustr, RID_SW_TP_STD_FONT },
{ u"Writer"_ustr, u"BasicFontsAsian"_ustr, RID_SW_TP_STD_FONT_CJK },
{ u"Writer"_ustr, u"BasicFontsCTL"_ustr, RID_SW_TP_STD_FONT_CTL },
{ u"Writer"_ustr, u"Print"_ustr, RID_SW_TP_OPTPRINT_PAGE },
{ u"Writer"_ustr, u"Table"_ustr, RID_SW_TP_OPTTABLE_PAGE },
{ u"Writer"_ustr, u"Changes"_ustr, RID_SW_TP_REDLINE_OPT },
{ u"Writer"_ustr, u"Comparison"_ustr, RID_SW_TP_COMPARISON_OPT },
{ u"Writer"_ustr, u"Compatibility"_ustr, RID_SW_TP_OPTCOMPATIBILITY_PAGE },
{ u"Writer"_ustr, u"AutoCaption"_ustr, RID_SW_TP_OPTCAPTION_PAGE },
{ u"Writer"_ustr, u"MailMerge"_ustr, RID_SW_TP_MAILCONFIG },
{ u"WriterWeb"_ustr, u""_ustr, SID_SW_ONLINEOPTIONS },
{ u"WriterWeb"_ustr, u"View"_ustr, RID_SW_TP_HTML_CONTENT_OPT },
{ u"WriterWeb"_ustr, u"FormattingAids"_ustr, RID_SW_TP_HTML_OPTSHDWCRSR },
{ u"WriterWeb"_ustr, u"Grid"_ustr, RID_SW_TP_HTML_OPTGRID_PAGE },
{ u"WriterWeb"_ustr, u"Print"_ustr, RID_SW_TP_HTML_OPTPRINT_PAGE },
{ u"WriterWeb"_ustr, u"Table"_ustr, RID_SW_TP_HTML_OPTTABLE_PAGE },
{ u"WriterWeb"_ustr, u"Background"_ustr, RID_SW_TP_BACKGROUND },
{ u"Math"_ustr, u""_ustr, SID_SM_EDITOPTIONS },
{ u"Math"_ustr, u"Settings"_ustr, SID_SM_TP_PRINTOPTIONS },
{ u"Calc"_ustr, u""_ustr, SID_SC_EDITOPTIONS },
{ u"Calc"_ustr, u"General"_ustr, SID_SC_TP_LAYOUT },
{ u"Calc"_ustr, u"View"_ustr, SID_SC_TP_CONTENT },
{ u"Calc"_ustr, u"Calculate"_ustr, SID_SC_TP_CALC },
{ u"Calc"_ustr, u"Formula"_ustr, SID_SC_TP_FORMULA },
{ u"Calc"_ustr, u"SortLists"_ustr, SID_SC_TP_USERLISTS },
{ u"Calc"_ustr, u"Changes"_ustr, SID_SC_TP_CHANGES },
{ u"Calc"_ustr, u"Compatibility"_ustr, SID_SC_TP_COMPATIBILITY },
{ u"Calc"_ustr, u"Grid"_ustr, SID_SC_TP_GRID },
{ u"Calc"_ustr, u"Print"_ustr, RID_SC_TP_PRINT },
{ u"Impress"_ustr, u""_ustr, SID_SD_EDITOPTIONS },
{ u"Impress"_ustr, u"General"_ustr, SID_SI_TP_MISC },
{ u"Impress"_ustr, u"View"_ustr, SID_SI_TP_CONTENTS },
{ u"Impress"_ustr, u"Grid"_ustr, SID_SI_TP_SNAP },
{ u"Impress"_ustr, u"Print"_ustr, SID_SI_TP_PRINT },
{ u"Draw"_ustr, u""_ustr, SID_SD_GRAPHIC_OPTIONS },
{ u"Draw"_ustr, u"General"_ustr, SID_SD_TP_MISC },
{ u"Draw"_ustr, u"View"_ustr, SID_SD_TP_CONTENTS },
{ u"Draw"_ustr, u"Grid"_ustr, SID_SD_TP_SNAP },
{ u"Draw"_ustr, u"Print"_ustr, SID_SD_TP_PRINT },
{ u"Charts"_ustr, u""_ustr, SID_SCH_EDITOPTIONS },
{ u"Charts"_ustr, u"DefaultColors"_ustr, RID_OPTPAGE_CHART_DEFCOLORS },
{ u"Base"_ustr, u""_ustr, SID_SB_STARBASEOPTIONS },
{ u"Base"_ustr, u"Connections"_ustr, SID_SB_CONNECTIONPOOLING },
{ u"Base"_ustr, u"Databases"_ustr, SID_SB_DBREGISTEROPTIONS },
};
static bool lcl_getStringFromID( sal_uInt16 _nPageId, OUString& _rGroupName, OUString& _rPageName )
{
bool bRet = false;
for (const auto & rMapping : OptionsMap_Impl )
{
if ( _nPageId == rMapping.m_nPageId )
{
bRet = true;
_rGroupName = rMapping.m_aGroupName;
if ( !rMapping.m_aPageName.isEmpty() )
_rPageName = rMapping.m_aPageName;
break;
}
}
return bRet;
}
static bool lcl_isOptionHidden( sal_uInt16 _nPageId, const SvtOptionsDialogOptions& _rOptOptions )
{
bool bIsHidden = false;
OUString sGroupName, sPageName;
if ( lcl_getStringFromID( _nPageId, sGroupName, sPageName ) )
{
if ( sPageName.isEmpty() )
bIsHidden = _rOptOptions.IsGroupHidden( sGroupName );
else
bIsHidden = _rOptOptions.IsPageHidden( sPageName, sGroupName );
}
return bIsHidden;
}
struct OptionsPageInfo
{
std::unique_ptr<SfxTabPage> m_xPage;
sal_uInt16 m_nPageId;
OUString m_sPageURL;
OUString m_sEventHdl;
std::unique_ptr<ExtensionsTabPage> m_xExtPage;
explicit OptionsPageInfo( sal_uInt16 nId ) : m_nPageId( nId ) {}
};
struct OptionsGroupInfo
{
std::optional<SfxItemSet> m_pInItemSet;
std::unique_ptr<SfxItemSet> m_pOutItemSet;
SfxShell* m_pShell; // used to create the page
SfxModule* m_pModule; // used to create the ItemSet
sal_uInt16 m_nDialogId; // Id of the former dialog
OptionsGroupInfo( SfxShell* pSh, SfxModule* pMod, sal_uInt16 nId ) :
m_pShell( pSh ),
m_pModule( pMod ), m_nDialogId( nId ) {}
};
struct OptionsPageIdInfo
{
OUString m_sParentName;
OUString m_sPageName;
sal_uInt16 m_nParentId;
sal_uInt16 m_nPageId;
OptionsPageIdInfo(OUString sParentName, OUString sPageName, sal_uInt16 nParentId,
sal_uInt16 nPageId)
: m_sParentName(std::move(sParentName))
, m_sPageName(std::move(sPageName))
, m_nParentId(nParentId)
, m_nPageId(nPageId)
{
}
};
// Basic ctor with common initialization
OfaTreeOptionsDialog::OfaTreeOptionsDialog(weld::Window* pParent, bool fromExtensionManager)
: SfxOkDialogController(pParent, u"cui/ui/optionsdialog.ui"_ustr, u"OptionsDialog"_ustr)
, xOkPB(m_xBuilder->weld_button(u"ok"_ustr))
, xApplyPB(m_xBuilder->weld_button(u"apply"_ustr))
, xBackPB(m_xBuilder->weld_button(u"revert"_ustr))
, xTreeLB(m_xBuilder->weld_tree_view(u"pages"_ustr))
, xTabBox(m_xBuilder->weld_container(u"box"_ustr))
, m_xSearchEdit(m_xBuilder->weld_entry(u"searchEntry"_ustr))
, m_pParent(pParent)
, m_aUpdateDataTimer("OfaTreeOptionsDialog UpdateDataTimer")
, bIsFirtsInitialize(true)
, sTitle(m_xDialog->get_title())
, bForgetSelection(false)
, bIsFromExtensionManager(fromExtensionManager)
, bIsForSetDocumentLanguage(false)
, bNeedsRestart(false)
, eRestartReason(svtools::RESTART_REASON_NONE)
{
Size aSize(xTreeLB->get_approximate_digit_width() * 100, xTreeLB->get_height_rows(30));
AbsoluteScreenPixelRectangle aScreen
= Application::GetScreenPosSizePixel(Application::GetDisplayBuiltInScreen());
// clamp height to max of 80% of screen height to make buttons accessible on smaller screens
aSize.setHeight(std::min(static_cast<tools::Long>(aScreen.GetHeight() * 0.8), aSize.Height()));
xTabBox->set_size_request(aSize.Width(), aSize.Height());
xTreeLB->set_size_request(xTreeLB->get_approximate_digit_width() * 35, aSize.Height());
// Init tree and handler
xTreeLB->set_help_id(HID_OFADLG_TREELISTBOX);
xTreeLB->connect_changed(LINK(this, OfaTreeOptionsDialog, ShowPageHdl_Impl));
xBackPB->connect_clicked(LINK(this, OfaTreeOptionsDialog, BackHdl_Impl));
xApplyPB->connect_clicked(LINK(this, OfaTreeOptionsDialog, ApplyHdl_Impl));
xOkPB->connect_clicked(LINK(this, OfaTreeOptionsDialog, ApplyHdl_Impl));
m_xSearchEdit->connect_changed(LINK(this, OfaTreeOptionsDialog, SearchUpdateHdl));
m_xSearchEdit->connect_focus_out(LINK(this, OfaTreeOptionsDialog, FocusOut_Impl));
m_xDialog->connect_help(LINK(this, OfaTreeOptionsDialog, HelpHdl_Impl));
m_aUpdateDataTimer.SetInvokeHandler(LINK(this, OfaTreeOptionsDialog, ImplUpdateDataHdl));
m_aUpdateDataTimer.SetTimeout(EDIT_UPDATEDATA_TIMEOUT);
// Initialize search util
m_options.AlgorithmType2 = util::SearchAlgorithms2::ABSOLUTE;
m_options.transliterateFlags |= TransliterationFlags::IGNORE_CASE;
m_options.searchFlag
|= (util::SearchFlags::REG_NOT_BEGINOFLINE | util::SearchFlags::REG_NOT_ENDOFLINE);
xTreeLB->set_accessible_name(sTitle);
}
// Ctor() with Frame -----------------------------------------------------
OfaTreeOptionsDialog::OfaTreeOptionsDialog(weld::Window* pParent, const Reference< XFrame >& _xFrame, bool bActivateLastSelection)
: OfaTreeOptionsDialog(pParent, false)
{
Initialize( _xFrame );
LoadExtensionOptions( u"" );
if (bActivateLastSelection)
ActivateLastSelection();
}
// Ctor() with ExtensionId -----------------------------------------------
OfaTreeOptionsDialog::OfaTreeOptionsDialog(weld::Window* pParent, std::u16string_view rExtensionId)
: OfaTreeOptionsDialog(pParent, !rExtensionId.empty())
{
LoadExtensionOptions( rExtensionId );
ActivateLastSelection();
}
void OfaTreeOptionsDialog::ImplDestroy()
{
xCurrentPageEntry.reset();
std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
bool bEntry = xTreeLB->get_iter_first(*xEntry);
// first children
while (bEntry)
{
// if Child (has parent), then OptionsPageInfo
if (xTreeLB->get_iter_depth(*xEntry))
{
OptionsPageInfo *pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xEntry));
if(pPageInfo->m_xPage)
{
pPageInfo->m_xPage->FillUserData();
OUString aPageData(pPageInfo->m_xPage->GetUserData());
if ( !aPageData.isEmpty() )
{
SvtViewOptions aTabPageOpt( EViewType::TabPage, OUString::number( pPageInfo->m_nPageId) );
SetViewOptUserItem( aTabPageOpt, aPageData );
}
pPageInfo->m_xPage.reset();
}
if (pPageInfo->m_nPageId == RID_SFXPAGE_LINGU)
{
// write personal dictionaries
Reference< XSearchableDictionaryList > xDicList( LinguMgr::GetDictionaryList() );
if (xDicList.is())
{
linguistic::SaveDictionaries( xDicList );
}
}
pPageInfo->m_xExtPage.reset();
delete pPageInfo;
}
bEntry = xTreeLB->iter_next(*xEntry);
}
// and parents
bEntry = xTreeLB->get_iter_first(*xEntry);
while (bEntry)
{
if (!xTreeLB->get_iter_depth(*xEntry))
{
OptionsGroupInfo* pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xEntry));
delete pGroupInfo;
}
bEntry = xTreeLB->iter_next(*xEntry);
}
deleteGroupNames();
}
OfaTreeOptionsDialog::~OfaTreeOptionsDialog()
{
suppress_fun_call_w_exception(ImplDestroy());
}
OptionsPageInfo* OfaTreeOptionsDialog::AddTabPage(
sal_uInt16 nId, const OUString& rPageName, sal_uInt16 nGroup )
{
std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator();
if (!xTreeLB->get_iter_first(*xParent))
return nullptr;
xTreeLB->iter_nth_sibling(*xParent, nGroup);
OptionsPageInfo* pPageInfo = new OptionsPageInfo( nId );
OUString sId(weld::toId(pPageInfo));
xTreeLB->insert(xParent.get(), -1, &rPageName, &sId, nullptr, nullptr, false, nullptr);
return pPageInfo;
}
// the ItemSet* is passed on to the dialog's ownership
sal_uInt16 OfaTreeOptionsDialog::AddGroup(const OUString& rGroupName,
SfxShell* pCreateShell,
SfxModule* pCreateModule,
sal_uInt16 nDialogId )
{
OptionsGroupInfo* pInfo =
new OptionsGroupInfo( pCreateShell, pCreateModule, nDialogId );
OUString sId(weld::toId(pInfo));
xTreeLB->append(sId, rGroupName);
sal_uInt16 nRet = 0;
std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
bool bEntry = xTreeLB->get_iter_first(*xEntry);
while (bEntry)
{
if (!xTreeLB->get_iter_depth(*xEntry))
nRet++;
bEntry = xTreeLB->iter_next(*xEntry);
}
return nRet - 1;
}
IMPL_LINK_NOARG(OfaTreeOptionsDialog, ShowPageHdl_Impl, weld::TreeView&, void)
{
SelectHdl_Impl();
}
void OfaTreeOptionsDialog::ResetCurrentPageFromConfig()
{
if (!(xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry)))
return;
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry));
if (pPageInfo->m_xPage)
{
std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator(xCurrentPageEntry.get());
xTreeLB->iter_parent(*xParent);
OptionsGroupInfo* pGroupInfo =
weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xParent));
pPageInfo->m_xPage->Reset( &*pGroupInfo->m_pInItemSet );
}
else if ( pPageInfo->m_xExtPage )
pPageInfo->m_xExtPage->ResetPage();
}
IMPL_LINK_NOARG(OfaTreeOptionsDialog, BackHdl_Impl, weld::Button&, void)
{
ResetCurrentPageFromConfig();
}
void OfaTreeOptionsDialog::ApplyOptions()
{
std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
bool bEntry = xTreeLB->get_iter_first(*xEntry);
while (bEntry)
{
if (xTreeLB->get_iter_depth(*xEntry))
{
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xEntry));
if ( pPageInfo->m_xPage && !pPageInfo->m_xPage->HasExchangeSupport() )
{
std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator(xEntry.get());
xTreeLB->iter_parent(*xParent);
OptionsGroupInfo* pGroupInfo =
weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xParent));
pPageInfo->m_xPage->FillItemSet(pGroupInfo->m_pOutItemSet.get());
}
if ( pPageInfo->m_xExtPage )
{
pPageInfo->m_xExtPage->DeactivatePage();
pPageInfo->m_xExtPage->SavePage();
}
if ( pPageInfo->m_xPage && RID_OPTPAGE_CHART_DEFCOLORS == pPageInfo->m_nPageId )
{
SvxDefaultColorOptPage* pPage = static_cast<SvxDefaultColorOptPage *>(pPageInfo->m_xPage.get());
pPage->SaveChartOptions();
}
}
bEntry = xTreeLB->iter_next(*xEntry);
}
}
IMPL_LINK_NOARG(OfaTreeOptionsDialog, HelpHdl_Impl, weld::Widget&, bool)
{
Help* pHelp = Application::GetHelp();
if (pHelp && xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry))
{
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry));
if (pPageInfo->m_xPage)
{
OUString sHelpId(pPageInfo->m_xPage->GetHelpId());
pHelp->Start(sHelpId, m_xDialog.get());
return false;
}
}
return true;
}
IMPL_LINK(OfaTreeOptionsDialog, ApplyHdl_Impl, weld::Button&, rButton, void)
{
bool bOkPressed = &rButton == xOkPB.get();
OptionsGroupInfo* pGroupInfo = nullptr;
if (xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry))
{
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry));
if ( pPageInfo->m_xPage )
{
std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator(xCurrentPageEntry.get());
xTreeLB->iter_parent(*xParent);
pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xParent));
if ( RID_SVXPAGE_COLOR != pPageInfo->m_nPageId
&& pPageInfo->m_xPage->HasExchangeSupport() )
{
DeactivateRC nLeave = pPageInfo->m_xPage->DeactivatePage(pGroupInfo->m_pOutItemSet.get());
if ( nLeave == DeactivateRC::KeepPage )
{
// the page mustn't be left, so return early
assert(xTreeLB->is_selected(*xCurrentPageEntry)); // presumably this must be true here
if (bOkPressed)
return;
}
}
}
}
ApplyOptions();
ApplyItemSets();
utl::ConfigManager::storeConfigItems();
if (bOkPressed)
m_xDialog->response(RET_OK);
else
{
// tdf#137930 rebuild the in and out itemsets to reflect the current
// post-apply state
if (pGroupInfo && pGroupInfo->m_pInItemSet)
{
// tdf#138596 seeing as the SfxTabPages keep pointers to the m_pInItemSet
// we update the contents of the existing SfxItemSets to match
// the current settings, rather than create new ones
auto xInItemSet = pGroupInfo->m_pShell
? pGroupInfo->m_pShell->CreateItemSet( pGroupInfo->m_nDialogId )
: CreateItemSet( pGroupInfo->m_nDialogId );
pGroupInfo->m_pInItemSet->Set(*xInItemSet, false);
pGroupInfo->m_pOutItemSet->ClearItem();
}
// for the Apply case, now that the settings are saved to config,
// reload the current page so it knows what the config now states
ResetCurrentPageFromConfig();
// reselect it to undo possible DeactivatePage above
xCurrentPageEntry.reset();
SelectHdl_Impl();
}
if (!bNeedsRestart)
return;
SolarMutexGuard aGuard;
weld::Window* pParent;
if (!bOkPressed)
pParent = m_xDialog.get();
else
{
m_xDialog->hide();
pParent = m_pParent;
}
bool bRestart = ::svtools::executeRestartDialog(comphelper::getProcessComponentContext(),
pParent, eRestartReason);
if (bRestart && !bOkPressed)
m_xDialog->response(RET_OK);
}
IMPL_LINK_NOARG(OfaTreeOptionsDialog, FocusOut_Impl, weld::Widget&, void)
{
if (m_aUpdateDataTimer.IsActive())
{
m_aUpdateDataTimer.Stop();
m_aUpdateDataTimer.Invoke();
}
}
IMPL_LINK_NOARG(OfaTreeOptionsDialog, SearchUpdateHdl, weld::Entry&, void)
{
m_aUpdateDataTimer.Start();
}
IMPL_LINK_NOARG(OfaTreeOptionsDialog, ImplUpdateDataHdl, Timer*, void)
{
// initializeAllDialogs() can take a long time, show wait cursor and disable input
m_xSearchEdit->set_editable(false);
m_xSearchEdit->set_busy_cursor(true);
// Pause redraw
xTreeLB->freeze();
if (bIsFirtsInitialize)
{
m_xSearchEdit->freeze();
xTreeLB->hide();
initializeAllDialogs();
m_xSearchEdit->thaw();
xTreeLB->show();
bIsFirtsInitialize = false;
}
// Apply the search filter
OUString aSearchTerm(m_xSearchEdit->get_text());
int nMatchFound = applySearchFilter(aSearchTerm);
// Resume redraw
xTreeLB->thaw();
// select first child of first node after the search done
if (nMatchFound != -1)
selectFirstEntry();
m_xSearchEdit->set_editable(true);
m_xSearchEdit->set_busy_cursor(false);
}
void OfaTreeOptionsDialog::selectFirstEntry()
{
std::unique_ptr<weld::TreeIter> xTemp = xTreeLB->make_iterator();
bool bTemp = xTreeLB->get_iter_first(*xTemp);
while (bTemp)
{
// select only the first child
if (xTreeLB->get_iter_depth(*xTemp) && xTreeLB->get_id(*xTemp).toInt64())
{
std::unique_ptr<weld::TreeIter> xEntry(xTreeLB->make_iterator(xTemp.get()));
std::unique_ptr<weld::TreeIter> xParent(xTreeLB->make_iterator(xEntry.get()));
xTreeLB->iter_parent(*xParent);
xTreeLB->expand_row(*xParent);
xTreeLB->scroll_to_row(*xParent);
xTreeLB->scroll_to_row(*xEntry);
xTreeLB->set_cursor(*xEntry);
xTreeLB->select(*xEntry);
SelectHdl_Impl();
break;
}
bTemp = xTreeLB->iter_next(*xTemp);
}
}
void OfaTreeOptionsDialog::initializeAllDialogs()
{
std::unique_ptr<weld::TreeIter> xEntry;
std::unique_ptr<weld::TreeIter> xTemp = xTreeLB->make_iterator();
bool bTemp = xTreeLB->get_iter_first(*xTemp);
while (bTemp)
{
if (xTreeLB->get_iter_depth(*xTemp) && xTreeLB->get_id(*xTemp).toInt64())
{
if (!(xEntry = xTreeLB->make_iterator(xTemp.get())))
{
xEntry = xTreeLB->make_iterator();
if (!xTreeLB->get_iter_first(*xEntry) || !xTreeLB->iter_next(*xEntry))
xEntry.reset();
}
if (!xEntry)
return;
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xEntry));
if (TreeOptHelper::getStringsFromDialog(pPageInfo->m_nPageId).isEmpty())
{
SolarMutexGuard aGuard;
initializeCurrentDialog(pPageInfo, xEntry);
}
}
bTemp = xTreeLB->iter_next(*xTemp);
}
}
void OfaTreeOptionsDialog::clearOptionsDialog()
{
// clear and reset
std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
bool bEntry = xTreeLB->get_iter_first(*xEntry);
while (bEntry)
{
if (xTreeLB->get_iter_depth(*xEntry))
{
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xEntry));
if (pPageInfo->m_xPage)
pPageInfo->m_xPage.reset();
}
bEntry = xTreeLB->iter_next(*xEntry);
}
xCurrentPageEntry.reset();
}
// store Options tree with their page names
void OfaTreeOptionsDialog::storeOptionsTree()
{
m_aTreePageIds.clear();
sal_uInt16 aParentId = 0;
OUString sParentName;
std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
bool bEntry = xTreeLB->get_iter_first(*xEntry);
while (bEntry)
{
OptionsGroupInfo* pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xEntry));
bool bIsParentNode = !xTreeLB->get_iter_depth(*xEntry);
if (bIsParentNode)
{
// Parent node
sParentName = xTreeLB->get_text(*xEntry);
aParentId = pGroupInfo->m_nDialogId;
m_aTreePageIds.push_back(new OptionsPageIdInfo(sParentName, sParentName, aParentId, 0));
}
else
{
// Child node
OUString sChildName = xTreeLB->get_text(*xEntry);
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xEntry));
m_aTreePageIds.push_back(
new OptionsPageIdInfo(sParentName, sChildName, aParentId, pPageInfo->m_nPageId));
}
bEntry = xTreeLB->iter_next(*xEntry);
}
}
int OfaTreeOptionsDialog::applySearchFilter(const OUString& rSearchTerm)
{
if (rSearchTerm.isEmpty())
{
clearOptionsDialog();
xTreeLB->clear();
Initialize(m_xFrame);
return 0;
}
m_options.searchString = rSearchTerm;
utl::TextSearch textSearch(m_options);
clearOptionsDialog();
if (xTreeLB->n_children() > 0)
xTreeLB->clear();
std::vector<std::pair<sal_uInt16, std::vector<sal_uInt16>>> aFoundIdsVector;
for (std::size_t i = 0; i < m_aTreePageIds.size(); ++i)
{
const OUString sParentName = m_aTreePageIds[i]->m_sParentName;
const OUString sPageName = m_aTreePageIds[i]->m_sPageName;
const sal_uInt16 nParentId = m_aTreePageIds[i]->m_nParentId;
const sal_uInt16 nPageId = m_aTreePageIds[i]->m_nPageId;
const OUString sPageStrings = TreeOptHelper::getStringsFromDialog(nPageId);
const OUString sPageNameAndStrings = sParentName + " " + sPageName + " " + sPageStrings;
sal_Int32 aStartPos = 0;
sal_Int32 aEndPos = sPageNameAndStrings.getLength();
// check if rSearchTerm matches with sPageNameAndStrings
if (textSearch.SearchForward(sPageNameAndStrings, &aStartPos, &aEndPos))
{
bool isFound = false;
for (auto& aEntryId : aFoundIdsVector)
{
if (aEntryId.first == nParentId)
{
isFound = true;
aEntryId.second.push_back(nPageId);
}
}
if (!isFound)
aFoundIdsVector.push_back({ nParentId, { nPageId } });
}
}
showDialog(aFoundIdsVector);
// if treeview is empty, return -1
return xTreeLB->n_children() ? 0 : -1;
}
void OfaTreeOptionsDialog::showDialog(VectorOfMatchedIds& pSearchIds)
{
//
// void generalOptions(); // SID_GENERAL_OPTIONS
// void loadAndSaveOptions(); // SID_FILTER_DLG
// void languageOptions(); // SID_LANGUAGE_OPTIONS
// void writerOptions(); // SID_SW_EDITOPTIONS
// void writerWebOptions(); // SID_SW_ONLINEOPTIONS
// void calcOptions(); // SID_SC_EDITOPTIONS
// void impressOptions(); // SID_SD_EDITOPTIONS
// void drawOptions(); // SID_SD_GRAPHIC_OPTIONS
// void mathOptions(); // SID_SM_EDITOPTIONS
// void databaseOptions(); // SID_SB_STARBASEOPTIONS
// void chartOptions(); // SID_SCH_EDITOPTIONS
// void internetOptions(); // SID_INET_DLG
//
for (auto& aEntryId : pSearchIds)
{
switch (aEntryId.first)
{
case SID_GENERAL_OPTIONS:
generalOptions(aEntryId.second);
break;
case SID_FILTER_DLG:
loadAndSaveOptions(aEntryId.second);
break;
case SID_LANGUAGE_OPTIONS:
languageOptions(aEntryId.second);
break;
case SID_SW_EDITOPTIONS:
writerOptions(aEntryId.second);
break;
case SID_SW_ONLINEOPTIONS:
writerWebOptions(aEntryId.second);
break;
case SID_SC_EDITOPTIONS:
calcOptions(aEntryId.second);
break;
case SID_SD_EDITOPTIONS:
impressOptions(aEntryId.second);
break;
case SID_SD_GRAPHIC_OPTIONS:
drawOptions(aEntryId.second);
break;
case SID_SM_EDITOPTIONS:
mathOptions(aEntryId.second);
break;
case SID_SB_STARBASEOPTIONS:
databaseOptions(aEntryId.second);
break;
case SID_SCH_EDITOPTIONS:
chartOptions(aEntryId.second);
break;
case SID_INET_DLG:
internetOptions(aEntryId.second);
break;
default:
break;
}
}
}
void OfaTreeOptionsDialog::ApplyItemSets()
{
std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
bool bEntry = xTreeLB->get_iter_first(*xEntry);
while (bEntry)
{
if (!xTreeLB->get_iter_depth(*xEntry))
{
OptionsGroupInfo* pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xEntry));
if(pGroupInfo->m_pOutItemSet)
{
if(pGroupInfo->m_pShell)
pGroupInfo->m_pShell->ApplyItemSet( pGroupInfo->m_nDialogId, *pGroupInfo->m_pOutItemSet);
else
ApplyItemSet( pGroupInfo->m_nDialogId, *pGroupInfo->m_pOutItemSet);
}
}
bEntry = xTreeLB->iter_next(*xEntry);
}
}
void OfaTreeOptionsDialog::ActivatePage( sal_uInt16 nResId )
{
bIsForSetDocumentLanguage = false;
if ( nResId == OFA_TP_LANGUAGES_FOR_SET_DOCUMENT_LANGUAGE )
{
bIsForSetDocumentLanguage = true;
nResId = OFA_TP_LANGUAGES;
}
DBG_ASSERT( !bIsFromExtensionManager, "OfaTreeOptionsDialog::ActivatePage(): call from extension manager" );
if ( !pLastPageSaver )
pLastPageSaver = new LastPageSaver;
bForgetSelection = true;
sal_uInt16 nTemp = pLastPageSaver->m_nLastPageId;
pLastPageSaver->m_nLastPageId = nResId;
ActivateLastSelection();
pLastPageSaver->m_nLastPageId = nTemp;
}
void OfaTreeOptionsDialog::ActivatePage( const OUString& rPageURL )
{
DBG_ASSERT( !bIsFromExtensionManager, "OfaTreeOptionsDialog::ActivatePage(): call from extension manager" );
if ( !pLastPageSaver )
pLastPageSaver = new LastPageSaver;
bForgetSelection = true;
pLastPageSaver->m_nLastPageId = 0;
pLastPageSaver->m_sLastPageURL_Tools = rPageURL;
ActivateLastSelection();
}
void OfaTreeOptionsDialog::ActivateLastSelection()
{
std::unique_ptr<weld::TreeIter> xEntry;
if (pLastPageSaver)
{
OUString sLastURL = bIsFromExtensionManager ? pLastPageSaver->m_sLastPageURL_ExtMgr
: pLastPageSaver->m_sLastPageURL_Tools;
if ( sLastURL.isEmpty() )
{
sLastURL = !bIsFromExtensionManager ? pLastPageSaver->m_sLastPageURL_ExtMgr
: pLastPageSaver->m_sLastPageURL_Tools;
}
bool bMustExpand = ( INetURLObject( sLastURL ).GetProtocol() == INetProtocol::File );
std::unique_ptr<weld::TreeIter> xTemp = xTreeLB->make_iterator();
bool bTemp = xTreeLB->get_iter_first(*xTemp);
while (bTemp)
{
// restore only selection of a leaf
if (xTreeLB->get_iter_depth(*xTemp) && xTreeLB->get_id(*xTemp).toInt64())
{
OptionsPageInfo* pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xTemp));
OUString sPageURL = pPageInfo->m_sPageURL;
if ( bMustExpand )
{
sPageURL = comphelper::getExpandedUri(
comphelper::getProcessComponentContext(), sPageURL);
}
if ( ( !bIsFromExtensionManager
&& pPageInfo->m_nPageId && pPageInfo->m_nPageId == pLastPageSaver->m_nLastPageId )
|| ( !pPageInfo->m_nPageId && sLastURL == sPageURL ) )
{
xEntry = xTreeLB->make_iterator(xTemp.get());
break;
}
}
bTemp = xTreeLB->iter_next(*xTemp);
}
}
if (!xEntry)
{
xEntry = xTreeLB->make_iterator();
if (!xTreeLB->get_iter_first(*xEntry) || !xTreeLB->iter_next(*xEntry))
xEntry.reset();
}
if (!xEntry)
return;
std::unique_ptr<weld::TreeIter> xParent(xTreeLB->make_iterator(xEntry.get()));
xTreeLB->iter_parent(*xParent);
xTreeLB->expand_row(*xParent);
xTreeLB->scroll_to_row(*xParent);
xTreeLB->scroll_to_row(*xEntry);
xTreeLB->set_cursor(*xEntry);
xTreeLB->select(*xEntry);
m_xSearchEdit->grab_focus();
SelectHdl_Impl();
}
void OfaTreeOptionsDialog::InitItemSets(OptionsGroupInfo& rGroupInfo)
{
if (!rGroupInfo.m_pInItemSet)
rGroupInfo.m_pInItemSet.emplace( rGroupInfo.m_pShell
? *rGroupInfo.m_pShell->CreateItemSet( rGroupInfo.m_nDialogId )
: *CreateItemSet( rGroupInfo.m_nDialogId ) );
if (!rGroupInfo.m_pOutItemSet)
rGroupInfo.m_pOutItemSet = std::make_unique<SfxItemSet>(
*rGroupInfo.m_pInItemSet->GetPool(),
rGroupInfo.m_pInItemSet->GetRanges());
}
void OfaTreeOptionsDialog::initializeCurrentDialog(OptionsPageInfo*& pPageInfo,
std::unique_ptr<weld::TreeIter>& xEntry)
{
std::unique_ptr<weld::TreeIter> xParent(xTreeLB->make_iterator(xEntry.get()));
bool bParent = xTreeLB->iter_parent(*xParent);
if (!bParent)
return;
if (pPageInfo->m_xPage)
{
TreeOptHelper::storeStringsOfDialog(pPageInfo->m_nPageId,
pPageInfo->m_xPage->GetAllStrings());
return;
}
OptionsGroupInfo* pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xParent));
if (!pPageInfo->m_xPage && pPageInfo->m_nPageId > 0)
{
InitItemSets(*pGroupInfo);
pPageInfo->m_xPage = ::CreateGeneralTabPage(pPageInfo->m_nPageId, xTabBox.get(), this,
*pGroupInfo->m_pInItemSet);
if (!pPageInfo->m_xPage && pGroupInfo->m_pModule)
pPageInfo->m_xPage = pGroupInfo->m_pModule->CreateTabPage(
pPageInfo->m_nPageId, xTabBox.get(), this, *pGroupInfo->m_pInItemSet);
DBG_ASSERT(pPageInfo->m_xPage, "tabpage could not created");
if (pPageInfo->m_xPage)
{
SvtViewOptions aTabPageOpt(EViewType::TabPage, OUString::number(pPageInfo->m_nPageId));
pPageInfo->m_xPage->SetUserData(GetViewOptUserItem(aTabPageOpt));
pPageInfo->m_xPage->SetFrame(m_xFrame);
pPageInfo->m_xPage->Reset(&*pGroupInfo->m_pInItemSet);
}
TreeOptHelper::storeStringsOfDialog(pPageInfo->m_nPageId,
pPageInfo->m_xPage->GetAllStrings());
pPageInfo->m_xPage->set_visible(false);
}
else if (0 == pPageInfo->m_nPageId && !pPageInfo->m_xExtPage)
{
if (!m_xContainerWinProvider.is())
m_xContainerWinProvider
= awt::ContainerWindowProvider::create(::comphelper::getProcessComponentContext());
pPageInfo->m_xExtPage = std::make_unique<ExtensionsTabPage>(
xTabBox.get(), pPageInfo->m_sPageURL, pPageInfo->m_sEventHdl, m_xContainerWinProvider);
pPageInfo->m_xExtPage->Hide();
}
BuilderPage* pNewPage = pPageInfo->m_xPage.get();
// fdo#58170 use current page's layout child HelpId, unless there isn't a current page
OUString sHelpId(pNewPage ? pNewPage->GetHelpId() : OUString());
if (sHelpId.isEmpty())
sHelpId = HID_OFADLG_TREELISTBOX;
xTreeLB->set_help_id(sHelpId);
}
void OfaTreeOptionsDialog::SelectHdl_Impl()
{
std::unique_ptr<weld::TreeIter> xEntry(xTreeLB->make_iterator());
if (!xTreeLB->get_cursor(xEntry.get()))
return;
if (xCurrentPageEntry && xCurrentPageEntry->equal(*xEntry))
return;
std::unique_ptr<weld::TreeIter> xParent(xTreeLB->make_iterator(xEntry.get()));
bool bParent = xTreeLB->iter_parent(*xParent);
// If the user has selected a category, automatically switch to a suitable
// default sub-page instead.
if (!bParent)
return;
BuilderPage* pNewPage = nullptr;
OptionsPageInfo* pOptPageInfo = (xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry))
? weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry)) : nullptr;
if (pOptPageInfo && pOptPageInfo->m_xPage && pOptPageInfo->m_xPage->IsVisible())
{
std::unique_ptr<weld::TreeIter> xCurParent(xTreeLB->make_iterator(xCurrentPageEntry.get()));
xTreeLB->iter_parent(*xCurParent);
OptionsGroupInfo* pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xCurParent));
DeactivateRC nLeave = DeactivateRC::LeavePage;
if ( RID_SVXPAGE_COLOR != pOptPageInfo->m_nPageId && pOptPageInfo->m_xPage->HasExchangeSupport() )
nLeave = pOptPageInfo->m_xPage->DeactivatePage( pGroupInfo->m_pOutItemSet.get() );
if ( nLeave == DeactivateRC::KeepPage )
{
// we cannot leave this page, this is may be from a user clicking a different entry
// in the tree so reselect the current page
xTreeLB->select(*xCurrentPageEntry);
return;
}
else
pOptPageInfo->m_xPage->set_visible(false);
}
else if ( pOptPageInfo && pOptPageInfo->m_xExtPage )
{
pOptPageInfo->m_xExtPage->Hide();
pOptPageInfo->m_xExtPage->DeactivatePage();
}
OptionsPageInfo *pPageInfo = weld::fromId<OptionsPageInfo*>(xTreeLB->get_id(*xEntry));
OptionsGroupInfo* pGroupInfo = weld::fromId<OptionsGroupInfo*>(xTreeLB->get_id(*xParent));
if(!pPageInfo->m_xPage && pPageInfo->m_nPageId > 0)
{
InitItemSets(*pGroupInfo);
pPageInfo->m_xPage = ::CreateGeneralTabPage(pPageInfo->m_nPageId, xTabBox.get(), this, *pGroupInfo->m_pInItemSet);
if(!pPageInfo->m_xPage && pGroupInfo->m_pModule)
pPageInfo->m_xPage = pGroupInfo->m_pModule->CreateTabPage(pPageInfo->m_nPageId, xTabBox.get(), this, *pGroupInfo->m_pInItemSet);
DBG_ASSERT( pPageInfo->m_xPage, "tabpage could not created");
if ( pPageInfo->m_xPage )
{
SvtViewOptions aTabPageOpt( EViewType::TabPage, OUString::number( pPageInfo->m_nPageId) );
pPageInfo->m_xPage->SetUserData( GetViewOptUserItem( aTabPageOpt ) );
pPageInfo->m_xPage->SetFrame( m_xFrame );
pPageInfo->m_xPage->Reset( &*pGroupInfo->m_pInItemSet );
}
}
else if ( 0 == pPageInfo->m_nPageId && !pPageInfo->m_xExtPage )
{
if ( !m_xContainerWinProvider.is() )
{
m_xContainerWinProvider = awt::ContainerWindowProvider::create( ::comphelper::getProcessComponentContext() );
}
pPageInfo->m_xExtPage = std::make_unique<ExtensionsTabPage>(
xTabBox.get(), pPageInfo->m_sPageURL, pPageInfo->m_sEventHdl, m_xContainerWinProvider);
}
if ( pPageInfo->m_xPage )
{
if ( RID_SVXPAGE_COLOR != pPageInfo->m_nPageId &&
pPageInfo->m_xPage->HasExchangeSupport())
{
pPageInfo->m_xPage->ActivatePage(*pGroupInfo->m_pOutItemSet);
}
pPageInfo->m_xPage->set_visible(true);
}
else if ( pPageInfo->m_xExtPage )
{
pPageInfo->m_xExtPage->Show();
pPageInfo->m_xExtPage->ActivatePage();
}
{
OUString sTitleText = sTitle
+ " - " + xTreeLB->get_text(*xParent)
+ " - " + xTreeLB->get_text(*xEntry);
m_xDialog->set_title(sTitleText);
}
xCurrentPageEntry = std::move(xEntry);
if ( !bForgetSelection )
{
if ( !pLastPageSaver )
pLastPageSaver = new LastPageSaver;
if ( !bIsFromExtensionManager )
pLastPageSaver->m_nLastPageId = pPageInfo->m_nPageId;
if ( pPageInfo->m_xExtPage )
{
if ( bIsFromExtensionManager )
pLastPageSaver->m_sLastPageURL_ExtMgr = pPageInfo->m_sPageURL;
else
pLastPageSaver->m_sLastPageURL_Tools = pPageInfo->m_sPageURL;
}
}
pNewPage = pPageInfo->m_xPage.get();
// fdo#58170 use current page's layout child HelpId, unless there isn't a current page
OUString sHelpId(pNewPage ? pNewPage->GetHelpId() : OUString());
if (sHelpId.isEmpty())
sHelpId = HID_OFADLG_TREELISTBOX;
xTreeLB->set_help_id(sHelpId);
}
std::optional<SfxItemSet> OfaTreeOptionsDialog::CreateItemSet( sal_uInt16 nId )
{
Reference< XLinguProperties > xProp( LinguMgr::GetLinguPropertySet() );
std::optional<SfxItemSet> pRet;
switch(nId)
{
case SID_GENERAL_OPTIONS:
{
pRet.emplace(
SfxGetpApp()->GetPool(),
svl::Items<
SID_HTML_MODE, SID_HTML_MODE,
SID_ATTR_METRIC, SID_ATTR_METRIC,
SID_AUTOSPELL_CHECK, SID_AUTOSPELL_CHECK,
SID_ATTR_QUICKLAUNCHER, SID_ATTR_QUICKLAUNCHER,
SID_ATTR_YEAR2000, SID_ATTR_YEAR2000> );
SfxItemSetFixed<SID_ATTR_QUICKLAUNCHER, SID_ATTR_QUICKLAUNCHER> aOptSet( SfxGetpApp()->GetPool() );
SfxApplication::GetOptions(aOptSet);
pRet->Put(aOptSet);
SfxViewFrame* pViewFrame = SfxViewFrame::Current();
if ( pViewFrame )
{
SfxPoolItemHolder aResult;
const SfxItemState aState(pViewFrame->GetDispatcher()->QueryState(SID_ATTR_YEAR2000, aResult));
const SfxUInt16Item* pItem(static_cast<const SfxUInt16Item*>(aResult.getItem()));
// miscellaneous - Year2000
if(SfxItemState::DEFAULT <= aState && nullptr != pItem)
pRet->Put( SfxUInt16Item( SID_ATTR_YEAR2000, pItem->GetValue() ) );
else
pRet->Put( SfxUInt16Item( SID_ATTR_YEAR2000, officecfg::Office::Common::DateFormat::TwoDigitYear::get() ) );
}
else
pRet->Put( SfxUInt16Item( SID_ATTR_YEAR2000, officecfg::Office::Common::DateFormat::TwoDigitYear::get() ) );
// miscellaneous - Tabulator
pRet->Put(SfxBoolItem(SID_PRINTER_NOTFOUND_WARN, officecfg::Office::Common::Print::Warning::NotFound::get()));
SfxPrinterChangeFlags nFlag = officecfg::Office::Common::Print::Warning::PaperSize::get() ? SfxPrinterChangeFlags::CHG_SIZE : SfxPrinterChangeFlags::NONE;
nFlag |= officecfg::Office::Common::Print::Warning::PaperOrientation::get() ? SfxPrinterChangeFlags::CHG_ORIENTATION : SfxPrinterChangeFlags::NONE;
pRet->Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC, static_cast<int>(nFlag) ));
}
break;
case SID_LANGUAGE_OPTIONS :
{
pRet.emplace(
SfxGetpApp()->GetPool(),
svl::Items<
SID_ATTR_CHAR_CJK_LANGUAGE, SID_ATTR_CHAR_CJK_LANGUAGE,
SID_ATTR_CHAR_CTL_LANGUAGE, SID_ATTR_CHAR_CTL_LANGUAGE,
SID_SET_DOCUMENT_LANGUAGE, SID_SET_DOCUMENT_LANGUAGE,
SID_ATTR_LANGUAGE, SID_ATTR_LANGUAGE,
SID_AUTOSPELL_CHECK, SID_AUTOSPELL_CHECK,
SID_OPT_LOCALE_CHANGED, SID_OPT_LOCALE_CHANGED>);
// for linguistic
SfxHyphenRegionItem aHyphen( SID_ATTR_HYPHENREGION );
sal_Int16 nMinLead = 2,
nMinTrail = 2;
if (xProp.is())
{
nMinLead = xProp->getHyphMinLeading();
nMinTrail = xProp->getHyphMinTrailing();
}
aHyphen.GetMinLead() = static_cast<sal_uInt8>(nMinLead);
aHyphen.GetMinTrail() = static_cast<sal_uInt8>(nMinTrail);
SfxViewFrame* pViewFrame = SfxViewFrame::Current();
if ( pViewFrame )
{
SfxPoolItemHolder aResult;
SfxDispatcher* pDispatch(pViewFrame->GetDispatcher());
SfxItemState aState(pDispatch->QueryState(SID_ATTR_LANGUAGE, aResult));
if(SfxItemState::DEFAULT <= aState)
pRet->Put(*aResult.getItem());
aState = pDispatch->QueryState(SID_ATTR_CHAR_CJK_LANGUAGE, aResult);
if(SfxItemState::DEFAULT <= aState)
pRet->Put(*aResult.getItem());
aState = pDispatch->QueryState(SID_ATTR_CHAR_CTL_LANGUAGE, aResult);
if(SfxItemState::DEFAULT <= aState)
pRet->Put(*aResult.getItem());
pRet->Put(aHyphen);
aState = pDispatch->QueryState(SID_AUTOSPELL_CHECK, aResult);
if(SfxItemState::DEFAULT <= aState)
{
pRet->Put(*aResult.getItem()); // allow share/refcounting
// pRet->Put(std::unique_ptr<SfxPoolItem>(aResult.getItem()->Clone()));
}
else
{
bool bVal = false;
if (xProp.is())
{
bVal = xProp->getIsSpellAuto();
}
pRet->Put(SfxBoolItem(SID_AUTOSPELL_CHECK, bVal));
}
}
pRet->Put( SfxBoolItem( SID_SET_DOCUMENT_LANGUAGE, bIsForSetDocumentLanguage ) );
}
break;
case SID_INET_DLG :
pRet.emplace( SfxGetpApp()->GetPool(),
svl::Items<
//SID_OPTIONS_START - ..END
SID_SAVEREL_INET, SID_SAVEREL_FSYS,
SID_INET_NOPROXY, SID_INET_HTTP_PROXY_PORT,
SID_SECURE_URL, SID_SECURE_URL> );
SfxApplication::GetOptions(*pRet);
break;
case SID_FILTER_DLG:
pRet.emplace(
SfxGetpApp()->GetPool(),
svl::Items<
SID_ATTR_WARNALIENFORMAT, SID_ATTR_WARNALIENFORMAT,
SID_ATTR_DOCINFO, SID_ATTR_AUTOSAVEMINUTE,
SID_SAVEREL_INET, SID_SAVEREL_FSYS,
SID_ATTR_PRETTYPRINTING, SID_ATTR_PRETTYPRINTING> );
SfxApplication::GetOptions(*pRet);
break;
case SID_SB_STARBASEOPTIONS:
pRet.emplace( SfxGetpApp()->GetPool(),
svl::Items<SID_SB_POOLING_ENABLED, SID_SB_DB_REGISTER> );
::offapp::ConnectionPoolConfig::GetOptions(*pRet);
svx::DbRegisteredNamesConfig::GetOptions(*pRet);
break;
case SID_SCH_EDITOPTIONS:
{
pRet.emplace( SfxGetpApp()->GetPool(), svl::Items<SID_SCH_EDITOPTIONS, SID_SCH_EDITOPTIONS> );
pRet->Put( SvxChartColorTableItem( SID_SCH_EDITOPTIONS, SvxChartOptions::GetDefaultColors() ) );
break;
}
}
return pRet;
}
void OfaTreeOptionsDialog::ApplyItemSet( sal_uInt16 nId, const SfxItemSet& rSet )
{
switch(nId)
{
case SID_GENERAL_OPTIONS:
{
std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
SfxItemSetFixed<SID_ATTR_QUICKLAUNCHER, SID_ATTR_QUICKLAUNCHER> aOptSet(SfxGetpApp()->GetPool());
aOptSet.Put(rSet);
if(aOptSet.Count())
SfxApplication::SetOptions( aOptSet );
// get dispatcher anew, because SetOptions() might have destroyed the dispatcher
SfxViewFrame *pViewFrame = SfxViewFrame::Current();
// evaluate Year2000
sal_uInt16 nY2K = USHRT_MAX;
const SfxUInt16Item* pYearItem = rSet.GetItemIfSet( SID_ATTR_YEAR2000, false );
if( pYearItem )
nY2K = pYearItem->GetValue();
if( USHRT_MAX != nY2K )
{
if ( pViewFrame )
{
SfxDispatcher* pDispatch = pViewFrame->GetDispatcher();
pDispatch->ExecuteList(SID_ATTR_YEAR2000,
SfxCallMode::ASYNCHRON, { pYearItem });
}
officecfg::Office::Common::DateFormat::TwoDigitYear::set(nY2K, batch);
}
// evaluate print
if(const SfxBoolItem* pWarnItem = rSet.GetItemIfSet(SID_PRINTER_NOTFOUND_WARN, false))
officecfg::Office::Common::Print::Warning::NotFound::set(pWarnItem->GetValue(), batch);
if(const SfxFlagItem* pFlag = rSet.GetItemIfSet(SID_PRINTER_CHANGESTODOC, false))
{
bool bPaperSizeWarning = bool(static_cast<SfxPrinterChangeFlags>(pFlag->GetValue()) & SfxPrinterChangeFlags::CHG_SIZE);
officecfg::Office::Common::Print::Warning::PaperSize::set(bPaperSizeWarning, batch);
bool bPaperOrientationWarning = bool(static_cast<SfxPrinterChangeFlags>(pFlag->GetValue()) & SfxPrinterChangeFlags::CHG_ORIENTATION);
officecfg::Office::Common::Print::Warning::PaperOrientation::set(bPaperOrientationWarning, batch);
}
// evaluate help options
bool bHelpTips = officecfg::Office::Common::Help::Tip::get();
if ( bHelpTips != Help::IsQuickHelpEnabled() )
bHelpTips ? Help::EnableQuickHelp() : Help::DisableQuickHelp();
bool bExtendedHelp = officecfg::Office::Common::Help::ExtendedTip::get();
if ( bExtendedHelp != Help::IsBalloonHelpEnabled() )
bExtendedHelp ? Help::EnableBalloonHelp() : Help::DisableBalloonHelp();
batch->commit();
}
break;
case SID_LANGUAGE_OPTIONS :
{
OfaTreeOptionsDialog::ApplyLanguageOptions(rSet);
}
break;
case SID_INET_DLG :
case SID_FILTER_DLG:
SfxApplication::SetOptions( rSet );
break;
case SID_SB_STARBASEOPTIONS:
::offapp::ConnectionPoolConfig::SetOptions( rSet );
svx::DbRegisteredNamesConfig::SetOptions(rSet);
break;
case SID_SCH_EDITOPTIONS:
// nothing to do. Chart options only apply to newly created charts
break;
default:
{
SAL_WARN("cui.options", "Unhandled option in ApplyItemSet");
}
break;
}
}
void OfaTreeOptionsDialog::ApplyLanguageOptions(const SfxItemSet& rSet)
{
bool bSaveSpellCheck = false;
const SfxPoolItem* pItem = nullptr;
const Reference< XComponentContext >& xContext( ::comphelper::getProcessComponentContext() );
Reference< XLinguProperties > xProp = LinguProperties::create( xContext );
if ( const SfxHyphenRegionItem* pHyphenItem = rSet.GetItemIfSet(SID_ATTR_HYPHENREGION, false ) )
{
xProp->setHyphMinLeading( static_cast<sal_Int16>(pHyphenItem->GetMinLead()) );
xProp->setHyphMinTrailing( static_cast<sal_Int16>(pHyphenItem->GetMinTrail()) );
bSaveSpellCheck = true;
}
SfxViewFrame *pViewFrame = SfxViewFrame::Current();
if ( pViewFrame )
{
SfxDispatcher* pDispatch = pViewFrame->GetDispatcher();
pItem = nullptr;
if(SfxItemState::SET == rSet.GetItemState( SID_ATTR_LANGUAGE, false, &pItem ))
{
pDispatch->ExecuteList(pItem->Which(), SfxCallMode::SYNCHRON, { pItem });
bSaveSpellCheck = true;
}
if(SfxItemState::SET == rSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE, false, &pItem ))
{
pDispatch->ExecuteList(pItem->Which(), SfxCallMode::SYNCHRON, { pItem });
bSaveSpellCheck = true;
}
if(SfxItemState::SET == rSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE, false, &pItem ))
{
pDispatch->ExecuteList(pItem->Which(), SfxCallMode::SYNCHRON, { pItem });
bSaveSpellCheck = true;
}
if( SfxItemState::SET == rSet.GetItemState(SID_AUTOSPELL_CHECK, false, &pItem ))
{
bool bOnlineSpelling = static_cast<const SfxBoolItem*>(pItem)->GetValue();
pDispatch->ExecuteList(SID_AUTOSPELL_CHECK,
SfxCallMode::ASYNCHRON|SfxCallMode::RECORD, { pItem });
xProp->setIsSpellAuto( bOnlineSpelling );
}
if( bSaveSpellCheck )
{
//! the config item has changed since we modified the
//! property set it uses
pDispatch->Execute(SID_SPELLCHECKER_CHANGED, SfxCallMode::ASYNCHRON);
}
}
if( SfxItemState::SET == rSet.GetItemState(SID_OPT_LOCALE_CHANGED, false, &pItem ))
{
SfxViewFrame* _pViewFrame = SfxViewFrame::GetFirst();
while ( _pViewFrame )
{
_pViewFrame->GetDispatcher()->ExecuteList(pItem->Which(),
SfxCallMode::ASYNCHRON, { pItem });
_pViewFrame = SfxViewFrame::GetNext( *_pViewFrame );
}
}
}
OUString OfaTreeOptionsDialog::getCurrentFactory_Impl( const Reference< XFrame >& _xFrame )
{
OUString sIdentifier;
Reference < XFrame > xCurrentFrame( _xFrame );
Reference < XModuleManager2 > xModuleManager = ModuleManager::create(::comphelper::getProcessComponentContext());
if ( !xCurrentFrame.is() )
{
Reference< XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
xCurrentFrame = xDesktop->getCurrentFrame();
}
if ( xCurrentFrame.is() )
{
try
{
sIdentifier = xModuleManager->identify( xCurrentFrame );
}
catch ( css::frame::UnknownModuleException& )
{
SAL_INFO( "cui.options", "unknown module" );
}
catch ( Exception const & )
{
TOOLS_WARN_EXCEPTION( "cui.options", "getActiveModule_Impl(): exception of XModuleManager::identify()" );
}
}
return sIdentifier;
}
void OfaTreeOptionsDialog::generalOptions(const std::vector<sal_uInt16>& vPageId)
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_GENERAL_OPTIONS, aOptionsDlgOpt ) )
{
setGroupName(u"ProductName", CuiResId(SID_GENERAL_OPTIONS_RES[0].first));
sal_uInt16 nGroup = AddGroup(CuiResId(SID_GENERAL_OPTIONS_RES[0].first), nullptr, nullptr, SID_GENERAL_OPTIONS );
for (size_t i = 1; i < std::size(SID_GENERAL_OPTIONS_RES); ++i)
{
OUString sNewTitle = CuiResId(SID_GENERAL_OPTIONS_RES[i].first);
sal_uInt16 nPageId = SID_GENERAL_OPTIONS_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
// Disable Online Update page if neither mode is available
if( RID_SVXPAGE_ONLINEUPDATE == nPageId
&& !(SvxOnlineUpdateTabPage::isTraditionalOnlineUpdateAvailable()
|| SvxOnlineUpdateTabPage::isMarOnlineUpdateAvailable()) )
{
continue;
}
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, sNewTitle, nGroup);
}
else
AddTabPage(nPageId, sNewTitle, nGroup);
}
}
}
void OfaTreeOptionsDialog::loadAndSaveOptions(const std::vector<sal_uInt16>& vPageId)
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_FILTER_DLG, aOptionsDlgOpt ) )
{
setGroupName( u"LoadSave", CuiResId(SID_FILTER_DLG_RES[0].first) );
sal_uInt16 nGroup = AddGroup( CuiResId(SID_FILTER_DLG_RES[0].first), nullptr, nullptr, SID_FILTER_DLG );
for ( size_t i = 1; i < std::size(SID_FILTER_DLG_RES); ++i )
{
sal_uInt16 nPageId = SID_FILTER_DLG_RES[i].second;
if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_FILTER_DLG_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_FILTER_DLG_RES[i].first), nGroup);
}
}
}
}
void OfaTreeOptionsDialog::languageOptions(const std::vector<sal_uInt16>& vPageId)
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_LANGUAGE_OPTIONS, aOptionsDlgOpt ) )
{
setGroupName(u"LanguageSettings", CuiResId(SID_LANGUAGE_OPTIONS_RES[0].first));
sal_uInt16 nGroup = AddGroup(CuiResId(SID_LANGUAGE_OPTIONS_RES[0].first), nullptr, nullptr, SID_LANGUAGE_OPTIONS );
for (size_t i = 1; i < std::size(SID_LANGUAGE_OPTIONS_RES); ++i)
{
sal_uInt16 nPageId = SID_LANGUAGE_OPTIONS_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
// Disable DeepL translation settings, if experimental mode is not enabled
if( RID_SVXPAGE_DEEPL_OPTIONS == nPageId )
{
if( ! officecfg::Office::Common::Misc::ExperimentalMode::get() )
continue;
}
if ( ( RID_SVXPAGE_JSEARCH_OPTIONS != nPageId || SvtCJKOptions::IsJapaneseFindEnabled() ) &&
( RID_SVXPAGE_ASIAN_LAYOUT != nPageId || SvtCJKOptions::IsAsianTypographyEnabled() ) &&
( RID_SVXPAGE_OPTIONS_CTL != nPageId || SvtCTLOptions::IsCTLFontEnabled() ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_LANGUAGE_OPTIONS_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_LANGUAGE_OPTIONS_RES[i].first), nGroup);
}
}
}
}
void OfaTreeOptionsDialog::writerOptions(const std::vector<sal_uInt16>& vPageId)
{
if (SvtModuleOptions().IsWriterInstalled())
{
// text document
OUString aFactory = getCurrentFactory_Impl(m_xFrame);
DBG_ASSERT(GetModuleIdentifier(m_xFrame) == aFactory, "This should not happen");
if ( aFactory == "com.sun.star.text.TextDocument"
|| aFactory == "com.sun.star.text.WebDocument"
|| aFactory == "com.sun.star.text.GlobalDocument" )
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SW_EDITOPTIONS, aOptionsDlgOpt ) )
{
if ( aFactory == "com.sun.star.text.WebDocument" )
setGroupName( u"WriterWeb", CuiResId(SID_SW_EDITOPTIONS_RES[0].first) );
else
setGroupName( u"Writer", CuiResId(SID_SW_EDITOPTIONS_RES[0].first) );
SfxModule* pSwMod = SfxApplication::GetModule(SfxToolsModule::Writer);
sal_uInt16 nGroup = AddGroup(CuiResId(SID_SW_EDITOPTIONS_RES[0].first), pSwMod, pSwMod, SID_SW_EDITOPTIONS );
SvtCTLOptions aCTLLanguageOptions;
for ( size_t i = 1; i < std::size(SID_SW_EDITOPTIONS_RES); ++i )
{
sal_uInt16 nPageId = SID_SW_EDITOPTIONS_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
if ( ( RID_SW_TP_STD_FONT_CJK != nPageId || SvtCJKOptions::IsCJKFontEnabled() ) &&
( RID_SW_TP_STD_FONT_CTL != nPageId || SvtCTLOptions::IsCTLFontEnabled() ) &&
( RID_SW_TP_MAILCONFIG != nPageId || MailMergeCfgIsEmailSupported() ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SW_EDITOPTIONS_RES[i].first),
nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SW_EDITOPTIONS_RES[i].first), nGroup);
}
}
#ifdef DBG_UTIL
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), RID_SW_TP_OPTTEST_PAGE)
!= vPageId.end())
AddTabPage(RID_SW_TP_OPTTEST_PAGE, u"Internal Test"_ustr, nGroup);
}
else
AddTabPage(RID_SW_TP_OPTTEST_PAGE, u"Internal Test"_ustr, nGroup);
#endif
}
}
}
}
void OfaTreeOptionsDialog::writerWebOptions(const std::vector<sal_uInt16>& vPageId)
{
if (SvtModuleOptions().IsWriterInstalled())
{
// text document
OUString aFactory = getCurrentFactory_Impl(m_xFrame);
DBG_ASSERT(GetModuleIdentifier(m_xFrame) == aFactory, "This should not happen");
if ( aFactory == "com.sun.star.text.TextDocument"
|| aFactory == "com.sun.star.text.WebDocument"
|| aFactory == "com.sun.star.text.GlobalDocument" )
{
// HTML documents
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SW_ONLINEOPTIONS, aOptionsDlgOpt ) )
{
SfxModule* pSwMod = SfxApplication::GetModule(SfxToolsModule::Writer);
sal_uInt16 nGroup = AddGroup(CuiResId(SID_SW_ONLINEOPTIONS_RES[0].first), pSwMod, pSwMod, SID_SW_ONLINEOPTIONS );
for( size_t i = 1; i < std::size(SID_SW_ONLINEOPTIONS_RES); ++i )
{
sal_uInt16 nPageId = SID_SW_ONLINEOPTIONS_RES[i].second;
if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SW_ONLINEOPTIONS_RES[i].first),
nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SW_ONLINEOPTIONS_RES[i].first),
nGroup);
}
}
#ifdef DBG_UTIL
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), RID_SW_TP_OPTTEST_PAGE)
!= vPageId.end())
AddTabPage(RID_SW_TP_OPTTEST_PAGE, u"Internal Test"_ustr, nGroup);
}
else
AddTabPage(RID_SW_TP_OPTTEST_PAGE, u"Internal Test"_ustr, nGroup);
#endif
}
}
}
}
void OfaTreeOptionsDialog::calcOptions(const std::vector<sal_uInt16>& vPageId)
{
// Calc options
if (SvtModuleOptions().IsCalcInstalled())
{
OUString aFactory = getCurrentFactory_Impl(m_xFrame);
DBG_ASSERT(GetModuleIdentifier(m_xFrame) == aFactory, "This should not happen");
if ( aFactory == "com.sun.star.sheet.SpreadsheetDocument" )
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SC_EDITOPTIONS, aOptionsDlgOpt ) )
{
SfxModule* pScMod = SfxApplication::GetModule( SfxToolsModule::Calc );
setGroupName( u"Calc", CuiResId(SID_SC_EDITOPTIONS_RES[0].first) );
sal_uInt16 nGroup = AddGroup( CuiResId(SID_SC_EDITOPTIONS_RES[0].first), pScMod, pScMod, SID_SC_EDITOPTIONS );
for (size_t i = 1; i < std::size(SID_SC_EDITOPTIONS_RES); ++i)
{
sal_uInt16 nPageId = SID_SC_EDITOPTIONS_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SC_EDITOPTIONS_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SC_EDITOPTIONS_RES[i].first), nGroup);
}
}
}
}
}
void OfaTreeOptionsDialog::impressOptions(const std::vector<sal_uInt16>& vPageId)
{
// Impress options
if (SvtModuleOptions().IsImpressInstalled())
{
OUString aFactory = getCurrentFactory_Impl(m_xFrame);
DBG_ASSERT(GetModuleIdentifier(m_xFrame) == aFactory, "This should not happen");
if ( aFactory == "com.sun.star.presentation.PresentationDocument" )
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SD_EDITOPTIONS, aOptionsDlgOpt ) )
{
SfxModule* pSdMod = SfxApplication::GetModule(SfxToolsModule::Draw);
setGroupName( u"Impress", CuiResId(SID_SD_EDITOPTIONS_RES[0].first) );
sal_uInt16 nGroup = AddGroup( CuiResId(SID_SD_EDITOPTIONS_RES[0].first), pSdMod, pSdMod, SID_SD_EDITOPTIONS );
for (size_t i = 1; i < std::size(SID_SD_EDITOPTIONS_RES); ++i)
{
sal_uInt16 nPageId = SID_SD_EDITOPTIONS_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SD_EDITOPTIONS_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SD_EDITOPTIONS_RES[i].first), nGroup);
}
}
}
}
}
void OfaTreeOptionsDialog::drawOptions(const std::vector<sal_uInt16>& vPageId)
{
// Draw options
if (SvtModuleOptions().IsDrawInstalled())
{
OUString aFactory = getCurrentFactory_Impl(m_xFrame);
DBG_ASSERT(GetModuleIdentifier(m_xFrame) == aFactory, "This should not happen");
if ( aFactory == "com.sun.star.drawing.DrawingDocument" )
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SD_GRAPHIC_OPTIONS, aOptionsDlgOpt ) )
{
SfxModule* pSdMod = SfxApplication::GetModule(SfxToolsModule::Draw);
setGroupName( u"Draw", CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[0].first) );
sal_uInt16 nGroup = AddGroup( CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[0].first), pSdMod, pSdMod, SID_SD_GRAPHIC_OPTIONS );
for (size_t i = 1; i < std::size(SID_SD_GRAPHIC_OPTIONS_RES); ++i)
{
sal_uInt16 nPageId = SID_SD_GRAPHIC_OPTIONS_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[i].first),
nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[i].first), nGroup);
}
}
}
}
}
void OfaTreeOptionsDialog::mathOptions(const std::vector<sal_uInt16>& vPageId)
{
// Math options
if (SvtModuleOptions().IsMathInstalled())
{
OUString aFactory = getCurrentFactory_Impl(m_xFrame);
DBG_ASSERT(GetModuleIdentifier(m_xFrame) == aFactory, "This should not happen");
if ( aFactory == "com.sun.star.formula.FormulaProperties" )
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SM_EDITOPTIONS, aOptionsDlgOpt ) )
{
SfxModule* pSmMod = SfxApplication::GetModule(SfxToolsModule::Math);
setGroupName( u"Math", CuiResId(SID_SM_EDITOPTIONS_RES[0].first) );
sal_uInt16 nGroup = AddGroup(CuiResId(SID_SM_EDITOPTIONS_RES[0].first), pSmMod, pSmMod, SID_SM_EDITOPTIONS );
for ( size_t i = 1; i < std::size(SID_SM_EDITOPTIONS_RES); ++i )
{
sal_uInt16 nPageId = SID_SM_EDITOPTIONS_RES[i].second;
if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SM_EDITOPTIONS_RES[i].first),
nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SM_EDITOPTIONS_RES[i].first), nGroup);
}
}
}
}
}
}
void OfaTreeOptionsDialog::databaseOptions(const std::vector<sal_uInt16>& vPageId)
{
SvtOptionsDialogOptions aOptionsDlgOpt;
SvtModuleOptions aModuleOpt;
// Database - needed only if there is an application which integrates with databases
if ( !lcl_isOptionHidden( SID_SB_STARBASEOPTIONS, aOptionsDlgOpt ) &&
( aModuleOpt.IsDataBaseInstalled()
|| aModuleOpt.IsWriterInstalled()
|| aModuleOpt.IsCalcInstalled()
) )
{
setGroupName( u"Base", CuiResId(SID_SB_STARBASEOPTIONS_RES[0].first) );
sal_uInt16 nGroup = AddGroup( CuiResId(SID_SB_STARBASEOPTIONS_RES[0].first), nullptr, nullptr, SID_SB_STARBASEOPTIONS );
for ( size_t i = 1; i < std::size(SID_SB_STARBASEOPTIONS_RES); ++i )
{
sal_uInt16 nPageId = SID_SB_STARBASEOPTIONS_RES[i].second;
if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SB_STARBASEOPTIONS_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SB_STARBASEOPTIONS_RES[i].first), nGroup);
}
}
}
}
void OfaTreeOptionsDialog::chartOptions(const std::vector<sal_uInt16>& vPageId)
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( !lcl_isOptionHidden( SID_SCH_EDITOPTIONS, aOptionsDlgOpt ) )
{
setGroupName( u"Charts", CuiResId(SID_SCH_EDITOPTIONS_RES[0].first) );
sal_uInt16 nGroup = AddGroup( CuiResId(SID_SCH_EDITOPTIONS_RES[0].first), nullptr, nullptr, SID_SCH_EDITOPTIONS );
for ( size_t i = 1; i < std::size(SID_SCH_EDITOPTIONS_RES); ++i )
{
sal_uInt16 nPageId = SID_SCH_EDITOPTIONS_RES[i].second;
if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
{
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_SCH_EDITOPTIONS_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_SCH_EDITOPTIONS_RES[i].first), nGroup);
}
}
}
}
void OfaTreeOptionsDialog::internetOptions(const std::vector<sal_uInt16>& vPageId)
{
SvtOptionsDialogOptions aOptionsDlgOpt;
if ( lcl_isOptionHidden( SID_INET_DLG, aOptionsDlgOpt ) )
return;
setGroupName(u"Internet", CuiResId(SID_INET_DLG_RES[0].first));
sal_uInt16 nGroup = AddGroup(CuiResId(SID_INET_DLG_RES[0].first), nullptr, nullptr, SID_INET_DLG );
for ( size_t i = 1; i < std::size(SID_INET_DLG_RES); ++i )
{
sal_uInt16 nPageId = SID_INET_DLG_RES[i].second;
if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
continue;
#if defined(_WIN32)
// Disable E-mail tab-page on Windows
if ( nPageId == RID_SVXPAGE_INET_MAIL )
continue;
#endif
if (!vPageId.empty())
{
if (std::find(vPageId.begin(), vPageId.end(), nPageId) != vPageId.end())
AddTabPage(nPageId, CuiResId(SID_INET_DLG_RES[i].first), nGroup);
}
else
AddTabPage(nPageId, CuiResId(SID_INET_DLG_RES[i].first), nGroup);
}
}
void OfaTreeOptionsDialog::Initialize(const Reference<XFrame>& _xFrame)
{
m_xFrame = _xFrame;
// %PRODUCTNAME options
generalOptions();
// Load and Save options
loadAndSaveOptions();
// Language options
languageOptions();
// Writer and Writer/Web options
writerOptions();
writerWebOptions();
// Calc options
calcOptions();
// Impress options
impressOptions();
// Draw options
drawOptions();
// Math options
mathOptions();
// Database - needed only if there is an application which integrates with databases
databaseOptions();
// Chart options (always installed and active)
chartOptions();
// Internet options
internetOptions();
// store Options Dialogs with their page names and strings
// in order to use them when searching
storeOptionsTree();
}
static bool isNodeActive( OptionsNode const * pNode, Module* pModule )
{
if ( !pNode )
return false;
// Node for all modules active?
if ( pNode->m_bAllModules )
return true;
// OOo-Nodes (Writer, Calc, Impress...) are active if node is already inserted
if ( !getGroupName( pNode->m_sId, false ).isEmpty() )
return true;
// no module -> not active
if ( !pModule )
return false;
// search node in active module
if ( pModule->m_bActive )
{
for (auto const& j : pModule->m_aNodeList)
if ( j->m_sId == pNode->m_sId )
return true;
}
return false;
}
void OfaTreeOptionsDialog::LoadExtensionOptions( std::u16string_view rExtensionId )
{
std::unique_ptr<Module> pModule;
// when called by Tools - Options then load nodes of active module
if ( rExtensionId.empty() )
{
pModule = LoadModule( GetModuleIdentifier( Reference< XFrame >() ) );
}
VectorOfNodes aNodeList = LoadNodes( pModule.get(), rExtensionId );
InsertNodes( aNodeList );
}
OUString OfaTreeOptionsDialog::GetModuleIdentifier( const Reference< XFrame >& rFrame )
{
OUString sModule;
Reference < XFrame > xCurrentFrame( rFrame );
const Reference< XComponentContext >& xContext = comphelper::getProcessComponentContext();
Reference < XModuleManager2 > xModuleManager = ModuleManager::create(xContext);
if ( !xCurrentFrame.is() )
{
Reference < XDesktop2 > xDesktop = Desktop::create( xContext );
xCurrentFrame = xDesktop->getCurrentFrame();
}
if ( xCurrentFrame.is() )
{
try
{
sModule = xModuleManager->identify( xCurrentFrame );
}
catch ( css::frame::UnknownModuleException& )
{
SAL_INFO( "cui.options", "unknown module" );
}
catch ( Exception const & )
{
TOOLS_WARN_EXCEPTION( "cui.options", "OfaTreeOptionsDialog::GetModuleIdentifier(): exception of XModuleManager::identify()");
}
}
return sModule;
}
std::unique_ptr<Module> OfaTreeOptionsDialog::LoadModule(
std::u16string_view rModuleIdentifier )
{
std::unique_ptr<Module> pModule;
Reference< XNameAccess > xSet(
officecfg::Office::OptionsDialog::Modules::get());
const Sequence< OUString > seqNames = xSet->getElementNames();
for ( const OUString& rModule : seqNames )
{
if ( rModuleIdentifier == rModule )
{
// current active module found
pModule.reset(new Module);
pModule->m_bActive = true;
Reference< XNameAccess > xModAccess;
xSet->getByName( rModule ) >>= xModAccess;
if ( xModAccess.is() )
{
// load the nodes of this module
Reference< XNameAccess > xNodeAccess;
xModAccess->getByName( u"Nodes"_ustr ) >>= xNodeAccess;
if ( xNodeAccess.is() )
{
const Sequence< OUString > xTemp = xNodeAccess->getElementNames();
Reference< XNameAccess > xAccess;
sal_Int32 nIndex = -1;
for ( const OUString& rNode : xTemp)
{
xNodeAccess->getByName( rNode ) >>= xAccess;
if ( xAccess.is() )
{
xAccess->getByName( u"Index"_ustr ) >>= nIndex;
if ( nIndex < 0 )
// append nodes with index < 0
pModule->m_aNodeList.push_back(
std::unique_ptr<OrderedEntry>(new OrderedEntry(nIndex, rNode)));
else
{
// search position of the node
std::vector<OrderedEntry *>::size_type y = 0;
for ( ; y < pModule->m_aNodeList.size(); ++y )
{
sal_Int32 nNodeIdx = pModule->m_aNodeList[y]->m_nIndex;
if ( nNodeIdx < 0 || nNodeIdx > nIndex )
break;
}
// and insert the node on this position
pModule->m_aNodeList.insert(
pModule->m_aNodeList.begin() + y,
std::unique_ptr<OrderedEntry>(new OrderedEntry( nIndex, rNode )) );
}
}
}
}
}
break;
}
}
return pModule;
}
VectorOfNodes OfaTreeOptionsDialog::LoadNodes(
Module* pModule, std::u16string_view rExtensionId)
{
VectorOfNodes aOutNodeList;
Reference< XNameAccess > xSet(
officecfg::Office::OptionsDialog::Nodes::get());
VectorOfNodes aNodeList;
const Sequence< OUString > seqNames = xSet->getElementNames();
for ( OUString const & sGroupName : seqNames )
{
Reference< XNameAccess > xNodeAccess;
xSet->getByName( sGroupName ) >>= xNodeAccess;
if ( xNodeAccess.is() )
{
OUString sNodeId, sLabel, sPageURL;
bool bAllModules = false;
sNodeId = sGroupName;
xNodeAccess->getByName( u"Label"_ustr ) >>= sLabel;
xNodeAccess->getByName( u"OptionsPage"_ustr ) >>= sPageURL;
xNodeAccess->getByName( u"AllModules"_ustr ) >>= bAllModules;
if ( sLabel.isEmpty() )
sLabel = sGroupName;
OUString sTemp = getGroupName( sLabel, !rExtensionId.empty() );
if ( !sTemp.isEmpty() )
sLabel = sTemp;
std::unique_ptr<OptionsNode> pNode(new OptionsNode(sNodeId, sLabel, bAllModules));
if ( rExtensionId.empty() && !isNodeActive( pNode.get(), pModule ) )
{
continue;
}
Reference< XNameAccess > xLeavesSet;
xNodeAccess->getByName( u"Leaves"_ustr ) >>= xLeavesSet;
if ( xLeavesSet.is() )
{
const Sequence< OUString > seqLeaves = xLeavesSet->getElementNames();
for ( OUString const & leafName : seqLeaves )
{
Reference< XNameAccess > xLeaveAccess;
xLeavesSet->getByName( leafName ) >>= xLeaveAccess;
if ( xLeaveAccess.is() )
{
OUString sId, sLeafLabel, sEventHdl, sLeafURL, sLeafGrpId;
sal_Int32 nLeafGrpIdx = 0;
xLeaveAccess->getByName( u"Id"_ustr ) >>= sId;
xLeaveAccess->getByName( u"Label"_ustr ) >>= sLeafLabel;
xLeaveAccess->getByName( u"OptionsPage"_ustr ) >>= sLeafURL;
xLeaveAccess->getByName( u"EventHandlerService"_ustr ) >>= sEventHdl;
xLeaveAccess->getByName( u"GroupId"_ustr ) >>= sLeafGrpId;
xLeaveAccess->getByName( u"GroupIndex"_ustr ) >>= nLeafGrpIdx;
if ( rExtensionId.empty() || sId == rExtensionId )
{
std::unique_ptr<OptionsLeaf> pLeaf(new OptionsLeaf(
sLeafLabel, sLeafURL, sEventHdl, sLeafGrpId, nLeafGrpIdx ));
if ( !sLeafGrpId.isEmpty() )
{
bool bAlreadyOpened = false;
if ( !pNode->m_aGroupedLeaves.empty() )
{
for (auto & rGroup : pNode->m_aGroupedLeaves)
{
if ( !rGroup.empty() &&
rGroup[0]->m_sGroupId == sLeafGrpId )
{
std::vector<std::unique_ptr<OptionsLeaf>>::size_type l = 0;
for ( ; l < rGroup.size(); ++l )
{
if ( rGroup[l]->m_nGroupIndex >= nLeafGrpIdx )
break;
}
rGroup.insert( rGroup.begin() + l, std::move(pLeaf) );
bAlreadyOpened = true;
break;
}
}
}
if ( !bAlreadyOpened )
{
std::vector< std::unique_ptr<OptionsLeaf> > aGroupedLeaves;
aGroupedLeaves.push_back( std::move(pLeaf) );
pNode->m_aGroupedLeaves.push_back( std::move(aGroupedLeaves) );
}
}
else
pNode->m_aLeaves.push_back( std::move(pLeaf) );
}
}
}
}
// do not insert nodes without leaves
if ( !pNode->m_aLeaves.empty() || !pNode->m_aGroupedLeaves.empty() )
{
pModule ? aNodeList.push_back( std::move(pNode) ) : aOutNodeList.push_back( std::move(pNode) );
}
}
}
if ( pModule && !aNodeList.empty() )
{
for ( auto const & i: pModule->m_aNodeList )
{
OUString sNodeId = i->m_sId;
for ( auto j = aNodeList.begin(); j != aNodeList.end(); ++j )
{
if ( (*j)->m_sId == sNodeId )
{
aOutNodeList.push_back( std::move(*j) );
aNodeList.erase( j );
break;
}
}
}
for ( auto & i: aNodeList )
aOutNodeList.push_back( std::move(i) );
}
return aOutNodeList;
}
static sal_uInt16 lcl_getGroupId( std::u16string_view rGroupName, const weld::TreeView& rTreeLB )
{
sal_uInt16 nRet = 0;
std::unique_ptr<weld::TreeIter> xEntry = rTreeLB.make_iterator();
bool bEntry = rTreeLB.get_iter_first(*xEntry);
while (bEntry)
{
if (!rTreeLB.get_iter_depth(*xEntry))
{
OUString sTemp(rTreeLB.get_text(*xEntry));
if (sTemp == rGroupName)
return nRet;
nRet++;
}
bEntry = rTreeLB.iter_next(*xEntry);
}
return USHRT_MAX;
}
static void lcl_insertLeaf(
OfaTreeOptionsDialog* pDlg, OptionsNode const * pNode, OptionsLeaf const * pLeaf, const weld::TreeView& rTreeLB )
{
sal_uInt16 nGrpId = lcl_getGroupId( pNode->m_sLabel, rTreeLB );
if ( USHRT_MAX == nGrpId )
{
sal_uInt16 nNodeGrpId = getGroupNodeId( pNode->m_sId );
nGrpId = pDlg->AddGroup( pNode->m_sLabel, nullptr, nullptr, nNodeGrpId );
}
OptionsPageInfo* pInfo = pDlg->AddTabPage( 0, pLeaf->m_sLabel, nGrpId );
pInfo->m_sPageURL = pLeaf->m_sPageURL;
pInfo->m_sEventHdl = pLeaf->m_sEventHdl;
}
void OfaTreeOptionsDialog::InsertNodes( const VectorOfNodes& rNodeList )
{
for (auto const& node : rNodeList)
{
if ( !node->m_aLeaves.empty() || !node->m_aGroupedLeaves.empty() )
{
for ( auto const & j: node->m_aGroupedLeaves )
{
for ( size_t k = 0; k < j.size(); ++k )
{
lcl_insertLeaf( this, node.get(), j[k].get(), *xTreeLB );
}
}
for ( auto const & j: node->m_aLeaves )
{
lcl_insertLeaf( this, node.get(), j.get(), *xTreeLB );
}
}
}
}
void OfaTreeOptionsDialog::SetNeedsRestart( svtools::RestartReason eReason)
{
bNeedsRestart = true;
eRestartReason = eReason;
}
short OfaTreeOptionsDialog::run()
{
std::unique_ptr< SvxDicListChgClamp > pClamp;
if ( !bIsFromExtensionManager )
{
// collect all DictionaryList Events while the dialog is executed
pClamp.reset(new SvxDicListChgClamp(LinguMgr::GetDictionaryList()));
}
return SfxOkDialogController::run();
}
// class ExtensionsTabPage -----------------------------------------------
ExtensionsTabPage::ExtensionsTabPage(
weld::Container* pParent, OUString aPageURL,
OUString aEvtHdl, const Reference< awt::XContainerWindowProvider >& rProvider )
: m_pContainer(pParent)
, m_sPageURL(std::move(aPageURL))
, m_sEventHdl(std::move(aEvtHdl))
, m_xWinProvider(rProvider)
{
}
ExtensionsTabPage::~ExtensionsTabPage()
{
Hide();
DeactivatePage();
if ( m_xPage.is() )
{
try
{
m_xPage->dispose();
}
catch (const Exception&)
{
}
m_xPage.clear();
}
if ( m_xPageParent.is() )
{
try
{
m_xPageParent->dispose();
}
catch (const Exception&)
{
}
m_xPageParent.clear();
}
}
void ExtensionsTabPage::CreateDialogWithHandler()
{
try
{
bool bWithHandler = !m_sEventHdl.isEmpty();
if ( bWithHandler )
{
Reference < XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
m_xEventHdl.set( xFactory->createInstance( m_sEventHdl ), UNO_QUERY );
}
if ( !bWithHandler || m_xEventHdl.is() )
{
m_xPageParent = m_pContainer->CreateChildFrame();
Reference<awt::XWindowPeer> xParent(m_xPageParent, UNO_QUERY);
m_xPage =
m_xWinProvider->createContainerWindow(
m_sPageURL, OUString(), xParent, m_xEventHdl );
Reference< awt::XControl > xPageControl( m_xPage, UNO_QUERY );
if ( xPageControl.is() )
{
Reference< awt::XWindowPeer > xWinPeer( xPageControl->getPeer() );
if ( xWinPeer.is() )
{
VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWinPeer );
if ( pWindow )
pWindow->SetStyle( pWindow->GetStyle() | WB_DIALOGCONTROL | WB_CHILDDLGCTRL );
}
}
}
}
catch (const Exception&)
{
TOOLS_WARN_EXCEPTION( "cui.options", "ExtensionsTabPage::CreateDialogWithHandler(): exception of XDialogProvider2::createDialogWithHandler()");
}
}
bool ExtensionsTabPage::DispatchAction( const OUString& rAction )
{
bool bRet = false;
if ( m_xEventHdl.is() )
{
try
{
bRet = m_xEventHdl->callHandlerMethod( m_xPage, Any( rAction ), u"external_event"_ustr );
}
catch ( Exception const & )
{
TOOLS_WARN_EXCEPTION( "cui.options", "ExtensionsTabPage::DispatchAction(): exception of XDialogEventHandler::callHandlerMethod()" );
}
}
return bRet;
}
void ExtensionsTabPage::Show()
{
if (!m_xPageParent.is())
return;
VclPtr<vcl::Window> xPageParent = VCLUnoHelper::GetWindow(m_xPageParent);
if (xPageParent)
{
// NoActivate otherwise setVisible will call Window::Show which will grab
// focus to the page by default
xPageParent->Show(true, ShowFlags::NoActivate);
}
m_xPageParent->setVisible(true);
}
void ExtensionsTabPage::Hide()
{
if (!m_xPageParent.is())
return;
m_xPageParent->setVisible(false);
}
void ExtensionsTabPage::ActivatePage()
{
if ( !m_xPage.is() )
{
CreateDialogWithHandler();
if ( m_xPage.is() )
{
auto aWindowRect = m_xPageParent->getPosSize();
m_xPage->setPosSize(0, 0, aWindowRect.Width, aWindowRect.Height, awt::PosSize::POSSIZE);
if ( !m_sEventHdl.isEmpty() )
DispatchAction( u"initialize"_ustr );
}
}
if ( m_xPage.is() )
{
m_xPage->setVisible( true );
}
}
void ExtensionsTabPage::DeactivatePage()
{
if ( m_xPage.is() )
m_xPage->setVisible( false );
}
void ExtensionsTabPage::ResetPage()
{
DispatchAction( u"back"_ustr );
ActivatePage();
}
void ExtensionsTabPage::SavePage()
{
DispatchAction( u"ok"_ustr );
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
View git blame Copy permalink