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

#include <vcl/timer.hxx>

#include <svl/slstitm.hxx>

#include <svl/itemiter.hxx>

#include <svl/style.hxx>

#include <svl/whiter.hxx>

#include <unotools/intlwrapper.hxx>

#include <unotools/moduleoptions.hxx>

#include <unotools/searchopt.hxx>

#include <unotools/syslocale.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/objsh.hxx>

#include <sfx2/module.hxx>

#include <sfx2/viewsh.hxx>

#include <sfx2/basedlgs.hxx>

#include <sfx2/viewfrm.hxx>

#include <svl/cjkoptions.hxx>

#include <svl/ctloptions.hxx>

#include <com/sun/star/awt/XWindow.hpp>

#include <com/sun/star/container/XNameAccess.hpp>

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

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

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

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

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

#include <com/sun/star/configuration/theDefaultProvider.hpp>

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

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

#include <comphelper/processfactory.hxx>

#include <comphelper/scopeguard.hxx>

#include <svl/itempool.hxx>

#include <sfx2/app.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <svx/srchdlg.hxx>

#include <svx/strarray.hxx>

#include <svx/strings.hrc>

#include <svx/svxids.hrc>

#include <svl/srchitem.hxx>

#include <svx/pageitem.hxx>

#include "srchctrl.hxx"

#include <svx/dialmgr.hxx>

#include <editeng/brushitem.hxx>

#include <tools/mapunit.hxx>

#include <tools/resary.hxx>

#include <svx/svxdlg.hxx>

#include <vcl/toolbox.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/Builder.hxx>

#include <vcl/weld/Dialog.hxx>

#include <o3tl/typed_flags_set.hxx>

#include <comphelper/lok.hxx>

#include <cstdlib>

#include <memory>

#include <findtextfield.hxx>

#include <svx/labelitemwindow.hxx>

#include <svx/xdef.hxx>

#include <officecfg/Office/Common.hxx>

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

using namespace com::sun::star;

using namespace comphelper;

static bool IsMobile()

{

    if (!comphelper::LibreOfficeKit::isActive())

        return false;

    SfxViewShell* pCurrent = SfxViewShell::Current();

    return pCurrent && pCurrent->isLOKMobilePhone();

}

enum class ModifyFlags {

    NONE         = 0x000000,

    Search       = 0x000001,

    Replace      = 0x000002,

    Word         = 0x000004,

    Exact        = 0x000008,

    Backwards    = 0x000010,

    Selection    = 0x000020,

    Regexp       = 0x000040,

    Layout       = 0x000080,

    Similarity   = 0x000100,

    Formulas     = 0x000200,

    Values       = 0x000400,

    CalcNotes    = 0x000800,

    Rows         = 0x001000,

    Columns      = 0x002000,

    AllTables    = 0x004000,

    Notes        = 0x008000,

    Wildcard     = 0x010000

};

namespace o3tl {

    template<> struct typed_flags<ModifyFlags> : is_typed_flags<ModifyFlags, 0x01ffff> {};

}

namespace

{

    bool GetCheckBoxValue(const weld::CheckButton& rBox)

    {

        return rBox.get_sensitive() && rBox.get_active();

    }

    bool GetNegatedCheckBoxValue(const weld::CheckButton& rBox)

    {

        return rBox.get_sensitive() && !rBox.get_active();

    }

}

struct SearchDlg_Impl

{

    bool        bSaveToModule  : 1,

                bFocusOnSearch : 1;

    WhichRangesContainer pRanges;

    Timer       aSelectionTimer { "svx SearchDlg_Impl aSelectionTimer" };

    uno::Reference< frame::XDispatch > xCommand1Dispatch;

    uno::Reference< frame::XDispatch > xCommand2Dispatch;

    util::URL   aCommand1URL;

    util::URL   aCommand2URL;

    SearchDlg_Impl()

        : bSaveToModule(true)

        , bFocusOnSearch(true)

    {

        aCommand1URL.Complete = aCommand1URL.Main = "vnd.sun.search:SearchViaComponent1";

        aCommand1URL.Protocol = "vnd.sun.search:";

        aCommand1URL.Path = "SearchViaComponent1";

        aCommand2URL.Complete = aCommand2URL.Main = "vnd.sun.search:SearchViaComponent2";

        aCommand2URL.Protocol = "vnd.sun.search:";

        aCommand2URL.Path = "SearchViaComponent2";

    }

};

static void ListToStrArr_Impl(TypedWhichId<SfxStringListItem> nId, std::vector<OUString>& rStrLst, weld::ComboBox& rCBox, sal_uInt16 nRememberSize)

{

    const SfxStringListItem* pSrchItem = SfxGetpApp()->GetItem( nId );

    if (!pSrchItem)

        return;

    std::vector<OUString> aLst = pSrchItem->GetList();

    if (aLst.size() > nRememberSize)

        aLst.resize(nRememberSize);

    for (const OUString & s : aLst)

    {

        rStrLst.push_back(s);

        rCBox.append_text(s);

    }

}

static void StrArrToList_Impl( TypedWhichId<SfxStringListItem> nId, const std::vector<OUString>& rStrLst )

