From 267c6f2ac71f92999e969232431ba04678e7437e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 07:54:39 +0200 Subject: Adding upstream version 4:24.2.0. Signed-off-by: Daniel Baumann --- sw/source/ui/dialog/abstract.cxx | 41 + sw/source/ui/dialog/addrdlg.cxx | 36 + sw/source/ui/dialog/ascfldlg.cxx | 448 +++++++ sw/source/ui/dialog/docstdlg.cxx | 131 ++ sw/source/ui/dialog/macassgn.cxx | 132 ++ sw/source/ui/dialog/swdlgfact.cxx | 1430 +++++++++++++++++++++ sw/source/ui/dialog/swdlgfact.hxx | 881 +++++++++++++ sw/source/ui/dialog/swmessdialog.cxx | 20 + sw/source/ui/dialog/swuiexp.cxx | 40 + sw/source/ui/dialog/uiregionsw.cxx | 2145 +++++++++++++++++++++++++++++++ sw/source/ui/dialog/wordcountdialog.cxx | 161 +++ 11 files changed, 5465 insertions(+) create mode 100644 sw/source/ui/dialog/abstract.cxx create mode 100644 sw/source/ui/dialog/addrdlg.cxx create mode 100644 sw/source/ui/dialog/ascfldlg.cxx create mode 100644 sw/source/ui/dialog/docstdlg.cxx create mode 100644 sw/source/ui/dialog/macassgn.cxx create mode 100644 sw/source/ui/dialog/swdlgfact.cxx create mode 100644 sw/source/ui/dialog/swdlgfact.hxx create mode 100644 sw/source/ui/dialog/swmessdialog.cxx create mode 100644 sw/source/ui/dialog/swuiexp.cxx create mode 100644 sw/source/ui/dialog/uiregionsw.cxx create mode 100644 sw/source/ui/dialog/wordcountdialog.cxx (limited to 'sw/source/ui/dialog') diff --git a/sw/source/ui/dialog/abstract.cxx b/sw/source/ui/dialog/abstract.cxx new file mode 100644 index 0000000000..01e0138955 --- /dev/null +++ b/sw/source/ui/dialog/abstract.cxx @@ -0,0 +1,41 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +SwInsertAbstractDlg::SwInsertAbstractDlg(weld::Window* pParent) + : SfxDialogController(pParent, "modules/swriter/ui/abstractdialog.ui", "AbstractDialog") + , m_xLevelNF(m_xBuilder->weld_spin_button("outlines")) + , m_xParaNF(m_xBuilder->weld_spin_button("paras")) +{ +} + +SwInsertAbstractDlg::~SwInsertAbstractDlg() {} + +sal_uInt8 SwInsertAbstractDlg::GetLevel() const +{ + return static_cast(m_xLevelNF->get_value() - 1); +} + +sal_uInt8 SwInsertAbstractDlg::GetPara() const +{ + return static_cast(m_xParaNF->get_value()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/addrdlg.cxx b/sw/source/ui/dialog/addrdlg.cxx new file mode 100644 index 0000000000..0dde165fc0 --- /dev/null +++ b/sw/source/ui/dialog/addrdlg.cxx @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include + +SwAddrDlg::SwAddrDlg(weld::Window* pParent, const SfxItemSet& rSet) + : SfxSingleTabDialogController(pParent, &rSet) +{ + SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); + ::CreateTabPage fnCreatePage = pFact->GetTabPageCreatorFunc(RID_SFXPAGE_GENERAL); + if (fnCreatePage) + { + // create TabPage + SetTabPage(fnCreatePage(get_content_area(), this, &rSet)); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/ascfldlg.cxx b/sw/source/ui/dialog/ascfldlg.cxx new file mode 100644 index 0000000000..43a3249823 --- /dev/null +++ b/sw/source/ui/dialog/ascfldlg.cxx @@ -0,0 +1,448 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace ::com::sun::star; + +namespace +{ + +const sal_Unicode cDialogExtraDataClose = '}'; +const char sDialogImpExtraData[] = "EncImpDlg:{"; +const char sDialogExpExtraData[] = "EncExpDlg:{"; +const sal_Int32 nDialogExtraDataLen = 11; // 12345678901 + +} + +SwAsciiFilterDlg::SwAsciiFilterDlg( weld::Window* pParent, SwDocShell& rDocSh, + SvStream* pStream ) + : SfxDialogController(pParent, "modules/swriter/ui/asciifilterdialog.ui", "AsciiFilterDialog") + , m_bSaveLineStatus(true) + , m_xCharSetLB(new SvxTextEncodingBox(m_xBuilder->weld_combo_box("charset"))) + , m_xFontFT(m_xBuilder->weld_label("fontft")) + , m_xFontLB(m_xBuilder->weld_combo_box("font")) + , m_xLanguageFT(m_xBuilder->weld_label("languageft")) + , m_xLanguageLB(new SvxLanguageBox(m_xBuilder->weld_combo_box("language"))) + , m_xCRLF_RB(m_xBuilder->weld_radio_button("crlf")) + , m_xCR_RB(m_xBuilder->weld_radio_button("cr")) + , m_xLF_RB(m_xBuilder->weld_radio_button("lf")) + , m_xIncludeBOM_CB(m_xBuilder->weld_check_button("includebom")) +{ + m_xFontLB->make_sorted(); + + SwAsciiOptions aOpt; + { + SvtViewOptions aDlgOpt(EViewType::Dialog, m_xDialog->get_help_id()); + if (aDlgOpt.Exists()) + { + css::uno::Any aUserItem = aDlgOpt.GetUserItem("UserItem"); + aUserItem >>= m_sExtraData; + } + + const SfxStringItem* pItem; + OUString sAsciiOptions; + if( rDocSh.GetMedium() != nullptr && + (pItem = rDocSh.GetMedium()->GetItemSet().GetItemIfSet( SID_FILE_FILTEROPTIONS ))) + { + sAsciiOptions = pItem->GetValue(); + } + + const OUString sFindNm = OUString::createFromAscii( + pStream ? sDialogImpExtraData + : sDialogExpExtraData); + sal_Int32 nStt = m_sExtraData.indexOf( sFindNm ); + if( -1 != nStt ) + { + nStt += nDialogExtraDataLen; + sal_Int32 nEnd = m_sExtraData.indexOf( cDialogExtraDataClose, nStt ); + if( -1 != nEnd ) + { + if(sAsciiOptions.isEmpty()) + sAsciiOptions = m_sExtraData.copy(nStt, nEnd - nStt); + nStt -= nDialogExtraDataLen; + m_sExtraData = m_sExtraData.replaceAt(nStt, nEnd - nStt + 1, u""); + } + } + if(!sAsciiOptions.isEmpty()) + aOpt.ReadUserData(sAsciiOptions); + } + + // read the first chars and check the charset, (language - with L&H) + if( pStream ) + { + char aBuffer[ 4098 ]; + const sal_uInt64 nOldPos = pStream->Tell(); + const size_t nBytesRead = pStream->ReadBytes(aBuffer, 4096); + pStream->Seek( nOldPos ); + + if( nBytesRead <= 4096 ) + { + aBuffer[ nBytesRead ] = '0'; + aBuffer[ nBytesRead+1 ] = '0'; + } + + bool bCR = false, bLF = false, bNullChar = false; + for( sal_uInt64 nCnt = 0; nCnt < nBytesRead; ++nCnt ) + switch( aBuffer[ nCnt ] ) + { + case 0x0: bNullChar = true; break; + case 0xA: bLF = true; break; + case 0xD: bCR = true; break; + case 0xC: + case 0x1A: + case 0x9: break; + default: break; + } + + if( !bNullChar ) + { + if( bCR ) + { + if( bLF ) + { + aOpt.SetParaFlags( LINEEND_CRLF ); + } + else + { + aOpt.SetParaFlags( LINEEND_CR ); + } + } + else if( bLF ) + { + aOpt.SetParaFlags( LINEEND_LF ); + } + } + + const sal_uInt16 nAppScriptType = SvtLanguageOptions::GetI18NScriptTypeOfLanguage( GetAppLanguage() ); + SwDoc* pDoc = rDocSh.GetDoc(); + + // initialize language + { + if( !aOpt.GetLanguage() ) + { + if(pDoc) + { + const TypedWhichId nWhich = GetWhichOfScript( RES_CHRATR_LANGUAGE, nAppScriptType); + const SvxLanguageItem& rLangItem = pDoc->GetDefault( nWhich ); + aOpt.SetLanguage( rLangItem.GetLanguage() ); + } + else + { + SvtLinguOptions aLinguOpt; + SvtLinguConfig().GetOptions( aLinguOpt ); + switch(nAppScriptType) + { + case css::i18n::ScriptType::ASIAN: + aOpt.SetLanguage(MsLangId::resolveSystemLanguageByScriptType(aLinguOpt.nDefaultLanguage_CJK, css::i18n::ScriptType::ASIAN)); + break; + case css::i18n::ScriptType::COMPLEX: + aOpt.SetLanguage(MsLangId::resolveSystemLanguageByScriptType(aLinguOpt.nDefaultLanguage_CTL, css::i18n::ScriptType::COMPLEX)); + break; + //SvtScriptType::LATIN: + default: + aOpt.SetLanguage(MsLangId::resolveSystemLanguageByScriptType(aLinguOpt.nDefaultLanguage, css::i18n::ScriptType::LATIN)); + } + } + } + + m_xLanguageLB->SetLanguageList( SvxLanguageListFlags::ALL, true ); + m_xLanguageLB->set_active_id(aOpt.GetLanguage()); + } + + { + bool bDelPrinter = false; + VclPtr pPrt = pDoc ? pDoc->getIDocumentDeviceAccess().getPrinter(false) : nullptr; + if( !pPrt ) + { + auto pSet = std::make_unique>( rDocSh.GetPool() ); + pPrt = VclPtr::Create( std::move(pSet) ); + bDelPrinter = true; + } + + // get the set of distinct available family names + std::set< OUString > aFontNames; + int nFontNames = pPrt->GetFontFaceCollectionCount(); + for( int i = 0; i < nFontNames; i++ ) + { + FontMetric aFontMetric( pPrt->GetFontMetricFromCollection( i ) ); + aFontNames.insert( aFontMetric.GetFamilyName() ); + } + + // insert into listbox + for( const auto& rFontName : aFontNames ) + { + m_xFontLB->append_text(rFontName); + } + + if( aOpt.GetFontName().isEmpty() ) + { + LanguageType eLang = aOpt.GetLanguage(); + vcl::Font aTmpFont(OutputDevice::GetDefaultFont(DefaultFontType::FIXED, eLang, GetDefaultFontFlags::OnlyOne, pPrt)); + aOpt.SetFontName(aTmpFont.GetFamilyName()); + } + + m_xFontLB->set_active_text(aOpt.GetFontName()); + + if( bDelPrinter ) + pPrt.disposeAndClear(); + } + + // hide the unused Controls for Export + m_xIncludeBOM_CB->hide(); + } + else + { + // hide the unused Controls for Export + m_xFontFT->hide(); + m_xFontLB->hide(); + m_xLanguageFT->hide(); + m_xLanguageLB->hide(); + + + SetIncludeBOM(aOpt.GetIncludeBOM()); + m_xIncludeBOM_CB->save_state(); + } + + // initialize character set + m_xCharSetLB->FillFromTextEncodingTable( pStream != nullptr ); + m_xCharSetLB->SelectTextEncoding( aOpt.GetCharSet() ); + + m_xCharSetLB->connect_changed( LINK( this, SwAsciiFilterDlg, CharSetSelHdl )); + m_xCRLF_RB->connect_toggled( LINK( this, SwAsciiFilterDlg, LineEndHdl )); + m_xLF_RB->connect_toggled( LINK( this, SwAsciiFilterDlg, LineEndHdl )); + m_xCR_RB->connect_toggled( LINK( this, SwAsciiFilterDlg, LineEndHdl )); + + SetCRLF( aOpt.GetParaFlags() ); + + m_xCRLF_RB->save_state(); + m_xLF_RB->save_state(); + m_xCR_RB->save_state(); + + UpdateIncludeBOMSensitiveState(); +} + +SwAsciiFilterDlg::~SwAsciiFilterDlg() +{ + SvtViewOptions aDlgOpt(EViewType::Dialog, m_xDialog->get_help_id()); + aDlgOpt.SetUserItem("UserItem", uno::Any(m_sExtraData)); +} + +void SwAsciiFilterDlg::FillOptions( SwAsciiOptions& rOptions ) +{ + sal_uLong nCCode = m_xCharSetLB->GetSelectTextEncoding(); + OUString sFont; + LanguageType nLng = LANGUAGE_SYSTEM; + if (m_xFontLB->get_visible()) + { + sFont = m_xFontLB->get_active_text(); + nLng = m_xLanguageLB->get_active_id(); + } + + rOptions.SetFontName( sFont ); + rOptions.SetCharSet( rtl_TextEncoding( nCCode ) ); + rOptions.SetLanguage( nLng ); + rOptions.SetParaFlags( GetCRLF() ); + rOptions.SetIncludeBOM( GetIncludeBOM() ); + + // save the user settings + OUString sData; + rOptions.WriteUserData( sData ); + if (sData.isEmpty()) + return; + + const OUString sFindNm = OUString::createFromAscii( + m_xFontLB->get_visible() ? sDialogImpExtraData + : sDialogExpExtraData); + sal_Int32 nStt = m_sExtraData.indexOf( sFindNm ); + if( -1 != nStt ) + { + // called twice, so remove "old" settings + sal_Int32 nEnd = m_sExtraData.indexOf( cDialogExtraDataClose, + nStt + nDialogExtraDataLen ); + if( -1 != nEnd ) + m_sExtraData = m_sExtraData.replaceAt( nStt, nEnd - nStt + 1, u"" ); + } + m_sExtraData += sFindNm + sData + OUStringChar(cDialogExtraDataClose); +} + +void SwAsciiFilterDlg::SetCRLF( LineEnd eEnd ) +{ + switch (eEnd) + { + case LINEEND_CR: + m_xCR_RB->set_active(true); + break; + case LINEEND_CRLF: + m_xCRLF_RB->set_active(true); + break; + case LINEEND_LF: + m_xLF_RB->set_active(true); + break; + } +} + +LineEnd SwAsciiFilterDlg::GetCRLF() const +{ + LineEnd eEnd; + if(m_xCR_RB->get_active()) + eEnd = LINEEND_CR; + else if (m_xLF_RB->get_active()) + eEnd = LINEEND_LF; + else + eEnd = LINEEND_CRLF; + return eEnd; +} + +void SwAsciiFilterDlg::SetIncludeBOM( bool bIncludeBOM ) +{ + m_xIncludeBOM_CB->set_state(bIncludeBOM ? TRISTATE_TRUE : TRISTATE_FALSE); +} + +bool SwAsciiFilterDlg::GetIncludeBOM() const +{ + return m_xIncludeBOM_CB->get_state() != TRISTATE_FALSE; +} + +void SwAsciiFilterDlg::UpdateIncludeBOMSensitiveState() +{ + if (!m_xIncludeBOM_CB->get_visible()) + return; + + switch (m_xCharSetLB->GetSelectTextEncoding()) + { + case RTL_TEXTENCODING_UTF8: + case RTL_TEXTENCODING_UCS2: + m_xIncludeBOM_CB->set_sensitive(true); + break; + default: + m_xIncludeBOM_CB->set_sensitive(false); + break; + } +} + +IMPL_LINK_NOARG(SwAsciiFilterDlg, CharSetSelHdl, weld::ComboBox&, void) +{ + LineEnd eOldEnd = GetCRLF(); + std::optional eEnd; + LanguageType nLng = m_xFontLB->get_visible() + ? m_xLanguageLB->get_active_id() + : LANGUAGE_SYSTEM, + nOldLng = nLng; + + rtl_TextEncoding nChrSet = m_xCharSetLB->GetSelectTextEncoding(); + if( nChrSet == osl_getThreadTextEncoding() ) + eEnd = GetSystemLineEnd(); + else + { + switch( nChrSet ) + { + case RTL_TEXTENCODING_MS_1252: +#ifdef UNX + eEnd = LINEEND_LF; +#else + eEnd = LINEEND_CRLF; // ANSI +#endif + break; + + case RTL_TEXTENCODING_APPLE_ROMAN: // MAC + eEnd = LINEEND_CR; + break; + + case RTL_TEXTENCODING_IBM_850: // DOS + eEnd = LINEEND_CRLF; + break; + + case RTL_TEXTENCODING_APPLE_ARABIC: + case RTL_TEXTENCODING_APPLE_CENTEURO: + case RTL_TEXTENCODING_APPLE_CROATIAN: + case RTL_TEXTENCODING_APPLE_CYRILLIC: + case RTL_TEXTENCODING_APPLE_DEVANAGARI: + case RTL_TEXTENCODING_APPLE_FARSI: + case RTL_TEXTENCODING_APPLE_GREEK: + case RTL_TEXTENCODING_APPLE_GUJARATI: + case RTL_TEXTENCODING_APPLE_GURMUKHI: + case RTL_TEXTENCODING_APPLE_HEBREW: + case RTL_TEXTENCODING_APPLE_ICELAND: + case RTL_TEXTENCODING_APPLE_ROMANIAN: + case RTL_TEXTENCODING_APPLE_THAI: + case RTL_TEXTENCODING_APPLE_TURKISH: + case RTL_TEXTENCODING_APPLE_UKRAINIAN: + case RTL_TEXTENCODING_APPLE_CHINSIMP: + case RTL_TEXTENCODING_APPLE_CHINTRAD: + case RTL_TEXTENCODING_APPLE_JAPANESE: + case RTL_TEXTENCODING_APPLE_KOREAN: + eEnd = LINEEND_CR; + break; + } + } + + m_bSaveLineStatus = false; + if( eEnd ) // changed? + { + if( eOldEnd != *eEnd ) + SetCRLF( *eEnd ); + } + else + { + // restore old user choice (not the automatic!) + m_xCRLF_RB->set_state(m_xCRLF_RB->get_saved_state()); + m_xCR_RB->set_state(m_xCR_RB->get_saved_state()); + m_xLF_RB->set_state(m_xLF_RB->get_saved_state()); + } + m_bSaveLineStatus = true; + + if (nOldLng != nLng && m_xFontLB->get_visible()) + m_xLanguageLB->set_active_id(nLng); + + UpdateIncludeBOMSensitiveState(); +} + +IMPL_LINK(SwAsciiFilterDlg, LineEndHdl, weld::Toggleable&, rBtn, void) +{ + if (m_bSaveLineStatus) + rBtn.save_state(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/docstdlg.cxx b/sw/source/ui/dialog/docstdlg.cxx new file mode 100644 index 0000000000..1b300206fc --- /dev/null +++ b/sw/source/ui/dialog/docstdlg.cxx @@ -0,0 +1,131 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +std::unique_ptr SwDocStatPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rSet) +{ + return std::make_unique(pPage, pController, *rSet); +} + +SwDocStatPage::SwDocStatPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet) + : SfxTabPage(pPage, pController, "modules/swriter/ui/statisticsinfopage.ui", "StatisticsInfoPage", &rSet) + , m_xPageNo(m_xBuilder->weld_label("nopages")) + , m_xTableNo(m_xBuilder->weld_label("notables")) + , m_xGrfNo(m_xBuilder->weld_label("nogrfs")) + , m_xOLENo(m_xBuilder->weld_label("nooles")) + , m_xParaNo(m_xBuilder->weld_label("noparas")) + , m_xWordNo(m_xBuilder->weld_label("nowords")) + , m_xCharNo(m_xBuilder->weld_label("nochars")) + , m_xCharExclSpacesNo(m_xBuilder->weld_label("nocharsexspaces")) + , m_xLineLbl(m_xBuilder->weld_label("lineft")) + , m_xLineNo(m_xBuilder->weld_label("nolines")) + , m_xUpdatePB(m_xBuilder->weld_button("update")) +{ + Update(); + m_xUpdatePB->connect_clicked(LINK(this, SwDocStatPage, UpdateHdl)); + //#111684# is the current view a page preview no SwFEShell can be found -> hide the update button + SwDocShell* pDocShell = static_cast( SfxObjectShell::Current() ); + SwFEShell* pFEShell = pDocShell ? pDocShell->GetFEShell() : nullptr; + if(!pFEShell) + { + m_xUpdatePB->hide(); + m_xLineLbl->hide(); + m_xLineNo->hide(); + } +} + +SwDocStatPage::~SwDocStatPage() +{ +} + +// Description: fill ItemSet when changed +bool SwDocStatPage::FillItemSet(SfxItemSet * /*rSet*/) +{ + return false; +} + +void SwDocStatPage::Reset(const SfxItemSet *) +{ +} + +// Description: update / set data +void SwDocStatPage::SetData(const SwDocStat &rStat) +{ + const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetUILocaleDataWrapper(); + m_xTableNo->set_label(rLocaleData.getNum(rStat.nTable, 0)); + m_xGrfNo->set_label(rLocaleData.getNum(rStat.nGrf, 0)); + m_xOLENo->set_label(rLocaleData.getNum(rStat.nOLE, 0)); + m_xPageNo->set_label(rLocaleData.getNum(rStat.nPage, 0)); + m_xParaNo->set_label(rLocaleData.getNum(rStat.nPara, 0)); + m_xWordNo->set_label(rLocaleData.getNum(rStat.nWord, 0)); + m_xCharNo->set_label(rLocaleData.getNum(rStat.nChar, 0)); + m_xCharExclSpacesNo->set_label(rLocaleData.getNum(rStat.nCharExcludingSpaces, 0)); +} + +// Description: update statistics +void SwDocStatPage::Update() +{ + SfxViewShell *pVSh = SfxViewShell::Current(); + SwViewShell *pSh = nullptr; + if ( auto pSwView = dynamic_cast( pVSh ) ) + pSh = pSwView->GetWrtShellPtr(); + else if ( auto pPagePreview = dynamic_cast( pVSh ) ) + pSh = pPagePreview->GetViewShell(); + + OSL_ENSURE( pSh, "Shell not found" ); + + if (!pSh) + return; + + SwWait aWait( *pSh->GetDoc()->GetDocShell(), true ); + pSh->StartAction(); + m_aDocStat = pSh->GetDoc()->getIDocumentStatistics().GetUpdatedDocStat( false, true ); + pSh->EndAction(); + + SetData(m_aDocStat); +} + +IMPL_LINK_NOARG(SwDocStatPage, UpdateHdl, weld::Button&, void) +{ + Update(); + SwDocShell* pDocShell = static_cast( SfxObjectShell::Current()); + SwFEShell* pFEShell = pDocShell ? pDocShell->GetFEShell() : nullptr; + if (pFEShell) + { + const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetUILocaleDataWrapper(); + OUString sLineCount = rLocaleData.getNum(pFEShell->GetLineCount(), 0); + m_xLineNo->set_label(sLineCount); + m_xLineNo->set_size_request(m_xLineNo->get_approximate_digit_width() * sLineCount.getLength(), -1); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/macassgn.cxx b/sw/source/ui/dialog/macassgn.cxx new file mode 100644 index 0000000000..375b1aca4f --- /dev/null +++ b/sw/source/ui/dialog/macassgn.cxx @@ -0,0 +1,132 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + +SfxEventNamesItem SwMacroAssignDlg::AddEvents( DlgEventType eType ) +{ + SfxEventNamesItem aItem(SID_EVENTCONFIG); + + sal_uInt16 nHtmlMode = ::GetHtmlMode(static_cast(SfxObjectShell::Current())); + bool bHtmlMode = nHtmlMode & HTMLMODE_ON; + + switch( eType ) + { + case MACASSGN_AUTOTEXT: + aItem.AddEvent( SwResId(STR_EVENT_START_INS_GLOSSARY), OUString(), + SvMacroItemId::SwStartInsGlossary ); + aItem.AddEvent( SwResId(STR_EVENT_END_INS_GLOSSARY), OUString(), + SvMacroItemId::SwEndInsGlossary); + // in order for the new handler to become active! + break; + case MACASSGN_ALLFRM: + case MACASSGN_GRAPHIC: // graphics + { + aItem.AddEvent( SwResId(STR_EVENT_IMAGE_ERROR), OUString(), + SvMacroItemId::OnImageLoadError); + aItem.AddEvent( SwResId(STR_EVENT_IMAGE_ABORT), OUString(), + SvMacroItemId::OnImageLoadCancel); + aItem.AddEvent( SwResId(STR_EVENT_IMAGE_LOAD), OUString(), + SvMacroItemId::OnImageLoadDone); + } + [[fallthrough]]; + case MACASSGN_FRMURL: // Frame - URL-Attributes + { + if( !bHtmlMode && + (MACASSGN_FRMURL == eType || MACASSGN_ALLFRM == eType)) + { + aItem.AddEvent( SwResId( STR_EVENT_FRM_KEYINPUT_A ), OUString(), + SvMacroItemId::SwFrmKeyInputAlpha ); + aItem.AddEvent( SwResId( STR_EVENT_FRM_KEYINPUT_NOA ), OUString(), + SvMacroItemId::SwFrmKeyInputNoAlpha ); + aItem.AddEvent( SwResId( STR_EVENT_FRM_RESIZE ), OUString(), + SvMacroItemId::SwFrmResize ); + aItem.AddEvent( SwResId( STR_EVENT_FRM_MOVE ), OUString(), + SvMacroItemId::SwFrmMove ); + } + } + [[fallthrough]]; + case MACASSGN_OLE: // OLE + { + if( !bHtmlMode ) + aItem.AddEvent( SwResId(STR_EVENT_OBJECT_SELECT), OUString(), + SvMacroItemId::SwObjectSelect ); + } + [[fallthrough]]; + case MACASSGN_INETFMT: // INetFormat-Attributes + { + aItem.AddEvent( SwResId(STR_EVENT_MOUSEOVER_OBJECT), OUString(), + SvMacroItemId::OnMouseOver ); + aItem.AddEvent( SwResId(STR_EVENT_MOUSECLICK_OBJECT), OUString(), + SvMacroItemId::OnClick); + aItem.AddEvent( SwResId(STR_EVENT_MOUSEOUT_OBJECT), OUString(), + SvMacroItemId::OnMouseOut); + } + break; + } + + return aItem; +} + +bool SwMacroAssignDlg::INetFormatDlg(weld::Window* pParent, SwWrtShell& rSh, + std::optional& rpINetItem ) +{ + bool bRet = false; + SfxItemSetFixed aSet( rSh.GetAttrPool() ); + SvxMacroItem aItem( RES_FRMMACRO ); + if( !rpINetItem ) + rpINetItem.emplace(); + else + aItem.SetMacroTable( *rpINetItem ); + + aSet.Put( aItem ); + aSet.Put( AddEvents( MACASSGN_INETFMT ) ); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr pMacroDlg( pFact->CreateEventConfigDialog(pParent, aSet, + rSh.GetView().GetViewFrame().GetFrame().GetFrameInterface() ) ); + if ( pMacroDlg && pMacroDlg->Execute() == RET_OK ) + { + const SfxItemSet* pOutSet = pMacroDlg->GetOutputItemSet(); + if( const SvxMacroItem* pItem = pOutSet->GetItemIfSet( RES_FRMMACRO, false )) + { + rpINetItem.emplace(pItem->GetMacroTable()); + bRet = true; + } + } + return bRet; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/swdlgfact.cxx b/sw/source/ui/dialog/swdlgfact.cxx new file mode 100644 index 0000000000..daf0dd6ff3 --- /dev/null +++ b/sw/source/ui/dialog/swdlgfact.cxx @@ -0,0 +1,1430 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include + +#include "swdlgfact.hxx" +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; +using namespace css::frame; +using namespace css::uno; + +short AbstractSwWordCountFloatDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwInsertAbstractDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short SwAbstractSfxController_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractNumFormatDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractNumFormatDlg_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return SfxSingleTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractSwAsciiFilterDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSplitTableDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractSplitTableDialog_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractSwTableWidthDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwTableHeightDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwMergeTableDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwPageNumberDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractSwPageNumberDlg_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractGenericDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractGenericDialog_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractSwSortDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractMultiTOXMarkDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractTabController_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractNumBulletDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwConvertTableDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwInsertDBColAutoPilot_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractDropDownFieldDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractDropDownFormFieldDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractDateFormFieldDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwLabDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwSelGlossaryDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwAutoFormatDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwFieldDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwRenameXNamedDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractSwContentControlListItemDlg_Impl::StartExecuteAsync(VclAbstractDialog::AsyncContext& rCtx) +{ + return weld::DialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractSwContentControlListItemDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractSwModalRedlineAcceptDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractGlossaryDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractFieldInputDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractInsFootNoteDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractJavaEditDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractMailMergeDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractMailMergeCreateFromDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractMailMergeFieldConnectionsDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractMultiTOXTabDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractMultiTOXTabDialog_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractEditRegionDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractInsertSectionTabDialog_Impl::Execute() +{ + return m_xDlg->run(); +} + +bool AbstractInsertSectionTabDialog_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractIndexMarkFloatDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +short AbstractAuthMarkFloatDlg_Impl::Execute() +{ + return m_xDlg->run(); +} + +void AbstractTabController_Impl::SetCurPageId( const OUString &rName ) +{ + m_xDlg->SetCurPageId( rName ); +} + +const SfxItemSet* AbstractTabController_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +WhichRangesContainer AbstractTabController_Impl::GetInputRanges(const SfxItemPool& pItem ) +{ + return m_xDlg->GetInputRanges( pItem ); +} + +void AbstractTabController_Impl::SetInputSet( const SfxItemSet* pInSet ) +{ + m_xDlg->SetInputSet( pInSet ); +} + +bool AbstractTabController_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +//From class Window. +void AbstractTabController_Impl::SetText( const OUString& rStr ) +{ + m_xDlg->set_title(rStr); +} + +void AbstractNumBulletDialog_Impl::SetCurPageId( const OUString &rName ) +{ + m_xDlg->SetCurPageId( rName ); +} + +const SfxItemSet* AbstractNumBulletDialog_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +const SfxItemSet* AbstractNumBulletDialog_Impl::GetInputItemSet() const +{ + return m_xDlg->GetInputItemSet(); +} + +WhichRangesContainer AbstractNumBulletDialog_Impl::GetInputRanges(const SfxItemPool& pItem ) +{ + return m_xDlg->GetInputRanges( pItem ); +} + +void AbstractNumBulletDialog_Impl::SetInputSet( const SfxItemSet* pInSet ) +{ + m_xDlg->SetInputSet( pInSet ); +} + +bool AbstractNumBulletDialog_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +//From class Window. +void AbstractNumBulletDialog_Impl::SetText( const OUString& rStr ) +{ + m_xDlg->set_title(rStr); +} + +IMPL_LINK_NOARG(AbstractApplyTabController_Impl, ApplyHdl, weld::Button&, void) +{ + if (m_xDlg->Apply()) + { + m_aHandler.Call(nullptr); + m_xDlg->Applied(); + } +} + +void AbstractApplyTabController_Impl::SetApplyHdl( const Link& rLink ) +{ + m_aHandler = rLink; + m_xDlg->SetApplyHandler(LINK(this, AbstractApplyTabController_Impl, ApplyHdl)); +} + +sal_uInt8 AbstractSwInsertAbstractDlg_Impl::GetLevel() const +{ + return m_xDlg->GetLevel(); +} + +sal_uInt8 AbstractSwInsertAbstractDlg_Impl::GetPara() const +{ + return m_xDlg->GetPara(); +} + +const SfxItemSet* SwAbstractSfxController_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +const SfxItemSet* AbstractNumFormatDlg_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +void SwAbstractSfxController_Impl::SetText(const OUString& rStr) +{ + m_xDlg->set_title(rStr); +} + +void AbstractNumFormatDlg_Impl::SetText(const OUString& rStr) +{ + m_xDlg->set_title(rStr); +} + +void AbstractSwAsciiFilterDlg_Impl::FillOptions( SwAsciiOptions& rOptions ) +{ + m_xDlg->FillOptions(rOptions); +} + +SplitTable_HeadlineOption AbstractSplitTableDialog_Impl::GetSplitMode() +{ + return m_xDlg->GetSplitMode(); +} + +OUString AbstractSwBreakDlg_Impl::GetTemplateName() +{ + SwBreakDlg* pDlg = dynamic_cast(m_xDlg.get()); + if (pDlg) + return pDlg->GetTemplateName(); + + return ""; +} + +sal_uInt16 AbstractSwBreakDlg_Impl:: GetKind() +{ + SwBreakDlg* pDlg = dynamic_cast(m_xDlg.get()); + if (pDlg) + return pDlg->GetKind(); + + return 0; +} + +::std::optional AbstractSwBreakDlg_Impl:: GetPageNumber() +{ + SwBreakDlg* pDlg = dynamic_cast(m_xDlg.get()); + if (pDlg) + return pDlg->GetPageNumber(); + + return 0; +} + +std::optional AbstractSwBreakDlg_Impl::GetClear() +{ + SwBreakDlg* pDlg = dynamic_cast(m_xDlg.get()); + if (pDlg) + return pDlg->GetClear(); + + return SwLineBreakClear::NONE; +} + +void AbstractSwConvertTableDlg_Impl::GetValues( sal_Unicode& rDelim,SwInsertTableOptions& rInsTableFlags, + SwTableAutoFormat const*& prTAFormat) +{ + m_xDlg->GetValues(rDelim,rInsTableFlags, prTAFormat); +} + +void AbstractSwInsertDBColAutoPilot_Impl::DataToDoc( const uno::Sequence< uno::Any >& rSelection, + uno::Reference< sdbc::XDataSource> rxSource, + uno::Reference< sdbc::XConnection> xConnection, + uno::Reference< sdbc::XResultSet > xResultSet) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + m_xDlg->DataToDoc(rSelection, rxSource, xConnection, xResultSet); +#else + (void) rSelection; + (void) rxSource; + (void) xConnection; + (void) xResultSet; +#endif +} + +bool AbstractDropDownFieldDialog_Impl::PrevButtonPressed() const +{ + return m_xDlg->PrevButtonPressed(); +} + +bool AbstractDropDownFieldDialog_Impl::NextButtonPressed() const +{ + return m_xDlg->NextButtonPressed(); +} + +void AbstractSwLabDlg_Impl::SetCurPageId( const OUString &rName ) +{ + m_xDlg->SetCurPageId( rName ); +} + +const SfxItemSet* AbstractSwLabDlg_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +WhichRangesContainer AbstractSwLabDlg_Impl::GetInputRanges(const SfxItemPool& pItem ) +{ + return m_xDlg->GetInputRanges( pItem ); +} + +void AbstractSwLabDlg_Impl::SetInputSet( const SfxItemSet* pInSet ) +{ + m_xDlg->SetInputSet( pInSet ); +} + +void AbstractSwLabDlg_Impl::SetText( const OUString& rStr ) +{ + m_xDlg->set_title(rStr); +} + +const OUString& AbstractSwLabDlg_Impl::GetBusinessCardStr() const +{ + return m_xDlg->GetBusinessCardStr(); +} + +Printer * AbstractSwLabDlg_Impl::GetPrt() +{ + return m_xDlg->GetPrt(); +} + +void AbstractSwSelGlossaryDlg_Impl::InsertGlos(const OUString &rRegion, const OUString &rGlosName) +{ + m_xDlg->InsertGlos( rRegion, rGlosName ); +} + +sal_Int32 AbstractSwSelGlossaryDlg_Impl::GetSelectedIdx() const +{ + return m_xDlg->GetSelectedIdx(); +} + +void AbstractSwSelGlossaryDlg_Impl::SelectEntryPos(sal_Int32 nIdx) +{ + m_xDlg->SelectEntryPos( nIdx ); +} + +std::unique_ptr AbstractSwAutoFormatDlg_Impl::FillAutoFormatOfIndex() const +{ + return m_xDlg->FillAutoFormatOfIndex(); +} + +void AbstractSwFieldDlg_Impl::SetCurPageId( const OUString &rName ) +{ + m_xDlg->SetCurPageId( rName ); +} + +const SfxItemSet* AbstractSwFieldDlg_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +WhichRangesContainer AbstractSwFieldDlg_Impl::GetInputRanges(const SfxItemPool& pItem ) +{ + return m_xDlg->GetInputRanges( pItem ); +} + +void AbstractSwFieldDlg_Impl::SetInputSet( const SfxItemSet* pInSet ) +{ + m_xDlg->SetInputSet( pInSet ); +} + +void AbstractSwFieldDlg_Impl::SetText( const OUString& rStr ) +{ + m_xDlg->set_title(rStr); +} + +bool AbstractSwFieldDlg_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + auto xDlg = m_xDlg; + return SfxTabDialogController::runAsync(m_xDlg, [=](sal_Int32 nResult){ + xDlg->Close(); + if (rCtx.isSet()) + rCtx.maEndDialogFn(nResult); + }); +} + +void AbstractSwFieldDlg_Impl::Initialize(SfxChildWinInfo *pInfo) +{ + m_xDlg->Initialize( pInfo ); +} + +void AbstractSwFieldDlg_Impl::ReInitDlg() +{ + m_xDlg->ReInitDlg(); +} + +void AbstractSwFieldDlg_Impl::ActivateDatabasePage() +{ + m_xDlg->ActivateDatabasePage(); +} + +void AbstractSwFieldDlg_Impl::ShowReferencePage() +{ + m_xDlg->ShowReferencePage(); +} + +std::shared_ptr AbstractSwFieldDlg_Impl::GetController() +{ + return m_xDlg; +} + +void AbstractSwRenameXNamedDlg_Impl::SetForbiddenChars( const OUString& rSet ) +{ + m_xDlg->SetForbiddenChars( rSet ); +} + +void AbstractSwRenameXNamedDlg_Impl::SetAlternativeAccess( + css::uno::Reference< css::container::XNameAccess > & xSecond, + css::uno::Reference< css::container::XNameAccess > & xThird ) +{ + m_xDlg->SetAlternativeAccess( xSecond, xThird); +} + +OUString AbstractGlossaryDlg_Impl::GetCurrGrpName() const +{ + return m_xDlg->GetCurrGrpName(); +} + +OUString AbstractGlossaryDlg_Impl::GetCurrShortName() const +{ + return m_xDlg->GetCurrShortName(); +} + +void AbstractFieldInputDlg_Impl::EndDialog(sal_Int32 n) +{ + m_xDlg->response(n); +} + +bool AbstractFieldInputDlg_Impl::PrevButtonPressed() const +{ + return m_xDlg->PrevButtonPressed(); +} + +bool AbstractFieldInputDlg_Impl::NextButtonPressed() const +{ + return m_xDlg->NextButtonPressed(); +} + +OUString AbstractInsFootNoteDlg_Impl::GetFontName() +{ + return m_xDlg->GetFontName(); +} + +int AbstractSwPageNumberDlg_Impl::GetPageNumberPosition() const +{ + return m_xDlg->GetPageNumberPosition(); +} + +int AbstractSwPageNumberDlg_Impl::GetPageNumberAlignment() const +{ + return m_xDlg->GetPageNumberAlignment(); +} + +bool AbstractSwPageNumberDlg_Impl::GetMirrorOnEvenPages() const +{ + return m_xDlg->GetMirrorOnEvenPages(); +} + +bool AbstractSwPageNumberDlg_Impl::GetIncludePageTotal() const +{ + return m_xDlg->GetIncludePageTotal(); +} + +SvxNumType AbstractSwPageNumberDlg_Impl::GetPageNumberType() const +{ + return m_xDlg->GetPageNumberType(); +} + +void AbstractSwPageNumberDlg_Impl::SetPageNumberType(SvxNumType nSet) +{ + m_xDlg->SetPageNumberType(nSet); +} + +bool AbstractInsFootNoteDlg_Impl::IsEndNote() +{ + return m_xDlg->IsEndNote(); +} + +OUString AbstractInsFootNoteDlg_Impl::GetStr() +{ + return m_xDlg->GetStr(); +} + +void AbstractInsFootNoteDlg_Impl::SetHelpId(const OUString& rHelpId) +{ + m_xDlg->set_help_id(rHelpId); +} + +void AbstractInsFootNoteDlg_Impl::SetText( const OUString& rStr ) +{ + m_xDlg->set_title(rStr); +} + +void AbstractInsTableDlg_Impl::GetValues( OUString& rName, sal_uInt16& rRow, sal_uInt16& rCol, + SwInsertTableOptions& rInsTableFlags, OUString& rTableAutoFormatName, + std::unique_ptr& prTAFormat ) +{ + SwInsTableDlg* pDlg = dynamic_cast(m_xDlg.get()); + if (pDlg) + pDlg->GetValues(rName, rRow, rCol, rInsTableFlags, rTableAutoFormatName, prTAFormat); +} + +OUString AbstractJavaEditDialog_Impl::GetScriptText() const +{ + return m_xDlg->GetScriptText(); +} + +OUString AbstractJavaEditDialog_Impl::GetScriptType() const +{ + return m_xDlg->GetScriptType(); +} + +bool AbstractJavaEditDialog_Impl::IsUrl() const +{ + return m_xDlg->IsUrl(); +} + +bool AbstractJavaEditDialog_Impl::IsNew() const +{ + return m_xDlg->IsNew(); +} + +bool AbstractJavaEditDialog_Impl::IsUpdate() const +{ + return m_xDlg->IsUpdate(); +} + +DBManagerOptions AbstractMailMergeDlg_Impl::GetMergeType() +{ + return m_xDlg->GetMergeType(); +} + +const OUString& AbstractMailMergeDlg_Impl::GetSaveFilter() const +{ + return m_xDlg->GetSaveFilter(); +} + +css::uno::Sequence< css::uno::Any > AbstractMailMergeDlg_Impl::GetSelection() const +{ + return m_xDlg->GetSelection(); +} + +uno::Reference< sdbc::XResultSet> AbstractMailMergeDlg_Impl::GetResultSet() const +{ + return m_xDlg->GetResultSet(); +} + +bool AbstractMailMergeDlg_Impl::IsSaveSingleDoc() const +{ + return m_xDlg->IsSaveSingleDoc(); +} + +bool AbstractMailMergeDlg_Impl::IsGenerateFromDataBase() const +{ + return m_xDlg->IsGenerateFromDataBase(); +} + +bool AbstractMailMergeDlg_Impl::IsFileEncryptedFromDataBase() const +{ + return m_xDlg->IsFileEncryptedFromDataBase(); +} + +OUString AbstractMailMergeDlg_Impl::GetColumnName() const +{ + return m_xDlg->GetColumnName(); +} + +OUString AbstractMailMergeDlg_Impl::GetPasswordColumnName() const +{ + return m_xDlg->GetPasswordColumnName(); +} + +OUString AbstractMailMergeDlg_Impl::GetTargetURL() const +{ + return m_xDlg->GetTargetURL(); +} + +bool AbstractMailMergeCreateFromDlg_Impl::IsThisDocument() const +{ + return m_xDlg->IsThisDocument(); +} + +bool AbstractMailMergeFieldConnectionsDlg_Impl::IsUseExistingConnections() const +{ + return m_xDlg->IsUseExistingConnections(); +} + +CurTOXType AbstractMultiTOXTabDialog_Impl::GetCurrentTOXType() const +{ + return m_xDlg->GetCurrentTOXType(); +} + +SwTOXDescription& AbstractMultiTOXTabDialog_Impl::GetTOXDescription(CurTOXType eTOXTypes) +{ + return m_xDlg->GetTOXDescription(eTOXTypes); +} + +const SfxItemSet* AbstractMultiTOXTabDialog_Impl::GetOutputItemSet() const +{ + return m_xDlg->GetOutputItemSet(); +} + +void AbstractEditRegionDlg_Impl::SelectSection(const OUString& rSectionName) +{ + m_xDlg->SelectSection(rSectionName); +} + +void +AbstractInsertSectionTabDialog_Impl::SetSectionData(SwSectionData const& rSect) +{ + m_xDlg->SetSectionData(rSect); +} + +void AbstractIndexMarkFloatDlg_Impl::ReInitDlg(SwWrtShell& rWrtShell) +{ + m_xDlg->ReInitDlg( rWrtShell); +} + +std::shared_ptr AbstractIndexMarkFloatDlg_Impl::GetController() +{ + return m_xDlg; +} + +void AbstractAuthMarkFloatDlg_Impl::ReInitDlg(SwWrtShell& rWrtShell) +{ + m_xDlg->ReInitDlg(rWrtShell); +} + +std::shared_ptr AbstractAuthMarkFloatDlg_Impl::GetController() +{ + return m_xDlg; +} + +std::shared_ptr AbstractSwWordCountFloatDlg_Impl::GetController() +{ + return m_xDlg; +} + +void AbstractSwWordCountFloatDlg_Impl::UpdateCounts() +{ + m_xDlg->UpdateCounts(); +} + +void AbstractSwWordCountFloatDlg_Impl::SetCounts(const SwDocStat &rCurrCnt, const SwDocStat &rDocStat) +{ + m_xDlg->SetCounts(rCurrCnt, rDocStat); +} + +AbstractMailMergeWizard_Impl::~AbstractMailMergeWizard_Impl() +{ +} + +bool AbstractMailMergeWizard_Impl::StartExecuteAsync(AsyncContext &rCtx) +{ + // SwMailMergeWizardExecutor wants to run the lifecycle of this dialog + // so clear mxOwner here and leave it up to SwMailMergeWizardExecutor + rCtx.mxOwner.clear(); + return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn); +} + +short AbstractMailMergeWizard_Impl::Execute() +{ + return m_xDlg->run(); +} + +OUString AbstractMailMergeWizard_Impl::GetReloadDocument() const +{ + return m_xDlg->GetReloadDocument(); +} + +void AbstractMailMergeWizard_Impl::ShowPage( sal_uInt16 nLevel ) +{ + m_xDlg->skipUntil(nLevel); +} + +sal_uInt16 AbstractMailMergeWizard_Impl::GetRestartPage() const +{ + return m_xDlg->GetRestartPage(); +} + +std::optional AbstractSwTranslateLangSelectDlg_Impl::GetSelectedLanguage() +{ +#if HAVE_FEATURE_CURL && !ENABLE_WASM_STRIP_EXTRA + return SwTranslateLangSelectDlg::GetSelectedLanguage(); +#else + return {}; +#endif +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwInsertAbstractDlg(weld::Window* pParent) +{ + return VclPtr::Create(std::make_unique(pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwAddressAbstractDlg(weld::Window* pParent, + const SfxItemSet& rSet) +{ + return VclPtr::Create(std::make_unique(pParent, rSet)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwDropCapsDialog(weld::Window* pParent, + const SfxItemSet& rSet) +{ + return VclPtr::Create(std::make_unique(pParent, rSet)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwBackgroundDialog(weld::Window* pParent, + const SfxItemSet& rSet) +{ + return VclPtr::Create(std::make_unique(pParent, rSet)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateNumFormatDialog(weld::Widget* pParent, const SfxItemSet& rSet) +{ + return VclPtr::Create(std::make_shared(pParent, rSet)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwAsciiFilterDlg(weld::Window* pParent, + SwDocShell& rDocSh, SvStream* pStream) +{ + return VclPtr::Create(std::make_unique(pParent, rDocSh, pStream)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwInsertBookmarkDlg(weld::Window *pParent, + SwWrtShell &rSh, OUString const*const pSelected) +{ + return VclPtr::Create(std::make_shared(pParent, rSh, pSelected)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwContentControlDlg(weld::Window* pParent, + SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSh)); +} + +VclPtr +SwAbstractDialogFactory_Impl::CreateSwContentControlListItemDlg(weld::Window* pParent, + SwContentControlListItem& rItem) +{ + return VclPtr::Create( + std::make_shared(pParent, rItem)); +} + +std::shared_ptr SwAbstractDialogFactory_Impl::CreateSwBreakDlg(weld::Window* pParent, SwWrtShell &rSh) +{ + return std::make_shared(std::make_unique(pParent, rSh)); +} + +std::shared_ptr SwAbstractDialogFactory_Impl::CreateSwTranslateLangSelectDlg(weld::Window* pParent, SwWrtShell &rSh) +{ +#if HAVE_FEATURE_CURL && !ENABLE_WASM_STRIP_EXTRA + return std::make_shared(std::make_unique(pParent, rSh)); +#else + (void) pParent; + (void) rSh; + return nullptr; +#endif +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwChangeDBDlg(SwView& rVw) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + return VclPtr::Create(std::make_shared(rVw)); +#else + (void) rVw; + return nullptr; +#endif +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwCharDlg(weld::Window* pParent, SwView& pVw, + const SfxItemSet& rCoreSet, SwCharDlgMode nDialogMode, const OUString* pFormatStr) +{ + return VclPtr::Create(std::make_shared(pParent, pVw, rCoreSet, nDialogMode, pFormatStr)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwConvertTableDlg(SwView& rView, bool bToTable) +{ + return VclPtr::Create(std::make_unique(rView, bToTable)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwCaptionDialog(weld::Window *pParent, SwView &rV) +{ + return VclPtr::Create(std::make_shared(pParent, rV)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwInsertDBColAutoPilot( SwView& rView, + uno::Reference< sdbc::XDataSource> rxSource, + uno::Reference xColSupp, + const SwDBData& rData) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + return VclPtr::Create(std::make_unique(rView, rxSource, xColSupp, rData)); +#else + (void) rView; + (void) rxSource; + (void) xColSupp; + (void) rData; + return nullptr; +#endif +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwFootNoteOptionDlg(weld::Window *pParent, SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateDropDownFieldDialog(weld::Widget *pParent, + SwWrtShell &rSh, SwField* pField, bool bPrevButton, bool bNextButton) +{ + return VclPtr::Create(std::make_unique(pParent, rSh, pField, bPrevButton, bNextButton)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateDropDownFormFieldDialog(weld::Widget *pParent, sw::mark::IFieldmark* pDropDownField) +{ + return VclPtr::Create(std::make_unique(pParent, pDropDownField)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateDateFormFieldDialog(weld::Widget *pParent, sw::mark::IDateFieldmark* pDateField, SwDoc& rDoc) +{ + return VclPtr::Create(std::make_unique(pParent, pDateField, rDoc)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwEnvDlg(weld::Window* pParent, const SfxItemSet& rSet, + SwWrtShell* pWrtSh, Printer* pPrt, + bool bInsert) +{ + return VclPtr::Create(std::make_shared(pParent, rSet, pWrtSh,pPrt, bInsert)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwLabDlg(weld::Window* pParent, const SfxItemSet& rSet, + SwDBManager* pDBManager, bool bLabel) +{ + return VclPtr::Create(std::make_unique(pParent, rSet, pDBManager, bLabel)); +} + +SwLabDlgMethod SwAbstractDialogFactory_Impl::GetSwLabDlgStaticMethod () +{ + return SwLabDlg::UpdateFieldInformation; +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwParaDlg(weld::Window *pParent, SwView& rVw, + const SfxItemSet& rCoreSet, + bool bDraw , + const OUString& sDefPage) +{ + return VclPtr::Create(std::make_shared(pParent, rVw, rCoreSet, DLG_STD, nullptr, bDraw, sDefPage)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwAutoMarkDialog(weld::Window *pParent, SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwColumnDialog(weld::Window *pParent, SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwTableHeightDialog(weld::Window *pParent, SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_unique(pParent, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwSortingDialog(weld::Window *pParent, SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_unique(pParent, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSplitTableDialog(weld::Window *pParent, SwWrtShell &rSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwSelGlossaryDlg(weld::Window *pParent, const OUString &rShortName) +{ + return VclPtr::Create(std::make_unique(pParent, rShortName)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwAutoFormatDlg(weld::Window* pParent, + SwWrtShell* pShell, bool bSetAutoFormat, const SwTableAutoFormat* pSelFormat) +{ + return VclPtr::Create( + std::unique_ptr>( + new SwAutoFormatDlg(pParent, pShell, bSetAutoFormat, pSelFormat))); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwBorderDlg(weld::Window* pParent, SfxItemSet& rSet, SwBorderModes nType ) +{ + return VclPtr::Create(std::make_unique(pParent, rSet, nType)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwWrapDlg(weld::Window* pParent, SfxItemSet& rSet, SwWrtShell* pSh) +{ + return VclPtr::Create(std::make_unique(pParent, rSet, pSh, true/*bDrawMode*/)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwTableWidthDlg(weld::Window *pParent, SwTableFUNC &rFnc) +{ + return VclPtr::Create(std::make_unique(pParent, rFnc)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwTableTabDlg(weld::Window* pParent, + const SfxItemSet* pItemSet, SwWrtShell* pSh) +{ + return VclPtr::Create(std::make_shared(pParent, pItemSet, pSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwFieldDlg(SfxBindings* pB, SwChildWinWrapper* pCW, weld::Window *pParent) +{ + return VclPtr::Create(std::make_shared(pB, pCW, pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwFieldEditDlg(SwView& rVw) +{ + return VclPtr::Create(std::make_unique(rVw)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwRenameXNamedDlg(weld::Widget* pParent, + css::uno::Reference< css::container::XNamed > & xNamed, + css::uno::Reference< css::container::XNameAccess > & xNameAccess) +{ + return VclPtr::Create(std::make_unique(pParent,xNamed, xNameAccess)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwModalRedlineAcceptDlg(weld::Window *pParent) +{ + return VclPtr::Create(std::make_unique(pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwPageNumberDlg(weld::Window *pParent) +{ + return VclPtr::Create(std::make_shared(pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateTableMergeDialog(weld::Window* pParent, bool& rWithPrev) +{ + return VclPtr::Create(std::make_unique(pParent, rWithPrev)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateFrameTabDialog(const OUString &rDialogType, + SfxViewFrame& rFrame, weld::Window *pParent, + const SfxItemSet& rCoreSet, + bool bNewFrame, + const OUString& sDefPage ) +{ + return VclPtr::Create(std::make_shared(rFrame, pParent, rCoreSet, bNewFrame, rDialogType, false/*bFormat*/, sDefPage, nullptr)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateTemplateDialog( + weld::Window *pParent, + SfxStyleSheetBase& rBase, + SfxStyleFamily nRegion, + const OUString& sPage, + SwWrtShell* pActShell, + bool bNew ) +{ + return VclPtr::Create(std::make_shared(pParent, rBase, nRegion, + sPage, pActShell, bNew)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateGlossaryDlg(SfxViewFrame& rViewFrame, SwGlossaryHdl* pGlosHdl, + SwWrtShell *pWrtShell) +{ + return VclPtr::Create(std::make_unique(rViewFrame, pGlosHdl, pWrtShell)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateFieldInputDlg(weld::Widget *pParent, + SwWrtShell &rSh, SwField* pField, bool bPrevButton, bool bNextButton) +{ + return VclPtr::Create(std::make_unique(pParent, rSh, pField, bPrevButton, bNextButton)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateInsFootNoteDlg( + weld::Window * pParent, SwWrtShell &rSh, bool bEd ) +{ + return VclPtr::Create(std::make_unique(pParent, rSh, bEd)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateTitlePageDlg(weld::Window *pParent) +{ + return VclPtr::Create(std::make_shared(pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateVclSwViewDialog(SwView& rView) +{ + return VclPtr::Create(std::make_shared(rView)); +} + +std::shared_ptr SwAbstractDialogFactory_Impl::CreateInsTableDlg(SwView& rView) +{ + return std::make_shared(std::make_shared(rView)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateJavaEditDialog( + weld::Window* pParent, SwWrtShell* pWrtSh) +{ + return VclPtr::Create(std::make_unique(pParent, pWrtSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateMailMergeDlg( + weld::Window* pParent, SwWrtShell& rSh, + const OUString& rSourceName, + const OUString& rTableName, + sal_Int32 nCommandType, + const uno::Reference< sdbc::XConnection>& xConnection ) +{ + return VclPtr::Create(std::make_unique(pParent, rSh, rSourceName, rTableName, nCommandType, xConnection, nullptr)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateMailMergeCreateFromDlg(weld::Window* pParent) +{ + return VclPtr::Create(std::make_unique(pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateMailMergeFieldConnectionsDlg(weld::Window* pParent) +{ + return VclPtr::Create(std::make_unique(pParent)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateMultiTOXMarkDlg(weld::Window* pParent, SwTOXMgr &rTOXMgr) +{ + return VclPtr::Create(std::make_unique(pParent, rTOXMgr)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSvxNumBulletTabDialog(weld::Window* pParent, + const SfxItemSet& rSwItemSet, + SwWrtShell & rWrtSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSwItemSet, rWrtSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateOutlineTabDialog(weld::Window* pParent, + const SfxItemSet* pSwItemSet, + SwWrtShell & rWrtSh ) +{ + return VclPtr::Create(std::make_shared(pParent, pSwItemSet, rWrtSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateMultiTOXTabDialog(weld::Widget* pParent, const SfxItemSet& rSet, + SwWrtShell &rShell, SwTOXBase* pCurTOX, bool bGlobal) +{ + return VclPtr::Create(std::make_shared(pParent, rSet, rShell, pCurTOX, USHRT_MAX, bGlobal)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateEditRegionDlg(weld::Window* pParent, SwWrtShell& rWrtSh) +{ + return VclPtr::Create(std::make_shared(pParent, rWrtSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateInsertSectionTabDialog(weld::Window* pParent, + const SfxItemSet& rSet, SwWrtShell& rSh) +{ + return VclPtr::Create(std::make_shared(pParent, rSet, rSh)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateIndexMarkFloatDlg( + SfxBindings* pBindings, + SfxChildWindow* pChild, + weld::Window *pParent, + SfxChildWinInfo* pInfo ) +{ + return VclPtr::Create(std::make_shared(pBindings, pChild, pParent, pInfo, true/*bNew*/)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateAuthMarkFloatDlg( + SfxBindings* pBindings, + SfxChildWindow* pChild, + weld::Window *pParent, + SfxChildWinInfo* pInfo) +{ + return VclPtr::Create(std::make_shared(pBindings, pChild, pParent, pInfo, true/*bNew*/)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateSwWordCountDialog( + SfxBindings* pBindings, + SfxChildWindow* pChild, + weld::Window *pParent, + SfxChildWinInfo* pInfo) +{ + return VclPtr::Create(std::make_shared(pBindings, pChild, pParent, pInfo)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateIndexMarkModalDlg(weld::Window *pParent, SwWrtShell& rSh, SwTOXMark* pCurTOXMark ) +{ + return VclPtr::Create(std::make_shared(pParent, rSh, pCurTOXMark)); +} + +VclPtr SwAbstractDialogFactory_Impl::CreateMailMergeWizard( + SwView& rView, std::shared_ptr& rConfigItem) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + return VclPtr::Create(std::make_shared(rView, rConfigItem)); +#else + (void) rView; + (void) rConfigItem; + return nullptr; +#endif +} + +GlossaryGetCurrGroup SwAbstractDialogFactory_Impl::GetGlossaryCurrGroupFunc() +{ + return SwGlossaryDlg::GetCurrGroup; +} + +GlossarySetActGroup SwAbstractDialogFactory_Impl::SetGlossaryActGroupFunc() +{ + return SwGlossaryDlg::SetActGroup; +} + +// Factories for TabPages +CreateTabPage SwAbstractDialogFactory_Impl::GetTabPageCreatorFunc( sal_uInt16 nId ) +{ + CreateTabPage pRet = nullptr; + switch ( nId ) + { + case RID_SW_TP_OPTCOMPATIBILITY_PAGE : + pRet = SwCompatibilityOptPage::Create; + break; + case RID_SW_TP_OPTLOAD_PAGE : + pRet = SwLoadOptPage::Create; + break; + case RID_SW_TP_OPTCAPTION_PAGE: + return SwCaptionOptPage::Create; + case RID_SW_TP_CONTENT_OPT: + case RID_SW_TP_HTML_CONTENT_OPT: + pRet = SwContentOptPage::Create; + break; + case RID_SW_TP_OPTSHDWCRSR: + case RID_SW_TP_HTML_OPTSHDWCRSR: + pRet = SwShdwCursorOptionsTabPage::Create; + break; + case RID_SW_TP_REDLINE_OPT : + pRet = SwRedlineOptionsTabPage::Create; + break; + case RID_SW_TP_OPTTEST_PAGE : +#ifdef DBG_UTIL + pRet = SwTestTabPage::Create; +#endif + break; + case TP_OPTPRINT_PAGE : + case RID_SW_TP_HTML_OPTPRINT_PAGE: + case RID_SW_TP_OPTPRINT_PAGE: + pRet = SwAddPrinterTabPage::Create; + break; + case RID_SW_TP_STD_FONT: + case RID_SW_TP_STD_FONT_CJK: + case RID_SW_TP_STD_FONT_CTL: + pRet = SwStdFontTabPage::Create; + break; + case RID_SW_TP_HTML_OPTTABLE_PAGE: + case RID_SW_TP_OPTTABLE_PAGE: + pRet = SwTableOptionsTabPage::Create; + break; + case RID_SW_TP_DOC_STAT : + pRet = SwDocStatPage::Create; + break; + case RID_SW_TP_MAILCONFIG: + pRet = SwMailConfigPage::Create; + break; + case RID_SW_TP_COMPARISON_OPT : + pRet = SwCompareOptionsTabPage::Create; + break; + } + + return pRet; +} + +void SwAbstractDialogFactory_Impl::ExecuteMMResultSaveDialog(weld::Window* pParent) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + SwMMResultSaveDialog aDialog(pParent); + aDialog.run(); +#else + (void) pParent; +#endif +} + +void SwAbstractDialogFactory_Impl::ExecuteMMResultPrintDialog(weld::Window* pParent) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + SwMMResultPrintDialog aDialog(pParent); + aDialog.run(); +#else + (void) pParent; +#endif +} + +void SwAbstractDialogFactory_Impl::ExecuteMMResultEmailDialog(weld::Window* pParent) +{ +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + SwMMResultEmailDialog aDialog(pParent); + aDialog.run(); +#else + (void) pParent; +#endif +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/swdlgfact.hxx b/sw/source/ui/dialog/swdlgfact.hxx new file mode 100644 index 0000000000..d5c1c43806 --- /dev/null +++ b/sw/source/ui/dialog/swdlgfact.hxx @@ -0,0 +1,881 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_SW_SOURCE_UI_DIALOG_SWDLGFACT_HXX +#define INCLUDED_SW_SOURCE_UI_DIALOG_SWDLGFACT_HXX + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +class SwInsertAbstractDlg; +class SwAsciiFilterDlg; +class SwBreakDlg; +class SwMultiTOXMarkDlg; +class SwSortDlg; +class SwTableHeightDlg; +class SwTableWidthDlg; +class SwMergeTableDlg; +class SfxTabDialog; +class SwConvertTableDlg; +class SwInsertDBColAutoPilot; +class SwLabDlg; +class SwSelGlossaryDlg; +class SwAutoFormatDlg; +class SwFieldDlg; +class SwRenameXNamedDlg; +class SwModalRedlineAcceptDlg; +class SwTOXMark; +class SwSplitTableDlg; +namespace sw +{ +class DropDownFieldDialog; +class DropDownFormFieldDialog; +class DateFormFieldDialog; +} +class SwWordCountFloatDlg; + + +class AbstractSwWordCountFloatDlg_Impl : public AbstractSwWordCountFloatDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractSwWordCountFloatDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void UpdateCounts() override; + virtual void SetCounts(const SwDocStat &rCurrCnt, const SwDocStat &rDocStat) override; + virtual std::shared_ptr GetController() override; +}; + +class AbstractSwInsertAbstractDlg_Impl : public AbstractSwInsertAbstractDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwInsertAbstractDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual sal_uInt8 GetLevel() const override ; + virtual sal_uInt8 GetPara() const override ; +}; + +class SwAbstractSfxController_Impl : public SfxAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit SwAbstractSfxController_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual const SfxItemSet* GetOutputItemSet() const override; + virtual void SetText(const OUString& rStr) override; +}; + +class AbstractNumFormatDlg_Impl : public SfxAbstractDialog +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractNumFormatDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual const SfxItemSet* GetOutputItemSet() const override; + virtual void SetText(const OUString& rStr) override; +}; + +class AbstractSwAsciiFilterDlg_Impl : public AbstractSwAsciiFilterDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwAsciiFilterDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void FillOptions( SwAsciiOptions& rOptions ) override; +}; + +/// Interface implementation for the insert -> fields -> page number wizard dialog +class AbstractSwPageNumberDlg_Impl : public AbstractSwPageNumberDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractSwPageNumberDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual int GetPageNumberPosition() const override; + virtual int GetPageNumberAlignment() const override; + bool GetMirrorOnEvenPages() const override; + bool GetIncludePageTotal() const override; + SvxNumType GetPageNumberType() const override; + void SetPageNumberType(SvxNumType nSet) override; +}; + +class AbstractGenericDialog_Impl : public VclAbstractDialog +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractGenericDialog_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; +}; + +class AbstractSwSortDlg_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwSortDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractMultiTOXMarkDlg_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractMultiTOXMarkDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractNumBulletDialog_Impl : public AbstractNumBulletDialog +{ +protected: + std::shared_ptr m_xDlg; +public: + explicit AbstractNumBulletDialog_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual void SetCurPageId( const OUString &rName ) override; + virtual const SfxItemSet* GetOutputItemSet() const override; + virtual const SfxItemSet* GetInputItemSet() const override; + virtual WhichRangesContainer GetInputRanges( const SfxItemPool& pItem ) override; + virtual void SetInputSet( const SfxItemSet* pInSet ) override; + //From class Window. + virtual void SetText( const OUString& rStr ) override; +}; + +class AbstractSwBreakDlg_Impl : public AbstractSwBreakDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractSwBreakDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual OUString GetTemplateName() override; + virtual sal_uInt16 GetKind() override; + virtual ::std::optional GetPageNumber() override; + std::optional GetClear() override; + + virtual std::shared_ptr getDialogController() override { return m_xDlg; } +}; + +class AbstractSwTranslateLangSelectDlg_Impl : public AbstractSwTranslateLangSelectDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractSwTranslateLangSelectDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + + virtual std::shared_ptr getDialogController() override { return m_xDlg; } + virtual std::optional GetSelectedLanguage() override; +}; + +class AbstractSwTableWidthDlg_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwTableWidthDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractSwTableHeightDlg_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwTableHeightDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractSwMergeTableDlg_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwMergeTableDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractSplitTableDialog_Impl : public AbstractSplitTableDialog // add for +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractSplitTableDialog_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual SplitTable_HeadlineOption GetSplitMode() override; +}; + +class AbstractTabController_Impl : virtual public SfxAbstractTabDialog +{ +protected: + std::shared_ptr m_xDlg; +public: + explicit AbstractTabController_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual void SetCurPageId( const OUString &rName ) override; + virtual const SfxItemSet* GetOutputItemSet() const override; + virtual WhichRangesContainer GetInputRanges( const SfxItemPool& pItem ) override; + virtual void SetInputSet( const SfxItemSet* pInSet ) override; + //From class Window. + virtual void SetText( const OUString& rStr ) override; +}; + +class AbstractApplyTabController_Impl : public AbstractTabController_Impl, virtual public SfxAbstractApplyTabDialog +{ +public: + explicit AbstractApplyTabController_Impl(std::shared_ptr p) + : AbstractTabController_Impl(std::move(p)) + { + } + DECL_LINK(ApplyHdl, weld::Button&, void); +private: + Link m_aHandler; + virtual void SetApplyHdl( const Link& rLink ) override; +}; + +class AbstractSwConvertTableDlg_Impl : public AbstractSwConvertTableDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwConvertTableDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void GetValues( sal_Unicode& rDelim,SwInsertTableOptions& rInsTableFlags, + SwTableAutoFormat const*& prTAFormat) override; +}; + +class AbstractSwInsertDBColAutoPilot_Impl : public AbstractSwInsertDBColAutoPilot +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwInsertDBColAutoPilot_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void DataToDoc( const css::uno::Sequence< css::uno::Any >& rSelection, + css::uno::Reference< css::sdbc::XDataSource> rxSource, + css::uno::Reference< css::sdbc::XConnection> xConnection, + css::uno::Reference< css::sdbc::XResultSet > xResultSet) override; +}; + +class AbstractDropDownFieldDialog_Impl : public AbstractDropDownFieldDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractDropDownFieldDialog_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool PrevButtonPressed() const override; + virtual bool NextButtonPressed() const override; +}; + +class AbstractDropDownFormFieldDialog_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractDropDownFormFieldDialog_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractDateFormFieldDialog_Impl : public VclAbstractDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractDateFormFieldDialog_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class AbstractSwLabDlg_Impl : public AbstractSwLabDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwLabDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void SetCurPageId( const OUString &rName ) override; + virtual const SfxItemSet* GetOutputItemSet() const override; + virtual WhichRangesContainer GetInputRanges( const SfxItemPool& pItem ) override; + virtual void SetInputSet( const SfxItemSet* pInSet ) override; + //From class Window. + virtual void SetText( const OUString& rStr ) override; + virtual const OUString& GetBusinessCardStr() const override; + virtual Printer *GetPrt() override; +}; + +class AbstractSwSelGlossaryDlg_Impl : public AbstractSwSelGlossaryDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwSelGlossaryDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void InsertGlos(const OUString &rRegion, const OUString &rGlosName) override; // inline + virtual sal_Int32 GetSelectedIdx() const override; // inline + virtual void SelectEntryPos(sal_Int32 nIdx) override; // inline +}; + +class AbstractSwAutoFormatDlg_Impl : public AbstractSwAutoFormatDlg +{ + std::unique_ptr> m_xDlg; +public: + explicit AbstractSwAutoFormatDlg_Impl(std::unique_ptr> p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual std::unique_ptr FillAutoFormatOfIndex() const override; +}; + +class AbstractSwFieldDlg_Impl : public AbstractSwFieldDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractSwFieldDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual void SetCurPageId( const OUString &rName ) override; + virtual const SfxItemSet* GetOutputItemSet() const override; + virtual WhichRangesContainer GetInputRanges( const SfxItemPool& pItem ) override; + virtual void SetInputSet( const SfxItemSet* pInSet ) override; + //From class Window. + virtual void SetText( const OUString& rStr ) override; + virtual void ShowReferencePage() override; + virtual void Initialize(SfxChildWinInfo *pInfo) override; + virtual void ReInitDlg() override; + virtual void ActivateDatabasePage() override; + virtual std::shared_ptr GetController() override; +}; + +class AbstractSwRenameXNamedDlg_Impl : public AbstractSwRenameXNamedDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwRenameXNamedDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void SetForbiddenChars( const OUString& rSet ) override; + virtual void SetAlternativeAccess( + css::uno::Reference< css::container::XNameAccess > & xSecond, + css::uno::Reference< css::container::XNameAccess > & xThird ) override; +}; + +/** + * Implementation of AbstractSwContentControlListItemDlg, that is only visible to + * SwAbstractDialogFactory_Impl::CreateSwContentControlListItemDlg(). + */ +class AbstractSwContentControlListItemDlg_Impl : public AbstractSwContentControlListItemDlg +{ + std::shared_ptr m_xDlg; + +public: + explicit AbstractSwContentControlListItemDlg_Impl( + std::shared_ptr xDlg) + : m_xDlg(std::move(xDlg)) + { + } + + short Execute() override; + bool StartExecuteAsync(VclAbstractDialog::AsyncContext &) override; +}; + +class AbstractSwModalRedlineAcceptDlg_Impl : public AbstractSwModalRedlineAcceptDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractSwModalRedlineAcceptDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; +}; + +class SwGlossaryDlg; +class AbstractGlossaryDlg_Impl : public AbstractGlossaryDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractGlossaryDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual OUString GetCurrGrpName() const override; + virtual OUString GetCurrShortName() const override; +}; + +class SwFieldInputDlg; +class AbstractFieldInputDlg_Impl : public AbstractFieldInputDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractFieldInputDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void EndDialog(sal_Int32) override; + virtual bool PrevButtonPressed() const override; + virtual bool NextButtonPressed() const override; +}; + +class SwInsFootNoteDlg; +class AbstractInsFootNoteDlg_Impl : public AbstractInsFootNoteDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractInsFootNoteDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual OUString GetFontName() override; + virtual bool IsEndNote() override; + virtual OUString GetStr() override; + //from class Window + virtual void SetHelpId( const OUString& sHelpId ) override; + virtual void SetText( const OUString& rStr ) override; +}; + +class SwInsTableDlg; +class AbstractInsTableDlg_Impl : public AbstractInsTableDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractInsTableDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual void GetValues( OUString& rName, sal_uInt16& rRow, sal_uInt16& rCol, + SwInsertTableOptions& rInsTableFlags, OUString& rTableAutoFormatName, + std::unique_ptr& prTAFormat ) override; + virtual std::shared_ptr getDialogController() override { return m_xDlg; } +}; + +class SwJavaEditDialog; +class AbstractJavaEditDialog_Impl : public AbstractJavaEditDialog +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractJavaEditDialog_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual OUString GetScriptText() const override; + virtual OUString GetScriptType() const override; + virtual bool IsUrl() const override; + virtual bool IsNew() const override; + virtual bool IsUpdate() const override; +}; + +class SwMailMergeDlg; +class AbstractMailMergeDlg_Impl : public AbstractMailMergeDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractMailMergeDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual DBManagerOptions GetMergeType() override ; + virtual const OUString& GetSaveFilter() const override; + virtual css::uno::Sequence< css::uno::Any > GetSelection() const override ; + virtual css::uno::Reference< css::sdbc::XResultSet> GetResultSet() const override; + virtual bool IsSaveSingleDoc() const override; + virtual bool IsGenerateFromDataBase() const override; + virtual bool IsFileEncryptedFromDataBase() const override; + virtual OUString GetColumnName() const override; + virtual OUString GetPasswordColumnName() const override; + virtual OUString GetTargetURL() const override; +}; + +class SwMailMergeCreateFromDlg; +class AbstractMailMergeCreateFromDlg_Impl : public AbstractMailMergeCreateFromDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractMailMergeCreateFromDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool IsThisDocument() const override ; +}; + +class SwMailMergeFieldConnectionsDlg; +class AbstractMailMergeFieldConnectionsDlg_Impl : public AbstractMailMergeFieldConnectionsDlg +{ + std::unique_ptr m_xDlg; +public: + explicit AbstractMailMergeFieldConnectionsDlg_Impl(std::unique_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool IsUseExistingConnections() const override ; +}; + +class SwMultiTOXTabDialog; +class AbstractMultiTOXTabDialog_Impl : public AbstractMultiTOXTabDialog +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractMultiTOXTabDialog_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(VclAbstractDialog::AsyncContext &rCtx) override; + virtual CurTOXType GetCurrentTOXType() const override ; + virtual SwTOXDescription& GetTOXDescription(CurTOXType eTOXTypes) override; + //from SfxTabDialog + virtual const SfxItemSet* GetOutputItemSet() const override; +}; + +class SwEditRegionDlg; +class AbstractEditRegionDlg_Impl : public AbstractEditRegionDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractEditRegionDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void SelectSection(const OUString& rSectionName) override; +}; + +class SwInsertSectionTabDialog; +class AbstractInsertSectionTabDialog_Impl : public AbstractInsertSectionTabDialog +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractInsertSectionTabDialog_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual bool StartExecuteAsync(AsyncContext &rCtx) override; + virtual void SetSectionData(SwSectionData const& rSect) override; +}; + +class SwIndexMarkFloatDlg; +class AbstractIndexMarkFloatDlg_Impl : public AbstractMarkFloatDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractIndexMarkFloatDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void ReInitDlg(SwWrtShell& rWrtShell) override; + virtual std::shared_ptr GetController() override; +}; + +class SwAuthMarkFloatDlg; +class AbstractAuthMarkFloatDlg_Impl : public AbstractMarkFloatDlg +{ + std::shared_ptr m_xDlg; +public: + explicit AbstractAuthMarkFloatDlg_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual short Execute() override; + virtual void ReInitDlg(SwWrtShell& rWrtShell) override; + virtual std::shared_ptr GetController() override; +}; + +class SwMailMergeWizard; +class AbstractMailMergeWizard_Impl : public AbstractMailMergeWizard +{ + std::shared_ptr m_xDlg; + +public: + explicit AbstractMailMergeWizard_Impl(std::shared_ptr p) + : m_xDlg(std::move(p)) + { + } + virtual ~AbstractMailMergeWizard_Impl() override; + virtual bool StartExecuteAsync(VclAbstractDialog::AsyncContext &rCtx) override; + virtual short Execute() override; + + virtual OUString GetReloadDocument() const override; + virtual void ShowPage( sal_uInt16 nLevel ) override; + virtual sal_uInt16 GetRestartPage() const override; +}; + +//AbstractDialogFactory_Impl implementations +class SwAbstractDialogFactory_Impl : public SwAbstractDialogFactory +{ + +public: + virtual ~SwAbstractDialogFactory_Impl() {} + + virtual VclPtr CreateNumFormatDialog(weld::Widget* pParent, const SfxItemSet& rAttr) override; + virtual VclPtr CreateSwDropCapsDialog(weld::Window* pParent, const SfxItemSet& rSet) override; + virtual VclPtr CreateSwBackgroundDialog(weld::Window* pParent, const SfxItemSet& rSet) override; + virtual VclPtr CreateSwWordCountDialog(SfxBindings* pBindings, + SfxChildWindow* pChild, weld::Window *pParent, SfxChildWinInfo* pInfo) override; + virtual VclPtr CreateSwInsertAbstractDlg(weld::Window* pParent) override; + virtual VclPtr CreateSwAddressAbstractDlg(weld::Window* pParent, const SfxItemSet& rSet) override; + virtual VclPtr CreateSwAsciiFilterDlg(weld::Window* pParent, SwDocShell& rDocSh, + SvStream* pStream) override; + virtual VclPtr CreateSwInsertBookmarkDlg(weld::Window *pParent, SwWrtShell &rSh, OUString const* pSelected) override; + virtual VclPtr CreateSwContentControlDlg(weld::Window *pParent, SwWrtShell &rSh) override; + virtual VclPtr CreateSwPageNumberDlg(weld::Window *pParent) override; + + VclPtr + CreateSwContentControlListItemDlg(weld::Window* pParent, + SwContentControlListItem& rItem) override; + + virtual std::shared_ptr CreateSwBreakDlg(weld::Window *pParent, SwWrtShell &rSh) override; + virtual std::shared_ptr CreateSwTranslateLangSelectDlg(weld::Window *pParent, SwWrtShell &rSh) override; + virtual VclPtr CreateSwChangeDBDlg(SwView& rVw) override; + virtual VclPtr CreateSwCharDlg(weld::Window* pParent, SwView& pVw, const SfxItemSet& rCoreSet, + SwCharDlgMode nDialogMode, const OUString* pFormatStr = nullptr) override; + virtual VclPtr CreateSwConvertTableDlg(SwView& rView, bool bToTable) override; + virtual VclPtr CreateSwCaptionDialog(weld::Window *pParent, SwView &rV) override; + virtual VclPtr CreateSwInsertDBColAutoPilot(SwView& rView, + css::uno::Reference< css::sdbc::XDataSource> rxSource, + css::uno::Reference xColSupp, + const SwDBData& rData) override; + virtual VclPtr CreateSwFootNoteOptionDlg(weld::Window *pParent, SwWrtShell &rSh) override; + + virtual VclPtr CreateDropDownFieldDialog(weld::Widget* pParent, SwWrtShell &rSh, + SwField* pField, bool bPrevButton, bool bNextButton) override; + virtual VclPtr CreateDropDownFormFieldDialog(weld::Widget* pParent, sw::mark::IFieldmark* pDropDownField) override; + virtual VclPtr CreateDateFormFieldDialog(weld::Widget* pParent, sw::mark::IDateFieldmark* pDateField, SwDoc& rDoc) override; + + virtual VclPtr CreateSwEnvDlg(weld::Window* pParent, const SfxItemSet& rSet, SwWrtShell* pWrtSh, Printer* pPrt, bool bInsert) override; + virtual VclPtr CreateSwLabDlg(weld::Window* pParent, const SfxItemSet& rSet, + SwDBManager* pDBManager, bool bLabel) override; + + virtual SwLabDlgMethod GetSwLabDlgStaticMethod () override; + virtual VclPtr CreateSwParaDlg(weld::Window *pParent, + SwView& rVw, + const SfxItemSet& rCoreSet, + bool bDraw, + const OUString& sDefPage = {}) override; + + virtual VclPtr CreateSwAutoMarkDialog(weld::Window *pParent, SwWrtShell &rSh) override; + virtual VclPtr CreateSwSelGlossaryDlg(weld::Window *pParent, const OUString &rShortName) override; + virtual VclPtr CreateSwSortingDialog(weld::Window *pParent, SwWrtShell &rSh) override; + virtual VclPtr CreateSwTableHeightDialog(weld::Window *pParent, SwWrtShell &rSh) override; + virtual VclPtr CreateSwColumnDialog(weld::Window *pParent, SwWrtShell &rSh) override; + virtual VclPtr CreateSplitTableDialog(weld::Window* pParent, SwWrtShell &rSh) override; + + virtual VclPtr CreateSwAutoFormatDlg(weld::Window* pParent, SwWrtShell* pShell, + bool bSetAutoFormat = true, + const SwTableAutoFormat* pSelFormat = nullptr) override; + virtual VclPtr CreateSwBorderDlg(weld::Window* pParent, SfxItemSet& rSet, SwBorderModes nType) override; + + virtual VclPtr CreateSwWrapDlg(weld::Window* pParent, SfxItemSet& rSet, SwWrtShell* pSh) override; + virtual VclPtr CreateSwTableWidthDlg(weld::Window *pParent, SwTableFUNC &rFnc) override; + virtual VclPtr CreateSwTableTabDlg(weld::Window* pParent, + const SfxItemSet* pItemSet, SwWrtShell* pSh) override; + virtual VclPtr CreateSwFieldDlg(SfxBindings* pB, SwChildWinWrapper* pCW, weld::Window *pParent) override; + virtual VclPtr CreateSwFieldEditDlg ( SwView& rVw ) override; + virtual VclPtr CreateSwRenameXNamedDlg(weld::Widget* pParent, + css::uno::Reference< css::container::XNamed > & xNamed, + css::uno::Reference< css::container::XNameAccess > & xNameAccess) override; + virtual VclPtr CreateSwModalRedlineAcceptDlg(weld::Window *pParent) override; + + virtual VclPtr CreateTableMergeDialog(weld::Window* pParent, bool& rWithPrev) override; + virtual VclPtr CreateFrameTabDialog( const OUString &rDialogType, + SfxViewFrame& rFrame, weld::Window *pParent, + const SfxItemSet& rCoreSet, + bool bNewFrame = true, + const OUString& sDefPage = {}) override; + virtual VclPtr CreateTemplateDialog( + weld::Window *pParent, + SfxStyleSheetBase& rBase, + SfxStyleFamily nRegion, + const OUString& sPage, + SwWrtShell* pActShell, + bool bNew) override; + virtual VclPtr CreateGlossaryDlg(SfxViewFrame& rViewFrame, + SwGlossaryHdl* pGlosHdl, + SwWrtShell *pWrtShell) override; + virtual VclPtr CreateFieldInputDlg(weld::Widget *pParent, + SwWrtShell &rSh, SwField* pField, bool bPrevButton, bool bNextButton) override; + virtual VclPtr CreateInsFootNoteDlg( + weld::Window * pParent, SwWrtShell &rSh, bool bEd = false) override; + virtual VclPtr CreateTitlePageDlg(weld::Window* pParent) override; + virtual VclPtr CreateVclSwViewDialog(SwView& rView) override; + virtual std::shared_ptr CreateInsTableDlg(SwView& rView) override; + virtual VclPtr CreateJavaEditDialog(weld::Window* pParent, + SwWrtShell* pWrtSh) override; + virtual VclPtr CreateMailMergeDlg( + weld::Window* pParent, SwWrtShell& rSh, + const OUString& rSourceName, + const OUString& rTableName, + sal_Int32 nCommandType, + const css::uno::Reference< css::sdbc::XConnection>& xConnection ) override; + virtual VclPtr CreateMailMergeCreateFromDlg(weld::Window* pParent) override; + virtual VclPtr CreateMailMergeFieldConnectionsDlg(weld::Window* pParent) override; + virtual VclPtr CreateMultiTOXMarkDlg(weld::Window* pParent, SwTOXMgr &rTOXMgr) override; + virtual VclPtr CreateOutlineTabDialog(weld::Window* pParent, const SfxItemSet* pSwItemSet, + SwWrtShell &) override; + virtual VclPtr CreateSvxNumBulletTabDialog(weld::Window* pParent, + const SfxItemSet& rSwItemSet, + SwWrtShell &) override; + virtual VclPtr CreateMultiTOXTabDialog( + weld::Widget* pParent, const SfxItemSet& rSet, + SwWrtShell &rShell, + SwTOXBase* pCurTOX, + bool bGlobal) override; + virtual VclPtr CreateEditRegionDlg(weld::Window* pParent, SwWrtShell& rWrtSh) override; + virtual VclPtr CreateInsertSectionTabDialog( + weld::Window* pParent, const SfxItemSet& rSet, SwWrtShell& rSh) override; + virtual VclPtr CreateIndexMarkFloatDlg( + SfxBindings* pBindings, + SfxChildWindow* pChild, + weld::Window *pParent, + SfxChildWinInfo* pInfo) override; + virtual VclPtr CreateAuthMarkFloatDlg( + SfxBindings* pBindings, + SfxChildWindow* pChild, + weld::Window *pParent, + SfxChildWinInfo* pInfo) override; + virtual VclPtr CreateIndexMarkModalDlg( + weld::Window *pParent, SwWrtShell& rSh, SwTOXMark* pCurTOXMark ) override; + + virtual VclPtr CreateMailMergeWizard(SwView& rView, std::shared_ptr& rConfigItem) override; + + virtual GlossaryGetCurrGroup GetGlossaryCurrGroupFunc() override; + virtual GlossarySetActGroup SetGlossaryActGroupFunc() override; + + // For TabPage + virtual CreateTabPage GetTabPageCreatorFunc( sal_uInt16 nId ) override; + + virtual void ExecuteMMResultSaveDialog(weld::Window* pParent) override; + virtual void ExecuteMMResultPrintDialog(weld::Window* pParent) override; + virtual void ExecuteMMResultEmailDialog(weld::Window* pParent) override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/swmessdialog.cxx b/sw/source/ui/dialog/swmessdialog.cxx new file mode 100644 index 0000000000..abdf16bf4d --- /dev/null +++ b/sw/source/ui/dialog/swmessdialog.cxx @@ -0,0 +1,20 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include + +SwMessageAndEditDialog::SwMessageAndEditDialog(weld::Window* pParent, const OUString& rID, + const OUString& rUIXMLDescription) + : MessageDialogController(pParent, rUIXMLDescription, rID, "grid") + , m_xEdit(m_xBuilder->weld_entry("edit")) + , m_xOKPB(m_xBuilder->weld_button("ok")) +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/swuiexp.cxx b/sw/source/ui/dialog/swuiexp.cxx new file mode 100644 index 0000000000..e141dab80d --- /dev/null +++ b/sw/source/ui/dialog/swuiexp.cxx @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include "swdlgfact.hxx" + +#include + +namespace swui +{ +SwAbstractDialogFactory& GetFactory() +{ + static SwAbstractDialogFactory_Impl aFactory; + return aFactory; +} +} + +extern "C" { +SAL_DLLPUBLIC_EXPORT SwAbstractDialogFactory* SwCreateDialogFactory() +{ + return &::swui::GetFactory(); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/uiregionsw.cxx b/sw/source/ui/dialog/uiregionsw.cxx new file mode 100644 index 0000000000..f0318a4caf --- /dev/null +++ b/sw/source/ui/dialog/uiregionsw.cxx @@ -0,0 +1,2145 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +namespace { + +OUString BuildBitmap(bool bProtect, bool bHidden) +{ + if (bProtect) + return bHidden ? RID_BMP_PROT_HIDE : RID_BMP_PROT_NO_HIDE; + return bHidden ? RID_BMP_HIDE : RID_BMP_NO_HIDE; +} + +OUString CollapseWhiteSpaces(std::u16string_view sName) +{ + const sal_Int32 nLen = sName.size(); + const sal_Unicode cRef = ' '; + OUStringBuffer aBuf(nLen); + for (sal_Int32 i = 0; iGetParent() && + pFormat->IsInNodesArr() && + (eTmpType = pFormat->GetSection()->GetType()) != SectionType::ToxContent + && SectionType::ToxHeader != eTmpType ) + { + const OUString sString(pFormat->GetSection()->GetSectionName()); + if (pAvailNames) + pAvailNames->append_text(sString); + rSubRegions.append_text(sString); + lcl_FillList( rSh, rSubRegions, pAvailNames, pFormat ); + } + } + } + else + { + SwSections aTmpArr; + pNewFormat->GetChildSections(aTmpArr, SectionSort::Pos); + if( !aTmpArr.empty() ) + { + SectionType eTmpType; + for( const auto pSect : aTmpArr ) + { + const SwSectionFormat* pFormat = pSect->GetFormat(); + if( pFormat->IsInNodesArr()&& + (eTmpType = pFormat->GetSection()->GetType()) != SectionType::ToxContent + && SectionType::ToxHeader != eTmpType ) + { + const OUString sString(pFormat->GetSection()->GetSectionName()); + if (pAvailNames) + pAvailNames->append_text(sString); + rSubRegions.append_text(sString); + lcl_FillList( rSh, rSubRegions, pAvailNames, pFormat ); + } + } + } + } +} + +static void lcl_FillSubRegionList( SwWrtShell& rSh, weld::ComboBox& rSubRegions, weld::ComboBox* pAvailNames ) +{ + rSubRegions.clear(); + lcl_FillList( rSh, rSubRegions, pAvailNames, nullptr ); + IDocumentMarkAccess* const pMarkAccess = rSh.getIDocumentMarkAccess(); + for( IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getBookmarksBegin(); + ppMark != pMarkAccess->getBookmarksEnd(); + ++ppMark) + { + const ::sw::mark::IMark* pBkmk = *ppMark; + if( pBkmk->IsExpanded() ) + rSubRegions.append_text( pBkmk->GetName() ); + } +} + +// user data class for region information +class SectRepr +{ +private: + SwSectionData m_SectionData; + SwFormatCol m_Col; + std::unique_ptr m_Brush; + SwFormatFootnoteAtTextEnd m_FootnoteNtAtEnd; + SwFormatEndAtTextEnd m_EndNtAtEnd; + SwFormatNoBalancedColumns m_Balance; + std::shared_ptr m_FrameDirItem; + std::shared_ptr m_LRSpaceItem; + const size_t m_nArrPos; + // shows, if maybe textcontent is in the region + bool m_bContent : 1; + // for multiselection, mark at first, then work with TreeListBox! + bool m_bSelected : 1; + uno::Sequence m_TempPasswd; + +public: + SectRepr(size_t nPos, SwSection& rSect); + + SwSectionData & GetSectionData() { return m_SectionData; } + SwFormatCol& GetCol() { return m_Col; } + std::unique_ptr& GetBackground() { return m_Brush; } + SwFormatFootnoteAtTextEnd& GetFootnoteNtAtEnd() { return m_FootnoteNtAtEnd; } + SwFormatEndAtTextEnd& GetEndNtAtEnd() { return m_EndNtAtEnd; } + SwFormatNoBalancedColumns& GetBalance() { return m_Balance; } + std::shared_ptr& GetFrameDir() { return m_FrameDirItem; } + std::shared_ptr& GetLRSpace() { return m_LRSpaceItem; } + + size_t GetArrPos() const { return m_nArrPos; } + OUString GetFile() const; + OUString GetSubRegion() const; + void SetFile(std::u16string_view rFile); + void SetFilter(std::u16string_view rFilter); + void SetSubRegion(std::u16string_view rSubRegion); + + bool IsContent() const { return m_bContent; } + void SetContent(bool const bValue) { m_bContent = bValue; } + + void SetSelected() { m_bSelected = true; } + bool IsSelected() const { return m_bSelected; } + + uno::Sequence & GetTempPasswd() { return m_TempPasswd; } + void SetTempPasswd(const uno::Sequence & rPasswd) + { m_TempPasswd = rPasswd; } +}; + +SectRepr::SectRepr( size_t nPos, SwSection& rSect ) + : m_SectionData( rSect ) + , m_Brush(std::make_unique(RES_BACKGROUND)) + , m_FrameDirItem(std::make_shared(SvxFrameDirection::Environment, RES_FRAMEDIR)) + , m_LRSpaceItem(std::make_shared(RES_LR_SPACE)) + , m_nArrPos(nPos) + , m_bContent(m_SectionData.GetLinkFileName().isEmpty()) + , m_bSelected(false) +{ + SwSectionFormat *pFormat = rSect.GetFormat(); + if( pFormat ) + { + m_Col = pFormat->GetCol(); + m_Brush = pFormat->makeBackgroundBrushItem(); + m_FootnoteNtAtEnd = pFormat->GetFootnoteAtTextEnd(); + m_EndNtAtEnd = pFormat->GetEndAtTextEnd(); + m_Balance.SetValue(pFormat->GetBalancedColumns().GetValue()); + m_FrameDirItem.reset(pFormat->GetFrameDir().Clone()); + m_LRSpaceItem.reset(pFormat->GetLRSpace().Clone()); + } +} + +void SectRepr::SetFile( std::u16string_view rFile ) +{ + OUString sNewFile( INetURLObject::decode( rFile, + INetURLObject::DecodeMechanism::Unambiguous )); + const OUString sOldFileName( m_SectionData.GetLinkFileName() ); + const std::u16string_view sSub( o3tl::getToken(sOldFileName, 2, sfx2::cTokenSeparator ) ); + + if( !rFile.empty() || !sSub.empty() ) + { + sNewFile += OUStringChar(sfx2::cTokenSeparator); + if( !rFile.empty() ) // Filter only with FileName + sNewFile += o3tl::getToken(sOldFileName, 1, sfx2::cTokenSeparator ); + + sNewFile += OUStringChar(sfx2::cTokenSeparator) + sSub; + } + + m_SectionData.SetLinkFileName( sNewFile ); + + if( !rFile.empty() || !sSub.empty() ) + { + m_SectionData.SetType( SectionType::FileLink ); + } + else + { + m_SectionData.SetType( SectionType::Content ); + } +} + +void SectRepr::SetFilter( std::u16string_view rFilter ) +{ + OUString sNewFile; + const OUString sOldFileName( m_SectionData.GetLinkFileName() ); + sal_Int32 nIdx{ 0 }; + const std::u16string_view sFile( o3tl::getToken(sOldFileName, 0, sfx2::cTokenSeparator, nIdx ) ); // token 0 + const std::u16string_view sSub( o3tl::getToken(sOldFileName, 1, sfx2::cTokenSeparator, nIdx ) ); // token 2 + + if( !sFile.empty() ) + sNewFile = sFile + OUStringChar(sfx2::cTokenSeparator) + + rFilter + OUStringChar(sfx2::cTokenSeparator) + sSub; + else if( !sSub.empty() ) + sNewFile = OUStringChar(sfx2::cTokenSeparator) + OUStringChar(sfx2::cTokenSeparator) + sSub; + + m_SectionData.SetLinkFileName( sNewFile ); + + if( !sNewFile.isEmpty() ) + { + m_SectionData.SetType( SectionType::FileLink ); + } +} + +void SectRepr::SetSubRegion(std::u16string_view rSubRegion) +{ + OUString sNewFile; + sal_Int32 n(0); + const OUString sLinkFileName(m_SectionData.GetLinkFileName()); + const std::u16string_view sOldFileName( o3tl::getToken(sLinkFileName, 0, sfx2::cTokenSeparator, n ) ); + const std::u16string_view sFilter( o3tl::getToken(sLinkFileName, 0, sfx2::cTokenSeparator, n ) ); + + if( !rSubRegion.empty() || !sOldFileName.empty() ) + sNewFile = sOldFileName + OUStringChar(sfx2::cTokenSeparator) + + sFilter + OUStringChar(sfx2::cTokenSeparator) + rSubRegion; + + m_SectionData.SetLinkFileName( sNewFile ); + + if( !rSubRegion.empty() || !sOldFileName.empty() ) + { + m_SectionData.SetType( SectionType::FileLink ); + } + else + { + m_SectionData.SetType( SectionType::Content ); + } +} + +OUString SectRepr::GetFile() const +{ + const OUString sLinkFile( m_SectionData.GetLinkFileName() ); + + if( sLinkFile.isEmpty() ) + { + return sLinkFile; + } + if (SectionType::DdeLink == m_SectionData.GetType()) + { + sal_Int32 n = 0; + return sLinkFile.replaceFirst( OUStringChar(sfx2::cTokenSeparator), " ", &n ) + .replaceFirst( OUStringChar(sfx2::cTokenSeparator), " ", &n ); + } + return INetURLObject::decode( o3tl::getToken(sLinkFile, 0, sfx2::cTokenSeparator ), + INetURLObject::DecodeMechanism::Unambiguous ); +} + +OUString SectRepr::GetSubRegion() const +{ + const OUString sLinkFile( m_SectionData.GetLinkFileName() ); + if( !sLinkFile.isEmpty() ) + return sLinkFile.getToken( 2, sfx2::cTokenSeparator ); + return sLinkFile; +} + +// dialog edit regions +SwEditRegionDlg::SwEditRegionDlg(weld::Window* pParent, SwWrtShell& rWrtSh) + : SfxDialogController(pParent, "modules/swriter/ui/editsectiondialog.ui", + "EditSectionDialog") + , m_bSubRegionsFilled(false) + , m_rSh(rWrtSh) + , m_bDontCheckPasswd(true) + , m_xCurName(m_xBuilder->weld_entry("curname")) + , m_xTree(m_xBuilder->weld_tree_view("tree")) + , m_xFileCB(m_xBuilder->weld_check_button("link")) + , m_xDDECB(m_xBuilder->weld_check_button("dde")) + , m_xDDEFrame(m_xBuilder->weld_widget("ddedepend")) + , m_xFileNameFT(m_xBuilder->weld_label("filenameft")) + , m_xDDECommandFT(m_xBuilder->weld_label("ddeft")) + , m_xFileNameED(m_xBuilder->weld_entry("filename")) + , m_xFilePB(m_xBuilder->weld_button("file")) + , m_xSubRegionFT(m_xBuilder->weld_label("sectionft")) + , m_xSubRegionED(m_xBuilder->weld_combo_box("section")) + , m_xProtectCB(m_xBuilder->weld_check_button("protect")) + , m_xPasswdCB(m_xBuilder->weld_check_button("withpassword")) + , m_xPasswdPB(m_xBuilder->weld_button("password")) + , m_xHideCB(m_xBuilder->weld_check_button("hide")) + , m_xConditionFT(m_xBuilder->weld_label("conditionft")) + , m_xConditionED(new ConditionEdit(m_xBuilder->weld_entry("condition"))) + , m_xEditInReadonlyCB(m_xBuilder->weld_check_button("editinro")) + , m_xOK(m_xBuilder->weld_button("ok")) + , m_xOptionsPB(m_xBuilder->weld_button("options")) + , m_xDismiss(m_xBuilder->weld_button("remove")) + , m_xHideFrame(m_xBuilder->weld_widget("hideframe")) +{ + m_xTree->set_size_request(-1, m_xTree->get_height_rows(16)); + m_xFileCB->set_state(TRISTATE_FALSE); + m_xSubRegionED->make_sorted(); + m_xProtectCB->set_state(TRISTATE_FALSE); + m_xHideCB->set_state(TRISTATE_FALSE); + // edit in readonly sections + m_xEditInReadonlyCB->set_state(TRISTATE_FALSE); + + bool bWeb = dynamic_cast( m_rSh.GetView().GetDocShell() ) != nullptr; + + m_xTree->connect_changed(LINK(this, SwEditRegionDlg, GetFirstEntryHdl)); + m_xCurName->connect_changed(LINK(this, SwEditRegionDlg, NameEditHdl)); + m_xConditionED->connect_changed( LINK( this, SwEditRegionDlg, ConditionEditHdl)); + m_xOK->connect_clicked( LINK( this, SwEditRegionDlg, OkHdl)); + m_xPasswdCB->connect_toggled(LINK(this, SwEditRegionDlg, TogglePasswdHdl)); + m_xPasswdPB->connect_clicked(LINK(this, SwEditRegionDlg, ChangePasswdHdl)); + m_xHideCB->connect_toggled(LINK(this, SwEditRegionDlg, ChangeHideHdl)); + // edit in readonly sections + m_xEditInReadonlyCB->connect_toggled(LINK(this, SwEditRegionDlg, ChangeEditInReadonlyHdl)); + + m_xOptionsPB->connect_clicked(LINK(this, SwEditRegionDlg, OptionsHdl)); + m_xProtectCB->connect_toggled(LINK(this, SwEditRegionDlg, ChangeProtectHdl)); + m_xDismiss->connect_clicked( LINK( this, SwEditRegionDlg, ChangeDismissHdl)); + m_xFileCB->connect_toggled(LINK(this, SwEditRegionDlg, UseFileHdl)); + m_xFilePB->connect_clicked(LINK(this, SwEditRegionDlg, FileSearchHdl)); + m_xFileNameED->connect_changed(LINK(this, SwEditRegionDlg, FileNameEntryHdl)); + m_xSubRegionED->connect_changed(LINK(this, SwEditRegionDlg, FileNameComboBoxHdl)); + m_xSubRegionED->connect_popup_toggled(LINK(this, SwEditRegionDlg, SubRegionEventHdl)); + m_xSubRegionED->set_entry_completion(true, true); + + m_xTree->set_selection_mode(SelectionMode::Multiple); + + if (bWeb) + { + m_xDDECB->hide(); + m_xHideFrame->hide(); + m_xPasswdCB->hide(); + } + + m_xDDECB->connect_toggled(LINK(this, SwEditRegionDlg, DDEHdl)); + + m_pCurrSect = m_rSh.GetCurrSection(); + RecurseList( nullptr, nullptr ); + + // if the cursor is not in a region the first one will always be selected + if (!m_xTree->get_selected(nullptr)) + { + std::unique_ptr xIter(m_xTree->make_iterator()); + if (m_xTree->get_iter_first(*xIter)) + { + m_xTree->select(*xIter); + GetFirstEntryHdl(*m_xTree); + } + } + + m_xTree->show(); + m_bDontCheckPasswd = false; + + if(comphelper::LibreOfficeKit::isActive()) + { + m_xDDECB->hide(); + m_xDDECommandFT->hide(); + m_xFileNameFT->hide(); + m_xFileNameED->hide(); + m_xFilePB->hide(); + } +} + +bool SwEditRegionDlg::CheckPasswd(weld::Toggleable* pBox) +{ + if (m_bDontCheckPasswd) + return true; + bool bRet = true; + + m_xTree->selected_foreach([this, &bRet](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + if (!pRepr->GetTempPasswd().hasElements() + && pRepr->GetSectionData().GetPassword().hasElements()) + { + SfxPasswordDialog aPasswdDlg(m_xDialog.get()); + bRet = false; + if (aPasswdDlg.run()) + { + const OUString sNewPasswd(aPasswdDlg.GetPassword()); + css::uno::Sequence aNewPasswd; + SvPasswordHelper::GetHashPassword( aNewPasswd, sNewPasswd ); + if (SvPasswordHelper::CompareHashPassword( + pRepr->GetSectionData().GetPassword(), sNewPasswd)) + { + pRepr->SetTempPasswd(aNewPasswd); + bRet = true; + } + else + { + std::unique_ptr xInfoBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Info, VclButtonsType::Ok, + SwResId(STR_WRONG_PASSWORD))); + xInfoBox->run(); + } + } + } + return false; + }); + if (!bRet && pBox) + { + //reset old button state + if (pBox->get_state() != TRISTATE_INDET) + pBox->set_active(!pBox->get_active()); + } + + return bRet; +} + +// recursively look for child-sections +void SwEditRegionDlg::RecurseList(const SwSectionFormat* pFormat, const weld::TreeIter* pEntry) +{ + std::unique_ptr xIter(m_xTree->make_iterator()); + if (!pFormat) + { + const size_t nCount=m_rSh.GetSectionFormatCount(); + for ( size_t n = 0; n < nCount; n++ ) + { + SectionType eTmpType; + if( !( pFormat = &m_rSh.GetSectionFormat(n))->GetParent() && + pFormat->IsInNodesArr() && + (eTmpType = pFormat->GetSection()->GetType()) != SectionType::ToxContent + && SectionType::ToxHeader != eTmpType ) + { + SwSection *pSect = pFormat->GetSection(); + SectRepr* pSectRepr = new SectRepr( n, *pSect ); + + OUString sText(pSect->GetSectionName()); + OUString sImage(BuildBitmap(pSect->IsProtect(),pSect->IsHidden())); + OUString sId(weld::toId(pSectRepr)); + m_xTree->insert(nullptr, -1, &sText, &sId, nullptr, nullptr, false, xIter.get()); + m_xTree->set_image(*xIter, sImage); + + RecurseList(pFormat, xIter.get()); + if (m_xTree->iter_has_child(*xIter)) + m_xTree->expand_row(*xIter); + if (m_pCurrSect==pSect) + { + m_xTree->select(*xIter); + m_xTree->scroll_to_row(*xIter); + GetFirstEntryHdl(*m_xTree); + } + } + } + } + else + { + SwSections aTmpArr; + pFormat->GetChildSections(aTmpArr, SectionSort::Pos); + for( const auto pSect : aTmpArr ) + { + SectionType eTmpType; + pFormat = pSect->GetFormat(); + if( pFormat->IsInNodesArr() && + (eTmpType = pFormat->GetSection()->GetType()) != SectionType::ToxContent + && SectionType::ToxHeader != eTmpType ) + { + SectRepr* pSectRepr=new SectRepr( + FindArrPos( pSect->GetFormat() ), *pSect ); + + OUString sText(pSect->GetSectionName()); + OUString sImage = BuildBitmap(pSect->IsProtect(), pSect->IsHidden()); + OUString sId(weld::toId(pSectRepr)); + m_xTree->insert(pEntry, -1, &sText, &sId, nullptr, nullptr, false, xIter.get()); + m_xTree->set_image(*xIter, sImage); + + RecurseList(pSect->GetFormat(), xIter.get()); + if (m_xTree->iter_has_child(*xIter)) + m_xTree->expand_row(*xIter); + if (m_pCurrSect==pSect) + { + m_xTree->select(*xIter); + m_xTree->scroll_to_row(*xIter); + GetFirstEntryHdl(*m_xTree); + } + } + } + } +} + +size_t SwEditRegionDlg::FindArrPos(const SwSectionFormat* pFormat ) +{ + const size_t nCount=m_rSh.GetSectionFormatCount(); + for ( size_t i = 0; i < nCount; i++ ) + if ( pFormat == &m_rSh.GetSectionFormat(i) ) + return i; + + OSL_FAIL("SectionFormat not on the list" ); + return SIZE_MAX; +} + +SwEditRegionDlg::~SwEditRegionDlg( ) +{ + std::unique_ptr xIter(m_xTree->make_iterator()); + if (m_xTree->get_iter_first(*xIter)) + { + do + { + delete weld::fromId(m_xTree->get_id(*xIter)); + } while (m_xTree->iter_next(*xIter)); + } +} + +void SwEditRegionDlg::SelectSection(std::u16string_view rSectionName) +{ + std::unique_ptr xIter(m_xTree->make_iterator()); + if (!m_xTree->get_iter_first(*xIter)) + return; + + do + { + SectRepr* pRepr = weld::fromId(m_xTree->get_id(*xIter)); + if (pRepr->GetSectionData().GetSectionName() == rSectionName) + { + m_xTree->unselect_all(); + m_xTree->select(*xIter); + m_xTree->scroll_to_row(*xIter); + GetFirstEntryHdl(*m_xTree); + break; + } + } while (m_xTree->iter_next(*xIter)); +} + +// selected entry in TreeListBox is showed in Edit window in case of +// multiselection some controls are disabled +IMPL_LINK(SwEditRegionDlg, GetFirstEntryHdl, weld::TreeView&, rBox, void) +{ + m_bDontCheckPasswd = true; + std::unique_ptr xIter(rBox.make_iterator()); + bool bEntry = rBox.get_selected(xIter.get()); + m_xHideCB->set_sensitive(true); + // edit in readonly sections + m_xEditInReadonlyCB->set_sensitive(true); + + m_xProtectCB->set_sensitive(true); + m_xFileCB->set_sensitive(true); + css::uno::Sequence aCurPasswd; + if (1 < rBox.count_selected_rows()) + { + m_xHideCB->set_state(TRISTATE_INDET); + m_xProtectCB->set_state(TRISTATE_INDET); + // edit in readonly sections + m_xEditInReadonlyCB->set_state(TRISTATE_INDET); + m_xFileCB->set_state(TRISTATE_INDET); + + bool bHiddenValid = true; + bool bProtectValid = true; + bool bConditionValid = true; + // edit in readonly sections + bool bEditInReadonlyValid = true; + bool bEditInReadonly = true; + + bool bHidden = true; + bool bProtect = true; + OUString sCondition; + bool bFirst = true; + bool bFileValid = true; + bool bFile = true; + bool bPasswdValid = true; + + m_xTree->selected_foreach([&](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + SwSectionData const& rData( pRepr->GetSectionData() ); + if(bFirst) + { + sCondition = rData.GetCondition(); + bHidden = rData.IsHidden(); + bProtect = rData.IsProtectFlag(); + // edit in readonly sections + bEditInReadonly = rData.IsEditInReadonlyFlag(); + + bFile = (rData.GetType() != SectionType::Content); + aCurPasswd = rData.GetPassword(); + } + else + { + if(sCondition != rData.GetCondition()) + bConditionValid = false; + bHiddenValid = (bHidden == rData.IsHidden()); + bProtectValid = (bProtect == rData.IsProtectFlag()); + // edit in readonly sections + bEditInReadonlyValid = + (bEditInReadonly == rData.IsEditInReadonlyFlag()); + + bFileValid = (bFile == + (rData.GetType() != SectionType::Content)); + bPasswdValid = (aCurPasswd == rData.GetPassword()); + } + bFirst = false; + return false; + }); + + m_xHideCB->set_state(!bHiddenValid ? TRISTATE_INDET : + bHidden ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xProtectCB->set_state(!bProtectValid ? TRISTATE_INDET : + bProtect ? TRISTATE_TRUE : TRISTATE_FALSE); + // edit in readonly sections + m_xEditInReadonlyCB->set_state(!bEditInReadonlyValid ? TRISTATE_INDET : + bEditInReadonly ? TRISTATE_TRUE : TRISTATE_FALSE); + + m_xFileCB->set_state(!bFileValid ? TRISTATE_INDET : + bFile ? TRISTATE_TRUE : TRISTATE_FALSE); + + if (bConditionValid) + m_xConditionED->set_text(sCondition); + else + { + m_xConditionFT->set_sensitive(false); + m_xConditionED->set_sensitive(false); + } + + m_xCurName->set_sensitive(false); + m_xDDECB->set_sensitive(false); + m_xDDEFrame->set_sensitive(false); + m_xOptionsPB->set_sensitive(false); + bool bPasswdEnabled = m_xProtectCB->get_state() == TRISTATE_TRUE; + m_xPasswdCB->set_sensitive(bPasswdEnabled); + m_xPasswdPB->set_sensitive(bPasswdEnabled); + if(!bPasswdValid) + { + rBox.get_selected(xIter.get()); + rBox.unselect_all(); + rBox.select(*xIter); + GetFirstEntryHdl(rBox); + return; + } + else + m_xPasswdCB->set_active(aCurPasswd.hasElements()); + } + else if (bEntry ) + { + m_xCurName->set_sensitive(true); + m_xOptionsPB->set_sensitive(true); + SectRepr* pRepr = weld::fromId(m_xTree->get_id(*xIter)); + SwSectionData const& rData( pRepr->GetSectionData() ); + m_xConditionED->set_text(rData.GetCondition()); + m_xHideCB->set_sensitive(true); + m_xHideCB->set_state((rData.IsHidden()) ? TRISTATE_TRUE : TRISTATE_FALSE); + bool bHide = TRISTATE_TRUE == m_xHideCB->get_state(); + m_xConditionED->set_sensitive(bHide); + m_xConditionFT->set_sensitive(bHide); + m_xPasswdCB->set_active(rData.GetPassword().hasElements()); + + m_xOK->set_sensitive(true); + m_xPasswdCB->set_sensitive(true); + m_xCurName->set_text(rBox.get_text(*xIter)); + m_xCurName->set_sensitive(true); + m_xDismiss->set_sensitive(true); + const OUString aFile = pRepr->GetFile(); + const OUString sSub = pRepr->GetSubRegion(); + m_xSubRegionED->clear(); + m_xSubRegionED->append_text(""); // put in a dummy entry, which is replaced when m_bSubRegionsFilled is set + m_bSubRegionsFilled = false; + if( !aFile.isEmpty() || !sSub.isEmpty() ) + { + m_xFileCB->set_active(true); + m_xFileNameED->set_text(aFile); + m_xSubRegionED->set_entry_text(sSub); + m_xDDECB->set_active(rData.GetType() == SectionType::DdeLink); + } + else + { + m_xFileCB->set_active(false); + m_xFileNameED->set_text(aFile); + m_xDDECB->set_sensitive(false); + m_xDDECB->set_active(false); + } + UseFileHdl(*m_xFileCB); + DDEHdl(*m_xDDECB); + m_xProtectCB->set_state((rData.IsProtectFlag()) + ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xProtectCB->set_sensitive(true); + + // edit in readonly sections + m_xEditInReadonlyCB->set_state((rData.IsEditInReadonlyFlag()) + ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xEditInReadonlyCB->set_sensitive(true); + + bool bPasswdEnabled = m_xProtectCB->get_active(); + m_xPasswdCB->set_sensitive(bPasswdEnabled); + m_xPasswdPB->set_sensitive(bPasswdEnabled); + } + m_bDontCheckPasswd = false; +} + +// in OkHdl the modified settings are being applied and reversed regions are deleted +IMPL_LINK_NOARG(SwEditRegionDlg, OkHdl, weld::Button&, void) +{ + // temp. Array because during changing of a region the position + // inside of the "Core-Arrays" can be shifted: + // - at linked regions, when they have more SubRegions or get + // new ones. + // StartUndo must certainly also happen not before the formats + // are copied (ClearRedo!) + + const SwSectionFormats& rDocFormats = m_rSh.GetDoc()->GetSections(); + SwSectionFormats aOrigArray(rDocFormats); + + m_rSh.StartAllAction(); + m_rSh.StartUndo(); + m_rSh.ResetSelect( nullptr,false ); + + std::unique_ptr xIter(m_xTree->make_iterator()); + if (m_xTree->get_iter_first(*xIter)) + { + do + { + SectRepr* pRepr = weld::fromId(m_xTree->get_id(*xIter)); + SwSectionFormat* pFormat = aOrigArray[ pRepr->GetArrPos() ]; + if (!pRepr->GetSectionData().IsProtectFlag()) + { + pRepr->GetSectionData().SetPassword(uno::Sequence()); + } + size_t nNewPos = rDocFormats.GetPos(pFormat); + if ( SIZE_MAX != nNewPos ) + { + SwAttrSet aSet(pFormat->GetAttrSet().CloneAsValue( false )); + if( pFormat->GetCol() != pRepr->GetCol() ) + aSet.Put( pRepr->GetCol() ); + + std::unique_ptr aBrush(pFormat->makeBackgroundBrushItem(false)); + if( pRepr->GetBackground() && *aBrush != *pRepr->GetBackground() ) + aSet.Put( *pRepr->GetBackground() ); + + if( pFormat->GetFootnoteAtTextEnd(false) != pRepr->GetFootnoteNtAtEnd() ) + aSet.Put( pRepr->GetFootnoteNtAtEnd() ); + + if( pFormat->GetEndAtTextEnd(false) != pRepr->GetEndNtAtEnd() ) + aSet.Put( pRepr->GetEndNtAtEnd() ); + + if( pFormat->GetBalancedColumns() != pRepr->GetBalance() ) + aSet.Put( pRepr->GetBalance() ); + + if( pFormat->GetFrameDir() != *pRepr->GetFrameDir() ) + aSet.Put( *pRepr->GetFrameDir() ); + + if( pFormat->GetLRSpace() != *pRepr->GetLRSpace()) + aSet.Put( *pRepr->GetLRSpace()); + + m_rSh.UpdateSection( nNewPos, pRepr->GetSectionData(), + aSet.Count() ? &aSet : nullptr ); + } + } while (m_xTree->iter_next(*xIter)); + } + + for (SectReprs_t::reverse_iterator it = m_SectReprs.rbegin(), aEnd = m_SectReprs.rend(); it != aEnd; ++it) + { + assert(it->first == it->second->GetArrPos()); + SwSectionFormat* pFormat = aOrigArray[ it->second->GetArrPos() ]; + const size_t nNewPos = rDocFormats.GetPos( pFormat ); + if( SIZE_MAX != nNewPos ) + m_rSh.DelSectionFormat( nNewPos ); + } + + aOrigArray.clear(); + + // response must be called ahead of EndAction's end, + // otherwise ScrollError can occur. + m_xDialog->response(RET_OK); + + m_rSh.EndUndo(); + m_rSh.EndAllAction(); +} + +// Toggle protect +IMPL_LINK(SwEditRegionDlg, ChangeProtectHdl, weld::Toggleable&, rButton, void) +{ + if (!CheckPasswd(&rButton)) + return; + bool bCheck = TRISTATE_TRUE == rButton.get_state(); + m_xTree->selected_foreach([this, bCheck](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + pRepr->GetSectionData().SetProtectFlag(bCheck); + OUString aImage = BuildBitmap(bCheck, TRISTATE_TRUE == m_xHideCB->get_state()); + m_xTree->set_image(rEntry, aImage); + return false; + }); + m_xPasswdCB->set_sensitive(bCheck); + m_xPasswdPB->set_sensitive(bCheck); +} + +// Toggle hide +IMPL_LINK( SwEditRegionDlg, ChangeHideHdl, weld::Toggleable&, rButton, void) +{ + if (!CheckPasswd(&rButton)) + return; + m_xTree->selected_foreach([this, &rButton](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + pRepr->GetSectionData().SetHidden(TRISTATE_TRUE == rButton.get_state()); + OUString aImage = BuildBitmap(TRISTATE_TRUE == m_xProtectCB->get_state(), + TRISTATE_TRUE == rButton.get_state()); + m_xTree->set_image(rEntry, aImage); + return false; + }); + bool bHide = TRISTATE_TRUE == rButton.get_state(); + m_xConditionED->set_sensitive(bHide); + m_xConditionFT->set_sensitive(bHide); +} + +// Toggle edit in readonly +IMPL_LINK(SwEditRegionDlg, ChangeEditInReadonlyHdl, weld::Toggleable&, rButton, void) +{ + if (!CheckPasswd(&rButton)) + return; + m_xTree->selected_foreach([this, &rButton](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + pRepr->GetSectionData().SetEditInReadonlyFlag( + TRISTATE_TRUE == rButton.get_state()); + return false; + }); +} + +// clear selected region +IMPL_LINK_NOARG(SwEditRegionDlg, ChangeDismissHdl, weld::Button&, void) +{ + if(!CheckPasswd()) + return; + // at first mark all selected + m_xTree->selected_foreach([this](weld::TreeIter& rEntry){ + SectRepr* const pSectRepr = weld::fromId(m_xTree->get_id(rEntry)); + pSectRepr->SetSelected(); + return false; + }); + + std::unique_ptr xEntry(m_xTree->make_iterator()); + bool bEntry(m_xTree->get_selected(xEntry.get())); + // then delete + while (bEntry) + { + SectRepr* const pSectRepr = weld::fromId(m_xTree->get_id(*xEntry)); + std::unique_ptr xRemove; + bool bRestart = false; + if (pSectRepr->IsSelected()) + { + m_SectReprs.insert(std::make_pair(pSectRepr->GetArrPos(), + std::unique_ptr(pSectRepr))); + if (m_xTree->iter_has_child(*xEntry)) + { + std::unique_ptr xChild(m_xTree->make_iterator(xEntry.get())); + (void)m_xTree->iter_children(*xChild); + std::unique_ptr xParent(m_xTree->make_iterator(xEntry.get())); + if (!m_xTree->iter_parent(*xParent)) + xParent.reset(); + bool bChild = true; + do + { + // because of the repositioning we have to start at the beginning again + bRestart = true; + std::unique_ptr xMove(m_xTree->make_iterator(xChild.get())); + bChild = m_xTree->iter_next_sibling(*xChild); + m_xTree->move_subtree(*xMove, xParent.get(), m_xTree->get_iter_index_in_parent(*xEntry)); + } while (bChild); + } + xRemove = m_xTree->make_iterator(xEntry.get()); + } + if (bRestart) + bEntry = m_xTree->get_iter_first(*xEntry); + else + bEntry = m_xTree->iter_next(*xEntry); + if (xRemove) + m_xTree->remove(*xRemove); + } + + if (m_xTree->get_selected(nullptr)) + return; + + m_xConditionFT->set_sensitive(false); + m_xConditionED->set_sensitive(false); + m_xDismiss->set_sensitive(false); + m_xCurName->set_sensitive(false); + m_xProtectCB->set_sensitive(false); + m_xPasswdCB->set_sensitive(false); + m_xHideCB->set_sensitive(false); + // edit in readonly sections + m_xEditInReadonlyCB->set_sensitive(false); + m_xEditInReadonlyCB->set_state(TRISTATE_FALSE); + m_xProtectCB->set_state(TRISTATE_FALSE); + m_xPasswdCB->set_active(false); + m_xHideCB->set_state(TRISTATE_FALSE); + m_xFileCB->set_active(false); + // otherwise the focus would be on HelpButton + m_xOK->grab_focus(); + UseFileHdl(*m_xFileCB); +} + +// link CheckBox to file? +IMPL_LINK(SwEditRegionDlg, UseFileHdl, weld::Toggleable&, rButton, void) +{ + if (!CheckPasswd(&rButton)) + return; + bool bMulti = 1 < m_xTree->count_selected_rows(); + bool bFile = rButton.get_active(); + if (m_xTree->get_selected(nullptr)) + { + m_xTree->selected_foreach([&](weld::TreeIter& rEntry){ + SectRepr* const pSectRepr = weld::fromId(m_xTree->get_id(rEntry)); + bool bContent = pSectRepr->IsContent(); + if( rButton.get_active() && bContent && m_rSh.HasSelection() ) + { + std::unique_ptr xQueryBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Question, VclButtonsType::YesNo, + SwResId(STR_QUERY_CONNECT))); + if (RET_NO == xQueryBox->run()) + rButton.set_active( false ); + } + if( bFile ) + pSectRepr->SetContent(false); + else + { + pSectRepr->SetFile(u""); + pSectRepr->SetSubRegion(std::u16string_view()); + pSectRepr->GetSectionData().SetLinkFilePassword(OUString()); + } + return false; + }); + m_xDDECB->set_sensitive(bFile && !bMulti); + m_xDDEFrame->set_sensitive(bFile && !bMulti); + if( bFile ) + { + m_xProtectCB->set_state(TRISTATE_TRUE); + m_xFileNameED->grab_focus(); + + } + else + { + m_xDDECB->set_active(false); + m_xSubRegionED->set_entry_text(OUString()); + } + DDEHdl(*m_xDDECB); + } + else + { + rButton.set_active(false); + rButton.set_sensitive(false); + m_xDDECB->set_active(false); + m_xDDECB->set_sensitive(false); + m_xDDEFrame->set_sensitive(false); + } +} + +// call dialog paste file +IMPL_LINK_NOARG(SwEditRegionDlg, FileSearchHdl, weld::Button&, void) +{ + if(!CheckPasswd()) + return; + m_pDocInserter.reset(new ::sfx2::DocumentInserter(m_xDialog.get(), "swriter")); + m_pDocInserter->StartExecuteModal( LINK( this, SwEditRegionDlg, DlgClosedHdl ) ); +} + +IMPL_LINK_NOARG(SwEditRegionDlg, OptionsHdl, weld::Button&, void) +{ + if(!CheckPasswd()) + return; + SectRepr* pSectRepr = weld::fromId(m_xTree->get_selected_id()); + if (!pSectRepr) + return; + + SfxItemSetFixed< + RES_FRM_SIZE, RES_FRM_SIZE, + RES_LR_SPACE, RES_LR_SPACE, + RES_BACKGROUND, RES_BACKGROUND, + RES_COL, RES_COL, + RES_FTN_AT_TXTEND, RES_FRAMEDIR, + XATTR_FILL_FIRST, XATTR_FILL_LAST, + SID_ATTR_PAGE_SIZE, SID_ATTR_PAGE_SIZE> aSet( m_rSh.GetView().GetPool() ); + + aSet.Put( pSectRepr->GetCol() ); + aSet.Put( *pSectRepr->GetBackground() ); + aSet.Put( pSectRepr->GetFootnoteNtAtEnd() ); + aSet.Put( pSectRepr->GetEndNtAtEnd() ); + aSet.Put( pSectRepr->GetBalance() ); + aSet.Put( *pSectRepr->GetFrameDir() ); + aSet.Put( *pSectRepr->GetLRSpace() ); + + const SwSectionFormats& rDocFormats = m_rSh.GetDoc()->GetSections(); + SwSectionFormats aOrigArray(rDocFormats); + + SwSectionFormat* pFormat = aOrigArray[pSectRepr->GetArrPos()]; + tools::Long nWidth = m_rSh.GetSectionWidth(*pFormat); + aOrigArray.clear(); + if (!nWidth) + nWidth = USHRT_MAX; + + aSet.Put(SwFormatFrameSize(SwFrameSize::Variable, nWidth)); + aSet.Put(SvxSizeItem(SID_ATTR_PAGE_SIZE, Size(nWidth, nWidth))); + + auto pDlg = std::make_shared(m_xDialog.get(), aSet, m_rSh); + SfxTabDialogController::runAsync(pDlg, [pDlg, this](sal_Int32 nResult){ + if (nResult == RET_OK) { + const SfxItemSet* pOutSet = pDlg->GetOutputItemSet(); + if( !(pOutSet && pOutSet->Count()) ) + return; + + const SwFormatCol* pColItem = pOutSet->GetItemIfSet( + RES_COL, false ); + const SvxBrushItem* pBrushItem = pOutSet->GetItemIfSet( + RES_BACKGROUND, false ); + const SwFormatFootnoteAtTextEnd* pFootnoteItem = pOutSet->GetItemIfSet( + RES_FTN_AT_TXTEND, false ); + const SwFormatEndAtTextEnd* pEndItem = pOutSet->GetItemIfSet( + RES_END_AT_TXTEND, false ); + const SwFormatNoBalancedColumns* pBalanceItem = pOutSet->GetItemIfSet( + RES_COLUMNBALANCE, false ); + const SvxFrameDirectionItem* pFrameDirItem = pOutSet->GetItemIfSet( + RES_FRAMEDIR, false ); + const SvxLRSpaceItem* pLRSpaceItem = pOutSet->GetItemIfSet( + RES_LR_SPACE, false ); + + if( !(pColItem || + pBrushItem || + pFootnoteItem || + pEndItem || + pBalanceItem || + pFrameDirItem || + pLRSpaceItem) ) + return; + + m_xTree->selected_foreach([&](weld::TreeIter& rEntry) + { + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + if (pColItem) + pRepr->GetCol() = *pColItem; + if (pBrushItem) + pRepr->GetBackground().reset(pBrushItem->Clone()); + if (pFootnoteItem) + pRepr->GetFootnoteNtAtEnd() = *pFootnoteItem; + if (pEndItem) + pRepr->GetEndNtAtEnd() = *pEndItem; + if (pBalanceItem) + pRepr->GetBalance().SetValue(pBalanceItem->GetValue()); + if (pFrameDirItem) + pRepr->GetFrameDir()->SetValue(pFrameDirItem->GetValue()); + if (pLRSpaceItem) + pRepr->GetLRSpace().reset(pLRSpaceItem->Clone()); + return false; + }); + } + }); + +} + +IMPL_LINK(SwEditRegionDlg, FileNameComboBoxHdl, weld::ComboBox&, rEdit, void) +{ + int nStartPos, nEndPos; + rEdit.get_entry_selection_bounds(nStartPos, nEndPos); + if (!CheckPasswd()) + return; + rEdit.select_entry_region(nStartPos, nEndPos); + SectRepr* pSectRepr = weld::fromId(m_xTree->get_selected_id()); + pSectRepr->SetSubRegion( rEdit.get_active_text() ); +} + +// Applying of the filename or the linked region +IMPL_LINK(SwEditRegionDlg, FileNameEntryHdl, weld::Entry&, rEdit, void) +{ + int nStartPos, nEndPos; + rEdit.get_selection_bounds(nStartPos, nEndPos); + if (!CheckPasswd()) + return; + rEdit.select_region(nStartPos, nEndPos); + SectRepr* pSectRepr = weld::fromId(m_xTree->get_selected_id()); + m_xSubRegionED->clear(); + m_xSubRegionED->append_text(""); // put in a dummy entry, which is replaced when m_bSubRegionsFilled is set + m_bSubRegionsFilled = false; + if (m_xDDECB->get_active()) + { + OUString sLink( CollapseWhiteSpaces(rEdit.get_text()) ); + sal_Int32 nPos = 0; + sLink = sLink.replaceFirst( " ", OUStringChar(sfx2::cTokenSeparator), &nPos ); + if (nPos>=0) + { + sLink = sLink.replaceFirst( " ", OUStringChar(sfx2::cTokenSeparator), &nPos ); + } + + pSectRepr->GetSectionData().SetLinkFileName( sLink ); + pSectRepr->GetSectionData().SetType( SectionType::DdeLink ); + } + else + { + OUString sTmp(rEdit.get_text()); + if(!sTmp.isEmpty()) + { + SfxMedium* pMedium = m_rSh.GetView().GetDocShell()->GetMedium(); + INetURLObject aAbs; + if( pMedium ) + aAbs = pMedium->GetURLObject(); + sTmp = URIHelper::SmartRel2Abs( + aAbs, sTmp, URIHelper::GetMaybeFileHdl() ); + } + pSectRepr->SetFile( sTmp ); + pSectRepr->GetSectionData().SetLinkFilePassword(OUString()); + } +} + +IMPL_LINK(SwEditRegionDlg, DDEHdl, weld::Toggleable&, rButton, void) +{ + if (!CheckPasswd(&rButton)) + return; + SectRepr* pSectRepr = weld::fromId(m_xTree->get_selected_id()); + if (!pSectRepr) + return; + + bool bFile = m_xFileCB->get_active(); + SwSectionData & rData( pSectRepr->GetSectionData() ); + bool bDDE = rButton.get_active(); + if(bDDE) + { + m_xFileNameFT->hide(); + m_xDDECommandFT->set_sensitive(true); + m_xDDECommandFT->show(); + m_xSubRegionFT->hide(); + m_xSubRegionED->hide(); + if (SectionType::FileLink == rData.GetType()) + { + pSectRepr->SetFile(u""); + m_xFileNameED->set_text(OUString()); + rData.SetLinkFilePassword(OUString()); + } + rData.SetType(SectionType::DdeLink); + } + else + { + m_xDDECommandFT->hide(); + m_xFileNameFT->set_sensitive(bFile); + if(!comphelper::LibreOfficeKit::isActive()) + m_xFileNameFT->show(); + m_xSubRegionED->show(); + m_xSubRegionFT->show(); + m_xSubRegionED->set_sensitive(bFile); + m_xSubRegionFT->set_sensitive(bFile); + m_xSubRegionED->set_sensitive(bFile); + if (SectionType::DdeLink == rData.GetType()) + { + rData.SetType(SectionType::FileLink); + pSectRepr->SetFile(u""); + rData.SetLinkFilePassword(OUString()); + m_xFileNameED->set_text(OUString()); + } + } + m_xFilePB->set_sensitive(bFile && !bDDE); +} + +void SwEditRegionDlg::ChangePasswd(bool bChange) +{ + if (!CheckPasswd()) + { + if (!bChange) + m_xPasswdCB->set_active(!m_xPasswdCB->get_active()); + return; + } + + bool bSet = bChange ? bChange : m_xPasswdCB->get_active(); + + m_xTree->selected_foreach([this, bChange, bSet](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + if(bSet) + { + if(!pRepr->GetTempPasswd().hasElements() || bChange) + { + SfxPasswordDialog aPasswdDlg(m_xDialog.get()); + aPasswdDlg.ShowExtras(SfxShowExtras::CONFIRM); + if (RET_OK == aPasswdDlg.run()) + { + const OUString sNewPasswd(aPasswdDlg.GetPassword()); + if (aPasswdDlg.GetConfirm() == sNewPasswd) + { + SvPasswordHelper::GetHashPassword( pRepr->GetTempPasswd(), sNewPasswd ); + } + else + { + std::unique_ptr xInfoBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Info, VclButtonsType::Ok, + SwResId(STR_WRONG_PASSWD_REPEAT))); + xInfoBox->run(); + ChangePasswd(bChange); + return true; + } + } + else + { + if(!bChange) + m_xPasswdCB->set_active(false); + return true; + } + } + pRepr->GetSectionData().SetPassword(pRepr->GetTempPasswd()); + } + else + { + pRepr->GetSectionData().SetPassword(uno::Sequence()); + } + return false; + }); +} + +IMPL_LINK_NOARG(SwEditRegionDlg, TogglePasswdHdl, weld::Toggleable&, void) +{ + ChangePasswd(false); +} + +IMPL_LINK_NOARG(SwEditRegionDlg, ChangePasswdHdl, weld::Button&, void) +{ + ChangePasswd(true); +} + +// the current region name is being added to the TreeListBox immediately during +// editing, with empty string no Ok() +IMPL_LINK_NOARG(SwEditRegionDlg, NameEditHdl, weld::Entry&, void) +{ + if(!CheckPasswd()) + return; + std::unique_ptr xIter(m_xTree->make_iterator()); + if (m_xTree->get_selected(xIter.get())) + { + const OUString aName = m_xCurName->get_text(); + m_xTree->set_text(*xIter, aName); + SectRepr* pRepr = weld::fromId(m_xTree->get_id(*xIter)); + pRepr->GetSectionData().SetSectionName(aName); + + m_xOK->set_sensitive(!aName.isEmpty()); + } +} + +IMPL_LINK( SwEditRegionDlg, ConditionEditHdl, weld::Entry&, rEdit, void ) +{ + int nStartPos, nEndPos; + rEdit.get_selection_bounds(nStartPos, nEndPos); + if(!CheckPasswd()) + return; + rEdit.select_region(nStartPos, nEndPos); + + m_xTree->selected_foreach([this, &rEdit](weld::TreeIter& rEntry){ + SectRepr* pRepr = weld::fromId(m_xTree->get_id(rEntry)); + pRepr->GetSectionData().SetCondition(rEdit.get_text()); + return false; + }); +} + +IMPL_LINK( SwEditRegionDlg, DlgClosedHdl, sfx2::FileDialogHelper *, _pFileDlg, void ) +{ + OUString sFileName, sFilterName, sPassword; + if ( _pFileDlg->GetError() == ERRCODE_NONE ) + { + std::unique_ptr pMedium(m_pDocInserter->CreateMedium("sglobal")); + if ( pMedium ) + { + sFileName = pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + sFilterName = pMedium->GetFilter()->GetFilterName(); + if ( const SfxStringItem* pItem = pMedium->GetItemSet().GetItemIfSet( SID_PASSWORD, false ) ) + sPassword = pItem->GetValue(); + ::lcl_ReadSections(*pMedium, *m_xSubRegionED); + } + } + + SectRepr* pSectRepr = weld::fromId(m_xTree->get_selected_id()); + if (pSectRepr) + { + pSectRepr->SetFile( sFileName ); + pSectRepr->SetFilter( sFilterName ); + pSectRepr->GetSectionData().SetLinkFilePassword(sPassword); + m_xFileNameED->set_text(pSectRepr->GetFile()); + } +} + +IMPL_LINK_NOARG(SwEditRegionDlg, SubRegionEventHdl, weld::ComboBox&, void) +{ + if (m_bSubRegionsFilled) + return; + + //if necessary fill the names bookmarks/sections/tables now + + OUString sFileName = m_xFileNameED->get_text(); + if(!sFileName.isEmpty()) + { + SfxMedium* pMedium = m_rSh.GetView().GetDocShell()->GetMedium(); + INetURLObject aAbs; + if( pMedium ) + aAbs = pMedium->GetURLObject(); + sFileName = URIHelper::SmartRel2Abs( + aAbs, sFileName, URIHelper::GetMaybeFileHdl() ); + + //load file and set the shell + SfxMedium aMedium( sFileName, StreamMode::STD_READ ); + sFileName = aMedium.GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + ::lcl_ReadSections(aMedium, *m_xSubRegionED); + } + else + lcl_FillSubRegionList(m_rSh, *m_xSubRegionED, nullptr); + m_bSubRegionsFilled = true; +} + +// helper function - read section names from medium +static void lcl_ReadSections( SfxMedium& rMedium, weld::ComboBox& rBox ) +{ + rBox.clear(); + uno::Reference < embed::XStorage > xStg; + if( !(rMedium.IsStorage() && (xStg = rMedium.GetStorage()).is()) ) + return; + + std::vector aArr; + SotClipboardFormatId nFormat = SotStorage::GetFormatID( xStg ); + if ( nFormat == SotClipboardFormatId::STARWRITER_60 || nFormat == SotClipboardFormatId::STARWRITERGLOB_60 || + nFormat == SotClipboardFormatId::STARWRITER_8 || nFormat == SotClipboardFormatId::STARWRITERGLOB_8) + SwGetReaderXML()->GetSectionList( rMedium, aArr ); + + for (auto const& it : aArr) + { + rBox.append_text(it); + } +} + +SwInsertSectionTabDialog::SwInsertSectionTabDialog( + weld::Window* pParent, const SfxItemSet& rSet, SwWrtShell& rSh) + : SfxTabDialogController(pParent, "modules/swriter/ui/insertsectiondialog.ui", + "InsertSectionDialog",&rSet) + , m_rWrtSh(rSh) +{ + SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); + AddTabPage("section", SwInsertSectionTabPage::Create, nullptr); + AddTabPage("columns", SwColumnPage::Create, nullptr); + AddTabPage("background", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BKG), nullptr); + AddTabPage("notes", SwSectionFootnoteEndTabPage::Create, nullptr); + AddTabPage("indents", SwSectionIndentTabPage::Create, nullptr); + + tools::Long nHtmlMode = SvxHtmlOptions::GetExportMode(); + + bool bWeb = dynamic_cast( rSh.GetView().GetDocShell() ) != nullptr ; + if(bWeb) + { + RemoveTabPage("notes"); + RemoveTabPage("indents"); + if( HTML_CFG_NS40 != nHtmlMode && HTML_CFG_WRITER != nHtmlMode) + RemoveTabPage("columns"); + } + SetCurPageId("section"); +} + +SwInsertSectionTabDialog::~SwInsertSectionTabDialog() +{ +} + +void SwInsertSectionTabDialog::PageCreated(const OUString& rId, SfxTabPage &rPage) +{ + if (rId == "section") + static_cast(rPage).SetWrtShell(m_rWrtSh); + else if (rId == "background") + { + SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool())); + aSet.Put (SfxUInt32Item(SID_FLAG_TYPE, static_cast(SvxBackgroundTabFlags::SHOW_SELECTOR))); + rPage.PageCreated(aSet); + } + else if (rId == "columns") + { + const SwFormatFrameSize& rSize = GetInputSetImpl()->Get(RES_FRM_SIZE); + static_cast(rPage).SetPageWidth(rSize.GetWidth()); + static_cast(rPage).ShowBalance(true); + static_cast(rPage).SetInSection(true); + } + else if (rId == "indents") + static_cast(rPage).SetWrtShell(m_rWrtSh); +} + +void SwInsertSectionTabDialog::SetSectionData(SwSectionData const& rSect) +{ + m_pSectionData.reset( new SwSectionData(rSect) ); +} + +short SwInsertSectionTabDialog::Ok() +{ + short nRet = SfxTabDialogController::Ok(); + OSL_ENSURE(m_pSectionData, "SwInsertSectionTabDialog: no SectionData?"); + const SfxItemSet* pOutputItemSet = GetOutputItemSet(); + m_rWrtSh.InsertSection(*m_pSectionData, pOutputItemSet); + SfxViewFrame& rViewFrame = m_rWrtSh.GetView().GetViewFrame(); + uno::Reference< frame::XDispatchRecorder > xRecorder = + rViewFrame.GetBindings().GetRecorder(); + if ( xRecorder.is() ) + { + SfxRequest aRequest(rViewFrame, FN_INSERT_REGION); + if(const SwFormatCol* pCol = pOutputItemSet->GetItemIfSet(RES_COL, false)) + { + aRequest.AppendItem(SfxUInt16Item(SID_ATTR_COLUMNS, + pCol->GetColumns().size())); + } + aRequest.AppendItem(SfxStringItem( FN_PARAM_REGION_NAME, + m_pSectionData->GetSectionName())); + aRequest.AppendItem(SfxStringItem( FN_PARAM_REGION_CONDITION, + m_pSectionData->GetCondition())); + aRequest.AppendItem(SfxBoolItem( FN_PARAM_REGION_HIDDEN, + m_pSectionData->IsHidden())); + aRequest.AppendItem(SfxBoolItem( FN_PARAM_REGION_PROTECT, + m_pSectionData->IsProtectFlag())); + // edit in readonly sections + aRequest.AppendItem(SfxBoolItem( FN_PARAM_REGION_EDIT_IN_READONLY, + m_pSectionData->IsEditInReadonlyFlag())); + + const OUString sLinkFileName( m_pSectionData->GetLinkFileName() ); + sal_Int32 n = 0; + aRequest.AppendItem(SfxStringItem( FN_PARAM_1, sLinkFileName.getToken( 0, sfx2::cTokenSeparator, n ))); + aRequest.AppendItem(SfxStringItem( FN_PARAM_2, sLinkFileName.getToken( 0, sfx2::cTokenSeparator, n ))); + aRequest.AppendItem(SfxStringItem( FN_PARAM_3, sLinkFileName.getToken( 0, sfx2::cTokenSeparator, n ))); + aRequest.Done(); + } + return nRet; +} + +SwInsertSectionTabPage::SwInsertSectionTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rAttrSet) + : SfxTabPage(pPage, pController, "modules/swriter/ui/sectionpage.ui", "SectionPage", &rAttrSet) + , m_pWrtSh(nullptr) + , m_xCurName(m_xBuilder->weld_entry_tree_view("sectionnames", "sectionnames-entry", + "sectionnames-list")) + , m_xFileCB(m_xBuilder->weld_check_button("link")) + , m_xDDECB(m_xBuilder->weld_check_button("dde")) + , m_xDDECommandFT(m_xBuilder->weld_label("ddelabel")) + , m_xFileNameFT(m_xBuilder->weld_label("filelabel")) + , m_xFileNameED(m_xBuilder->weld_entry("filename")) + , m_xFilePB(m_xBuilder->weld_button("selectfile")) + , m_xSubRegionFT(m_xBuilder->weld_label("sectionlabel")) + , m_xSubRegionED(m_xBuilder->weld_combo_box("sectionname")) + , m_xProtectCB(m_xBuilder->weld_check_button("protect")) + , m_xPasswdCB(m_xBuilder->weld_check_button("withpassword")) + , m_xPasswdPB(m_xBuilder->weld_button("selectpassword")) + , m_xHideCB(m_xBuilder->weld_check_button("hide")) + , m_xConditionFT(m_xBuilder->weld_label("condlabel")) + , m_xConditionED(new ConditionEdit(m_xBuilder->weld_entry("withcond"))) + // edit in readonly sections + , m_xEditInReadonlyCB(m_xBuilder->weld_check_button("editable")) +{ + m_xCurName->make_sorted(); + m_xCurName->set_height_request_by_rows(12); + m_xSubRegionED->make_sorted(); + + m_xProtectCB->connect_toggled( LINK( this, SwInsertSectionTabPage, ChangeProtectHdl)); + m_xPasswdCB->connect_toggled( LINK( this, SwInsertSectionTabPage, TogglePasswdHdl)); + m_xPasswdPB->connect_clicked( LINK( this, SwInsertSectionTabPage, ChangePasswdHdl)); + m_xHideCB->connect_toggled( LINK( this, SwInsertSectionTabPage, ChangeHideHdl)); + m_xFileCB->connect_toggled( LINK( this, SwInsertSectionTabPage, UseFileHdl )); + m_xFilePB->connect_clicked( LINK( this, SwInsertSectionTabPage, FileSearchHdl )); + m_xCurName->connect_changed( LINK( this, SwInsertSectionTabPage, NameEditHdl)); + m_xDDECB->connect_toggled( LINK( this, SwInsertSectionTabPage, DDEHdl )); + ChangeProtectHdl(*m_xProtectCB); + m_xSubRegionED->set_entry_completion(true, true); + + // Hide Link section. In general it makes no sense to insert a file from the jail, + // because it does not contain any usable files (documents). + if(comphelper::LibreOfficeKit::isActive()) + { + m_xBuilder->weld_label("label1")->hide(); // Link + m_xFileCB->hide(); + m_xDDECB->hide(); + m_xDDECommandFT->hide(); + m_xFileNameFT->hide(); + m_xFileNameED->hide(); + m_xFilePB->hide(); + m_xSubRegionFT->hide(); + m_xSubRegionED->hide(); + } +} + +SwInsertSectionTabPage::~SwInsertSectionTabPage() +{ +} + +void SwInsertSectionTabPage::SetWrtShell(SwWrtShell& rSh) +{ + m_pWrtSh = &rSh; + + bool bWeb = dynamic_cast( m_pWrtSh->GetView().GetDocShell() )!= nullptr; + if(bWeb) + { + m_xHideCB->hide(); + m_xConditionED->hide(); + m_xConditionFT->hide(); + m_xDDECB->hide(); + m_xDDECommandFT->hide(); + } + + lcl_FillSubRegionList(*m_pWrtSh, *m_xSubRegionED, m_xCurName.get()); + + SwSectionData *const pSectionData = + static_cast(GetDialogController()) + ->GetSectionData(); + if (pSectionData) // something set? + { + const OUString sSectionName(pSectionData->GetSectionName()); + m_xCurName->set_entry_text(rSh.GetUniqueSectionName(&sSectionName)); + m_xProtectCB->set_active( pSectionData->IsProtectFlag() ); + ChangeProtectHdl(*m_xProtectCB); + m_sFileName = pSectionData->GetLinkFileName(); + m_sFilePasswd = pSectionData->GetLinkFilePassword(); + m_xFileCB->set_active( !m_sFileName.isEmpty() ); + m_xFileNameED->set_text( m_sFileName ); + UseFileHdl(*m_xFileCB); + } + else + { + m_xCurName->set_entry_text(rSh.GetUniqueSectionName()); + } +} + +bool SwInsertSectionTabPage::FillItemSet( SfxItemSet* ) +{ + SwSectionData aSection(SectionType::Content, m_xCurName->get_active_text()); + aSection.SetCondition(m_xConditionED->get_text()); + bool bProtected = m_xProtectCB->get_active(); + aSection.SetProtectFlag(bProtected); + aSection.SetHidden(m_xHideCB->get_active()); + // edit in readonly sections + aSection.SetEditInReadonlyFlag(m_xEditInReadonlyCB->get_active()); + + if(bProtected) + { + aSection.SetPassword(m_aNewPasswd); + } + const OUString sFileName = m_xFileNameED->get_text(); + const OUString sSubRegion = m_xSubRegionED->get_active_text(); + bool bDDe = m_xDDECB->get_active(); + if (m_xFileCB->get_active() && (!sFileName.isEmpty() || !sSubRegion.isEmpty() || bDDe)) + { + OUString aLinkFile; + if( bDDe ) + { + aLinkFile = CollapseWhiteSpaces(sFileName); + sal_Int32 nPos = 0; + aLinkFile = aLinkFile.replaceFirst( " ", OUStringChar(sfx2::cTokenSeparator), &nPos ); + if (nPos>=0) + { + aLinkFile = aLinkFile.replaceFirst( " ", OUStringChar(sfx2::cTokenSeparator), &nPos ); + } + } + else + { + if(!sFileName.isEmpty()) + { + SfxMedium* pMedium = m_pWrtSh->GetView().GetDocShell()->GetMedium(); + INetURLObject aAbs; + if( pMedium ) + aAbs = pMedium->GetURLObject(); + aLinkFile = URIHelper::SmartRel2Abs( + aAbs, sFileName, URIHelper::GetMaybeFileHdl() ); + aSection.SetLinkFilePassword( m_sFilePasswd ); + } + + aLinkFile += OUStringChar(sfx2::cTokenSeparator) + m_sFilterName + + OUStringChar(sfx2::cTokenSeparator) + sSubRegion; + } + + aSection.SetLinkFileName(aLinkFile); + if (!aLinkFile.isEmpty()) + { + aSection.SetType( m_xDDECB->get_active() ? + SectionType::DdeLink : + SectionType::FileLink); + } + } + static_cast(GetDialogController())->SetSectionData(aSection); + return true; +} + +void SwInsertSectionTabPage::Reset( const SfxItemSet* ) +{ +} + +std::unique_ptr SwInsertSectionTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique(pPage, pController, *rAttrSet); +} + +IMPL_LINK(SwInsertSectionTabPage, ChangeHideHdl, weld::Toggleable&, rBox, void) +{ + bool bHide = rBox.get_active(); + m_xConditionED->set_sensitive(bHide); + m_xConditionFT->set_sensitive(bHide); +} + +IMPL_LINK(SwInsertSectionTabPage, ChangeProtectHdl, weld::Toggleable&, rBox, void) +{ + bool bCheck = rBox.get_active(); + m_xPasswdCB->set_sensitive(bCheck); + m_xPasswdPB->set_sensitive(bCheck); +} + +void SwInsertSectionTabPage::ChangePasswd(bool bChange) +{ + bool bSet = bChange ? bChange : m_xPasswdCB->get_active(); + if (bSet) + { + if(!m_aNewPasswd.hasElements() || bChange) + { + SfxPasswordDialog aPasswdDlg(GetFrameWeld()); + aPasswdDlg.ShowExtras(SfxShowExtras::CONFIRM); + if (RET_OK == aPasswdDlg.run()) + { + const OUString sNewPasswd(aPasswdDlg.GetPassword()); + if (aPasswdDlg.GetConfirm() == sNewPasswd) + { + SvPasswordHelper::GetHashPassword( m_aNewPasswd, sNewPasswd ); + } + else + { + std::unique_ptr xInfoBox(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Info, VclButtonsType::Ok, + SwResId(STR_WRONG_PASSWD_REPEAT))); + xInfoBox->run(); + } + } + else if(!bChange) + m_xPasswdCB->set_active(false); + } + } + else + m_aNewPasswd.realloc(0); +} + +IMPL_LINK_NOARG(SwInsertSectionTabPage, TogglePasswdHdl, weld::Toggleable&, void) +{ + ChangePasswd(false); +} + +IMPL_LINK_NOARG(SwInsertSectionTabPage, ChangePasswdHdl, weld::Button&, void) +{ + ChangePasswd(true); +} + + +IMPL_LINK_NOARG(SwInsertSectionTabPage, NameEditHdl, weld::ComboBox&, void) +{ + const OUString aName = m_xCurName->get_active_text(); + GetDialogController()->GetOKButton().set_sensitive(!aName.isEmpty() && + m_xCurName->find_text(aName) == -1); +} + +IMPL_LINK(SwInsertSectionTabPage, UseFileHdl, weld::Toggleable&, rButton, void) +{ + if (rButton.get_active()) + { + if (m_pWrtSh->HasSelection()) + { + std::unique_ptr xQueryBox(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Question, VclButtonsType::YesNo, + SwResId(STR_QUERY_CONNECT))); + if (RET_NO == xQueryBox->run()) + rButton.set_active(false); + } + } + + bool bFile = rButton.get_active(); + m_xFileNameFT->set_sensitive(bFile); + m_xFileNameED->set_sensitive(bFile); + m_xFilePB->set_sensitive(bFile); + m_xSubRegionFT->set_sensitive(bFile); + m_xSubRegionED->set_sensitive(bFile); + m_xDDECommandFT->set_sensitive(bFile); + m_xDDECB->set_sensitive(bFile); + if (bFile) + { + m_xFileNameED->grab_focus(); + m_xProtectCB->set_active(true); + ChangeProtectHdl(*m_xProtectCB); + } + else + { + m_xDDECB->set_active(false); + DDEHdl(*m_xDDECB); + } +} + +IMPL_LINK_NOARG(SwInsertSectionTabPage, FileSearchHdl, weld::Button&, void) +{ + m_pDocInserter.reset(new ::sfx2::DocumentInserter(GetFrameWeld(), "swriter")); + m_pDocInserter->StartExecuteModal( LINK( this, SwInsertSectionTabPage, DlgClosedHdl ) ); +} + +IMPL_LINK( SwInsertSectionTabPage, DDEHdl, weld::Toggleable&, rButton, void ) +{ + bool bDDE = rButton.get_active(); + bool bFile = m_xFileCB->get_active(); + m_xFilePB->set_sensitive(!bDDE && bFile); + if (bDDE) + { + m_xFileNameFT->hide(); + m_xDDECommandFT->set_sensitive(bDDE); + m_xDDECommandFT->show(); + m_xSubRegionFT->hide(); + m_xSubRegionED->hide(); + m_xFileNameED->set_accessible_name(m_xDDECommandFT->get_label()); + } + else + { + m_xDDECommandFT->hide(); + m_xFileNameFT->set_sensitive(bFile); + if(!comphelper::LibreOfficeKit::isActive()) + m_xFileNameFT->show(); + m_xSubRegionFT->show(); + m_xSubRegionED->show(); + m_xSubRegionED->set_sensitive(bFile); + m_xFileNameED->set_accessible_name(m_xFileNameFT->get_label()); + } +} + +IMPL_LINK( SwInsertSectionTabPage, DlgClosedHdl, sfx2::FileDialogHelper *, _pFileDlg, void ) +{ + if ( _pFileDlg->GetError() == ERRCODE_NONE ) + { + std::unique_ptr pMedium(m_pDocInserter->CreateMedium("sglobal")); + if ( pMedium ) + { + m_sFileName = pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + m_sFilterName = pMedium->GetFilter()->GetFilterName(); + if ( const SfxStringItem* pItem = pMedium->GetItemSet().GetItemIfSet( SID_PASSWORD, false ) ) + m_sFilePasswd = pItem->GetValue(); + m_xFileNameED->set_text( INetURLObject::decode( + m_sFileName, INetURLObject::DecodeMechanism::Unambiguous ) ); + ::lcl_ReadSections(*pMedium, *m_xSubRegionED); + } + } + else + { + m_sFilterName.clear(); + m_sFilePasswd.clear(); + } +} + +SwSectionFootnoteEndTabPage::SwSectionFootnoteEndTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rAttrSet) + : SfxTabPage(pPage, pController, "modules/swriter/ui/footnotesendnotestabpage.ui", "FootnotesEndnotesTabPage", &rAttrSet) + , m_xFootnoteNtAtTextEndCB(m_xBuilder->weld_check_button("ftnntattextend")) + , m_xFootnoteNtNumCB(m_xBuilder->weld_check_button("ftnntnum")) + , m_xFootnoteOffsetLbl(m_xBuilder->weld_label("ftnoffset_label")) + , m_xFootnoteOffsetField(m_xBuilder->weld_spin_button("ftnoffset")) + , m_xFootnoteNtNumFormatCB(m_xBuilder->weld_check_button("ftnntnumfmt")) + , m_xFootnotePrefixFT(m_xBuilder->weld_label("ftnprefix_label")) + , m_xFootnotePrefixED(m_xBuilder->weld_entry("ftnprefix")) + , m_xFootnoteNumViewBox(new SwNumberingTypeListBox(m_xBuilder->weld_combo_box("ftnnumviewbox"))) + , m_xFootnoteSuffixFT(m_xBuilder->weld_label("ftnsuffix_label")) + , m_xFootnoteSuffixED(m_xBuilder->weld_entry("ftnsuffix")) + , m_xEndNtAtTextEndCB(m_xBuilder->weld_check_button("endntattextend")) + , m_xEndNtNumCB(m_xBuilder->weld_check_button("endntnum")) + , m_xEndOffsetLbl(m_xBuilder->weld_label("endoffset_label")) + , m_xEndOffsetField(m_xBuilder->weld_spin_button("endoffset")) + , m_xEndNtNumFormatCB(m_xBuilder->weld_check_button("endntnumfmt")) + , m_xEndPrefixFT(m_xBuilder->weld_label("endprefix_label")) + , m_xEndPrefixED(m_xBuilder->weld_entry("endprefix")) + , m_xEndNumViewBox(new SwNumberingTypeListBox(m_xBuilder->weld_combo_box("endnumviewbox"))) + , m_xEndSuffixFT(m_xBuilder->weld_label("endsuffix_label")) + , m_xEndSuffixED(m_xBuilder->weld_entry("endsuffix")) +{ + m_xFootnoteNumViewBox->Reload(SwInsertNumTypes::Extended); + m_xEndNumViewBox->Reload(SwInsertNumTypes::Extended); + + Link aLk( LINK( this, SwSectionFootnoteEndTabPage, FootEndHdl)); + m_xFootnoteNtAtTextEndCB->connect_toggled( aLk ); + m_xFootnoteNtNumCB->connect_toggled( aLk ); + m_xEndNtAtTextEndCB->connect_toggled( aLk ); + m_xEndNtNumCB->connect_toggled( aLk ); + m_xFootnoteNtNumFormatCB->connect_toggled( aLk ); + m_xEndNtNumFormatCB->connect_toggled( aLk ); +} + +SwSectionFootnoteEndTabPage::~SwSectionFootnoteEndTabPage() +{ +} + +bool SwSectionFootnoteEndTabPage::FillItemSet( SfxItemSet* rSet ) +{ + SwFormatFootnoteAtTextEnd aFootnote( m_xFootnoteNtAtTextEndCB->get_active() + ? ( m_xFootnoteNtNumCB->get_active() + ? ( m_xFootnoteNtNumFormatCB->get_active() + ? FTNEND_ATTXTEND_OWNNUMANDFMT + : FTNEND_ATTXTEND_OWNNUMSEQ ) + : FTNEND_ATTXTEND ) + : FTNEND_ATPGORDOCEND ); + + switch( aFootnote.GetValue() ) + { + case FTNEND_ATTXTEND_OWNNUMANDFMT: + aFootnote.SetNumType( m_xFootnoteNumViewBox->GetSelectedNumberingType() ); + aFootnote.SetPrefix( m_xFootnotePrefixED->get_text().replaceAll("\\t", "\t") ); // fdo#65666 + aFootnote.SetSuffix( m_xFootnoteSuffixED->get_text().replaceAll("\\t", "\t") ); + [[fallthrough]]; + + case FTNEND_ATTXTEND_OWNNUMSEQ: + aFootnote.SetOffset( static_cast< sal_uInt16 >( m_xFootnoteOffsetField->get_value()-1 ) ); + break; + default: break; + } + + SwFormatEndAtTextEnd aEnd( m_xEndNtAtTextEndCB->get_active() + ? ( m_xEndNtNumCB->get_active() + ? ( m_xEndNtNumFormatCB->get_active() + ? FTNEND_ATTXTEND_OWNNUMANDFMT + : FTNEND_ATTXTEND_OWNNUMSEQ ) + : FTNEND_ATTXTEND ) + : FTNEND_ATPGORDOCEND ); + + switch( aEnd.GetValue() ) + { + case FTNEND_ATTXTEND_OWNNUMANDFMT: + aEnd.SetNumType( m_xEndNumViewBox->GetSelectedNumberingType() ); + aEnd.SetPrefix( m_xEndPrefixED->get_text().replaceAll("\\t", "\t") ); + aEnd.SetSuffix( m_xEndSuffixED->get_text().replaceAll("\\t", "\t") ); + [[fallthrough]]; + + case FTNEND_ATTXTEND_OWNNUMSEQ: + aEnd.SetOffset( static_cast< sal_uInt16 >( m_xEndOffsetField->get_value()-1 ) ); + break; + default: break; + } + + rSet->Put( aFootnote ); + rSet->Put( aEnd ); + + return true; +} + +void SwSectionFootnoteEndTabPage::ResetState( bool bFootnote, + const SwFormatFootnoteEndAtTextEnd& rAttr ) +{ + weld::CheckButton *pNtAtTextEndCB, *pNtNumCB, *pNtNumFormatCB; + weld::Label *pPrefixFT, *pSuffixFT; + weld::Entry *pPrefixED, *pSuffixED; + SwNumberingTypeListBox *pNumViewBox; + weld::Label *pOffsetText; + weld::SpinButton *pOffsetField; + + if( bFootnote ) + { + pNtAtTextEndCB = m_xFootnoteNtAtTextEndCB.get(); + pNtNumCB = m_xFootnoteNtNumCB.get(); + pNtNumFormatCB = m_xFootnoteNtNumFormatCB.get(); + pPrefixFT = m_xFootnotePrefixFT.get(); + pPrefixED = m_xFootnotePrefixED.get(); + pSuffixFT = m_xFootnoteSuffixFT.get(); + pSuffixED = m_xFootnoteSuffixED.get(); + pNumViewBox = m_xFootnoteNumViewBox.get(); + pOffsetText = m_xFootnoteOffsetLbl.get(); + pOffsetField = m_xFootnoteOffsetField.get(); + } + else + { + pNtAtTextEndCB = m_xEndNtAtTextEndCB.get(); + pNtNumCB = m_xEndNtNumCB.get(); + pNtNumFormatCB = m_xEndNtNumFormatCB.get(); + pPrefixFT = m_xEndPrefixFT.get(); + pPrefixED = m_xEndPrefixED.get(); + pSuffixFT = m_xEndSuffixFT.get(); + pSuffixED = m_xEndSuffixED.get(); + pNumViewBox = m_xEndNumViewBox.get(); + pOffsetText = m_xEndOffsetLbl.get(); + pOffsetField = m_xEndOffsetField.get(); + } + + const sal_uInt16 eState = rAttr.GetValue(); + switch( eState ) + { + case FTNEND_ATTXTEND_OWNNUMANDFMT: + pNtNumFormatCB->set_state( TRISTATE_TRUE ); + [[fallthrough]]; + + case FTNEND_ATTXTEND_OWNNUMSEQ: + pNtNumCB->set_state( TRISTATE_TRUE ); + [[fallthrough]]; + + case FTNEND_ATTXTEND: + pNtAtTextEndCB->set_state( TRISTATE_TRUE ); + // no break; + } + + pNumViewBox->SelectNumberingType( rAttr.GetNumType() ); + pOffsetField->set_value( rAttr.GetOffset() + 1 ); + pPrefixED->set_text( rAttr.GetPrefix().replaceAll("\t", "\\t") ); + pSuffixED->set_text( rAttr.GetSuffix().replaceAll("\t", "\\t") ); + + switch( eState ) + { + case FTNEND_ATPGORDOCEND: + pNtNumCB->set_sensitive( false ); + [[fallthrough]]; + + case FTNEND_ATTXTEND: + pNtNumFormatCB->set_sensitive( false ); + pOffsetField->set_sensitive( false ); + pOffsetText->set_sensitive( false ); + [[fallthrough]]; + + case FTNEND_ATTXTEND_OWNNUMSEQ: + pNumViewBox->set_sensitive( false ); + pPrefixFT->set_sensitive( false ); + pPrefixED->set_sensitive( false ); + pSuffixFT->set_sensitive( false ); + pSuffixED->set_sensitive( false ); + // no break; + } +} + +void SwSectionFootnoteEndTabPage::Reset( const SfxItemSet* rSet ) +{ + ResetState( true, rSet->Get( RES_FTN_AT_TXTEND, false )); + ResetState( false, rSet->Get( RES_END_AT_TXTEND, false )); +} + +std::unique_ptr SwSectionFootnoteEndTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique(pPage, pController, *rAttrSet); +} + +IMPL_LINK( SwSectionFootnoteEndTabPage, FootEndHdl, weld::Toggleable&, rBox, void ) +{ + bool bFoot = m_xFootnoteNtAtTextEndCB.get() == &rBox || m_xFootnoteNtNumCB.get() == &rBox || + m_xFootnoteNtNumFormatCB.get() == &rBox ; + + weld::CheckButton *pNumBox, *pNumFormatBox, *pEndBox; + SwNumberingTypeListBox* pNumViewBox; + weld::Label *pOffsetText; + weld::SpinButton *pOffsetField; + weld::Label *pPrefixFT, *pSuffixFT; + weld::Entry *pPrefixED, *pSuffixED; + + if( bFoot ) + { + pEndBox = m_xFootnoteNtAtTextEndCB.get(); + pNumBox = m_xFootnoteNtNumCB.get(); + pNumFormatBox = m_xFootnoteNtNumFormatCB.get(); + pNumViewBox = m_xFootnoteNumViewBox.get(); + pOffsetText = m_xFootnoteOffsetLbl.get(); + pOffsetField = m_xFootnoteOffsetField.get(); + pPrefixFT = m_xFootnotePrefixFT.get(); + pSuffixFT = m_xFootnoteSuffixFT.get(); + pPrefixED = m_xFootnotePrefixED.get(); + pSuffixED = m_xFootnoteSuffixED.get(); + } + else + { + pEndBox = m_xEndNtAtTextEndCB.get(); + pNumBox = m_xEndNtNumCB.get(); + pNumFormatBox = m_xEndNtNumFormatCB.get(); + pNumViewBox = m_xEndNumViewBox.get(); + pOffsetText = m_xEndOffsetLbl.get(); + pOffsetField = m_xEndOffsetField.get(); + pPrefixFT = m_xEndPrefixFT.get(); + pSuffixFT = m_xEndSuffixFT.get(); + pPrefixED = m_xEndPrefixED.get(); + pSuffixED = m_xEndSuffixED.get(); + } + + bool bEnableAtEnd = TRISTATE_TRUE == pEndBox->get_state(); + bool bEnableNum = bEnableAtEnd && TRISTATE_TRUE == pNumBox->get_state(); + bool bEnableNumFormat = bEnableNum && TRISTATE_TRUE == pNumFormatBox->get_state(); + + pNumBox->set_sensitive( bEnableAtEnd ); + pOffsetText->set_sensitive( bEnableNum ); + pOffsetField->set_sensitive( bEnableNum ); + pNumFormatBox->set_sensitive( bEnableNum ); + pNumViewBox->set_sensitive( bEnableNumFormat ); + pPrefixED->set_sensitive( bEnableNumFormat ); + pSuffixED->set_sensitive( bEnableNumFormat ); + pPrefixFT->set_sensitive( bEnableNumFormat ); + pSuffixFT->set_sensitive( bEnableNumFormat ); +} + +SwSectionPropertyTabDialog::SwSectionPropertyTabDialog( + weld::Window* pParent, const SfxItemSet& rSet, SwWrtShell& rSh) + : SfxTabDialogController(pParent, "modules/swriter/ui/formatsectiondialog.ui", + "FormatSectionDialog", &rSet) + , m_rWrtSh(rSh) +{ + SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); + AddTabPage("columns", SwColumnPage::Create, nullptr); + AddTabPage("background", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BKG), nullptr); + AddTabPage("notes", SwSectionFootnoteEndTabPage::Create, nullptr); + AddTabPage("indents", SwSectionIndentTabPage::Create, nullptr); + + tools::Long nHtmlMode = SvxHtmlOptions::GetExportMode(); + bool bWeb = dynamic_cast( rSh.GetView().GetDocShell() ) != nullptr ; + if(bWeb) + { + RemoveTabPage("notes"); + RemoveTabPage("indents"); + if( HTML_CFG_NS40 != nHtmlMode && HTML_CFG_WRITER != nHtmlMode) + RemoveTabPage("columns"); + } +} + +SwSectionPropertyTabDialog::~SwSectionPropertyTabDialog() +{ +} + +void SwSectionPropertyTabDialog::PageCreated(const OUString& rId, SfxTabPage &rPage) +{ + if (rId == "background") + { + SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool())); + aSet.Put (SfxUInt32Item(SID_FLAG_TYPE, static_cast(SvxBackgroundTabFlags::SHOW_SELECTOR))); + rPage.PageCreated(aSet); + } + else if (rId == "columns") + { + static_cast(rPage).ShowBalance(true); + static_cast(rPage).SetInSection(true); + } + else if (rId == "indents") + static_cast(rPage).SetWrtShell(m_rWrtSh); +} + +SwSectionIndentTabPage::SwSectionIndentTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rAttrSet) + : SfxTabPage(pPage, pController, "modules/swriter/ui/indentpage.ui", "IndentPage", &rAttrSet) + , m_xBeforeMF(m_xBuilder->weld_metric_spin_button("before", FieldUnit::CM)) + , m_xAfterMF(m_xBuilder->weld_metric_spin_button("after", FieldUnit::CM)) + , m_xPreviewWin(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWin)) +{ + Link aLk = LINK(this, SwSectionIndentTabPage, IndentModifyHdl); + m_xBeforeMF->connect_value_changed(aLk); + m_xAfterMF->connect_value_changed(aLk); +} + +SwSectionIndentTabPage::~SwSectionIndentTabPage() +{ +} + +bool SwSectionIndentTabPage::FillItemSet(SfxItemSet* rSet) +{ + if (m_xBeforeMF->get_value_changed_from_saved() || m_xAfterMF->get_value_changed_from_saved()) + { + SvxLRSpaceItem aLRSpace( + m_xBeforeMF->denormalize(m_xBeforeMF->get_value(FieldUnit::TWIP)) , + m_xAfterMF->denormalize(m_xAfterMF->get_value(FieldUnit::TWIP)), 0, RES_LR_SPACE); + rSet->Put(aLRSpace); + } + return true; +} + +void SwSectionIndentTabPage::Reset( const SfxItemSet* rSet) +{ + //this page doesn't show up in HTML mode + FieldUnit aMetric = ::GetDfltMetric(false); + SetFieldUnit(*m_xBeforeMF, aMetric); + SetFieldUnit(*m_xAfterMF , aMetric); + + SfxItemState eItemState = rSet->GetItemState( RES_LR_SPACE ); + if ( eItemState >= SfxItemState::DEFAULT ) + { + const SvxLRSpaceItem& rSpace = + rSet->Get( RES_LR_SPACE ); + + m_xBeforeMF->set_value(m_xBeforeMF->normalize(rSpace.GetLeft()), FieldUnit::TWIP); + m_xAfterMF->set_value(m_xAfterMF->normalize(rSpace.GetRight()), FieldUnit::TWIP); + } + else + { + m_xBeforeMF->set_text(""); + m_xAfterMF->set_text(""); + } + m_xBeforeMF->save_value(); + m_xAfterMF->save_value(); + IndentModifyHdl(*m_xBeforeMF); +} + +std::unique_ptr SwSectionIndentTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet) +{ + return std::make_unique(pPage, pController, *rAttrSet); +} + +void SwSectionIndentTabPage::SetWrtShell(SwWrtShell const & rSh) +{ + //set sensible values at the preview + m_aPreviewWin.SetAdjust(SvxAdjust::Block); + m_aPreviewWin.SetLastLine(SvxAdjust::Block); + const SwRect& rPageRect = rSh.GetAnyCurRect( CurRectType::Page ); + Size aPageSize(rPageRect.Width(), rPageRect.Height()); + m_aPreviewWin.SetSize(aPageSize); +} + +IMPL_LINK_NOARG(SwSectionIndentTabPage, IndentModifyHdl, weld::MetricSpinButton&, void) +{ + m_aPreviewWin.SetLeftMargin(m_xBeforeMF->denormalize(m_xBeforeMF->get_value(FieldUnit::TWIP))); + m_aPreviewWin.SetRightMargin(m_xAfterMF->denormalize(m_xAfterMF->get_value(FieldUnit::TWIP))); + m_aPreviewWin.Invalidate(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/ui/dialog/wordcountdialog.cxx b/sw/source/ui/dialog/wordcountdialog.cxx new file mode 100644 index 0000000000..1277545c6e --- /dev/null +++ b/sw/source/ui/dialog/wordcountdialog.cxx @@ -0,0 +1,161 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define IS_MOBILE_PHONE (comphelper::LibreOfficeKit::isActive() && SfxViewShell::Current() && SfxViewShell::Current()->isLOKMobilePhone()) + +SwWordCountFloatDlg::~SwWordCountFloatDlg() +{ + SwViewShell::SetCareDialog(nullptr); +} + +namespace +{ + void setValue(weld::Label& rWidget, sal_uLong nValue, const LocaleDataWrapper& rLocaleData) + { + rWidget.set_label(rLocaleData.getNum(nValue, 0)); + } + + void setDoubleValue(weld::Label& rWidget, double fValue) + { + OUString sValue(OUString::number(::rtl::math::round(fValue, 1))); + rWidget.set_label(sValue); + } +} + +void SwWordCountFloatDlg::SetValues(const SwDocStat& rCurrent, const SwDocStat& rDoc) +{ + const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetUILocaleDataWrapper(); + setValue(*m_xCurrentWordFT, rCurrent.nWord, rLocaleData); + setValue(*m_xCurrentCharacterFT, rCurrent.nChar, rLocaleData); + setValue(*m_xCurrentCharacterExcludingSpacesFT, rCurrent.nCharExcludingSpaces, rLocaleData); + setValue(*m_xCurrentCjkcharsFT, rCurrent.nAsianWord, rLocaleData); + setValue(*m_xDocWordFT, rDoc.nWord, rLocaleData); + setValue(*m_xDocCharacterFT, rDoc.nChar, rLocaleData); + setValue(*m_xDocCharacterExcludingSpacesFT, rDoc.nCharExcludingSpaces, rLocaleData); + setValue(*m_xDocCjkcharsFT, rDoc.nAsianWord, rLocaleData); + setValue(*m_xDocComments, rCurrent.nComments, rLocaleData); + + const sal_Int64 nCharsPerStandardizedPage = m_xStandardizedPagesLabelFT->get_visible() ? + officecfg::Office::Writer::WordCount::StandardizedPageSize::get() : 0; + if (nCharsPerStandardizedPage) + { + setDoubleValue(*m_xCurrentStandardizedPagesFT, + static_cast(rCurrent.nChar) / nCharsPerStandardizedPage); + setDoubleValue(*m_xDocStandardizedPagesFT, + static_cast(rDoc.nChar) / nCharsPerStandardizedPage); + } + + bool bShowCJK = (SvtCJKOptions::IsAnyEnabled() || rDoc.nAsianWord); + bool bToggleCJK = m_xCurrentCjkcharsFT->get_visible() != bShowCJK; + if (bToggleCJK) + { + showCJK(bShowCJK); + m_xDialog->resize_to_request(); //force resize of dialog + } +} + +void SwWordCountFloatDlg::showCJK(bool bShowCJK) +{ + m_xCurrentCjkcharsFT->set_visible(bShowCJK); + m_xDocCjkcharsFT->set_visible(bShowCJK); + if (IS_MOBILE_PHONE && m_xCjkcharsLabelFT2) + m_xCjkcharsLabelFT2->set_visible(bShowCJK); + m_xCjkcharsLabelFT->set_visible(bShowCJK); +} + +void SwWordCountFloatDlg::showStandardizedPages(bool bShowStandardizedPages) +{ + m_xCurrentStandardizedPagesFT->set_visible(bShowStandardizedPages); + m_xDocStandardizedPagesFT->set_visible(bShowStandardizedPages); + if (IS_MOBILE_PHONE && m_xStandardizedPagesLabelFT2) + m_xStandardizedPagesLabelFT2->set_visible(bShowStandardizedPages); + m_xStandardizedPagesLabelFT->set_visible(bShowStandardizedPages); +} + +SwWordCountFloatDlg::SwWordCountFloatDlg(SfxBindings* _pBindings, + SfxChildWindow* pChild, + weld::Window *pParent, + SfxChildWinInfo const * pInfo) + : SfxModelessDialogController(_pBindings, pChild, pParent, IS_MOBILE_PHONE ? OUString("modules/swriter/ui/wordcount-mobile.ui") : OUString("modules/swriter/ui/wordcount.ui"), "WordCountDialog") + , m_xCurrentWordFT(m_xBuilder->weld_label("selectwords")) + , m_xCurrentCharacterFT(m_xBuilder->weld_label("selectchars")) + , m_xCurrentCharacterExcludingSpacesFT(m_xBuilder->weld_label("selectcharsnospaces")) + , m_xCurrentCjkcharsFT(m_xBuilder->weld_label("selectcjkchars")) + , m_xCurrentStandardizedPagesFT(m_xBuilder->weld_label("selectstandardizedpages")) + , m_xDocWordFT(m_xBuilder->weld_label("docwords")) + , m_xDocCharacterFT(m_xBuilder->weld_label("docchars")) + , m_xDocCharacterExcludingSpacesFT(m_xBuilder->weld_label("doccharsnospaces")) + , m_xDocCjkcharsFT(m_xBuilder->weld_label("doccjkchars")) + , m_xDocStandardizedPagesFT(m_xBuilder->weld_label("docstandardizedpages")) + , m_xCjkcharsLabelFT(m_xBuilder->weld_label("cjkcharsft")) + , m_xCjkcharsLabelFT2(m_xBuilder->weld_label("cjkcharsft2")) + , m_xStandardizedPagesLabelFT(m_xBuilder->weld_label("standardizedpages")) + , m_xStandardizedPagesLabelFT2(m_xBuilder->weld_label("standardizedpages2")) + , m_xDocComments(m_xBuilder->weld_label("docComments")) +{ + showCJK(SvtCJKOptions::IsAnyEnabled()); + showStandardizedPages(officecfg::Office::Writer::WordCount::ShowStandardizedPageCount::get()); + + Initialize(pInfo); +} + +void SwWordCountFloatDlg::UpdateCounts() +{ + if (SwView* pView = GetActiveView()) + { + SwWrtShell &rSh = pView->GetWrtShell(); + SwDocStat aCurrCnt; + SwDocStat aDocStat; + { + auto& rDocShell(*pView->GetDocShell()); + SwWait aWait(rDocShell, true); + auto aLock = rDocShell.LockAllViews(); + rSh.StartAction(); + rSh.CountWords( aCurrCnt ); + aDocStat = rSh.GetUpdatedDocStat(); + rSh.EndAction(); + } + SwPostItMgr* pPostItMgr = rSh.GetPostItMgr(); + aCurrCnt.nComments = pPostItMgr->end() - pPostItMgr->begin(); + SetValues(aCurrCnt, aDocStat); + } +} + +void SwWordCountFloatDlg::SetCounts(const SwDocStat &rCurrCnt, const SwDocStat &rDocStat) +{ + SetValues(rCurrCnt, rDocStat); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3