LibreOffice Module cui (master)  1
treeopt.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <memory>
21 #include <string_view>
22 
23 #include <config_features.h>
24 #include <config_feature_opencl.h>
25 #include <config_feature_desktop.h>
26 #include <config_gpgme.h>
27 
28 #include <officecfg/Office/Common.hxx>
29 
30 #include <svx/dialogs.hrc>
31 #include <svx/svxids.hrc>
32 
33 #include <treeopt.hrc>
34 #include <helpids.h>
35 
36 #include "cfgchart.hxx"
37 #include "connpoolconfig.hxx"
38 #include "connpooloptions.hxx"
39 #include <cuioptgenrl.hxx>
40 #include <dbregister.hxx>
41 #include "dbregisterednamesconfig.hxx"
42 #include <dialmgr.hxx>
43 #include "fontsubs.hxx"
44 #include "optaccessibility.hxx"
45 #include <optasian.hxx>
46 #include "optchart.hxx"
47 #include "optcolor.hxx"
48 #include "optctl.hxx"
49 #include "optfltr.hxx"
50 #include "optgdlg.hxx"
51 #include "opthtml.hxx"
52 #include "optinet2.hxx"
53 #include "optjava.hxx"
54 #include "optjsearch.hxx"
55 #include <optlingu.hxx>
56 #if HAVE_FEATURE_OPENCL
57 #include "optopencl.hxx"
58 #endif
59 #include <optpath.hxx>
60 #include "optsave.hxx"
61 #include "optupdt.hxx"
62 #include "personalization.hxx"
63 #include <treeopt.hxx>
64 #include "optbasic.hxx"
65 
66 #include <com/sun/star/awt/XContainerWindowEventHandler.hpp>
67 #include <com/sun/star/awt/ContainerWindowProvider.hpp>
68 #include <com/sun/star/awt/XControl.hpp>
69 #include <com/sun/star/awt/PosSize.hpp>
70 #include <com/sun/star/frame/Desktop.hpp>
71 #include <com/sun/star/frame/ModuleManager.hpp>
72 #include <com/sun/star/frame/UnknownModuleException.hpp>
73 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
74 #include <com/sun/star/linguistic2/LinguProperties.hpp>
75 #include <com/sun/star/setup/UpdateCheck.hpp>
76 #include <comphelper/getexpandeduri.hxx>
77 #include <comphelper/processfactory.hxx>
78 #include <editeng/langitem.hxx>
79 #include <editeng/optitems.hxx>
80 #include <editeng/unolingu.hxx>
81 #include <linguistic/misc.hxx>
82 #include <officecfg/Office/OptionsDialog.hxx>
83 #include <sfx2/app.hxx>
84 #include <sfx2/dispatch.hxx>
85 #include <sfx2/module.hxx>
86 #include <sfx2/printopt.hxx>
87 #include <sfx2/shell.hxx>
88 #include <sfx2/viewsh.hxx>
89 #include <sfx2/viewfrm.hxx>
90 #include <svl/flagitem.hxx>
91 #include <svl/intitem.hxx>
92 #include <svl/cjkoptions.hxx>
93 #include <svl/ctloptions.hxx>
94 #include <svx/databaseregistrationui.hxx>
95 #include <toolkit/helper/vclunohelper.hxx>
96 #include <tools/urlobj.hxx>
97 #include <tools/diagnose_ex.h>
98 #include <unotools/configmgr.hxx>
99 #include <unotools/moduleoptions.hxx>
100 #include <unotools/optionsdlg.hxx>
101 #include <unotools/viewoptions.hxx>
102 #include <vcl/help.hxx>
103 #include <vcl/svapp.hxx>
104 #include <vcl/weldutils.hxx>
105 #include <vcl/window.hxx>
106 #include <sal/log.hxx>
107 
108 using namespace ::com::sun::star;
109 using namespace ::com::sun::star::beans;
110 using namespace ::com::sun::star::container;
111 using namespace ::com::sun::star::frame;
112 using namespace ::com::sun::star::lang;
113 using namespace ::com::sun::star::linguistic2;
114 using namespace ::com::sun::star::uno;
115 using namespace ::com::sun::star::util;
116 
117 LastPageSaver* OfaTreeOptionsDialog::pLastPageSaver = nullptr;
118 
119 // some stuff for easier changes for SvtViewOptions
120 constexpr OUStringLiteral VIEWOPT_DATANAME = u"page data";
121 
122 static void SetViewOptUserItem( SvtViewOptions& rOpt, const OUString& rData )
123 {
124  rOpt.SetUserItem( VIEWOPT_DATANAME, Any( rData ) );
125 }
126 
127 static OUString GetViewOptUserItem( const SvtViewOptions& rOpt )
128 {
129  Any aAny( rOpt.GetUserItem( VIEWOPT_DATANAME ) );
130  OUString aUserData;
131  aAny >>= aUserData;
132 
133  return aUserData;
134 }
135 
136 namespace {
137 
138 struct ModuleToGroupNameMap_Impl
139 {
140  std::u16string_view m_pModule;
141  OUString m_sGroupName;
142  sal_uInt16 m_nNodeId;
143 };
144 }
145 
146 static ModuleToGroupNameMap_Impl ModuleMap[] =
147 {
148  { u"ProductName", OUString(), SID_GENERAL_OPTIONS },
149  { u"LanguageSettings", OUString(), SID_LANGUAGE_OPTIONS },
150  { u"Internet", OUString(), SID_INET_DLG },
151  { u"LoadSave", OUString(), SID_FILTER_DLG },
152  { u"Writer", OUString(), SID_SW_EDITOPTIONS },
153  { u"WriterWeb", OUString(), SID_SW_ONLINEOPTIONS },
154  { u"Math", OUString(), SID_SM_EDITOPTIONS },
155  { u"Calc", OUString(), SID_SC_EDITOPTIONS },
156  { u"Impress", OUString(), SID_SD_EDITOPTIONS },
157  { u"Draw", OUString(), SID_SD_GRAPHIC_OPTIONS },
158  { u"Charts", OUString(), SID_SCH_EDITOPTIONS },
159  { u"Base", OUString(), SID_SB_STARBASEOPTIONS },
160 };
161 
162 static void setGroupName( std::u16string_view rModule, const OUString& rGroupName )
163 {
164  for (ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
165  {
166  if ( rEntry.m_pModule == rModule )
167  {
168  rEntry.m_sGroupName = rGroupName;
169  break;
170  }
171  }
172 }
173 
174 static OUString getGroupName( std::u16string_view rModule, bool bForced )
175 {
176  OUString sGroupName;
177  for (const ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
178  {
179  if ( rEntry.m_pModule == rModule )
180  {
181  sGroupName = rEntry.m_sGroupName;
182  break;
183  }
184  }
185 
186  if ( sGroupName.isEmpty() && bForced )
187  {
188  if ( rModule == u"Writer" )
189  sGroupName = CuiResId(SID_SW_EDITOPTIONS_RES[0].first);
190  else if ( rModule == u"WriterWeb" )
191  sGroupName = CuiResId(SID_SW_ONLINEOPTIONS_RES[0].first);
192  else if ( rModule == u"Calc" )
193  sGroupName = CuiResId(SID_SC_EDITOPTIONS_RES[0].first);
194  else if ( rModule == u"Impress" )
195  sGroupName = CuiResId(SID_SD_EDITOPTIONS_RES[0].first);
196  else if ( rModule == u"Draw" )
197  sGroupName = CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[0].first);
198  else if ( rModule == u"Math" )
199  sGroupName = CuiResId(SID_SM_EDITOPTIONS_RES[0].first);
200  else if ( rModule == u"Base" )
201  sGroupName = CuiResId(SID_SB_STARBASEOPTIONS_RES[0].first);
202  }
203  return sGroupName;
204 }
205 
206 static void deleteGroupNames()
207 {
208  for (ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
209  rEntry.m_sGroupName.clear();
210 }
211 
212 static sal_uInt16 getGroupNodeId( std::u16string_view rModule )
213 {
214  sal_uInt16 nNodeId = 0xFFFF;
215  for (const ModuleToGroupNameMap_Impl& rEntry : ModuleMap)
216  {
217  if ( rEntry.m_pModule == rModule )
218  {
219  nNodeId = rEntry.m_nNodeId;
220  break;
221  }
222  }
223 
224  return nNodeId;
225 }
226 
227 namespace {
228 
229 class MailMergeCfg_Impl : public utl::ConfigItem
230 {
231 private:
232  // variables
233  bool bIsEmailSupported;
234 
235  virtual void ImplCommit() override;
236 
237 public:
238  MailMergeCfg_Impl();
239 
240  virtual void Notify( const css::uno::Sequence< OUString >& _rPropertyNames) override;
241 
242  bool IsEmailSupported() const {return bIsEmailSupported;}
243 
244 };
245 
246 }
247 
248 MailMergeCfg_Impl::MailMergeCfg_Impl() :
249  utl::ConfigItem("Office.Writer/MailMergeWizard"),
250  bIsEmailSupported(false)
251 {
252  Sequence<OUString> aNames { "EMailSupported" };
253  const Sequence< Any > aValues = GetProperties(aNames);
254  const Any* pValues = aValues.getConstArray();
255  if(aValues.hasElements() && pValues[0].hasValue())
256  pValues[0] >>= bIsEmailSupported;
257 }
258 
259 void MailMergeCfg_Impl::ImplCommit()
260 {
261 }
262 
263 void MailMergeCfg_Impl::Notify( const css::uno::Sequence< OUString >& )
264 {
265 }
266 
267 //typedef SfxTabPage* (*FNCreateTabPage)(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rAttrSet);
268 static std::unique_ptr<SfxTabPage> CreateGeneralTabPage(sal_uInt16 nId, weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
269 {
270  CreateTabPage fnCreate = nullptr;
271  switch(nId)
272  {
273  case RID_SFXPAGE_SAVE: fnCreate = &SvxSaveTabPage::Create; break;
274  case RID_SFXPAGE_PATH: fnCreate = &SvxPathTabPage::Create; break;
275  case RID_SFXPAGE_GENERAL: fnCreate = &SvxGeneralTabPage::Create; break;
276  case RID_SFXPAGE_PRINTOPTIONS: fnCreate = &SfxCommonPrintOptionsTabPage::Create; break;
277  case OFA_TP_LANGUAGES: fnCreate = &OfaLanguagesTabPage::Create; break;
278  case RID_SFXPAGE_LINGU: fnCreate = &SvxLinguTabPage::Create; break;
279  case OFA_TP_VIEW: fnCreate = &OfaViewTabPage::Create; break;
280  case OFA_TP_MISC: fnCreate = &OfaMiscTabPage::Create; break;
281  case RID_SVXPAGE_ASIAN_LAYOUT: fnCreate = &SvxAsianLayoutPage::Create; break;
282  case RID_SVX_FONT_SUBSTITUTION: fnCreate = &SvxFontSubstTabPage::Create; break;
283  case RID_SVXPAGE_INET_PROXY: fnCreate = &SvxProxyTabPage::Create; break;
284  case RID_SVXPAGE_INET_SECURITY: fnCreate = &SvxSecurityTabPage::Create; break;
285  case RID_SVXPAGE_INET_MAIL: fnCreate = &SvxEMailTabPage::Create; break;
286 #if HAVE_FEATURE_DESKTOP
287  case RID_SVXPAGE_PERSONALIZATION: fnCreate = &SvxPersonalizationTabPage::Create; break;
288 #endif
289  case RID_SVXPAGE_COLORCONFIG: fnCreate = &SvxColorOptionsTabPage::Create; break;
290  case RID_OFAPAGE_HTMLOPT: fnCreate = &OfaHtmlTabPage::Create; break;
291  case SID_OPTFILTER_MSOFFICE: fnCreate = &OfaMSFilterTabPage::Create; break;
292  case RID_OFAPAGE_MSFILTEROPT2: fnCreate = &OfaMSFilterTabPage2::Create; break;
293  case RID_SVXPAGE_JSEARCH_OPTIONS: fnCreate = &SvxJSearchOptionsPage::Create ; break;
294  case SID_SB_CONNECTIONPOOLING: fnCreate = &::offapp::ConnectionPoolOptionsPage::Create; break;
295  case SID_SB_DBREGISTEROPTIONS: fnCreate = &svx::DbRegistrationOptionsPage::Create; break;
296  case RID_SVXPAGE_ACCESSIBILITYCONFIG: fnCreate = &SvxAccessibilityOptionsTabPage::Create; break;
297  case RID_SVXPAGE_OPTIONS_CTL: fnCreate = &SvxCTLOptionsPage::Create ; break;
298  case RID_SVXPAGE_OPTIONS_JAVA: fnCreate = &SvxJavaOptionsPage::Create ; break;
299 #if HAVE_FEATURE_OPENCL
300  case RID_SVXPAGE_OPENCL: fnCreate = &SvxOpenCLTabPage::Create ; break;
301 #endif
302  case RID_SVXPAGE_ONLINEUPDATE: fnCreate = &SvxOnlineUpdateTabPage::Create; break;
303  case RID_OPTPAGE_CHART_DEFCOLORS: fnCreate = &SvxDefaultColorOptPage::Create; break;
304 #if HAVE_FEATURE_SCRIPTING
305  case RID_SVXPAGE_BASICIDE_OPTIONS: fnCreate = &SvxBasicIDEOptionsPage::Create; break;
306 #endif
307  }
308 
309  return fnCreate ? (*fnCreate)( pPage, pController, &rSet ) : nullptr;
310 }
311 
312 namespace {
313 
314 struct OptionsMapping_Impl
315 {
316  const char* m_pGroupName;
317  const char* m_pPageName;
318  sal_uInt16 m_nPageId;
319 };
320 
321 }
322 
323 OptionsMapping_Impl const OptionsMap_Impl[] =
324 {
325 // GROUP PAGE PAGE-ID
326  { "ProductName", nullptr, SID_GENERAL_OPTIONS },
327  { "ProductName", "UserData", RID_SFXPAGE_GENERAL },
328  { "ProductName", "General", OFA_TP_MISC },
329  { "ProductName", "View", OFA_TP_VIEW },
330  { "ProductName", "Print", RID_SFXPAGE_PRINTOPTIONS },
331  { "ProductName", "Paths", RID_SFXPAGE_PATH },
332  { "ProductName", "Fonts", RID_SVX_FONT_SUBSTITUTION },
333  { "ProductName", "Security", RID_SVXPAGE_INET_SECURITY },
334  { "ProductName", "Personalization", RID_SVXPAGE_PERSONALIZATION },
335  { "ProductName", "Appearance", RID_SVXPAGE_COLORCONFIG },
336  { "ProductName", "Accessibility", RID_SVXPAGE_ACCESSIBILITYCONFIG },
337  { "ProductName", "Java", RID_SVXPAGE_OPTIONS_JAVA },
338  { "ProductName", "BasicIDEOptions", RID_SVXPAGE_BASICIDE_OPTIONS },
339  { "ProductName", "OnlineUpdate", RID_SVXPAGE_ONLINEUPDATE },
340  { "LanguageSettings", nullptr, SID_LANGUAGE_OPTIONS },
341  { "LanguageSettings", "Languages", OFA_TP_LANGUAGES },
342  { "LanguageSettings", "WritingAids", RID_SFXPAGE_LINGU },
343  { "LanguageSettings", "SearchingInJapanese", RID_SVXPAGE_JSEARCH_OPTIONS },
344  { "LanguageSettings", "AsianLayout", RID_SVXPAGE_ASIAN_LAYOUT },
345  { "LanguageSettings", "ComplexTextLayout", RID_SVXPAGE_OPTIONS_CTL },
346  { "Internet", nullptr, SID_INET_DLG },
347  { "Internet", "Proxy", RID_SVXPAGE_INET_PROXY },
348  { "Internet", "Email", RID_SVXPAGE_INET_MAIL },
349  { "LoadSave", nullptr, SID_FILTER_DLG },
350  { "LoadSave", "General", RID_SFXPAGE_SAVE },
351  { "LoadSave", "VBAProperties", SID_OPTFILTER_MSOFFICE },
352  { "LoadSave", "MicrosoftOffice", RID_OFAPAGE_MSFILTEROPT2 },
353  { "LoadSave", "HTMLCompatibility", RID_OFAPAGE_HTMLOPT },
354  { "Writer", nullptr, SID_SW_EDITOPTIONS },
355  { "Writer", "General", RID_SW_TP_OPTLOAD_PAGE },
356  { "Writer", "View", RID_SW_TP_CONTENT_OPT },
357  { "Writer", "FormattingAids", RID_SW_TP_OPTSHDWCRSR },
358  { "Writer", "Grid", RID_SVXPAGE_GRID },
359  { "Writer", "BasicFontsWestern", RID_SW_TP_STD_FONT },
360  { "Writer", "BasicFontsAsian", RID_SW_TP_STD_FONT_CJK },
361  { "Writer", "BasicFontsCTL", RID_SW_TP_STD_FONT_CTL },
362  { "Writer", "Print", RID_SW_TP_OPTPRINT_PAGE },
363  { "Writer", "Table", RID_SW_TP_OPTTABLE_PAGE },
364  { "Writer", "Changes", RID_SW_TP_REDLINE_OPT },
365  { "Writer", "Comparison", RID_SW_TP_COMPARISON_OPT },
366  { "Writer", "Compatibility", RID_SW_TP_OPTCOMPATIBILITY_PAGE },
367  { "Writer", "AutoCaption", RID_SW_TP_OPTCAPTION_PAGE },
368  { "Writer", "MailMerge", RID_SW_TP_MAILCONFIG },
369  { "WriterWeb", nullptr, SID_SW_ONLINEOPTIONS },
370  { "WriterWeb", "View", RID_SW_TP_HTML_CONTENT_OPT },
371  { "WriterWeb", "FormattingAids", RID_SW_TP_HTML_OPTSHDWCRSR },
372  { "WriterWeb", "Grid", RID_SW_TP_HTML_OPTGRID_PAGE },
373  { "WriterWeb", "Print", RID_SW_TP_HTML_OPTPRINT_PAGE },
374  { "WriterWeb", "Table", RID_SW_TP_HTML_OPTTABLE_PAGE },
375  { "WriterWeb", "Background", RID_SW_TP_BACKGROUND },
376  { "Math", nullptr, SID_SM_EDITOPTIONS },
377  { "Math", "Settings", SID_SM_TP_PRINTOPTIONS },
378  { "Calc", nullptr, SID_SC_EDITOPTIONS },
379  { "Calc", "General", SID_SC_TP_LAYOUT },
380  { "Calc", "View", SID_SC_TP_CONTENT },
381  { "Calc", "Calculate", SID_SC_TP_CALC },
382  { "Calc", "Formula", SID_SC_TP_FORMULA },
383  { "Calc", "SortLists", SID_SC_TP_USERLISTS },
384  { "Calc", "Changes", SID_SC_TP_CHANGES },
385  { "Calc", "Compatibility", SID_SC_TP_COMPATIBILITY },
386  { "Calc", "Grid", SID_SC_TP_GRID },
387  { "Calc", "Print", RID_SC_TP_PRINT },
388  { "Impress", nullptr, SID_SD_EDITOPTIONS },
389  { "Impress", "General", SID_SI_TP_MISC },
390  { "Impress", "View", SID_SI_TP_CONTENTS },
391  { "Impress", "Grid", SID_SI_TP_SNAP },
392  { "Impress", "Print", SID_SI_TP_PRINT },
393  { "Draw", nullptr, SID_SD_GRAPHIC_OPTIONS },
394  { "Draw", "General", SID_SD_TP_MISC },
395  { "Draw", "View", SID_SD_TP_CONTENTS },
396  { "Draw", "Grid", SID_SD_TP_SNAP },
397  { "Draw", "Print", SID_SD_TP_PRINT },
398  { "Charts", nullptr, SID_SCH_EDITOPTIONS },
399  { "Charts", "DefaultColors", RID_OPTPAGE_CHART_DEFCOLORS },
400  { "Base", nullptr, SID_SB_STARBASEOPTIONS },
401  { "Base", "Connections", SID_SB_CONNECTIONPOOLING },
402  { "Base", "Databases", SID_SB_DBREGISTEROPTIONS },
403  { nullptr, nullptr, 0 }
404 };
405 
406 static bool lcl_getStringFromID( sal_uInt16 _nPageId, OUString& _rGroupName, OUString& _rPageName )
407 {
408  bool bRet = false;
409 
410  sal_uInt16 nIdx = 0;
411  while ( OptionsMap_Impl[nIdx].m_pGroupName != nullptr )
412  {
413  if ( _nPageId == OptionsMap_Impl[nIdx].m_nPageId )
414  {
415  bRet = true;
416  _rGroupName = OUString::createFromAscii( OptionsMap_Impl[nIdx].m_pGroupName );
417  if ( OptionsMap_Impl[nIdx].m_pPageName != nullptr )
418  _rPageName = OUString::createFromAscii( OptionsMap_Impl[nIdx].m_pPageName );
419  break;
420  }
421  ++nIdx;
422  }
423 
424  return bRet;
425 }
426 
427 static bool lcl_isOptionHidden( sal_uInt16 _nPageId, const SvtOptionsDialogOptions& _rOptOptions )
428 {
429  bool bIsHidden = false;
430  OUString sGroupName, sPageName;
431  if ( lcl_getStringFromID( _nPageId, sGroupName, sPageName ) )
432  {
433  if ( sPageName.isEmpty() )
434  bIsHidden = _rOptOptions.IsGroupHidden( sGroupName );
435  else
436  bIsHidden = _rOptOptions.IsPageHidden( sPageName, sGroupName );
437  }
438  return bIsHidden;
439 }
440 
441 struct OptionsPageInfo
442 {
443  std::unique_ptr<SfxTabPage> m_xPage;
444  sal_uInt16 m_nPageId;
445  OUString m_sPageURL;
446  OUString m_sEventHdl;
447  std::unique_ptr<ExtensionsTabPage> m_xExtPage;
448 
449  explicit OptionsPageInfo( sal_uInt16 nId ) : m_nPageId( nId ) {}
450 };
451 
452 struct OptionsGroupInfo
453 {
454  std::optional<SfxItemSet> m_pInItemSet;
455  std::unique_ptr<SfxItemSet> m_pOutItemSet;
456  SfxShell* m_pShell; // used to create the page
457  SfxModule* m_pModule; // used to create the ItemSet
458  sal_uInt16 m_nDialogId; // Id of the former dialog
459 
460  OptionsGroupInfo( SfxShell* pSh, SfxModule* pMod, sal_uInt16 nId ) :
461  m_pShell( pSh ),
462  m_pModule( pMod ), m_nDialogId( nId ) {}
463 };
464 
465 #define INI_LIST() \
466  , m_pParent ( pParent )\
467  , sTitle ( m_xDialog->get_title() )\
468  , bForgetSelection ( false )\
469  , bIsFromExtensionManager( false ) \
470  , bIsForSetDocumentLanguage( false ) \
471  , bNeedsRestart ( false ) \
472  , eRestartReason( svtools::RESTART_REASON_NONE )
473 
474 void OfaTreeOptionsDialog::InitWidgets()
475 {
476  xOkPB = m_xBuilder->weld_button("ok");
477  xApplyPB = m_xBuilder->weld_button("apply");
478  xBackPB = m_xBuilder->weld_button("revert");
479  xTreeLB = m_xBuilder->weld_tree_view("pages");
480  xTabBox = m_xBuilder->weld_container("box");
481  Size aSize(xTreeLB->get_approximate_digit_width() * 82, xTreeLB->get_height_rows(30));
482 #if HAVE_FEATURE_GPGME
483  // tdf#115015: make enough space for crypto settings (approx. 14 text edits + padding)
484  aSize.setHeight((weld::GetMinimumEditHeight() + 6) * 14);
485 #endif
486  xTabBox->set_size_request(aSize.Width(), aSize.Height());
487  xTreeLB->set_size_request(xTreeLB->get_approximate_digit_width() * 35, aSize.Height());
488 }
489 
490 // Ctor() with Frame -----------------------------------------------------
491 OfaTreeOptionsDialog::OfaTreeOptionsDialog(weld::Window* pParent, const Reference< XFrame >& _xFrame, bool bActivateLastSelection)
492  : SfxOkDialogController(pParent, "cui/ui/optionsdialog.ui", "OptionsDialog")
493  INI_LIST()
494 {
495  InitWidgets();
496 
497  InitTreeAndHandler();
498  Initialize( _xFrame );
499  LoadExtensionOptions( u"" );
500  if (bActivateLastSelection)
501  ActivateLastSelection();
502 
503  xTreeLB->set_accessible_name(m_xDialog->get_title());
504 }
505 
506 // Ctor() with ExtensionId -----------------------------------------------
507 OfaTreeOptionsDialog::OfaTreeOptionsDialog(weld::Window* pParent, std::u16string_view rExtensionId)
508  : SfxOkDialogController(pParent, "cui/ui/optionsdialog.ui", "OptionsDialog")
509  INI_LIST()
510 {
511  InitWidgets();
512 
513  bIsFromExtensionManager = ( !rExtensionId.empty() );
514  InitTreeAndHandler();
515  LoadExtensionOptions( rExtensionId );
516  ActivateLastSelection();
517 }
518 
519 OfaTreeOptionsDialog::~OfaTreeOptionsDialog()
520 {
521  xCurrentPageEntry.reset();
522 
523  std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
524  bool bEntry = xTreeLB->get_iter_first(*xEntry);
525  // first children
526  while (bEntry)
527  {
528  // if Child (has parent), then OptionsPageInfo
529  if (xTreeLB->get_iter_depth(*xEntry))
530  {
531  OptionsPageInfo *pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xEntry).toInt64());
532  if(pPageInfo->m_xPage)
533  {
534  pPageInfo->m_xPage->FillUserData();
535  OUString aPageData(pPageInfo->m_xPage->GetUserData());
536  if ( !aPageData.isEmpty() )
537  {
538  SvtViewOptions aTabPageOpt( EViewType::TabPage, OUString::number( pPageInfo->m_nPageId) );
539  SetViewOptUserItem( aTabPageOpt, aPageData );
540  }
541  pPageInfo->m_xPage.reset();
542  }
543 
544  if (pPageInfo->m_nPageId == RID_SFXPAGE_LINGU)
545  {
546  // write personal dictionaries
547  Reference< XSearchableDictionaryList > xDicList( LinguMgr::GetDictionaryList() );
548  if (xDicList.is())
549  {
550  linguistic::SaveDictionaries( xDicList );
551  }
552  }
553 
554  pPageInfo->m_xExtPage.reset();
555 
556  delete pPageInfo;
557  }
558  bEntry = xTreeLB->iter_next(*xEntry);
559  }
560 
561  // and parents
562  bEntry = xTreeLB->get_iter_first(*xEntry);
563  while (bEntry)
564  {
565  if (!xTreeLB->get_iter_depth(*xEntry))
566  {
567  OptionsGroupInfo* pGroupInfo = reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xEntry).toInt64());
568  delete pGroupInfo;
569  }
570  bEntry = xTreeLB->iter_next(*xEntry);
571  }
572  deleteGroupNames();
573 }
574 
575 OptionsPageInfo* OfaTreeOptionsDialog::AddTabPage(
576  sal_uInt16 nId, const OUString& rPageName, sal_uInt16 nGroup )
577 {
578  std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator();
579  if (!xTreeLB->get_iter_first(*xParent))
580  return nullptr;
581  xTreeLB->iter_nth_sibling(*xParent, nGroup);
582 
583  OptionsPageInfo* pPageInfo = new OptionsPageInfo( nId );
584  OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pPageInfo)));
585  xTreeLB->insert(xParent.get(), -1, &rPageName, &sId, nullptr, nullptr, false, nullptr);
586  return pPageInfo;
587 }
588 
589 // the ItemSet* is passed on to the dialog's ownership
590 sal_uInt16 OfaTreeOptionsDialog::AddGroup(const OUString& rGroupName,
591  SfxShell* pCreateShell,
592  SfxModule* pCreateModule,
593  sal_uInt16 nDialogId )
594 {
595  OptionsGroupInfo* pInfo =
596  new OptionsGroupInfo( pCreateShell, pCreateModule, nDialogId );
597  OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pInfo)));
598  xTreeLB->append(sId, rGroupName);
599 
600  sal_uInt16 nRet = 0;
601  std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
602  bool bEntry = xTreeLB->get_iter_first(*xEntry);
603  while (bEntry)
604  {
605  if (!xTreeLB->get_iter_depth(*xEntry))
606  nRet++;
607  bEntry = xTreeLB->iter_next(*xEntry);
608  }
609  return nRet - 1;
610 }
611 
612 IMPL_LINK_NOARG(OfaTreeOptionsDialog, ShowPageHdl_Impl, weld::TreeView&, void)
613 {
614  SelectHdl_Impl();
615 }
616 
617 void OfaTreeOptionsDialog::ResetCurrentPageFromConfig()
618 {
619  if (!(xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry)))
620  return;
621 
622  OptionsPageInfo* pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry).toInt64());
623  if (pPageInfo->m_xPage)
624  {
625  std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator(xCurrentPageEntry.get());
626  xTreeLB->iter_parent(*xParent);
627  OptionsGroupInfo* pGroupInfo =
628  reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xParent).toInt64());
629  pPageInfo->m_xPage->Reset( &*pGroupInfo->m_pInItemSet );
630  }
631  else if ( pPageInfo->m_xExtPage )
632  pPageInfo->m_xExtPage->ResetPage();
633 }
634 
635 IMPL_LINK_NOARG(OfaTreeOptionsDialog, BackHdl_Impl, weld::Button&, void)
636 {
637  ResetCurrentPageFromConfig();
638 }
639 
640 void OfaTreeOptionsDialog::ApplyOptions()
641 {
642  std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
643  bool bEntry = xTreeLB->get_iter_first(*xEntry);
644  while (bEntry)
645  {
646  if (xTreeLB->get_iter_depth(*xEntry))
647  {
648  OptionsPageInfo* pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xEntry).toInt64());
649  if ( pPageInfo->m_xPage && !pPageInfo->m_xPage->HasExchangeSupport() )
650  {
651  std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator(xEntry.get());
652  xTreeLB->iter_parent(*xParent);
653  OptionsGroupInfo* pGroupInfo =
654  reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xParent).toInt64());
655  pPageInfo->m_xPage->FillItemSet(pGroupInfo->m_pOutItemSet.get());
656  }
657 
658  if ( pPageInfo->m_xExtPage )
659  {
660  pPageInfo->m_xExtPage->DeactivatePage();
661  pPageInfo->m_xExtPage->SavePage();
662  }
663  if ( pPageInfo->m_xPage && RID_OPTPAGE_CHART_DEFCOLORS == pPageInfo->m_nPageId )
664  {
665  SvxDefaultColorOptPage* pPage = static_cast<SvxDefaultColorOptPage *>(pPageInfo->m_xPage.get());
666  pPage->SaveChartOptions();
667  }
668  }
669  bEntry = xTreeLB->iter_next(*xEntry);
670  }
671 }
672 
673 IMPL_LINK_NOARG(OfaTreeOptionsDialog, HelpHdl_Impl, weld::Widget&, bool)
674 {
675  Help* pHelp = Application::GetHelp();
676  if (pHelp && xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry))
677  {
678  OptionsPageInfo* pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry).toInt64());
679  if (pPageInfo->m_xPage)
680  {
681  OString sHelpId(pPageInfo->m_xPage->GetHelpId());
682  pHelp->Start(OStringToOUString(sHelpId, RTL_TEXTENCODING_UTF8), m_xDialog.get());
683  return false;
684  }
685  }
686  return true;
687 }
688 
689 IMPL_LINK(OfaTreeOptionsDialog, ApplyHdl_Impl, weld::Button&, rButton, void)
690 {
691  bool bOkPressed = &rButton == xOkPB.get();
692 
693  OptionsGroupInfo* pGroupInfo = nullptr;
694 
695  if (xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry))
696  {
697  OptionsPageInfo* pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry).toInt64());
698  if ( pPageInfo->m_xPage )
699  {
700  std::unique_ptr<weld::TreeIter> xParent = xTreeLB->make_iterator(xCurrentPageEntry.get());
701  xTreeLB->iter_parent(*xParent);
702 
703  pGroupInfo = reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xParent).toInt64());
704  if ( RID_SVXPAGE_COLOR != pPageInfo->m_nPageId
705  && pPageInfo->m_xPage->HasExchangeSupport() )
706  {
707  DeactivateRC nLeave = pPageInfo->m_xPage->DeactivatePage(pGroupInfo->m_pOutItemSet.get());
708  if ( nLeave == DeactivateRC::KeepPage )
709  {
710  // the page mustn't be left, so return early
711  assert(xTreeLB->is_selected(*xCurrentPageEntry)); // presumably this must be true here
712  if (bOkPressed)
713  return;
714  }
715  }
716  }
717  }
718 
719  ApplyOptions();
720  ApplyItemSets();
721  utl::ConfigManager::storeConfigItems();
722 
723  if (bOkPressed)
724  m_xDialog->response(RET_OK);
725  else
726  {
727  // tdf#137930 rebuild the in and out itemsets to reflect the current
728  // post-apply state
729  if (pGroupInfo && pGroupInfo->m_pInItemSet)
730  {
731  // tdf#138596 seeing as the SfxTabPages keep pointers to the m_pInItemSet
732  // we update the contents of the existing SfxItemSets to match
733  // the current settings, rather than create new ones
734  auto xInItemSet = pGroupInfo->m_pShell
735  ? pGroupInfo->m_pShell->CreateItemSet( pGroupInfo->m_nDialogId )
736  : CreateItemSet( pGroupInfo->m_nDialogId );
737  pGroupInfo->m_pInItemSet->Set(*xInItemSet, false);
738  pGroupInfo->m_pOutItemSet->ClearItem();
739  }
740 
741  // for the Apply case, now that the settings are saved to config,
742  // reload the current page so it knows what the config now states
743  ResetCurrentPageFromConfig();
744  // reselect it to undo possible DeactivatePage above
745  xCurrentPageEntry.reset();
746  SelectHdl_Impl();
747  }
748 
749  if (!bNeedsRestart)
750  return;
751 
752  SolarMutexGuard aGuard;
753  weld::Window* pParent;
754  if (!bOkPressed)
755  pParent = m_xDialog.get();
756  else
757  {
758  m_xDialog->hide();
759  pParent = m_pParent;
760  }
761  bool bRestart = ::svtools::executeRestartDialog(comphelper::getProcessComponentContext(),
762  pParent, eRestartReason);
763  if (bRestart && !bOkPressed)
764  m_xDialog->response(RET_OK);
765 }
766 
767 void OfaTreeOptionsDialog::ApplyItemSets()
768 {
769  std::unique_ptr<weld::TreeIter> xEntry = xTreeLB->make_iterator();
770  bool bEntry = xTreeLB->get_iter_first(*xEntry);
771  while (bEntry)
772  {
773  if (!xTreeLB->get_iter_depth(*xEntry))
774  {
775  OptionsGroupInfo* pGroupInfo = reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xEntry).toInt64());
776  if(pGroupInfo->m_pOutItemSet)
777  {
778  if(pGroupInfo->m_pShell)
779  pGroupInfo->m_pShell->ApplyItemSet( pGroupInfo->m_nDialogId, *pGroupInfo->m_pOutItemSet);
780  else
781  ApplyItemSet( pGroupInfo->m_nDialogId, *pGroupInfo->m_pOutItemSet);
782  }
783  }
784  bEntry = xTreeLB->iter_next(*xEntry);
785  }
786 }
787 
788 void OfaTreeOptionsDialog::InitTreeAndHandler()
789 {
790  xTreeLB->set_help_id(HID_OFADLG_TREELISTBOX);
791  xTreeLB->connect_changed( LINK( this, OfaTreeOptionsDialog, ShowPageHdl_Impl ) );
792  xBackPB->connect_clicked( LINK( this, OfaTreeOptionsDialog, BackHdl_Impl ) );
793  xApplyPB->connect_clicked( LINK( this, OfaTreeOptionsDialog, ApplyHdl_Impl ) );
794  xOkPB->connect_clicked( LINK( this, OfaTreeOptionsDialog, ApplyHdl_Impl ) );
795  m_xDialog->connect_help( LINK( this, OfaTreeOptionsDialog, HelpHdl_Impl ) );
796 }
797 
798 void OfaTreeOptionsDialog::ActivatePage( sal_uInt16 nResId )
799 {
800  bIsForSetDocumentLanguage = false;
801  if ( nResId == OFA_TP_LANGUAGES_FOR_SET_DOCUMENT_LANGUAGE )
802  {
803  bIsForSetDocumentLanguage = true;
804  nResId = OFA_TP_LANGUAGES;
805  }
806 
807  DBG_ASSERT( !bIsFromExtensionManager, "OfaTreeOptionsDialog::ActivatePage(): call from extension manager" );
808  if ( !pLastPageSaver )
809  pLastPageSaver = new LastPageSaver;
810  bForgetSelection = true;
811  sal_uInt16 nTemp = pLastPageSaver->m_nLastPageId;
812  pLastPageSaver->m_nLastPageId = nResId;
813  ActivateLastSelection();
814  pLastPageSaver->m_nLastPageId = nTemp;
815 }
816 
817 void OfaTreeOptionsDialog::ActivatePage( const OUString& rPageURL )
818 {
819  DBG_ASSERT( !bIsFromExtensionManager, "OfaTreeOptionsDialog::ActivatePage(): call from extension manager" );
820  if ( !pLastPageSaver )
821  pLastPageSaver = new LastPageSaver;
822  bForgetSelection = true;
823  pLastPageSaver->m_nLastPageId = 0;
824  pLastPageSaver->m_sLastPageURL_Tools = rPageURL;
825  ActivateLastSelection();
826 }
827 
828 void OfaTreeOptionsDialog::ActivateLastSelection()
829 {
830  std::unique_ptr<weld::TreeIter> xEntry;
831 
832  if (pLastPageSaver)
833  {
834  OUString sLastURL = bIsFromExtensionManager ? pLastPageSaver->m_sLastPageURL_ExtMgr
835  : pLastPageSaver->m_sLastPageURL_Tools;
836  if ( sLastURL.isEmpty() )
837  {
838  sLastURL = !bIsFromExtensionManager ? pLastPageSaver->m_sLastPageURL_ExtMgr
839  : pLastPageSaver->m_sLastPageURL_Tools;
840  }
841 
842  bool bMustExpand = ( INetURLObject( sLastURL ).GetProtocol() == INetProtocol::File );
843 
844  std::unique_ptr<weld::TreeIter> xTemp = xTreeLB->make_iterator();
845  bool bTemp = xTreeLB->get_iter_first(*xTemp);
846  while (bTemp)
847  {
848  // restore only selection of a leaf
849  if (xTreeLB->get_iter_depth(*xTemp) && xTreeLB->get_id(*xTemp).toInt64())
850  {
851  OptionsPageInfo* pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xTemp).toInt64());
852  OUString sPageURL = pPageInfo->m_sPageURL;
853  if ( bMustExpand )
854  {
855  sPageURL = comphelper::getExpandedUri(
856  comphelper::getProcessComponentContext(), sPageURL);
857  }
858 
859  if ( ( !bIsFromExtensionManager
860  && pPageInfo->m_nPageId && pPageInfo->m_nPageId == pLastPageSaver->m_nLastPageId )
861  || ( !pPageInfo->m_nPageId && sLastURL == sPageURL ) )
862  {
863  xEntry = xTreeLB->make_iterator(xTemp.get());
864  break;
865  }
866  }
867  bTemp = xTreeLB->iter_next(*xTemp);
868  }
869  }
870 
871  if (!xEntry)
872  {
873  xEntry = xTreeLB->make_iterator();
874  if (!xTreeLB->get_iter_first(*xEntry) || !xTreeLB->iter_next(*xEntry))
875  xEntry.reset();
876  }
877 
878  if (!xEntry)
879  return;
880 
881  std::unique_ptr<weld::TreeIter> xParent(xTreeLB->make_iterator(xEntry.get()));
882  xTreeLB->iter_parent(*xParent);
883  xTreeLB->expand_row(*xParent);
884  xTreeLB->scroll_to_row(*xParent);
885  xTreeLB->scroll_to_row(*xEntry);
886  xTreeLB->set_cursor(*xEntry);
887  xTreeLB->select(*xEntry);
888  xTreeLB->grab_focus();
889  SelectHdl_Impl();
890 }
891 
892 void OfaTreeOptionsDialog::InitItemSets(OptionsGroupInfo& rGroupInfo)
893 {
894  if (!rGroupInfo.m_pInItemSet)
895  rGroupInfo.m_pInItemSet.emplace( rGroupInfo.m_pShell
896  ? *rGroupInfo.m_pShell->CreateItemSet( rGroupInfo.m_nDialogId )
897  : *CreateItemSet( rGroupInfo.m_nDialogId ) );
898  if (!rGroupInfo.m_pOutItemSet)
899  rGroupInfo.m_pOutItemSet = std::make_unique<SfxItemSet>(
900  *rGroupInfo.m_pInItemSet->GetPool(),
901  rGroupInfo.m_pInItemSet->GetRanges());
902 }
903 
904 void OfaTreeOptionsDialog::SelectHdl_Impl()
905 {
906  std::unique_ptr<weld::TreeIter> xEntry(xTreeLB->make_iterator());
907 
908  if (!xTreeLB->get_cursor(xEntry.get()))
909  return;
910 
911  if (xCurrentPageEntry && xCurrentPageEntry->equal(*xEntry))
912  return;
913 
914  std::unique_ptr<weld::TreeIter> xParent(xTreeLB->make_iterator(xEntry.get()));
915  bool bParent = xTreeLB->iter_parent(*xParent);
916 
917  // If the user has selected a category, automatically switch to a suitable
918  // default sub-page instead.
919  if (!bParent)
920  return;
921 
922  BuilderPage* pNewPage = nullptr;
923  OptionsPageInfo* pOptPageInfo = (xCurrentPageEntry && xTreeLB->get_iter_depth(*xCurrentPageEntry))
924  ? reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xCurrentPageEntry).toInt64()) : nullptr;
925 
926  if (pOptPageInfo && pOptPageInfo->m_xPage && pOptPageInfo->m_xPage->IsVisible())
927  {
928  std::unique_ptr<weld::TreeIter> xCurParent(xTreeLB->make_iterator(xCurrentPageEntry.get()));
929  xTreeLB->iter_parent(*xCurParent);
930 
931  OptionsGroupInfo* pGroupInfo = reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xCurParent).toInt64());
932  DeactivateRC nLeave = DeactivateRC::LeavePage;
933  if ( RID_SVXPAGE_COLOR != pOptPageInfo->m_nPageId && pOptPageInfo->m_xPage->HasExchangeSupport() )
934  nLeave = pOptPageInfo->m_xPage->DeactivatePage( pGroupInfo->m_pOutItemSet.get() );
935 
936  if ( nLeave == DeactivateRC::KeepPage )
937  {
938  // we cannot leave this page, this is may be from a user clicking a different entry
939  // in the tree so reselect the current page
940  xTreeLB->select(*xCurrentPageEntry);
941  return;
942  }
943  else
944  pOptPageInfo->m_xPage->set_visible(false);
945  }
946  else if ( pOptPageInfo && pOptPageInfo->m_xExtPage )
947  {
948  pOptPageInfo->m_xExtPage->Hide();
949  pOptPageInfo->m_xExtPage->DeactivatePage();
950  }
951 
952  OptionsPageInfo *pPageInfo = reinterpret_cast<OptionsPageInfo*>(xTreeLB->get_id(*xEntry).toInt64());
953  OptionsGroupInfo* pGroupInfo = reinterpret_cast<OptionsGroupInfo*>(xTreeLB->get_id(*xParent).toInt64());
954  if(!pPageInfo->m_xPage && pPageInfo->m_nPageId > 0)
955  {
956  InitItemSets(*pGroupInfo);
957 
958  pPageInfo->m_xPage = ::CreateGeneralTabPage(pPageInfo->m_nPageId, xTabBox.get(), this, *pGroupInfo->m_pInItemSet);
959 
960  if(!pPageInfo->m_xPage && pGroupInfo->m_pModule)
961  pPageInfo->m_xPage = pGroupInfo->m_pModule->CreateTabPage(pPageInfo->m_nPageId, xTabBox.get(), this, *pGroupInfo->m_pInItemSet);
962 
963  DBG_ASSERT( pPageInfo->m_xPage, "tabpage could not created");
964  if ( pPageInfo->m_xPage )
965  {
966  SvtViewOptions aTabPageOpt( EViewType::TabPage, OUString::number( pPageInfo->m_nPageId) );
967  pPageInfo->m_xPage->SetUserData( GetViewOptUserItem( aTabPageOpt ) );
968  pPageInfo->m_xPage->Reset( &*pGroupInfo->m_pInItemSet );
969  }
970  }
971  else if ( 0 == pPageInfo->m_nPageId && !pPageInfo->m_xExtPage )
972  {
973  if ( !m_xContainerWinProvider.is() )
974  {
975  m_xContainerWinProvider = awt::ContainerWindowProvider::create( ::comphelper::getProcessComponentContext() );
976  }
977 
978  pPageInfo->m_xExtPage = std::make_unique<ExtensionsTabPage>(
979  xTabBox.get(), pPageInfo->m_sPageURL, pPageInfo->m_sEventHdl, m_xContainerWinProvider);
980  }
981 
982  if ( pPageInfo->m_xPage )
983  {
984  if ( RID_SVXPAGE_COLOR != pPageInfo->m_nPageId &&
985  pPageInfo->m_xPage->HasExchangeSupport())
986  {
987  pPageInfo->m_xPage->ActivatePage(*pGroupInfo->m_pOutItemSet);
988  }
989  pPageInfo->m_xPage->set_visible(true);
990  }
991  else if ( pPageInfo->m_xExtPage )
992  {
993  pPageInfo->m_xExtPage->Show();
994  pPageInfo->m_xExtPage->ActivatePage();
995  }
996 
997  {
998  OUString sTitleText = sTitle
999  + " - " + xTreeLB->get_text(*xParent)
1000  + " - " + xTreeLB->get_text(*xEntry);
1001  m_xDialog->set_title(sTitleText);
1002  }
1003 
1004  xCurrentPageEntry = std::move(xEntry);
1005 
1006  if ( !bForgetSelection )
1007  {
1008  if ( !pLastPageSaver )
1009  pLastPageSaver = new LastPageSaver;
1010  if ( !bIsFromExtensionManager )
1011  pLastPageSaver->m_nLastPageId = pPageInfo->m_nPageId;
1012  if ( pPageInfo->m_xExtPage )
1013  {
1014  if ( bIsFromExtensionManager )
1015  pLastPageSaver->m_sLastPageURL_ExtMgr = pPageInfo->m_sPageURL;
1016  else
1017  pLastPageSaver->m_sLastPageURL_Tools = pPageInfo->m_sPageURL;
1018  }
1019  }
1020  pNewPage = pPageInfo->m_xPage.get();
1021 
1022  // fdo#58170 use current page's layout child HelpId, unless there isn't a current page
1023  OString sHelpId(pNewPage ? pNewPage->GetHelpId() : OString());
1024  if (sHelpId.isEmpty())
1025  sHelpId = HID_OFADLG_TREELISTBOX;
1026  xTreeLB->set_help_id(sHelpId);
1027 }
1028 
1029 std::optional<SfxItemSet> OfaTreeOptionsDialog::CreateItemSet( sal_uInt16 nId )
1030 {
1031  Reference< XLinguProperties > xProp( LinguMgr::GetLinguPropertySet() );
1032  std::optional<SfxItemSet> pRet;
1033  switch(nId)
1034  {
1035  case SID_GENERAL_OPTIONS:
1036  {
1037  pRet.emplace(
1038  SfxGetpApp()->GetPool(),
1039  svl::Items<
1040  SID_HTML_MODE, SID_HTML_MODE,
1041  SID_ATTR_METRIC, SID_ATTR_METRIC,
1042  SID_AUTOSPELL_CHECK, SID_AUTOSPELL_CHECK,
1043  SID_ATTR_QUICKLAUNCHER, SID_ATTR_QUICKLAUNCHER,
1044  SID_ATTR_YEAR2000, SID_ATTR_YEAR2000> );
1045 
1046  SfxItemSetFixed<SID_ATTR_QUICKLAUNCHER, SID_ATTR_QUICKLAUNCHER> aOptSet( SfxGetpApp()->GetPool() );
1047  SfxGetpApp()->GetOptions(aOptSet);
1048  pRet->Put(aOptSet);
1049 
1050  SfxViewFrame* pViewFrame = SfxViewFrame::Current();
1051  if ( pViewFrame )
1052  {
1053  const SfxPoolItem* pItem = nullptr;
1054  SfxDispatcher* pDispatch = pViewFrame->GetDispatcher();
1055 
1056  // miscellaneous - Year2000
1057  if( SfxItemState::DEFAULT <= pDispatch->QueryState( SID_ATTR_YEAR2000, pItem ) )
1058  pRet->Put( SfxUInt16Item( SID_ATTR_YEAR2000, static_cast<const SfxUInt16Item*>(pItem)->GetValue() ) );
1059  else
1060  pRet->Put( SfxUInt16Item( SID_ATTR_YEAR2000, officecfg::Office::Common::DateFormat::TwoDigitYear::get() ) );
1061  }
1062  else
1063  pRet->Put( SfxUInt16Item( SID_ATTR_YEAR2000, officecfg::Office::Common::DateFormat::TwoDigitYear::get() ) );
1064 
1065 
1066  // miscellaneous - Tabulator
1067  pRet->Put(SfxBoolItem(SID_PRINTER_NOTFOUND_WARN, officecfg::Office::Common::Print::Warning::NotFound::get()));
1068 
1069  SfxPrinterChangeFlags nFlag = officecfg::Office::Common::Print::Warning::PaperSize::get() ? SfxPrinterChangeFlags::CHG_SIZE : SfxPrinterChangeFlags::NONE;
1070  nFlag |= officecfg::Office::Common::Print::Warning::PaperOrientation::get() ? SfxPrinterChangeFlags::CHG_ORIENTATION : SfxPrinterChangeFlags::NONE;
1071  pRet->Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC, static_cast<int>(nFlag) ));
1072 
1073  }
1074  break;
1075  case SID_LANGUAGE_OPTIONS :
1076  {
1077  pRet.emplace(
1078  SfxGetpApp()->GetPool(),
1079  svl::Items<
1080  SID_ATTR_CHAR_CJK_LANGUAGE, SID_ATTR_CHAR_CJK_LANGUAGE,
1081  SID_ATTR_CHAR_CTL_LANGUAGE, SID_ATTR_CHAR_CTL_LANGUAGE,
1082  SID_SET_DOCUMENT_LANGUAGE, SID_SET_DOCUMENT_LANGUAGE,
1083  SID_ATTR_LANGUAGE, SID_ATTR_LANGUAGE,
1084  SID_AUTOSPELL_CHECK, SID_AUTOSPELL_CHECK,
1085  SID_OPT_LOCALE_CHANGED, SID_OPT_LOCALE_CHANGED>);
1086 
1087  // for linguistic
1088  SfxHyphenRegionItem aHyphen( SID_ATTR_HYPHENREGION );
1089 
1090  sal_Int16 nMinLead = 2,
1091  nMinTrail = 2;
1092  if (xProp.is())
1093  {
1094  nMinLead = xProp->getHyphMinLeading();
1095  nMinTrail = xProp->getHyphMinTrailing();
1096  }
1097  aHyphen.GetMinLead() = static_cast<sal_uInt8>(nMinLead);
1098  aHyphen.GetMinTrail() = static_cast<sal_uInt8>(nMinTrail);
1099 
1100  SfxViewFrame* pViewFrame = SfxViewFrame::Current();
1101  if ( pViewFrame )
1102  {
1103  const SfxPoolItem* pItem = nullptr;
1104  SfxDispatcher* pDispatch = pViewFrame->GetDispatcher();
1105  if(SfxItemState::DEFAULT <= pDispatch->QueryState(SID_ATTR_LANGUAGE, pItem))
1106  pRet->Put(
1107  SvxLanguageItem(
1108  (static_cast<const SvxLanguageItem*>(pItem)
1109  ->GetLanguage()),
1110  SID_ATTR_LANGUAGE));
1111  if(SfxItemState::DEFAULT <= pDispatch->QueryState(SID_ATTR_CHAR_CJK_LANGUAGE, pItem))
1112  pRet->Put(
1113  SvxLanguageItem(
1114  (static_cast<const SvxLanguageItem*>(pItem)
1115  ->GetLanguage()),
1116  SID_ATTR_CHAR_CJK_LANGUAGE));
1117  if(SfxItemState::DEFAULT <= pDispatch->QueryState(SID_ATTR_CHAR_CTL_LANGUAGE, pItem))
1118  pRet->Put(
1119  SvxLanguageItem(
1120  (static_cast<const SvxLanguageItem*>(pItem)
1121  ->GetLanguage()),
1122  SID_ATTR_CHAR_CTL_LANGUAGE));
1123 
1124  pRet->Put(aHyphen);
1125  if(SfxItemState::DEFAULT <= pDispatch->QueryState(SID_AUTOSPELL_CHECK, pItem))
1126  {
1127  pRet->Put(std::unique_ptr<SfxPoolItem>(pItem->Clone()));
1128  }
1129  else
1130  {
1131  bool bVal = false;
1132  if (xProp.is())
1133  {
1134  bVal = xProp->getIsSpellAuto();
1135  }
1136 
1137  pRet->Put(SfxBoolItem(SID_AUTOSPELL_CHECK, bVal));
1138  }
1139  }
1140  pRet->Put( SfxBoolItem( SID_SET_DOCUMENT_LANGUAGE, bIsForSetDocumentLanguage ) );
1141  }
1142  break;
1143  case SID_INET_DLG :
1144  pRet.emplace( SfxGetpApp()->GetPool(),
1145  svl::Items<
1146  //SID_OPTIONS_START - ..END
1147  SID_SAVEREL_INET, SID_SAVEREL_FSYS,
1148  SID_INET_NOPROXY, SID_INET_FTP_PROXY_PORT,
1149  SID_SECURE_URL, SID_SECURE_URL> );
1150  SfxGetpApp()->GetOptions(*pRet);
1151  break;
1152  case SID_FILTER_DLG:
1153  pRet.emplace(
1154  SfxGetpApp()->GetPool(),
1155  svl::Items<
1156  SID_ATTR_WARNALIENFORMAT, SID_ATTR_WARNALIENFORMAT,
1157  SID_ATTR_DOCINFO, SID_ATTR_AUTOSAVEMINUTE,
1158  SID_SAVEREL_INET, SID_SAVEREL_FSYS,
1159  SID_ATTR_PRETTYPRINTING, SID_ATTR_PRETTYPRINTING> );
1160  SfxGetpApp()->GetOptions(*pRet);
1161  break;
1162 
1163  case SID_SB_STARBASEOPTIONS:
1164  pRet.emplace( SfxGetpApp()->GetPool(),
1165  svl::Items<SID_SB_POOLING_ENABLED, SID_SB_DB_REGISTER> );
1166  ::offapp::ConnectionPoolConfig::GetOptions(*pRet);
1167  svx::DbRegisteredNamesConfig::GetOptions(*pRet);
1168  break;
1169 
1170  case SID_SCH_EDITOPTIONS:
1171  {
1172  SvxChartOptions aChartOpt;
1173  pRet.emplace( SfxGetpApp()->GetPool(), svl::Items<SID_SCH_EDITOPTIONS, SID_SCH_EDITOPTIONS> );
1174  pRet->Put( SvxChartColorTableItem( SID_SCH_EDITOPTIONS, aChartOpt.GetDefaultColors() ) );
1175  break;
1176  }
1177  }
1178  return pRet;
1179 }
1180 
1181 void OfaTreeOptionsDialog::ApplyItemSet( sal_uInt16 nId, const SfxItemSet& rSet )
1182 {
1183  switch(nId)
1184  {
1185  case SID_GENERAL_OPTIONS:
1186  {
1187  std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
1188 
1189  const SfxPoolItem* pItem = nullptr;
1190  SfxItemSetFixed<SID_ATTR_QUICKLAUNCHER, SID_ATTR_QUICKLAUNCHER> aOptSet(SfxGetpApp()->GetPool());
1191  aOptSet.Put(rSet);
1192  if(aOptSet.Count())
1193  SfxGetpApp()->SetOptions( aOptSet );
1194  // get dispatcher anew, because SetOptions() might have destroyed the dispatcher
1195  SfxViewFrame *pViewFrame = SfxViewFrame::Current();
1196 
1197 // evaluate Year2000
1198  sal_uInt16 nY2K = USHRT_MAX;
1199  if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_YEAR2000, false, &pItem ) )
1200  nY2K = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1201  if( USHRT_MAX != nY2K )
1202  {
1203  if ( pViewFrame )
1204  {
1205  SfxDispatcher* pDispatch = pViewFrame->GetDispatcher();
1206  pDispatch->ExecuteList(SID_ATTR_YEAR2000,
1207  SfxCallMode::ASYNCHRON, { pItem });
1208  }
1209  officecfg::Office::Common::DateFormat::TwoDigitYear::set(nY2K, batch);
1210  }
1211 
1212 // evaluate print
1213  if(SfxItemState::SET == rSet.GetItemState(SID_PRINTER_NOTFOUND_WARN, false, &pItem))
1214  officecfg::Office::Common::Print::Warning::NotFound::set(static_cast<const SfxBoolItem*>(pItem)->GetValue(), batch);
1215 
1216  if(SfxItemState::SET == rSet.GetItemState(SID_PRINTER_CHANGESTODOC, false, &pItem))
1217  {
1218  const SfxFlagItem* pFlag = static_cast<const SfxFlagItem*>(pItem);
1219  bool bPaperSizeWarning = bool(static_cast<SfxPrinterChangeFlags>(pFlag->GetValue()) & SfxPrinterChangeFlags::CHG_SIZE);
1220  officecfg::Office::Common::Print::Warning::PaperSize::set(bPaperSizeWarning, batch);
1221  bool bPaperOrientationWarning = bool(static_cast<SfxPrinterChangeFlags>(pFlag->GetValue()) & SfxPrinterChangeFlags::CHG_ORIENTATION);
1222  officecfg::Office::Common::Print::Warning::PaperOrientation::set(bPaperOrientationWarning, batch);
1223  }
1224 
1225 // evaluate help options
1226  bool bHelpTips = officecfg::Office::Common::Help::Tip::get();
1227  if ( bHelpTips != Help::IsQuickHelpEnabled() )
1228  bHelpTips ? Help::EnableQuickHelp() : Help::DisableQuickHelp();
1229  bool bExtendedHelp = officecfg::Office::Common::Help::ExtendedTip::get();
1230  if ( bExtendedHelp != Help::IsBalloonHelpEnabled() )
1231  bExtendedHelp ? Help::EnableBalloonHelp() : Help::DisableBalloonHelp();
1232 
1233  batch->commit();
1234  }
1235  break;
1236  case SID_LANGUAGE_OPTIONS :
1237  {
1238  OfaTreeOptionsDialog::ApplyLanguageOptions(rSet);
1239  }
1240  break;
1241  case SID_INET_DLG :
1242  case SID_FILTER_DLG:
1243  SfxGetpApp()->SetOptions( rSet );
1244  break;
1245 
1246  case SID_SB_STARBASEOPTIONS:
1247  ::offapp::ConnectionPoolConfig::SetOptions( rSet );
1248  svx::DbRegisteredNamesConfig::SetOptions(rSet);
1249  break;
1250 
1251  case SID_SCH_EDITOPTIONS:
1252  // nothing to do. Chart options only apply to newly created charts
1253  break;
1254 
1255  default:
1256  {
1257  OSL_FAIL( "Unhandled option in ApplyItemSet" );
1258  }
1259  break;
1260  }
1261 
1262 }
1263 void OfaTreeOptionsDialog::ApplyLanguageOptions(const SfxItemSet& rSet)
1264 {
1265  bool bSaveSpellCheck = false;
1266  const SfxPoolItem* pItem = nullptr;
1267 
1268  Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
1269  Reference< XLinguProperties > xProp = LinguProperties::create( xContext );
1270  if ( SfxItemState::SET == rSet.GetItemState(SID_ATTR_HYPHENREGION, false, &pItem ) )
1271  {
1272  const SfxHyphenRegionItem* pHyphenItem = static_cast<const SfxHyphenRegionItem*>(pItem);
1273 
1274  xProp->setHyphMinLeading( static_cast<sal_Int16>(pHyphenItem->GetMinLead()) );
1275  xProp->setHyphMinTrailing( static_cast<sal_Int16>(pHyphenItem->GetMinTrail()) );
1276  bSaveSpellCheck = true;
1277  }
1278 
1279  SfxViewFrame *pViewFrame = SfxViewFrame::Current();
1280  if ( pViewFrame )
1281  {
1282  SfxDispatcher* pDispatch = pViewFrame->GetDispatcher();
1283  pItem = nullptr;
1284  if(SfxItemState::SET == rSet.GetItemState( SID_ATTR_LANGUAGE, false, &pItem ))
1285  {
1286  pDispatch->ExecuteList(pItem->Which(), SfxCallMode::SYNCHRON, { pItem });
1287  bSaveSpellCheck = true;
1288  }
1289  if(SfxItemState::SET == rSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE, false, &pItem ))
1290  {
1291  pDispatch->ExecuteList(pItem->Which(), SfxCallMode::SYNCHRON, { pItem });
1292  bSaveSpellCheck = true;
1293  }
1294  if(SfxItemState::SET == rSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE, false, &pItem ))
1295  {
1296  pDispatch->ExecuteList(pItem->Which(), SfxCallMode::SYNCHRON, { pItem });
1297  bSaveSpellCheck = true;
1298  }
1299 
1300  if( SfxItemState::SET == rSet.GetItemState(SID_AUTOSPELL_CHECK, false, &pItem ))
1301  {
1302  bool bOnlineSpelling = static_cast<const SfxBoolItem*>(pItem)->GetValue();
1303  pDispatch->ExecuteList(SID_AUTOSPELL_CHECK,
1304  SfxCallMode::ASYNCHRON|SfxCallMode::RECORD, { pItem });
1305 
1306  xProp->setIsSpellAuto( bOnlineSpelling );
1307  }
1308 
1309  if( bSaveSpellCheck )
1310  {
1313  pDispatch->Execute(SID_SPELLCHECKER_CHANGED, SfxCallMode::ASYNCHRON);
1314  }
1315  }
1316 
1317  if( SfxItemState::SET == rSet.GetItemState(SID_OPT_LOCALE_CHANGED, false, &pItem ))
1318  {
1319  SfxViewFrame* _pViewFrame = SfxViewFrame::GetFirst();
1320  while ( _pViewFrame )
1321  {
1322  _pViewFrame->GetDispatcher()->ExecuteList(pItem->Which(),
1323  SfxCallMode::ASYNCHRON, { pItem });
1324  _pViewFrame = SfxViewFrame::GetNext( *_pViewFrame );
1325  }
1326  }
1327 }
1328 
1329 static OUString getCurrentFactory_Impl( const Reference< XFrame >& _xFrame )
1330 {
1331  OUString sIdentifier;
1332  Reference < XFrame > xCurrentFrame( _xFrame );
1333  Reference < XModuleManager2 > xModuleManager = ModuleManager::create(::comphelper::getProcessComponentContext());
1334  if ( !xCurrentFrame.is() )
1335  {
1336  Reference< XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
1337  xCurrentFrame = xDesktop->getCurrentFrame();
1338  }
1339 
1340  if ( xCurrentFrame.is() )
1341  {
1342  try
1343  {
1344  sIdentifier = xModuleManager->identify( xCurrentFrame );
1345  }
1346  catch ( css::frame::UnknownModuleException& )
1347  {
1348  SAL_INFO( "cui.options", "unknown module" );
1349  }
1350  catch ( Exception const & )
1351  {
1352  TOOLS_WARN_EXCEPTION( "cui.options", "getActiveModule_Impl(): exception of XModuleManager::identify()" );
1353  }
1354  }
1355 
1356  return sIdentifier;
1357 }
1358 
1359 void OfaTreeOptionsDialog::Initialize( const Reference< XFrame >& _xFrame )
1360 {
1361  sal_uInt16 nGroup = 0;
1362 
1363  SvtOptionsDialogOptions aOptionsDlgOpt;
1364  sal_uInt16 nPageId;
1365 
1366  // %PRODUCTNAME options
1367  if ( !lcl_isOptionHidden( SID_GENERAL_OPTIONS, aOptionsDlgOpt ) )
1368  {
1369  setGroupName(u"ProductName", CuiResId(SID_GENERAL_OPTIONS_RES[0].first));
1370  nGroup = AddGroup(CuiResId(SID_GENERAL_OPTIONS_RES[0].first), nullptr, nullptr, SID_GENERAL_OPTIONS );
1371  const sal_uInt16 nEnd = static_cast<sal_uInt16>(SAL_N_ELEMENTS(SID_GENERAL_OPTIONS_RES));
1372 
1373  for (sal_uInt16 i = 1; i < nEnd; ++i)
1374  {
1375  OUString sNewTitle = CuiResId(SID_GENERAL_OPTIONS_RES[i].first);
1376  nPageId = SID_GENERAL_OPTIONS_RES[i].second;
1377  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1378  continue;
1379 
1380  // Disable Online Update page if service not installed
1381  if( RID_SVXPAGE_ONLINEUPDATE == nPageId )
1382  {
1383  try
1384  {
1385  Reference < XInterface > xService( setup::UpdateCheck::create( ::comphelper::getProcessComponentContext() ) );
1386  if( ! xService.is() )
1387  continue;
1388  }
1389  catch ( css::uno::DeploymentException& )
1390  {
1391  continue;
1392  }
1393  }
1394 
1395  // Disable Basic IDE options, if experimental features are not enabled
1396  if( RID_SVXPAGE_BASICIDE_OPTIONS == nPageId )
1397  {
1398  if( ! officecfg::Office::Common::Misc::ExperimentalMode::get() )
1399  continue;
1400  }
1401 
1402  AddTabPage( nPageId, sNewTitle, nGroup );
1403  }
1404  }
1405 
1406  // Load and Save options
1407  if ( !lcl_isOptionHidden( SID_FILTER_DLG, aOptionsDlgOpt ) )
1408  {
1409  setGroupName( u"LoadSave", CuiResId(SID_FILTER_DLG_RES[0].first) );
1410  nGroup = AddGroup( CuiResId(SID_FILTER_DLG_RES[0].first), nullptr, nullptr, SID_FILTER_DLG );
1411  for ( size_t i = 1; i < SAL_N_ELEMENTS(SID_FILTER_DLG_RES); ++i )
1412  {
1413  nPageId = static_cast<sal_uInt16>(SID_FILTER_DLG_RES[i].second);
1414  if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1415  AddTabPage( nPageId, CuiResId(SID_FILTER_DLG_RES[i].first), nGroup );
1416  }
1417  }
1418 
1419  // Language options
1420  SvtCTLOptions aCTLLanguageOptions;
1421  if ( !lcl_isOptionHidden( SID_LANGUAGE_OPTIONS, aOptionsDlgOpt ) )
1422  {
1423  setGroupName(u"LanguageSettings", CuiResId(SID_LANGUAGE_OPTIONS_RES[0].first));
1424  nGroup = AddGroup(CuiResId(SID_LANGUAGE_OPTIONS_RES[0].first), nullptr, nullptr, SID_LANGUAGE_OPTIONS );
1425  for (size_t i = 1; i < SAL_N_ELEMENTS(SID_LANGUAGE_OPTIONS_RES); ++i)
1426  {
1427  nPageId = static_cast<sal_uInt16>(SID_LANGUAGE_OPTIONS_RES[i].second);
1428  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1429  continue;
1430  if ( ( RID_SVXPAGE_JSEARCH_OPTIONS != nPageId || SvtCJKOptions::IsJapaneseFindEnabled() ) &&
1431  ( RID_SVXPAGE_ASIAN_LAYOUT != nPageId || SvtCJKOptions::IsAsianTypographyEnabled() ) &&
1432  ( RID_SVXPAGE_OPTIONS_CTL != nPageId || aCTLLanguageOptions.IsCTLFontEnabled() ) )
1433  AddTabPage(nPageId, CuiResId(SID_LANGUAGE_OPTIONS_RES[i].first), nGroup);
1434  }
1435  }
1436 
1437  OUString aFactory = getCurrentFactory_Impl( _xFrame );
1438  DBG_ASSERT( GetModuleIdentifier( _xFrame ) == aFactory, "S H I T!!!" );
1439 
1440  // Writer and Writer/Web options
1441  SvtModuleOptions aModuleOpt;
1442  if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER ) )
1443  {
1444  // text document
1445  if ( aFactory == "com.sun.star.text.TextDocument"
1446  || aFactory == "com.sun.star.text.WebDocument"
1447  || aFactory == "com.sun.star.text.GlobalDocument" )
1448  {
1449  SfxModule* pSwMod = SfxApplication::GetModule(SfxToolsModule::Writer);
1450  if ( !lcl_isOptionHidden( SID_SW_EDITOPTIONS, aOptionsDlgOpt ) )
1451  {
1452  if ( aFactory == "com.sun.star.text.WebDocument" )
1453  setGroupName( u"WriterWeb", CuiResId(SID_SW_EDITOPTIONS_RES[0].first) );
1454  else
1455  setGroupName( u"Writer", CuiResId(SID_SW_EDITOPTIONS_RES[0].first) );
1456  nGroup = AddGroup(CuiResId(SID_SW_EDITOPTIONS_RES[0].first), pSwMod, pSwMod, SID_SW_EDITOPTIONS );
1457  for ( size_t i = 1; i < SAL_N_ELEMENTS(SID_SW_EDITOPTIONS_RES); ++i )
1458  {
1459  nPageId = static_cast<sal_uInt16>(SID_SW_EDITOPTIONS_RES[i].second);
1460  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1461  continue;
1462  if ( ( RID_SW_TP_STD_FONT_CJK != nPageId || SvtCJKOptions::IsCJKFontEnabled() ) &&
1463  ( RID_SW_TP_STD_FONT_CTL != nPageId || aCTLLanguageOptions.IsCTLFontEnabled() ) &&
1464  ( RID_SW_TP_MAILCONFIG != nPageId || MailMergeCfg_Impl().IsEmailSupported() ) )
1465  AddTabPage( nPageId, CuiResId(SID_SW_EDITOPTIONS_RES[i].first), nGroup );
1466  }
1467 #ifdef DBG_UTIL
1468  AddTabPage( RID_SW_TP_OPTTEST_PAGE, "Internal Test", nGroup );
1469 #endif
1470  }
1471 
1472  // HTML documents
1473  if ( !lcl_isOptionHidden( SID_SW_ONLINEOPTIONS, aOptionsDlgOpt ) )
1474  {
1475  nGroup = AddGroup(CuiResId(SID_SW_ONLINEOPTIONS_RES[0].first), pSwMod, pSwMod, SID_SW_ONLINEOPTIONS );
1476  for( size_t i = 1; i < SAL_N_ELEMENTS(SID_SW_ONLINEOPTIONS_RES); ++i )
1477  {
1478  nPageId = static_cast<sal_uInt16>(SID_SW_ONLINEOPTIONS_RES[i].second);
1479  if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1480  AddTabPage(nPageId, CuiResId(SID_SW_ONLINEOPTIONS_RES[i].first), nGroup);
1481  }
1482 #ifdef DBG_UTIL
1483  AddTabPage( RID_SW_TP_OPTTEST_PAGE, "Internal Test", nGroup );
1484 #endif
1485  }
1486  }
1487  }
1488 
1489  // Calc options
1490  if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC ) )
1491  {
1492  if ( aFactory == "com.sun.star.sheet.SpreadsheetDocument" )
1493  {
1494  if ( !lcl_isOptionHidden( SID_SC_EDITOPTIONS, aOptionsDlgOpt ) )
1495  {
1496  SfxModule* pScMod = SfxApplication::GetModule( SfxToolsModule::Calc );
1497  setGroupName( u"Calc", CuiResId(SID_SC_EDITOPTIONS_RES[0].first) );
1498  nGroup = AddGroup( CuiResId(SID_SC_EDITOPTIONS_RES[0].first), pScMod, pScMod, SID_SC_EDITOPTIONS );
1499  const sal_uInt16 nCount = static_cast<sal_uInt16>(SAL_N_ELEMENTS(SID_SC_EDITOPTIONS_RES));
1500  for ( sal_uInt16 i = 1; i < nCount; ++i )
1501  {
1502  nPageId = static_cast<sal_uInt16>(SID_SC_EDITOPTIONS_RES[i].second);
1503  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1504  continue;
1505 
1506  AddTabPage( nPageId, CuiResId(SID_SC_EDITOPTIONS_RES[i].first), nGroup );
1507  }
1508  }
1509  }
1510  }
1511 
1512  // Impress options
1513  SfxModule* pSdMod = SfxApplication::GetModule( SfxToolsModule::Draw );
1514  if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::IMPRESS ) )
1515  {
1516  if ( aFactory == "com.sun.star.presentation.PresentationDocument" )
1517  {
1518  if ( !lcl_isOptionHidden( SID_SD_EDITOPTIONS, aOptionsDlgOpt ) )
1519  {
1520  setGroupName( u"Impress", CuiResId(SID_SD_EDITOPTIONS_RES[0].first) );
1521  nGroup = AddGroup( CuiResId(SID_SD_EDITOPTIONS_RES[0].first), pSdMod, pSdMod, SID_SD_EDITOPTIONS );
1522  const sal_uInt16 nCount = static_cast<sal_uInt16>(SAL_N_ELEMENTS(SID_SD_EDITOPTIONS_RES));
1523  for ( sal_uInt16 i = 1; i < nCount; ++i )
1524  {
1525  nPageId = static_cast<sal_uInt16>(SID_SD_EDITOPTIONS_RES[i].second);
1526  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1527  continue;
1528 
1529  AddTabPage( nPageId, CuiResId(SID_SD_EDITOPTIONS_RES[i].first), nGroup );
1530  }
1531  }
1532  }
1533  }
1534 
1535  // Draw options
1536  if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DRAW ) )
1537  {
1538  if ( aFactory == "com.sun.star.drawing.DrawingDocument" )
1539  {
1540  if ( !lcl_isOptionHidden( SID_SD_GRAPHIC_OPTIONS, aOptionsDlgOpt ) )
1541  {
1542  setGroupName( u"Draw", CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[0].first) );
1543  nGroup = AddGroup( CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[0].first), pSdMod, pSdMod, SID_SD_GRAPHIC_OPTIONS );
1544  const sal_uInt16 nCount = static_cast<sal_uInt16>(SAL_N_ELEMENTS(SID_SD_GRAPHIC_OPTIONS_RES));
1545  for ( sal_uInt16 i = 1; i < nCount; ++i )
1546  {
1547  nPageId = static_cast<sal_uInt16>(SID_SD_GRAPHIC_OPTIONS_RES[i].second);
1548  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1549  continue;
1550 
1551  AddTabPage( nPageId, CuiResId(SID_SD_GRAPHIC_OPTIONS_RES[i].first), nGroup );
1552  }
1553  }
1554  }
1555  }
1556 
1557  // Math options
1558  if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::MATH ) )
1559  {
1560  if ( aFactory == "com.sun.star.formula.FormulaProperties" )
1561  {
1562  if ( !lcl_isOptionHidden( SID_SM_EDITOPTIONS, aOptionsDlgOpt ) )
1563  {
1564  SfxModule* pSmMod = SfxApplication::GetModule(SfxToolsModule::Math);
1565  setGroupName( u"Math", CuiResId(SID_SM_EDITOPTIONS_RES[0].first) );
1566  nGroup = AddGroup(CuiResId(SID_SM_EDITOPTIONS_RES[0].first), pSmMod, pSmMod, SID_SM_EDITOPTIONS );
1567  for ( size_t i = 1; i < SAL_N_ELEMENTS(SID_SM_EDITOPTIONS_RES); ++i )
1568  {
1569  nPageId = static_cast<sal_uInt16>(SID_SM_EDITOPTIONS_RES[i].second);
1570  if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1571  AddTabPage( nPageId, CuiResId(SID_SM_EDITOPTIONS_RES[i].first), nGroup );
1572  }
1573  }
1574  }
1575  }
1576 
1577  // Database - needed only if there is an application which integrates with databases
1578  if ( !lcl_isOptionHidden( SID_SB_STARBASEOPTIONS, aOptionsDlgOpt ) &&
1579  ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DATABASE )
1580  || aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER )
1581  || aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC )
1582  ) )
1583  {
1584  setGroupName( u"Base", CuiResId(SID_SB_STARBASEOPTIONS_RES[0].first) );
1585  nGroup = AddGroup( CuiResId(SID_SB_STARBASEOPTIONS_RES[0].first), nullptr, nullptr, SID_SB_STARBASEOPTIONS );
1586  for ( size_t i = 1; i < SAL_N_ELEMENTS(SID_SB_STARBASEOPTIONS_RES); ++i )
1587  {
1588  nPageId = static_cast<sal_uInt16>(SID_SB_STARBASEOPTIONS_RES[i].second);
1589  if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1590  AddTabPage( nPageId, CuiResId(SID_SB_STARBASEOPTIONS_RES[i].first), nGroup );
1591  }
1592  }
1593 
1594  // Chart options (always installed and active)
1595  if ( !lcl_isOptionHidden( SID_SCH_EDITOPTIONS, aOptionsDlgOpt ) )
1596  {
1597  setGroupName( u"Charts", CuiResId(SID_SCH_EDITOPTIONS_RES[0].first) );
1598  nGroup = AddGroup( CuiResId(SID_SCH_EDITOPTIONS_RES[0].first), nullptr, nullptr, SID_SCH_EDITOPTIONS );
1599  for ( size_t i = 1; i < SAL_N_ELEMENTS(SID_SCH_EDITOPTIONS_RES); ++i )
1600  {
1601  nPageId = static_cast<sal_uInt16>(SID_SCH_EDITOPTIONS_RES[i].second);
1602  if ( !lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1603  AddTabPage( nPageId, CuiResId(SID_SCH_EDITOPTIONS_RES[i].first), nGroup );
1604  }
1605  }
1606 
1607  // Internet options
1608  if ( lcl_isOptionHidden( SID_INET_DLG, aOptionsDlgOpt ) )
1609  return;
1610 
1611  setGroupName(u"Internet", CuiResId(SID_INET_DLG_RES[0].first));
1612  nGroup = AddGroup(CuiResId(SID_INET_DLG_RES[0].first), nullptr, nullptr, SID_INET_DLG );
1613 
1614  for ( size_t i = 1; i < SAL_N_ELEMENTS(SID_INET_DLG_RES); ++i )
1615  {
1616  nPageId = static_cast<sal_uInt16>(SID_INET_DLG_RES[i].second);
1617  if ( lcl_isOptionHidden( nPageId, aOptionsDlgOpt ) )
1618  continue;
1619 #if defined(_WIN32)
1620  // Disable E-mail tab-page on Windows
1621  if ( nPageId == RID_SVXPAGE_INET_MAIL )
1622  continue;
1623 #endif
1624  AddTabPage( nPageId, CuiResId(SID_INET_DLG_RES[i].first), nGroup );
1625  }
1626 }
1627 
1628 static bool isNodeActive( OptionsNode const * pNode, Module* pModule )
1629 {
1630  if ( !pNode )
1631  return false;
1632 
1633  // Node for all modules active?
1634  if ( pNode->m_bAllModules )
1635  return true;
1636 
1637  // OOo-Nodes (Writer, Calc, Impress...) are active if node is already inserted
1638  if ( !getGroupName( pNode->m_sId, false ).isEmpty() )
1639  return true;
1640 
1641  // no module -> not active
1642  if ( !pModule )
1643  return false;
1644 
1645  // search node in active module
1646  if ( pModule->m_bActive )
1647  {
1648  for (auto const& j : pModule->m_aNodeList)
1649  if ( j->m_sId == pNode->m_sId )
1650  return true;
1651  }
1652  return false;
1653 }
1654 
1655 void OfaTreeOptionsDialog::LoadExtensionOptions( std::u16string_view rExtensionId )
1656 {
1657  std::unique_ptr<Module> pModule;
1658 
1659  // when called by Tools - Options then load nodes of active module
1660  if ( rExtensionId.empty() )
1661  {
1662  pModule = LoadModule( GetModuleIdentifier( Reference< XFrame >() ) );
1663  }
1664 
1665  VectorOfNodes aNodeList = LoadNodes( pModule.get(), rExtensionId );
1666  InsertNodes( aNodeList );
1667 }
1668 
1669 OUString OfaTreeOptionsDialog::GetModuleIdentifier( const Reference< XFrame >& rFrame )
1670 {
1671  OUString sModule;
1672  Reference < XFrame > xCurrentFrame( rFrame );
1673  Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
1674  Reference < XModuleManager2 > xModuleManager = ModuleManager::create(xContext);
1675 
1676  if ( !xCurrentFrame.is() )
1677  {
1678  Reference < XDesktop2 > xDesktop = Desktop::create( xContext );
1679  xCurrentFrame = xDesktop->getCurrentFrame();
1680  }
1681 
1682  if ( xCurrentFrame.is() )
1683  {
1684  try
1685  {
1686  sModule = xModuleManager->identify( xCurrentFrame );
1687  }
1688  catch ( css::frame::UnknownModuleException& )
1689  {
1690  SAL_INFO( "cui.options", "unknown module" );
1691  }
1692  catch ( Exception const & )
1693  {
1694  TOOLS_WARN_EXCEPTION( "cui.options", "OfaTreeOptionsDialog::GetModuleIdentifier(): exception of XModuleManager::identify()");
1695  }
1696  }
1697  return sModule;
1698 }
1699 
1700 std::unique_ptr<Module> OfaTreeOptionsDialog::LoadModule(
1701  std::u16string_view rModuleIdentifier )
1702 {
1703  std::unique_ptr<Module> pModule;
1704  Reference< XNameAccess > xSet(
1705  officecfg::Office::OptionsDialog::Modules::get());
1706 
1707  const Sequence< OUString > seqNames = xSet->getElementNames();
1708  for ( const OUString& rModule : seqNames )
1709  {
1710  if ( rModuleIdentifier == rModule )
1711  {
1712  // current active module found
1713  pModule.reset(new Module);
1714  pModule->m_bActive = true;
1715 
1716  Reference< XNameAccess > xModAccess;
1717  xSet->getByName( rModule ) >>= xModAccess;
1718  if ( xModAccess.is() )
1719  {
1720  // load the nodes of this module
1721  Reference< XNameAccess > xNodeAccess;
1722  xModAccess->getByName( "Nodes" ) >>= xNodeAccess;
1723  if ( xNodeAccess.is() )
1724  {
1725  const Sequence< OUString > xTemp = xNodeAccess->getElementNames();
1726  Reference< XNameAccess > xAccess;
1727  sal_Int32 nIndex = -1;
1728  for ( const OUString& rNode : xTemp)
1729  {
1730  xNodeAccess->getByName( rNode ) >>= xAccess;
1731  if ( xAccess.is() )
1732  {
1733  xAccess->getByName( "Index" ) >>= nIndex;
1734  if ( nIndex < 0 )
1735  // append nodes with index < 0
1736  pModule->m_aNodeList.push_back(
1737  std::unique_ptr<OrderedEntry>(new OrderedEntry(nIndex, rNode)));
1738  else
1739  {
1740  // search position of the node
1741  std::vector<OrderedEntry *>::size_type y = 0;
1742  for ( ; y < pModule->m_aNodeList.size(); ++y )
1743  {
1744  sal_Int32 nNodeIdx = pModule->m_aNodeList[y]->m_nIndex;
1745  if ( nNodeIdx < 0 || nNodeIdx > nIndex )
1746  break;
1747  }
1748  // and insert the node on this position
1749  pModule->m_aNodeList.insert(
1750  pModule->m_aNodeList.begin() + y,
1751  std::unique_ptr<OrderedEntry>(new OrderedEntry( nIndex, rNode )) );
1752  }
1753  }
1754  }
1755  }
1756  }
1757  break;
1758  }
1759  }
1760  return pModule;
1761 }
1762 
1763 VectorOfNodes OfaTreeOptionsDialog::LoadNodes(
1764  Module* pModule, std::u16string_view rExtensionId)
1765 {
1766  VectorOfNodes aOutNodeList;
1767 
1768  Reference< XNameAccess > xSet(
1769  officecfg::Office::OptionsDialog::Nodes::get());
1770  VectorOfNodes aNodeList;
1771  const Sequence< OUString > seqNames = xSet->getElementNames();
1772 
1773  for ( OUString const & sGroupName : seqNames )
1774  {
1775  Reference< XNameAccess > xNodeAccess;
1776  xSet->getByName( sGroupName ) >>= xNodeAccess;
1777 
1778  if ( xNodeAccess.is() )
1779  {
1780  OUString sNodeId, sLabel, sPageURL;
1781  bool bAllModules = false;
1782 
1783  sNodeId = sGroupName;
1784  xNodeAccess->getByName( "Label" ) >>= sLabel;
1785  xNodeAccess->getByName( "OptionsPage" ) >>= sPageURL;
1786  xNodeAccess->getByName( "AllModules" ) >>= bAllModules;
1787 
1788  if ( sLabel.isEmpty() )
1789  sLabel = sGroupName;
1790  OUString sTemp = getGroupName( sLabel, !rExtensionId.empty() );
1791  if ( !sTemp.isEmpty() )
1792  sLabel = sTemp;
1793  std::unique_ptr<OptionsNode> pNode(new OptionsNode(sNodeId, sLabel, bAllModules));
1794 
1795  if ( rExtensionId.empty() && !isNodeActive( pNode.get(), pModule ) )
1796  {
1797  continue;
1798  }
1799 
1800  Reference< XNameAccess > xLeavesSet;
1801  xNodeAccess->getByName( "Leaves" ) >>= xLeavesSet;
1802  if ( xLeavesSet.is() )
1803  {
1804  const Sequence< OUString > seqLeaves = xLeavesSet->getElementNames();
1805  for ( OUString const & leafName : seqLeaves )
1806  {
1807  Reference< XNameAccess > xLeaveAccess;
1808  xLeavesSet->getByName( leafName ) >>= xLeaveAccess;
1809 
1810  if ( xLeaveAccess.is() )
1811  {
1812  OUString sId, sLeafLabel, sEventHdl, sLeafURL, sLeafGrpId;
1813  sal_Int32 nLeafGrpIdx = 0;
1814 
1815  xLeaveAccess->getByName( "Id" ) >>= sId;
1816  xLeaveAccess->getByName( "Label" ) >>= sLeafLabel;
1817  xLeaveAccess->getByName( "OptionsPage" ) >>= sLeafURL;
1818  xLeaveAccess->getByName( "EventHandlerService" ) >>= sEventHdl;
1819  xLeaveAccess->getByName( "GroupId" ) >>= sLeafGrpId;
1820  xLeaveAccess->getByName( "GroupIndex" ) >>= nLeafGrpIdx;
1821 
1822  if ( rExtensionId.empty() || sId == rExtensionId )
1823  {
1824  std::unique_ptr<OptionsLeaf> pLeaf(new OptionsLeaf(
1825  sLeafLabel, sLeafURL, sEventHdl, sLeafGrpId, nLeafGrpIdx ));
1826 
1827  if ( !sLeafGrpId.isEmpty() )
1828  {
1829  bool bAlreadyOpened = false;
1830  if ( !pNode->m_aGroupedLeaves.empty() )
1831  {
1832  for (auto & rGroup : pNode->m_aGroupedLeaves)
1833  {
1834  if ( !rGroup.empty() &&
1835  rGroup[0]->m_sGroupId == sLeafGrpId )
1836  {
1837  std::vector<std::unique_ptr<OptionsLeaf>>::size_type l = 0;
1838  for ( ; l < rGroup.size(); ++l )
1839  {
1840  if ( rGroup[l]->m_nGroupIndex >= nLeafGrpIdx )
1841  break;
1842  }
1843  rGroup.insert( rGroup.begin() + l, std::move(pLeaf) );
1844  bAlreadyOpened = true;
1845  break;
1846  }
1847  }
1848  }
1849  if ( !bAlreadyOpened )
1850  {
1851  std::vector< std::unique_ptr<OptionsLeaf> > aGroupedLeaves;
1852  aGroupedLeaves.push_back( std::move(pLeaf) );
1853  pNode->m_aGroupedLeaves.push_back( std::move(aGroupedLeaves) );
1854  }
1855  }
1856  else
1857  pNode->m_aLeaves.push_back( std::move(pLeaf) );
1858  }
1859  }
1860  }
1861  }
1862 
1863  // do not insert nodes without leaves
1864  if ( !pNode->m_aLeaves.empty() || !pNode->m_aGroupedLeaves.empty() )
1865  {
1866  pModule ? aNodeList.push_back( std::move(pNode) ) : aOutNodeList.push_back( std::move(pNode) );
1867  }
1868  }
1869  }
1870 
1871  if ( pModule && !aNodeList.empty() )
1872  {
1873  for ( auto const & i: pModule->m_aNodeList )
1874  {
1875  OUString sNodeId = i->m_sId;
1876  for ( auto j = aNodeList.begin(); j != aNodeList.end(); ++j )
1877  {
1878  if ( (*j)->m_sId == sNodeId )
1879  {
1880  aOutNodeList.push_back( std::move(*j) );
1881  aNodeList.erase( j );
1882  break;
1883  }
1884  }
1885  }
1886 
1887  for ( auto & i: aNodeList )
1888  aOutNodeList.push_back( std::move(i) );
1889  }
1890  return aOutNodeList;
1891 }
1892 
1893 static sal_uInt16 lcl_getGroupId( std::u16string_view rGroupName, const weld::TreeView& rTreeLB )
1894 {
1895  sal_uInt16 nRet = 0;
1896 
1897  std::unique_ptr<weld::TreeIter> xEntry = rTreeLB.make_iterator();
1898  bool bEntry = rTreeLB.get_iter_first(*xEntry);
1899  while (bEntry)
1900  {
1901  if (!rTreeLB.get_iter_depth(*xEntry))
1902  {
1903  OUString sTemp(rTreeLB.get_text(*xEntry));
1904  if (sTemp == rGroupName)
1905  return nRet;
1906  nRet++;
1907  }
1908  bEntry = rTreeLB.iter_next(*xEntry);
1909  }
1910 
1911  return USHRT_MAX;
1912 }
1913 
1914 static void lcl_insertLeaf(
1915  OfaTreeOptionsDialog* pDlg, OptionsNode const * pNode, OptionsLeaf const * pLeaf, const weld::TreeView& rTreeLB )
1916 {
1917  sal_uInt16 nGrpId = lcl_getGroupId( pNode->m_sLabel, rTreeLB );
1918  if ( USHRT_MAX == nGrpId )
1919  {
1920  sal_uInt16 nNodeGrpId = getGroupNodeId( pNode->m_sId );
1921  nGrpId = pDlg->AddGroup( pNode->m_sLabel, nullptr, nullptr, nNodeGrpId );
1922  }
1923  OptionsPageInfo* pInfo = pDlg->AddTabPage( 0, pLeaf->m_sLabel, nGrpId );
1924  pInfo->m_sPageURL = pLeaf->m_sPageURL;
1925  pInfo->m_sEventHdl = pLeaf->m_sEventHdl;
1926 }
1927 
1928 void OfaTreeOptionsDialog::InsertNodes( const VectorOfNodes& rNodeList )
1929 {
1930  for (auto const& node : rNodeList)
1931  {
1932  if ( !node->m_aLeaves.empty() || !node->m_aGroupedLeaves.empty() )
1933  {
1934  for ( auto const & j: node->m_aGroupedLeaves )
1935  {
1936  for ( size_t k = 0; k < j.size(); ++k )
1937  {
1938  lcl_insertLeaf( this, node.get(), j[k].get(), *xTreeLB );
1939  }
1940  }
1941 
1942  for ( auto const & j: node->m_aLeaves )
1943  {
1944  lcl_insertLeaf( this, node.get(), j.get(), *xTreeLB );
1945  }
1946  }
1947  }
1948 }
1949 
1950 void OfaTreeOptionsDialog::SetNeedsRestart( svtools::RestartReason eReason)
1951 {
1952  bNeedsRestart = true;
1953  eRestartReason = eReason;
1954 }
1955 
1956 short OfaTreeOptionsDialog::run()
1957 {
1958  std::unique_ptr< SvxDicListChgClamp > pClamp;
1959  if ( !bIsFromExtensionManager )
1960  {
1961  // collect all DictionaryList Events while the dialog is executed
1962  Reference<css::linguistic2::XSearchableDictionaryList> xDictionaryList(LinguMgr::GetDictionaryList());
1963  pClamp.reset( new SvxDicListChgClamp( xDictionaryList ) );
1964  }
1965 
1966  return SfxOkDialogController::run();
1967 }
1968 
1969 // class ExtensionsTabPage -----------------------------------------------
1970 ExtensionsTabPage::ExtensionsTabPage(
1971  weld::Container* pParent, const OUString& rPageURL,
1972  const OUString& rEvtHdl, const Reference< awt::XContainerWindowProvider >& rProvider )
1973  : m_pContainer(pParent)
1974  , m_sPageURL(rPageURL)
1975  , m_sEventHdl(rEvtHdl)
1976  , m_xWinProvider(rProvider)
1977 {
1978 }
1979 
1980 ExtensionsTabPage::~ExtensionsTabPage()
1981 {
1982  Hide();
1983  DeactivatePage();
1984 
1985  if ( m_xPage.is() )
1986  {
1987  try
1988  {
1989  m_xPage->dispose();
1990  }
1991  catch (const Exception&)
1992  {
1993  }
1994  m_xPage.clear();
1995  }
1996 
1997  if ( m_xPageParent.is() )
1998  {
1999  try
2000  {
2001  m_xPageParent->dispose();
2002  }
2003  catch (const Exception&)
2004  {
2005  }
2006  m_xPageParent.clear();
2007  }
2008 }
2009 
2010 void ExtensionsTabPage::CreateDialogWithHandler()
2011 {
2012  try
2013  {
2014  bool bWithHandler = !m_sEventHdl.isEmpty();
2015  if ( bWithHandler )
2016  {
2017  Reference < XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
2018  m_xEventHdl.set( xFactory->createInstance( m_sEventHdl ), UNO_QUERY );
2019  }
2020 
2021  if ( !bWithHandler || m_xEventHdl.is() )
2022  {
2023  m_xPageParent = m_pContainer->CreateChildFrame();
2024  Reference<awt::XWindowPeer> xParent(m_xPageParent, UNO_QUERY);
2025  m_xPage =
2026  m_xWinProvider->createContainerWindow(
2027  m_sPageURL, OUString(), xParent, m_xEventHdl );
2028 
2029  Reference< awt::XControl > xPageControl( m_xPage, UNO_QUERY );
2030  if ( xPageControl.is() )
2031  {
2032  Reference< awt::XWindowPeer > xWinPeer( xPageControl->getPeer() );
2033  if ( xWinPeer.is() )
2034  {
2035  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWinPeer );
2036  if ( pWindow )
2037  pWindow->SetStyle( pWindow->GetStyle() | WB_DIALOGCONTROL | WB_CHILDDLGCTRL );
2038  }
2039  }
2040  }
2041  }
2042  catch (const Exception&)
2043  {
2044  TOOLS_WARN_EXCEPTION( "cui.options", "ExtensionsTabPage::CreateDialogWithHandler(): exception of XDialogProvider2::createDialogWithHandler()");
2045  }
2046 }
2047 
2048 bool ExtensionsTabPage::DispatchAction( const OUString& rAction )
2049 {
2050  bool bRet = false;
2051  if ( m_xEventHdl.is() )
2052  {
2053  try
2054  {
2055  bRet = m_xEventHdl->callHandlerMethod( m_xPage, Any( rAction ), "external_event" );
2056  }
2057  catch ( Exception const & )
2058  {
2059  TOOLS_WARN_EXCEPTION( "cui.options", "ExtensionsTabPage::DispatchAction(): exception of XDialogEventHandler::callHandlerMethod()" );
2060  }
2061  }
2062  return bRet;
2063 }
2064 
2065 void ExtensionsTabPage::Show()
2066 {
2067  if (!m_xPageParent.is())
2068  return;
2069 
2070  VclPtr<vcl::Window> xPageParent = VCLUnoHelper::GetWindow(m_xPageParent);
2071  if (xPageParent)
2072  {
2073  // NoActivate otherwise setVisible will call Window::Show which will grab
2074  // focus to the page by default
2075  xPageParent->Show(true, ShowFlags::NoActivate);
2076  }
2077 
2078  m_xPageParent->setVisible(true);
2079 }
2080 
2081 void ExtensionsTabPage::Hide()
2082 {
2083  if (!m_xPageParent.is())
2084  return;
2085  m_xPageParent->setVisible(false);
2086 }
2087 
2088 void ExtensionsTabPage::ActivatePage()
2089 {
2090  if ( !m_xPage.is() )
2091  {
2092  CreateDialogWithHandler();
2093 
2094  if ( m_xPage.is() )
2095  {
2096  auto aWindowRect = m_xPageParent->getPosSize();
2097  m_xPage->setPosSize(0, 0, aWindowRect.Width, aWindowRect.Height, awt::PosSize::POSSIZE);
2098  if ( !m_sEventHdl.isEmpty() )
2099  DispatchAction( "initialize" );
2100  }
2101  }
2102 
2103  if ( m_xPage.is() )
2104  {
2105  m_xPage->setVisible( true );
2106  }
2107 }
2108 
2109 void ExtensionsTabPage::DeactivatePage()
2110 {
2111  if ( m_xPage.is() )
2112  m_xPage->setVisible( false );
2113 }
2114 
2115 void ExtensionsTabPage::ResetPage()
2116 {
2117  DispatchAction( "back" );
2118  ActivatePage();
2119 }
2120 
2121 void ExtensionsTabPage::SavePage()
2122 {
2123  DispatchAction( "ok" );
2124 }
2125 
2126 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SvtViewOptions::SetUserItem
void SetUserItem(const OUString &sName, const css::uno::Any &aValue)
OptionsPageInfo::OptionsPageInfo
OptionsPageInfo(sal_uInt16 nId)
Definition: treeopt.cxx:449
OptionsPageInfo::m_sEventHdl
OUString m_sEventHdl
Definition: treeopt.cxx:446
SfxDispatcher::ExecuteList
const SfxPoolItem * ExecuteList(sal_uInt16 nSlot, SfxCallMode nCall, std::initializer_list< SfxPoolItem const * > args, std::initializer_list< SfxPoolItem const * > internalargs=std::initializer_list< SfxPoolItem const * >())
Help::DisableBalloonHelp
static void DisableBalloonHelp()
nIndex
sal_Int32 nIndex
SvxJSearchOptionsPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optjsearch.cxx:58
RID_SVXPAGE_ONLINEUPDATE
#define RID_SVXPAGE_ONLINEUPDATE
OfaTreeOptionsDialog::xCurrentPageEntry
std::unique_ptr< weld::TreeIter > xCurrentPageEntry
Definition: treeopt.hxx:129
OptionsLeaf::m_sPageURL
OUString m_sPageURL
Definition: treeopt.hxx:59
SvtOptionsDialogOptions::IsPageHidden
bool IsPageHidden(std::u16string_view _rPage, std::u16string_view _rGroup) const
utl::ConfigManager::storeConfigItems
static void storeConfigItems()
RID_SVXPAGE_OPENCL
#define RID_SVXPAGE_OPENCL
SvxAsianLayoutPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optasian.cxx:139
svl::Items
static constexpr auto Items
SvtCJKOptions::IsCJKFontEnabled
bool IsCJKFontEnabled()
SvxSaveTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optsave.cxx:192
svx::DbRegistrationOptionsPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: dbregister.cxx:126
ExtensionsTabPage::m_xPageParent
css::uno::Reference< css::awt::XWindow > m_xPageParent
Definition: treeopt.hxx:208
SfxPoolItem::Clone
virtual SfxPoolItem * Clone(SfxItemPool *pPool=nullptr) const =0
Application::GetHelp
static Help * GetHelp()
offapp::ConnectionPoolConfig::GetOptions
static void GetOptions(SfxItemSet &_rFillItems)
Definition: connpoolconfig.cxx:75
OptionsLeaf::m_sEventHdl
OUString m_sEventHdl
Definition: treeopt.hxx:60
LastPageSaver::m_sLastPageURL_Tools
OUString m_sLastPageURL_Tools
Definition: treeopt.hxx:100
OfaTreeOptionsDialog::bIsFromExtensionManager
bool bIsFromExtensionManager
Definition: treeopt.hxx:134
SfxHyphenRegionItem::GetMinTrail
sal_uInt8 & GetMinTrail()
SfxViewFrame::GetDispatcher
SfxDispatcher * GetDispatcher()
INI_LIST
#define INI_LIST()
Definition: treeopt.cxx:465
RID_SVXPAGE_OPTIONS_CTL
#define RID_SVXPAGE_OPTIONS_CTL
getGroupNodeId
static sal_uInt16 getGroupNodeId(std::u16string_view rModule)
Definition: treeopt.cxx:212
SvtModuleOptions::IsModuleInstalled
bool IsModuleInstalled(EModule eModule) const
SvxOnlineUpdateTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optupdt.cxx:188
utl::ConfigItem::Notify
virtual void Notify(const css::uno::Sequence< OUString > &aPropertyNames)=0
RID_SVXPAGE_INET_SECURITY
#define RID_SVXPAGE_INET_SECURITY
SvxLinguTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optlingu.cxx:911
RID_SVXPAGE_PERSONALIZATION
#define RID_SVXPAGE_PERSONALIZATION
RID_SVXPAGE_COLORCONFIG
#define RID_SVXPAGE_COLORCONFIG
Help::Start
virtual bool Start(const OUString &rHelpId, weld::Widget *pWidget=nullptr)
VectorOfNodes
std::vector< std::unique_ptr< OptionsNode > > VectorOfNodes
Definition: treeopt.hxx:95
linguistic::SaveDictionaries
bool SaveDictionaries(const uno::Reference< XSearchableDictionaryList > &xDicList)
LastPageSaver::m_sLastPageURL_ExtMgr
OUString m_sLastPageURL_ExtMgr
Definition: treeopt.hxx:101
BuilderPage::GetHelpId
OString GetHelpId() const
SvtCTLOptions::IsCTLFontEnabled
bool IsCTLFontEnabled() const
OptionsMap_Impl
OptionsMapping_Impl const OptionsMap_Impl[]
Definition: treeopt.cxx:323
OfaTreeOptionsDialog::InitItemSets
void InitItemSets(OptionsGroupInfo &rGroupInfo)
Definition: treeopt.cxx:892
SvxDefaultColorOptPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rInAttrs)
Definition: optchart.cxx:144
ExtensionsTabPage::m_sPageURL
OUString m_sPageURL
Definition: treeopt.hxx:207
weld::TreeView::make_iterator
virtual std::unique_ptr< TreeIter > make_iterator(const TreeIter *pOrig=nullptr) const =0
SfxGetpApp
SfxApplication * SfxGetpApp()
LinguMgr::GetLinguPropertySet
static css::uno::Reference< css::linguistic2::XLinguProperties > GetLinguPropertySet()
OfaHtmlTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: opthtml.cxx:69
SvxCTLOptionsPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optctl.cxx:56
SvxSecurityTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optinet2.cxx:749
OfaTreeOptionsDialog::OfaTreeOptionsDialog
OfaTreeOptionsDialog(weld::Window *pParent, const css::uno::Reference< css::frame::XFrame > &_xFrame, bool bActivateLastSelection)
Help::EnableBalloonHelp
static void EnableBalloonHelp()
nPageId
sal_uInt16 nPageId
SfxHyphenRegionItem::GetMinLead
sal_uInt8 & GetMinLead()
SfxApplication::GetOptions
void GetOptions(SfxItemSet &)
SfxPrinterChangeFlags
SfxPrinterChangeFlags
ExtensionsTabPage::CreateDialogWithHandler
void CreateDialogWithHandler()
Definition: treeopt.cxx:2010
SvtCJKOptions::IsJapaneseFindEnabled
bool IsJapaneseFindEnabled()
Help::DisableQuickHelp
static void DisableQuickHelp()
ExtensionsTabPage::ExtensionsTabPage
ExtensionsTabPage(weld::Container *pParent, const OUString &rPageURL, const OUString &rEvtHdl, const css::uno::Reference< css::awt::XContainerWindowProvider > &rProvider)
Definition: treeopt.cxx:1970
SvxPersonalizationTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: personalization.cxx:51
VCLUnoHelper::GetWindow
static vcl::Window * GetWindow(const css::uno::Reference< css::awt::XWindow > &rxWindow)
OptionsLeaf::m_sLabel
OUString m_sLabel
Definition: treeopt.hxx:58
nCount
int nCount
RID_SVXPAGE_JSEARCH_OPTIONS
#define RID_SVXPAGE_JSEARCH_OPTIONS
LinguMgr::GetDictionaryList
static css::uno::Reference< css::linguistic2::XSearchableDictionaryList > GetDictionaryList()
GetViewOptUserItem
static OUString GetViewOptUserItem(const SvtViewOptions &rOpt)
Definition: treeopt.cxx:127
RID_SFXPAGE_PRINTOPTIONS
#define RID_SFXPAGE_PRINTOPTIONS
comphelper::ConfigurationChanges::create
static std::shared_ptr< ConfigurationChanges > create(css::uno::Reference< css::uno::XComponentContext > const &context=comphelper::getProcessComponentContext())
SvxProxyTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optinet2.cxx:184
HID_OFADLG_TREELISTBOX
constexpr OStringLiteral HID_OFADLG_TREELISTBOX
Definition: helpids.h:28
SfxCommonPrintOptionsTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *)
getCurrentFactory_Impl
static OUString getCurrentFactory_Impl(const Reference< XFrame > &_xFrame)
Definition: treeopt.cxx:1329
RID_SFXPAGE_PATH
#define RID_SFXPAGE_PATH
OfaTreeOptionsDialog::ResetCurrentPageFromConfig
void ResetCurrentPageFromConfig()
Definition: treeopt.cxx:617
RID_SVXPAGE_INET_MAIL
#define RID_SVXPAGE_INET_MAIL
OptionsNode::m_bAllModules
bool m_bAllModules
Definition: treeopt.hxx:82
OfaTreeOptionsDialog::AddTabPage
OptionsPageInfo * AddTabPage(sal_uInt16 nId, const OUString &rPageName, sal_uInt16 nGroup)
Definition: treeopt.cxx:575
y
float y
OptionsNode::m_sId
OUString m_sId
Definition: treeopt.hxx:80
SAL_N_ELEMENTS
#define SAL_N_ELEMENTS(arr)
OptionsNode::m_sLabel
OUString m_sLabel
Definition: treeopt.hxx:81
OptionsPageInfo::m_nPageId
sal_uInt16 m_nPageId
Definition: treeopt.cxx:444
GetValue
virtual tools::Long GetValue() const override
SvxChartOptions::GetDefaultColors
const SvxChartColorTable & GetDefaultColors()
Definition: cfgchart.cxx:172
CuiResId
OUString CuiResId(TranslateId aKey)
Definition: cuiresmgr.cxx:23
WB_DIALOGCONTROL
WinBits const WB_DIALOGCONTROL
ModuleMap
std::map< OUString, std::shared_ptr< NoAutoUnloadModule > > ModuleMap
OfaTreeOptionsDialog::GetModuleIdentifier
static OUString GetModuleIdentifier(const css::uno::Reference< css::frame::XFrame > &xFrame)
Definition: treeopt.cxx:1669
svx::DbRegisteredNamesConfig::GetOptions
static void GetOptions(SfxItemSet &_rFillItems)
Definition: dbregisterednamesconfig.cxx:37
TOOLS_WARN_EXCEPTION
#define TOOLS_WARN_EXCEPTION(area, stream)
ExtensionsTabPage::m_xPage
css::uno::Reference< css::awt::XWindow > m_xPage
Definition: treeopt.hxx:209
RID_OFAPAGE_MSFILTEROPT2
#define RID_OFAPAGE_MSFILTEROPT2
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
DBG_ASSERT
#define DBG_ASSERT(sCon, aError)
OfaTreeOptionsDialog::xTreeLB
std::unique_ptr< weld::TreeView > xTreeLB
Definition: treeopt.hxx:124
i
int i
OFA_TP_MISC
#define OFA_TP_MISC
diagnose_ex.h
OfaTreeOptionsDialog::xTabBox
std::unique_ptr< weld::Container > xTabBox
Definition: treeopt.hxx:125
SvxOpenCLTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optopencl.cxx:48
GetLanguage
LanguageType GetLanguage(SwWrtShell &rSh, sal_uInt16 nLangWhichId)
SfxFlagItem::GetValue
sal_uInt16 GetValue() const
OfaTreeOptionsDialog::ApplyLanguageOptions
static void ApplyLanguageOptions(const SfxItemSet &rSet)
Definition: treeopt.cxx:1263
Help::IsQuickHelpEnabled
static bool IsQuickHelpEnabled()
RID_OFAPAGE_HTMLOPT
#define RID_OFAPAGE_HTMLOPT
OfaLanguagesTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optgdlg.cxx:1204
OfaMSFilterTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optfltr.cxx:68
lcl_isOptionHidden
static bool lcl_isOptionHidden(sal_uInt16 _nPageId, const SvtOptionsDialogOptions &_rOptOptions)
Definition: treeopt.cxx:427
SfxApplication::SetOptions
void SetOptions(const SfxItemSet &)
SfxItemSet::Count
sal_uInt16 Count() const
OptionsGroupInfo::m_pOutItemSet
std::unique_ptr< SfxItemSet > m_pOutItemSet
Definition: treeopt.cxx:455
SfxViewFrame::GetNext
static SfxViewFrame * GetNext(const SfxViewFrame &rPrev, const SfxObjectShell *pDoc=nullptr, bool bOnlyVisible=true)
WB_CHILDDLGCTRL
WinBits const WB_CHILDDLGCTRL
offapp::ConnectionPoolConfig::SetOptions
static void SetOptions(const SfxItemSet &_rSourceItems)
Definition: connpoolconfig.cxx:137
weld::TreeView::iter_next
virtual bool iter_next(TreeIter &rIter) const =0
u
float u
ExtensionsTabPage::DeactivatePage
void DeactivatePage()
Definition: treeopt.cxx:2109
OfaTreeOptionsDialog::Initialize
void Initialize(const css::uno::Reference< css::frame::XFrame > &_xFrame)
Definition: treeopt.cxx:1359
SvtOptionsDialogOptions::IsGroupHidden
bool IsGroupHidden(std::u16string_view _rGroup) const
RID_SFXPAGE_SAVE
#define RID_SFXPAGE_SAVE
SvtCJKOptions::IsAsianTypographyEnabled
bool IsAsianTypographyEnabled()
SvxColorOptionsTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optcolor.cxx:741
SvxBasicIDEOptionsPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optbasic.cxx:121
RID_SVX_FONT_SUBSTITUTION
#define RID_SVX_FONT_SUBSTITUTION
weld::TreeView::get_text
virtual OUString get_text(int row, int col=-1) const =0
OfaMSFilterTabPage2::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optfltr.cxx:152
OfaTreeOptionsDialog::bIsForSetDocumentLanguage
bool bIsForSetDocumentLanguage
Definition: treeopt.hxx:137
OptionsPageInfo::m_xExtPage
std::unique_ptr< ExtensionsTabPage > m_xExtPage
Definition: treeopt.cxx:447
VIEWOPT_DATANAME
constexpr OUStringLiteral VIEWOPT_DATANAME
Definition: treeopt.cxx:120
RID_SVXPAGE_COLOR
#define RID_SVXPAGE_COLOR
lcl_getGroupId
static sal_uInt16 lcl_getGroupId(std::u16string_view rGroupName, const weld::TreeView &rTreeLB)
Definition: treeopt.cxx:1893
OFA_TP_VIEW
#define OFA_TP_VIEW
svx::DbRegisteredNamesConfig::SetOptions
static void SetOptions(const SfxItemSet &_rSourceItems)
Definition: dbregisterednamesconfig.cxx:66
RID_SFXPAGE_GENERAL
#define RID_SFXPAGE_GENERAL
vcl::Window::SetStyle
void SetStyle(WinBits nStyle)
Help::IsBalloonHelpEnabled
static bool IsBalloonHelpEnabled()
OfaTreeOptionsDialog::xApplyPB
std::unique_ptr< weld::Button > xApplyPB
Definition: treeopt.hxx:121
OfaTreeOptionsDialog::pLastPageSaver
static LastPageSaver * pLastPageSaver
Definition: treeopt.hxx:145
comphelper::getExpandedUri
COMPHELPER_DLLPUBLIC OUString getExpandedUri(css::uno::Reference< css::uno::XComponentContext > const &context, OUString const &uri)
OptionsGroupInfo::m_nDialogId
sal_uInt16 m_nDialogId
Definition: treeopt.cxx:458
lcl_insertLeaf
static void lcl_insertLeaf(OfaTreeOptionsDialog *pDlg, OptionsNode const *pNode, OptionsLeaf const *pLeaf, const weld::TreeView &rTreeLB)
Definition: treeopt.cxx:1914
OfaTreeOptionsDialog::LoadNodes
static VectorOfNodes LoadNodes(Module *pModule, std::u16string_view rExtensionId)
Definition: treeopt.cxx:1763
SvxFontSubstTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: fontsubs.cxx:137
OfaTreeOptionsDialog::eRestartReason
svtools::RestartReason eRestartReason
Definition: treeopt.hxx:140
ExtensionsTabPage::m_xEventHdl
css::uno::Reference< css::awt::XContainerWindowEventHandler > m_xEventHdl
Definition: treeopt.hxx:212
LastPageSaver::m_nLastPageId
sal_uInt16 m_nLastPageId
Definition: treeopt.hxx:99
getGroupName
static OUString getGroupName(std::u16string_view rModule, bool bForced)
Definition: treeopt.cxx:174
weld::Container::CreateChildFrame
virtual css::uno::Reference< css::awt::XWindow > CreateChildFrame()=0
RID_SVXPAGE_ACCESSIBILITYCONFIG
#define RID_SVXPAGE_ACCESSIBILITYCONFIG
OfaTreeOptionsDialog::xOkPB
std::unique_ptr< weld::Button > xOkPB
Definition: treeopt.hxx:120
Module::m_bActive
bool m_bActive
Definition: treeopt.hxx:48
OfaTreeOptionsDialog::LoadExtensionOptions
void LoadExtensionOptions(std::u16string_view rExtensionId)
Definition: treeopt.cxx:1655
pValues
const PropertyValue * pValues
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
OfaTreeOptionsDialog::~OfaTreeOptionsDialog
virtual ~OfaTreeOptionsDialog() override
Definition: treeopt.cxx:519
comphelper::getProcessServiceFactory
Reference< XMultiServiceFactory > getProcessServiceFactory()
SfxViewFrame::Current
static SfxViewFrame * Current()
ExtensionsTabPage::m_xWinProvider
css::uno::Reference< css::awt::XContainerWindowProvider > m_xWinProvider
Definition: treeopt.hxx:214
OFA_TP_LANGUAGES_FOR_SET_DOCUMENT_LANGUAGE
#define OFA_TP_LANGUAGES_FOR_SET_DOCUMENT_LANGUAGE
OfaTreeOptionsDialog::ActivateLastSelection
void ActivateLastSelection()
Definition: treeopt.cxx:828
ExtensionsTabPage::DispatchAction
bool DispatchAction(const OUString &rAction)
Definition: treeopt.cxx:2048
OptionsPageInfo::m_xPage
std::unique_ptr< SfxTabPage > m_xPage
Definition: treeopt.cxx:443
OfaTreeOptionsDialog::LoadModule
static std::unique_ptr< Module > LoadModule(std::u16string_view rModuleIdentifier)
Definition: treeopt.cxx:1700
OfaTreeOptionsDialog::SetNeedsRestart
void SetNeedsRestart(svtools::RestartReason eReason)
Definition: treeopt.cxx:1950
sal_uInt8
unsigned char sal_uInt8
SvxJavaOptionsPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optjava.cxx:464
OptionsGroupInfo::m_pInItemSet
std::optional< SfxItemSet > m_pInItemSet
Definition: treeopt.cxx:454
SAL_INFO
#define SAL_INFO(area, stream)
RID_SVXPAGE_ASIAN_LAYOUT
#define RID_SVXPAGE_ASIAN_LAYOUT
INetURLObject::GetProtocol
INetProtocol GetProtocol() const
RET_OK
RET_OK
OfaTreeOptionsDialog::m_xContainerWinProvider
css::uno::Reference< css::awt::XContainerWindowProvider > m_xContainerWinProvider
Definition: treeopt.hxx:143
SetViewOptUserItem
static void SetViewOptUserItem(SvtViewOptions &rOpt, const OUString &rData)
Definition: treeopt.cxx:122
weld::TreeView::get_iter_first
virtual bool get_iter_first(TreeIter &rIter) const =0
m_xDialog
Reference< XExecutableDialog > m_xDialog
CreateTabPage
std::unique_ptr< SfxTabPage >(* CreateTabPage)(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
OfaTreeOptionsDialog::AddGroup
sal_uInt16 AddGroup(const OUString &rGroupName, SfxShell *pCreateShell, SfxModule *pCreateModule, sal_uInt16 nDialogId)
Definition: treeopt.cxx:590
OfaTreeOptionsDialog::ApplyItemSet
static void ApplyItemSet(sal_uInt16 nId, const SfxItemSet &rSet)
Definition: treeopt.cxx:1181
comphelper::getProcessComponentContext
Reference< XComponentContext > getProcessComponentContext()
SvtViewOptions::GetUserItem
css::uno::Any GetUserItem(const OUString &sName) const
RID_SVXPAGE_BASICIDE_OPTIONS
#define RID_SVXPAGE_BASICIDE_OPTIONS
Help::EnableQuickHelp
static void EnableQuickHelp()
SvxAccessibilityOptionsTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optaccessibility.cxx:46
SfxShell::ApplyItemSet
virtual void ApplyItemSet(sal_uInt16 nId, const SfxItemSet &rSet)
RID_SVXPAGE_INET_PROXY
#define RID_SVXPAGE_INET_PROXY
deleteGroupNames
static void deleteGroupNames()
Definition: treeopt.cxx:206
DeactivateRC
DeactivateRC
Size::setHeight
void setHeight(tools::Long nHeight)
SvxEMailTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optinet2.cxx:851
IMPL_LINK_NOARG
IMPL_LINK_NOARG(OfaTreeOptionsDialog, ShowPageHdl_Impl, weld::TreeView &, void)
Definition: treeopt.cxx:612
SfxViewFrame::GetFirst
static SfxViewFrame * GetFirst(const SfxObjectShell *pDoc=nullptr, bool bOnlyVisible=true)
OfaTreeOptionsDialog::CreateItemSet
std::optional< SfxItemSet > CreateItemSet(sal_uInt16 nId)
Definition: treeopt.cxx:1029
OfaTreeOptionsDialog::run
virtual short run() override
Definition: treeopt.cxx:1956
xFactory
Reference< XSingleServiceFactory > xFactory
offapp::ConnectionPoolOptionsPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *_rAttrSet)
Definition: connpooloptions.cxx:128
OfaTreeOptionsDialog::xBackPB
std::unique_ptr< weld::Button > xBackPB
Definition: treeopt.hxx:122
lcl_getStringFromID
static bool lcl_getStringFromID(sal_uInt16 _nPageId, OUString &_rGroupName, OUString &_rPageName)
Definition: treeopt.cxx:406
vcl::Window::GetStyle
WinBits GetStyle() const
OfaTreeOptionsDialog::InsertNodes
void InsertNodes(const VectorOfNodes &rNodeList)
Definition: treeopt.cxx:1928
utl::ConfigItem::ImplCommit
virtual void ImplCommit()=0
RID_SFXPAGE_LINGU
#define RID_SFXPAGE_LINGU
SfxDispatcher::Execute
const SfxPoolItem * Execute(sal_uInt16 nSlot, SfxCallMode nCall=SfxCallMode::SLOT, const SfxPoolItem **pArgs=nullptr, sal_uInt16 nModi=0, const SfxPoolItem **pInternalArgs=nullptr)
ExtensionsTabPage::m_pContainer
weld::Container * m_pContainer
Definition: treeopt.hxx:206
OfaViewTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optgdlg.cxx:663
ExtensionsTabPage::m_sEventHdl
OUString m_sEventHdl
Definition: treeopt.hxx:210
setGroupName
static void setGroupName(std::u16string_view rModule, const OUString &rGroupName)
Definition: treeopt.cxx:162
OfaTreeOptionsDialog::InitTreeAndHandler
void InitTreeAndHandler()
Definition: treeopt.cxx:788
SfxModule::CreateTabPage
virtual std::unique_ptr< SfxTabPage > CreateTabPage(sal_uInt16 nId, weld::Container *pPage, weld::DialogController *pController, const SfxItemSet &rSet)
OFA_TP_LANGUAGES
#define OFA_TP_LANGUAGES
first
constexpr OUStringLiteral first
OptionsGroupInfo::m_pShell
SfxShell * m_pShell
Definition: treeopt.cxx:456
OptionsGroupInfo::m_pModule
SfxModule * m_pModule
Definition: treeopt.cxx:457
CreateGeneralTabPage
static std::unique_ptr< SfxTabPage > CreateGeneralTabPage(sal_uInt16 nId, weld::Container *pPage, weld::DialogController *pController, const SfxItemSet &rSet)
Definition: treeopt.cxx:268
SvxPathTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rSet)
Definition: optpath.cxx:217
RID_OPTPAGE_CHART_DEFCOLORS
#define RID_OPTPAGE_CHART_DEFCOLORS
OfaMiscTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optgdlg.cxx:213
SvxGeneralTabPage::Create
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: optgenrl.cxx:339
SfxShell::CreateItemSet
virtual std::optional< SfxItemSet > CreateItemSet(sal_uInt16 nId)
SfxApplication::GetModule
static SfxModule * GetModule(SfxToolsModule nSharedLib)
SfxPoolItem::Which
sal_uInt16 Which() const
weld::GetMinimumEditHeight
int GetMinimumEditHeight()
IMPL_LINK
IMPL_LINK(OfaTreeOptionsDialog, ApplyHdl_Impl, weld::Button &, rButton, void)
Definition: treeopt.cxx:689
RID_SVXPAGE_OPTIONS_JAVA
#define RID_SVXPAGE_OPTIONS_JAVA
OptionsPageInfo::m_sPageURL
OUString m_sPageURL
Definition: treeopt.cxx:445
OptionsGroupInfo::OptionsGroupInfo
OptionsGroupInfo(SfxShell *pSh, SfxModule *pMod, sal_uInt16 nId)
Definition: treeopt.cxx:460
isNodeActive
static bool isNodeActive(OptionsNode const *pNode, Module *pModule)
Definition: treeopt.cxx:1628
Module::m_aNodeList
std::vector< std::unique_ptr< OrderedEntry > > m_aNodeList
Definition: treeopt.hxx:49
weld::TreeView::get_iter_depth
virtual int get_iter_depth(const TreeIter &rIter) const =0
OfaTreeOptionsDialog::ActivatePage
void ActivatePage(sal_uInt16 nResId)
Definition: treeopt.cxx:798
vcl::Window::Show
void Show(bool bVisible=true, ShowFlags nFlags=ShowFlags::NONE)
sId
OUString sId
Generated on Mon Jan 17 2022 08:29:11 for LibreOffice Module cui (master) by   doxygen 1.8.10