{

    DBG_ASSERT( !rStrLst.empty(), "check in advance");

    SfxGetpApp()->PutItem( SfxStringListItem( nId, &rStrLst ) );

}

SearchAttrItemList::SearchAttrItemList( SearchAttrItemList&& rList ) noexcept :

    SrchAttrInfoList(std::move(rList))

{

}

SearchAttrItemList::SearchAttrItemList( const SearchAttrItemList& rList ) :

    SrchAttrInfoList(rList)

{

}

SearchAttrItemList::~SearchAttrItemList()

{

    Clear();

}

void SearchAttrItemList::Put( const SfxItemSet& rSet )

{

    if ( !rSet.Count() )

        return;

    SfxItemPool* pPool = rSet.GetPool();

    for (SfxItemIter aIter(rSet); !aIter.IsAtEnd(); aIter.Next())

    {

        const sal_uInt16 nWhich(aIter.GetCurWhich());

        const sal_uInt16 nSlot(pPool->GetSlotId(nWhich));

        emplace_back(nSlot, SfxPoolItemHolder(*pPool, aIter.GetCurItem()));

    }

}

SfxItemSet& SearchAttrItemList::Get( SfxItemSet& rSet )

{

    SfxItemPool* pPool = rSet.GetPool();

    for ( size_t i = 0; i < size(); ++i )

        if ( IsInvalidItem( (*this)[i].aItemPtr.getItem() ) )

            rSet.InvalidateItem( pPool->GetWhichIDFromSlotID( (*this)[i].nSlot ) );

        else

            rSet.Put( *(*this)[i].aItemPtr.getItem() );

    return rSet;

}

void SearchAttrItemList::Clear()

{

    SrchAttrInfoList::clear();

}

// Deletes the pointer to the items

void SearchAttrItemList::Remove(size_t nPos)

{

    size_t nLen = 1;

    if ( nPos + nLen > size() )

        nLen = size() - nPos;

    SrchAttrInfoList::erase( begin() + nPos, begin() + nPos + nLen );

}

SvxSearchDialog::SvxSearchDialog(weld::Window* pParent, SfxChildWindow* pChildWin, SfxBindings& rBind)

    : SfxModelessDialogController(&rBind, pChildWin, pParent,

                                  IsMobile() ? u"svx/ui/findreplacedialog-mobile.ui"_ustr : u"svx/ui/findreplacedialog.ui"_ustr,

                                  u"FindReplaceDialog"_ustr)

    , m_rBindings(rBind)

    , m_aPresentIdle("Bring SvxSearchDialog to Foreground")

    , m_bWriter(false)

    , m_bSearch(true)

    , m_bFormat(false)

    , m_bReplaceBackwards(false)

    , m_nOptions(SearchOptionFlags::ALL)

    , m_bSet(false)

    , m_bConstruct(true)

    , m_nModifyFlag(ModifyFlags::NONE)

    , m_pReplaceList(new SearchAttrItemList)

    , m_nTransliterationFlags(TransliterationFlags::NONE)

    , m_xSearchFrame(m_xBuilder->weld_frame(u"searchframe"_ustr))

    , m_xSearchLB(m_xBuilder->weld_combo_box(u"searchterm"_ustr))

    , m_xSearchTmplLB(m_xBuilder->weld_combo_box(u"searchlist"_ustr))

    , m_xSearchAttrText(m_xBuilder->weld_label(u"searchdesc"_ustr))

    , m_xSearchLabel(m_xBuilder->weld_label(u"searchlabel"_ustr))

    , m_xSearchIcon(m_xBuilder->weld_image(u"searchicon"_ustr))

    , m_xSearchBox(m_xBuilder->weld_container(u"searchbox"_ustr))

    , m_xReplaceFrame(m_xBuilder->weld_frame(u"replaceframe"_ustr))

    , m_xReplaceLB(m_xBuilder->weld_combo_box(u"replaceterm"_ustr))

    , m_xReplaceTmplLB(m_xBuilder->weld_combo_box(u"replacelist"_ustr))

    , m_xReplaceAttrText(m_xBuilder->weld_label(u"replacedesc"_ustr))

    , m_xSearchBtn(m_xBuilder->weld_button(u"search"_ustr))

    , m_xBackSearchBtn(m_xBuilder->weld_button(u"backsearch"_ustr))

    , m_xSearchAllBtn(m_xBuilder->weld_button(u"searchall"_ustr))

    , m_xReplaceBtn(m_xBuilder->weld_button(u"replace"_ustr))

    , m_xReplaceAllBtn(m_xBuilder->weld_button(u"replaceall"_ustr))

    , m_xComponentFrame(m_xBuilder->weld_frame(u"componentframe"_ustr))

    , m_xSearchComponent1PB(m_xBuilder->weld_button(u"component1"_ustr))

    , m_xSearchComponent2PB(m_xBuilder->weld_button(u"component2"_ustr))

    , m_xMatchCaseCB(m_xBuilder->weld_check_button(u"matchcase"_ustr))

    , m_xSearchFormattedCB(m_xBuilder->weld_check_button(u"searchformatted"_ustr))

    , m_xWordBtn(m_xBuilder->weld_check_button(u"wholewords"_ustr))

    , m_xCloseBtn(m_xBuilder->weld_button(u"close"_ustr))

    , m_xHelpBtn(m_xBuilder->weld_button(u"help"_ustr))

    , m_xIncludeDiacritics(m_xBuilder->weld_check_button(u"includediacritics"_ustr))

    , m_xIncludeKashida(m_xBuilder->weld_check_button(u"includekashida"_ustr))

    , m_xOtherOptionsExpander(m_xBuilder->weld_expander(u"OptionsExpander"_ustr))

    , m_xSelectionBtn(m_xBuilder->weld_check_button(u"selection"_ustr))

    , m_xRegExpBtn(m_xBuilder->weld_check_button(u"regexp"_ustr))

    , m_xWildcardBtn(m_xBuilder->weld_check_button(u"wildcard"_ustr))

    , m_xSimilarityBox(m_xBuilder->weld_check_button(u"similarity"_ustr))

    , m_xSimilarityBtn(m_xBuilder->weld_button(u"similaritybtn"_ustr))

    , m_xLayoutBtn(m_xBuilder->weld_check_button(u"layout"_ustr))

    , m_xNotesBtn(m_xBuilder->weld_check_button(u"notes"_ustr))

    , m_xJapMatchFullHalfWidthCB(m_xBuilder->weld_check_button(u"matchcharwidth"_ustr))

    , m_xJapOptionsCB(m_xBuilder->weld_check_button(u"soundslike"_ustr))

    , m_xReplaceBackwardsCB(m_xBuilder->weld_check_button(u"replace_backwards"_ustr))

    , m_xJapOptionsBtn(m_xBuilder->weld_button(u"soundslikebtn"_ustr))

    , m_xAttributeBtn(m_xBuilder->weld_button(u"attributes"_ustr))

    , m_xFormatBtn(m_xBuilder->weld_button(u"format"_ustr))

    , m_xNoFormatBtn(m_xBuilder->weld_button(u"noformat"_ustr))

    , m_xCalcGrid(m_xBuilder->weld_widget(u"calcgrid"_ustr))

    , m_xCalcSearchInFT(m_xBuilder->weld_label(u"searchinlabel"_ustr))

    , m_xCalcSearchInLB(m_xBuilder->weld_combo_box(u"calcsearchin"_ustr))

    , m_xCalcSearchDirFT(m_xBuilder->weld_label(u"searchdir"_ustr))

    , m_xRowsBtn(m_xBuilder->weld_radio_button(u"rows"_ustr))

    , m_xColumnsBtn(m_xBuilder->weld_radio_button(u"cols"_ustr))

    , m_xAllSheetsCB(m_xBuilder->weld_check_button(u"allsheets"_ustr))

    , m_xCalcStrFT(m_xBuilder->weld_label(u"entirecells"_ustr))

{

    if (comphelper::LibreOfficeKit::isActive())

    {

        m_xCloseBtn->hide();

        m_xHelpBtn->hide();

        m_xSearchLB->set_entry_text(u""_ustr);

        m_xReplaceLB->set_entry_text(u""_ustr);

        m_xSearchLB->grab_focus();

    }

    m_aPresentIdle.SetTimeout(50);

    m_aPresentIdle.SetInvokeHandler(LINK(this, SvxSearchDialog, PresentTimeoutHdl_Impl));

    m_xSearchTmplLB->make_sorted();

    m_xSearchAttrText->hide();

    this->SetSearchLabel(u""_ustr); // hide the message but keep the box height

    //weird findreplacedialog-mobile.ui case doesn't have searchicon or searchbox

    if (m_xSearchIcon)

        m_xSearchIcon->set_size_request(24, 24); // vcl/res/infobar.png is 32x32 - too large here

    m_xReplaceTmplLB->make_sorted();

    m_xReplaceAttrText->hide();

    m_sCalcStr = m_xCalcStrFT->get_label();

    // m_xSimilarityBtn->set_height_request(m_xSimilarityBox->get_preferred_size().Height());

    // m_xJapOptionsBtn->set_height_request(m_xJapOptionsCB->get_preferred_size().Height());

    //tdf#122322

    m_nRememberSize = officecfg::Office::Common::Misc::FindReplaceRememberedSearches::get();

    if (m_nRememberSize < 1)

        m_nRememberSize = 1; //0 crashes with no results found

    auto nTermWidth = m_xSearchLB->get_approximate_digit_width() * 28;

    m_xSearchLB->set_size_request(nTermWidth, -1);

    m_xSearchTmplLB->set_size_request(nTermWidth, -1);

    m_xReplaceLB->set_size_request(nTermWidth, -1);

    m_xReplaceTmplLB->set_size_request(nTermWidth, -1);

    Construct_Impl();

}

IMPL_LINK_NOARG(SvxSearchDialog, PresentTimeoutHdl_Impl, Timer*, void)

{

    getDialog()->present();

}

void SvxSearchDialog::Present()

{

    PresentTimeoutHdl_Impl(nullptr);

    // tdf#133807 try again in a short timeout

    m_aPresentIdle.Start();

}

void SvxSearchDialog::SetSearchLBEntryTextAndGrabFocus(const OUString& rStr)

{

    m_xSearchLB->set_entry_text(rStr);

    m_xSearchLB->grab_focus();

}

void SvxSearchDialog::ChildWinDispose()

{

    m_rBindings.EnterRegistrations();

    m_pSearchController.reset();

    m_pOptionsController.reset();

    m_pFamilyController.reset();

    m_rBindings.LeaveRegistrations();

    SfxModelessDialogController::ChildWinDispose();

}

SvxSearchDialog::~SvxSearchDialog()

{

    m_aPresentIdle.Stop();

    m_pSearchItem.reset();

    m_pImpl.reset();

}

void SvxSearchDialog::Construct_Impl()

{

    m_pImpl.reset(new SearchDlg_Impl());

    m_pImpl->aSelectionTimer.SetTimeout(500);

    m_pImpl->aSelectionTimer.SetInvokeHandler(LINK(this, SvxSearchDialog, TimeoutHdl_Impl));

    EnableControls_Impl( SearchOptionFlags::NONE );

    // Store old Text from m_xWordBtn

    m_sCalcStr += "#";

    m_sCalcStr += m_xWordBtn->get_label();

    m_sLayoutStr = SvxResId(RID_SVXSTR_SEARCH_STYLES);

    m_sLayoutWriterStr = SvxResId(RID_SVXSTR_WRITER_STYLES);

    m_sLayoutCalcStr = SvxResId(RID_SVXSTR_CALC_STYLES);

    m_sStylesStr = m_xLayoutBtn->get_label();

    // Get stored search-strings from the application

    ListToStrArr_Impl(SID_SEARCHDLG_SEARCHSTRINGS, m_aSearchStrings, *m_xSearchLB, m_nRememberSize);

    ListToStrArr_Impl(SID_SEARCHDLG_REPLACESTRINGS, m_aReplaceStrings, *m_xReplaceLB,

                      m_nRememberSize);

    InitControls_Impl();

    // Get attribute sets only once in constructor()

    const SfxPoolItem* ppArgs[] = { m_pSearchItem.get(), nullptr };

    SfxPoolItemHolder aResult(

        m_rBindings.GetDispatcher()->Execute(FID_SEARCH_SEARCHSET, SfxCallMode::SLOT, ppArgs));

    const SvxSetItem* pSrchSetItem(static_cast<const SvxSetItem*>(aResult.getItem()));

    if ( pSrchSetItem )

        InitAttrList_Impl( &pSrchSetItem->GetItemSet(), nullptr );

    aResult

        = m_rBindings.GetDispatcher()->Execute(FID_SEARCH_REPLACESET, SfxCallMode::SLOT, ppArgs);

    const SvxSetItem* pReplSetItem(static_cast<const SvxSetItem*>(aResult.getItem()));

    if ( pReplSetItem )

        InitAttrList_Impl( nullptr, &pReplSetItem->GetItemSet() );

    // Create controller and update at once

    m_rBindings.EnterRegistrations();

    m_pSearchController.reset(new SvxSearchController(SID_SEARCH_ITEM, m_rBindings, *this));

    m_pOptionsController.reset(new SvxSearchController(SID_SEARCH_OPTIONS, m_rBindings, *this));

    m_rBindings.LeaveRegistrations();

    m_rBindings.GetDispatcher()->Execute(FID_SEARCH_ON, SfxCallMode::SLOT, ppArgs);

    m_pImpl->aSelectionTimer.Start();

    if(!SvtCJKOptions::IsJapaneseFindEnabled())

    {

        m_xJapOptionsCB->set_active( false );

        m_xJapOptionsCB->hide();

        m_xJapOptionsBtn->hide();

    }

    if(!SvtCJKOptions::IsCJKFontEnabled())

    {

        m_xJapMatchFullHalfWidthCB->hide();

    }

    // Do not disable and hide the m_xIncludeDiacritics button.

    // Include Diacritics == Not Ignore Diacritics => A does not match A-Umlaut (Diaeresis).

    // Confusingly these have negated names (following the UI) but the actual

    // transliteration is to *ignore* diacritics if "included" (sensitive) is

    // _not_ checked.

    if(!SvtCTLOptions::IsCTLFontEnabled())

    {

        m_xIncludeDiacritics->set_active( true );

        m_xIncludeKashida->set_active( true );

        m_xIncludeKashida->hide();

    }

    //component extension - show component search buttons if the commands

    // vnd.sun.star::SearchViaComponent1 and 2 are supported

    const uno::Reference<frame::XFrame> xFrame = m_rBindings.GetActiveFrame();

    const uno::Reference< frame::XDispatchProvider > xDispatchProv(xFrame, uno::UNO_QUERY);

    bool bSearchComponent1 = false;

    bool bSearchComponent2 = false;

    if(xDispatchProv.is())

    {

        OUString sTarget(u"_self"_ustr);

        m_pImpl->xCommand1Dispatch

            = xDispatchProv->queryDispatch(m_pImpl->aCommand1URL, sTarget, 0);

        if (m_pImpl->xCommand1Dispatch.is())

            bSearchComponent1 = true;

        m_pImpl->xCommand2Dispatch

            = xDispatchProv->queryDispatch(m_pImpl->aCommand2URL, sTarget, 0);

        if (m_pImpl->xCommand2Dispatch.is())

            bSearchComponent2 = true;

    }

    if( !(bSearchComponent1 || bSearchComponent2) )

        return;

    try

    {

        uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider =

                configuration::theDefaultProvider::get( comphelper::getProcessComponentContext() );

        uno::Sequence< uno::Any > aArgs {

                    Any(u"/org.openoffice.Office.Common/SearchOptions/"_ustr) };

        uno::Reference< uno::XInterface > xIFace = xConfigurationProvider->createInstanceWithArguments(

                    u"com.sun.star.configuration.ConfigurationUpdateAccess"_ustr,

                    aArgs);

        uno::Reference< container::XNameAccess> xDirectAccess(xIFace, uno::UNO_QUERY);

        if(xDirectAccess.is())

        {

            OUString sTemp;

            uno::Any aRet = xDirectAccess->getByName(u"ComponentSearchGroupLabel"_ustr);

            aRet >>= sTemp;

            m_xComponentFrame->set_label(sTemp);

            aRet = xDirectAccess->getByName(u"ComponentSearchCommandLabel1"_ustr);

            aRet >>= sTemp;

            m_xSearchComponent1PB->set_label( sTemp );

            aRet = xDirectAccess->getByName(u"ComponentSearchCommandLabel2"_ustr);

            aRet >>= sTemp;

            m_xSearchComponent2PB->set_label( sTemp );

        }

    }

    catch(uno::Exception&){}

    if(!m_xSearchComponent1PB->get_label().isEmpty() && bSearchComponent1 )

    {

        m_xComponentFrame->show();

        m_xSearchComponent1PB->show();

    }

    if( !m_xSearchComponent2PB->get_label().isEmpty() )

    {

        m_xComponentFrame->show();

        m_xSearchComponent2PB->show();

    }

}

void SvxSearchDialog::Close()

{

    // remember strings

    if (!m_aSearchStrings.empty())

        StrArrToList_Impl(SID_SEARCHDLG_SEARCHSTRINGS, m_aSearchStrings);

    if (!m_aReplaceStrings.empty())

        StrArrToList_Impl(SID_SEARCHDLG_REPLACESTRINGS, m_aReplaceStrings);

    // save settings to configuration

    SvtSearchOptions aOpt;

    aOpt.SetWholeWordsOnly          ( m_xWordBtn->get_active() );

    aOpt.SetBackwards               ( m_xReplaceBackwardsCB->get_active() );

    aOpt.SetUseRegularExpression    ( m_xRegExpBtn->get_active() );

    aOpt.SetUseWildcard             ( m_xWildcardBtn->get_active() );

    aOpt.SetSearchForStyles         ( m_xLayoutBtn->get_active() );

    aOpt.SetSimilaritySearch        ( m_xSimilarityBox->get_active() );

    aOpt.SetUseAsianOptions         ( m_xJapOptionsCB->get_active() );

    aOpt.SetNotes                   ( m_xNotesBtn->get_active() );

    aOpt.SetIgnoreDiacritics_CTL    ( !m_xIncludeDiacritics->get_active() );

    aOpt.SetIgnoreKashida_CTL       ( !m_xIncludeKashida->get_active() );

    aOpt.SetSearchFormatted         ( m_xSearchFormattedCB->get_active() );

    aOpt.Commit();

    if (IsClosing())

        return;

    const SfxPoolItem* ppArgs[] = { m_pSearchItem.get(), nullptr };

    m_rBindings.GetDispatcher()->Execute(FID_SEARCH_OFF, SfxCallMode::SLOT, ppArgs);

    m_rBindings.Invalidate(SID_SEARCH_DLG);

    SfxViewFrame* pViewFrame = SfxViewFrame::Current();

    if (pViewFrame)

        pViewFrame->ToggleChildWindow(SID_SEARCH_DLG);

}

TransliterationFlags SvxSearchDialog::GetTransliterationFlags() const

{

    if (!m_xMatchCaseCB->get_active())

        m_nTransliterationFlags |= TransliterationFlags::IGNORE_CASE;

    else

        m_nTransliterationFlags &= ~TransliterationFlags::IGNORE_CASE;

    if ( !m_xJapMatchFullHalfWidthCB->get_active())

        m_nTransliterationFlags |= TransliterationFlags::IGNORE_WIDTH;

    else

        m_nTransliterationFlags &= ~TransliterationFlags::IGNORE_WIDTH;

    return m_nTransliterationFlags;

}

void SvxSearchDialog::SetSaveToModule(bool b) { m_pImpl->bSaveToModule = b; }

void SvxSearchDialog::SetSearchLabel(const OUString& rStr)

{

    m_xSearchLabel->set_label(rStr);

    if (!rStr.isEmpty())

    {

        m_xSearchLabel->show();

        if (m_xSearchIcon)

        {

            m_xSearchIcon->show();

            const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

            if (rStyleSettings.GetDialogColor().IsDark())

                m_xSearchBox->set_background(Color(0x00, 0x56, 0x80));

            else

                m_xSearchBox->set_background(Color(0xBD, 0xE5, 0xF8)); // same as InfobarType::INFO

        }

    }

    else

    {

        m_xSearchLabel->hide();

        if (m_xSearchIcon)

        {

            const Size aSize = m_xSearchBox->get_preferred_size();

            m_xSearchIcon->hide();

            m_xSearchBox->set_size_request(-1, aSize.Height());

            m_xSearchBox->set_background(COL_TRANSPARENT);

        }

    }

    if (rStr == SvxResId(RID_SVXSTR_SEARCH_NOT_FOUND))

        m_xSearchLB->set_entry_message_type(weld::EntryMessageType::Error);

    else

        m_xSearchLB->set_entry_message_type(weld::EntryMessageType::Normal);

}

void SvxSearchDialog::ApplyTransliterationFlags_Impl( TransliterationFlags nSettings )

{

    m_nTransliterationFlags = nSettings;

    bool bVal(nSettings & TransliterationFlags::IGNORE_CASE);

    m_xMatchCaseCB->set_active( !bVal );

    bVal = bool(nSettings & TransliterationFlags::IGNORE_WIDTH);

    m_xJapMatchFullHalfWidthCB->set_active( !bVal );

}

bool SvxSearchDialog::IsOtherOptionsExpanded() const

{

    return m_xReplaceBackwardsCB->get_active() ||

           m_xSelectionBtn->get_active() ||

           m_xRegExpBtn->get_active() ||

           m_xLayoutBtn->get_active() ||

           m_xSimilarityBox->get_active() ||

           m_xJapMatchFullHalfWidthCB->get_active() ||

           m_xJapOptionsCB->get_active() ||

           m_xWildcardBtn->get_active() ||

           m_xNotesBtn->get_active() ||

           m_xIncludeKashida->get_active() ||

           !m_xIncludeDiacritics->get_active();//tdf#138173

}

void SvxSearchDialog::Activate()

{

    // apply possible transliteration changes of the SvxSearchItem member

    if (m_pSearchItem)

    {

        m_xMatchCaseCB->set_active(m_pSearchItem->GetExact());

        m_xJapMatchFullHalfWidthCB->set_active(!m_pSearchItem->IsMatchFullHalfWidthForms());

    }

    SfxModelessDialogController::Activate();

}

void SvxSearchDialog::InitControls_Impl()

{

    // CaseSensitives AutoComplete

    m_xSearchLB->set_entry_completion( true, true );

    m_xSearchLB->show();

    m_xReplaceLB->set_entry_completion( true, true );

    m_xReplaceLB->show();

    m_xFormatBtn->set_sensitive(false);

    m_xAttributeBtn->set_sensitive(false);

    m_xSearchLB->connect_changed( LINK( this, SvxSearchDialog, ModifyHdl_Impl ) );

    m_xReplaceLB->connect_changed( LINK( this, SvxSearchDialog, ModifyHdl_Impl ) );

    Link<weld::Widget&,void> aLink = LINK( this, SvxSearchDialog, FocusHdl_Impl );

    m_xSearchLB->connect_focus_in( aLink );

    m_xReplaceLB->connect_focus_in( aLink );

    aLink = LINK( this, SvxSearchDialog, LoseFocusHdl_Impl );

    m_xSearchLB->connect_focus_out( aLink );

    m_xReplaceLB->connect_focus_out( aLink );

    m_xSearchTmplLB->connect_focus_out( aLink );

    m_xReplaceTmplLB->connect_focus_out( aLink );

    Link<weld::Button&,void> aLink2 = LINK( this, SvxSearchDialog, CommandHdl_Impl );

    m_xSearchBtn->connect_clicked( aLink2 );

    m_xBackSearchBtn->connect_clicked( aLink2 );

    m_xSearchAllBtn->connect_clicked( aLink2 );

    m_xReplaceBtn->connect_clicked( aLink2 );

    m_xReplaceAllBtn->connect_clicked( aLink2 );

    m_xCloseBtn->connect_clicked( aLink2 );

    m_xSimilarityBtn->connect_clicked( aLink2 );

    m_xJapOptionsBtn->connect_clicked( aLink2 );

    m_xSearchComponent1PB->connect_clicked( aLink2 );

    m_xSearchComponent2PB->connect_clicked( aLink2 );

    Link<weld::Toggleable&,void> aLink3 = LINK( this, SvxSearchDialog, FlagHdl_Impl );

    m_xReplaceBackwardsCB->connect_toggled( aLink3 );

    m_xWordBtn->connect_toggled( aLink3 );

    m_xSelectionBtn->connect_toggled( aLink3 );

    m_xMatchCaseCB->connect_toggled( aLink3 );

    m_xRegExpBtn->connect_toggled( aLink3 );

    m_xWildcardBtn->connect_toggled( aLink3 );

    m_xNotesBtn->connect_toggled( aLink3 );

    m_xSimilarityBox->connect_toggled( aLink3 );

    m_xJapOptionsCB->connect_toggled( aLink3 );

    m_xJapMatchFullHalfWidthCB->connect_toggled( aLink3 );

    m_xIncludeDiacritics->connect_toggled( aLink3 );

    m_xIncludeKashida->connect_toggled( aLink3 );

    m_xLayoutBtn->connect_toggled( LINK( this, SvxSearchDialog, TemplateHdl_Impl ) );

    m_xFormatBtn->connect_clicked( LINK( this, SvxSearchDialog, FormatHdl_Impl ) );

    m_xNoFormatBtn->connect_clicked(

        LINK( this, SvxSearchDialog, NoFormatHdl_Impl ) );

    m_xAttributeBtn->connect_clicked(

        LINK( this, SvxSearchDialog, AttributeHdl_Impl ) );

}

namespace

{

    SvtModuleOptions::EFactory getModule(SfxBindings const & rBindings)

    {

        SvtModuleOptions::EFactory eFactory(SvtModuleOptions::EFactory::UNKNOWN_FACTORY);

        try

        {

            const uno::Reference< frame::XFrame > xFrame =

                rBindings.GetActiveFrame();

            uno::Reference< frame::XModuleManager2 > xModuleManager(

                frame::ModuleManager::create(::comphelper::getProcessComponentContext()));

            OUString aModuleIdentifier = xModuleManager->identify( xFrame );

            eFactory = SvtModuleOptions::ClassifyFactoryByServiceName(aModuleIdentifier);

        }

        catch (const uno::Exception&)

        {

        }

        return eFactory;

    }

}

void SvxSearchDialog::ShowOptionalControls_Impl()

{

    DBG_ASSERT(m_pSearchItem, "no search item");

    SvtModuleOptions::EFactory eFactory = getModule(m_rBindings);

    bool bDrawApp = eFactory == SvtModuleOptions::EFactory::DRAW;

    bool bWriterApp =

        eFactory == SvtModuleOptions::EFactory::WRITER ||

        eFactory == SvtModuleOptions::EFactory::WRITERWEB ||

        eFactory == SvtModuleOptions::EFactory::WRITERGLOBAL;

    bool bCalcApp = eFactory == SvtModuleOptions::EFactory::CALC;

    m_xLayoutBtn->set_visible(!bDrawApp);

    m_xNotesBtn->set_visible(bWriterApp);

    m_xRegExpBtn->set_visible(!bDrawApp);

    m_xWildcardBtn->set_visible(bCalcApp); /* TODO:WILDCARD enable for other apps if hey handle it */

    m_xReplaceBackwardsCB->show();

    m_xSimilarityBox->show();

    m_xSimilarityBtn->show();

    m_xSelectionBtn->show();

    m_xIncludeDiacritics->show();

    m_xIncludeKashida->set_visible(SvtCTLOptions::IsCTLFontEnabled());

    m_xJapMatchFullHalfWidthCB->set_visible(SvtCJKOptions::IsCJKFontEnabled());

    m_xJapOptionsCB->set_visible(SvtCJKOptions::IsJapaneseFindEnabled());

    m_xJapOptionsBtn->set_visible(SvtCJKOptions::IsJapaneseFindEnabled());

    if (m_bWriter)

    {

        m_xAttributeBtn->show();

        m_xFormatBtn->show();

        m_xNoFormatBtn->show();

    }

    if (bCalcApp)

    {

        m_xCalcSearchInFT->show();

        m_xCalcSearchInLB->show();

        m_xCalcSearchDirFT->show();

        m_xRowsBtn->show();

        m_xColumnsBtn->show();

        m_xAllSheetsCB->show();

        m_xSearchFormattedCB->show();

    }

}

namespace {

class ToggleSaveToModule

{

public:

    ToggleSaveToModule(SvxSearchDialog& rDialog, bool bValue) :

        mrDialog(rDialog), mbValue(bValue)

    {

        mrDialog.SetSaveToModule(mbValue);

    }

    ~ToggleSaveToModule()

    {

        mrDialog.SetSaveToModule(!mbValue);

    }

private:

    SvxSearchDialog& mrDialog;

    bool mbValue;

};

}

void SvxSearchDialog::Init_Impl( bool bSearchPattern )

{

    DBG_ASSERT(m_pSearchItem, "SearchItem == 0");

    // We don't want to save any intermediate state to the module while the

    // dialog is being initialized.

    ToggleSaveToModule aNoModuleSave(*this, false);

    SvtSearchOptions aOpt;

    m_bWriter = (m_pSearchItem->GetAppFlag() == SvxSearchApp::WRITER);

    if (!(m_nModifyFlag & ModifyFlags::Word))

        m_xWordBtn->set_active(m_pSearchItem->GetWordOnly());

    if (!(m_nModifyFlag & ModifyFlags::Exact))

        m_xMatchCaseCB->set_active(m_pSearchItem->GetExact());

    if (!(m_nModifyFlag & ModifyFlags::Backwards))

        m_xReplaceBackwardsCB->set_active(m_bReplaceBackwards); //adjustment to replace backwards

    if (!(m_nModifyFlag & ModifyFlags::Notes))

        m_xNotesBtn->set_active(m_pSearchItem->GetNotes());

    if (!(m_nModifyFlag & ModifyFlags::Selection))

        m_xSelectionBtn->set_active(m_pSearchItem->GetSelection());

    if (!(m_nModifyFlag & ModifyFlags::Regexp))

        m_xRegExpBtn->set_active(m_pSearchItem->GetRegExp());

    if (!(m_nModifyFlag & ModifyFlags::Wildcard))

        m_xWildcardBtn->set_active(m_pSearchItem->GetWildcard());

    if (!(m_nModifyFlag & ModifyFlags::Layout))

        m_xLayoutBtn->set_active(m_pSearchItem->GetPattern());

    if (m_xNotesBtn->get_active())

        m_xLayoutBtn->set_sensitive(false);

    m_xSimilarityBox->set_active(m_pSearchItem->IsLevenshtein());

    if ( m_xJapOptionsCB->get_visible() )

        m_xJapOptionsCB->set_active(m_pSearchItem->IsUseAsianOptions());

    m_xIncludeDiacritics->set_active( !aOpt.IsIgnoreDiacritics_CTL() );

    if ( m_xIncludeKashida->get_visible() )

        m_xIncludeKashida->set_active( !aOpt.IsIgnoreKashida_CTL() );

    ApplyTransliterationFlags_Impl(m_pSearchItem->GetTransliterationFlags());

    ShowOptionalControls_Impl();

    if (m_pSearchItem->GetAppFlag() == SvxSearchApp::CALC)

    {

        m_xCalcGrid->show();

        m_xSearchFormattedCB->set_active( aOpt.IsSearchFormatted() );

        Link<weld::Toggleable&,void> aLink = LINK( this, SvxSearchDialog, FlagHdl_Impl );

        m_xCalcSearchInLB->connect_changed( LINK( this, SvxSearchDialog, LBSelectHdl_Impl ) );

        m_xRowsBtn->connect_toggled( aLink );

        m_xColumnsBtn->connect_toggled( aLink );

        m_xAllSheetsCB->connect_toggled( aLink );

        m_xSearchFormattedCB->connect_toggled( aLink );

        ModifyFlags nModifyFlagCheck;

        switch (m_pSearchItem->GetCellType())

        {

            case SvxSearchCellType::FORMULA:

                nModifyFlagCheck = ModifyFlags::Formulas;

                break;

            case SvxSearchCellType::VALUE:

                nModifyFlagCheck = ModifyFlags::Values;

                break;

            case SvxSearchCellType::NOTE:

                nModifyFlagCheck = ModifyFlags::CalcNotes;

                break;

            default:

                std::abort(); // cannot happen

        }

        if (!(m_nModifyFlag & nModifyFlagCheck))

            m_xCalcSearchInLB->set_active(static_cast<sal_Int32>(m_pSearchItem->GetCellType()));

        m_xWordBtn->set_label(m_sCalcStr.getToken(0, '#'));

        if (m_pSearchItem->GetRowDirection() && !(m_nModifyFlag & ModifyFlags::Rows))

            m_xRowsBtn->set_active(true);

        else if (!m_pSearchItem->GetRowDirection() && !(m_nModifyFlag & ModifyFlags::Columns))

            m_xColumnsBtn->set_active(true);

        if (!(m_nModifyFlag & ModifyFlags::AllTables))

            m_xAllSheetsCB->set_active(m_pSearchItem->IsAllTables());

        // only look for formatting in Writer

        m_xFormatBtn->hide();

        m_xNoFormatBtn->hide();

        m_xAttributeBtn->hide();

    }

    else

    {

        m_xSearchFormattedCB->hide();

        m_xWordBtn->set_label(m_sCalcStr.getToken(1, '#'));

        if (m_pSearchItem->GetAppFlag() == SvxSearchApp::DRAW)

        {

            m_xSearchAllBtn->hide();

            m_xRegExpBtn->hide();

            m_xWildcardBtn->hide();

            m_xLayoutBtn->hide();

            // only look for formatting in Writer

            m_xFormatBtn->hide();

            m_xNoFormatBtn->hide();

            m_xAttributeBtn->hide();

        }

        else

        {

            m_xWildcardBtn->hide(); /* TODO:WILDCARD do not hide for other apps if they handle it */

            if (!m_pSearchList)

            {

                // Get attribute sets, if it not has been done already

                const SfxPoolItem* ppArgs[] = { m_pSearchItem.get(), nullptr };

                SfxPoolItemHolder aResult(m_rBindings.GetDispatcher()->Execute(

                    FID_SEARCH_SEARCHSET, SfxCallMode::SLOT, ppArgs));

                const SvxSetItem* pSrchSetItem(static_cast<const SvxSetItem*>(aResult.getItem()));

                if ( pSrchSetItem )

                    InitAttrList_Impl( &pSrchSetItem->GetItemSet(), nullptr );