/* -*- 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 <com/sun/star/style/XStyleFamiliesSupplier.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/frame/XModel.hpp>

#include <futempl.hxx>

#include <svx/svxids.hrc>
#include <sfx2/bindings.hxx>
#include <sfx2/dispatch.hxx>
#include <editeng/eeitem.hxx>
#include <sfx2/request.hxx>
#include <sfx2/sfxdlg.hxx>
#include <editeng/numitem.hxx>
#include <svx/svdopage.hxx>
#include <editeng/colritem.hxx>
#include <editeng/brushitem.hxx>
#include <svx/svditer.hxx>
#include <svx/sdr/properties/properties.hxx>
#include <svl/intitem.hxx>

#include <sfx2/viewfrm.hxx>
#include <svx/xlndsit.hxx>
#include <svx/xlnstit.hxx>
#include <svx/xlnedit.hxx>
#include <svx/xbtmpit.hxx>
#include <svx/xflgrit.hxx>
#include <svx/xflftrit.hxx>
#include <svx/xflhtit.hxx>
#include <o3tl/string_view.hxx>
#include <app.hrc>
#include <stlsheet.hxx>
#include <sdpage.hxx>
#include <stlpool.hxx>
#include <sdmod.hxx>
#include <View.hxx>
#include <drawdoc.hxx>
#include <DrawDocShell.hxx>
#include <DrawViewShell.hxx>
#include <ViewShell.hxx>

#include <strings.hrc>
#include <prlayout.hxx>
#include <sdresid.hxx>
#include <OutlineView.hxx>
#include <sdabstdlg.hxx>
#include <memory>

using namespace com::sun::star::uno;
using namespace com::sun::star::container;
using namespace com::sun::star::beans;
using namespace com::sun::star::style;

namespace sd
{


FuTemplate::FuTemplate (
    ViewShell& rViewSh,
    ::sd::Window* pWin,
    ::sd::View* pView,
    SdDrawDocument& rDoc,
    SfxRequest& rReq )
    : FuPoor( rViewSh, pWin, pView, rDoc, rReq )
{
}

rtl::Reference<FuPoor> FuTemplate::Create( ViewShell& rViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument& rDoc, SfxRequest& rReq )
{
    rtl::Reference<FuPoor> xFunc( new FuTemplate( rViewSh, pWin, pView, rDoc, rReq ) );
    xFunc->DoExecute(rReq);
    return xFunc;
}

void FuTemplate::DoExecute( SfxRequest& rReq )
{
    const SfxItemSet* pArgs = rReq.GetArgs();
    sal_uInt16 nSId = rReq.GetSlot();

    // get StyleSheet parameter
    SfxStyleSheetBasePool* pSSPool = mrDoc.GetDocSh()->GetStyleSheetPool();
    SfxStyleSheetBase* pStyleSheet = nullptr;

    const SfxPoolItem* pItem;
    SfxStyleFamily nFamily = SfxStyleFamily(USHRT_MAX);
    if( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILY,
        false, &pItem ))
    {
        nFamily = static_cast<SfxStyleFamily>( pArgs->Get( SID_STYLE_FAMILY ).GetValue());
    }
    else if( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILYNAME,
        false, &pItem ))
    {
        OUString sFamily = pArgs->Get( SID_STYLE_FAMILYNAME ).GetValue();
        if (sFamily == "graphics")
            nFamily = SfxStyleFamily::Para;
        else
            nFamily = SfxStyleFamily::Pseudo;
    }

    OUString aStyleName;
    sal_uInt16 nRetMask = static_cast<sal_uInt16>(SfxStyleSearchBits::All);

    switch( nSId )
    {
        case SID_STYLE_APPLY:
        case SID_STYLE_EDIT:
        case SID_STYLE_DELETE:
        case SID_STYLE_HIDE:
        case SID_STYLE_SHOW:
        case SID_STYLE_FAMILY:
        case SID_STYLE_NEW_BY_EXAMPLE:
        {
            const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_APPLY_STYLE);
            const SfxStringItem* pFamilyItem = rReq.GetArg(SID_STYLE_FAMILYNAME);
            if ( pFamilyItem && pNameItem )
            {
                try
                {
                    Reference< XStyleFamiliesSupplier > xModel(mrDoc.GetDocSh()->GetModel(), UNO_QUERY_THROW );
                    Reference< XNameAccess > xCont( xModel->getStyleFamilies() );
                    Reference< XNameAccess > xStyles( xCont->getByName(pFamilyItem->GetValue()), UNO_QUERY_THROW );
                    Reference< XPropertySet > xInfo( xStyles->getByName( pNameItem->GetValue() ), UNO_QUERY_THROW );

                    OUString aUIName;
                    xInfo->getPropertyValue( u"DisplayName"_ustr ) >>= aUIName;
                    if ( !aUIName.isEmpty() )
                        rReq.AppendItem( SfxStringItem( nSId, aUIName ) );
                }
                catch( Exception& )
                {
                }
            }

            if (pArgs && pArgs->GetItemState(nSId) == SfxItemState::SET)
                aStyleName = static_cast<const SfxStringItem &>( pArgs->Get( nSId ) ).GetValue();
        }
    }

    switch( nSId )
    {
        case SID_STYLE_NEW:
        {
            SfxStyleSheetBase *p = pSSPool->Find(aStyleName, nFamily );
            if(p)
            {
                pSSPool->Remove(p);
                p = nullptr;
            }
            pStyleSheet = &pSSPool->Make( aStyleName, nFamily, SfxStyleSearchBits::UserDefined );

            if (pArgs && pArgs->GetItemState(SID_STYLE_REFERENCE) == SfxItemState::SET)
            {
                OUString aParentName( pArgs->Get(SID_STYLE_REFERENCE).GetValue());
                pStyleSheet->SetParent(aParentName);
            }
            else
            {
                pStyleSheet->SetParent(SdResId(STR_STANDARD_STYLESHEET_NAME));
            }
        }
        break;

        case SID_STYLE_NEW_BY_EXAMPLE:
        {
            // at the moment, the dialog to enter the name of the template is still opened
            SfxStyleSheetBase *p = pSSPool->Find(aStyleName, nFamily );
            if(p)
            {
                pSSPool->Remove(p);
                p = nullptr;
            }
            pStyleSheet = &pSSPool->Make( aStyleName, nFamily, SfxStyleSearchBits::UserDefined );
            pStyleSheet->SetParent(SdResId(STR_STANDARD_STYLESHEET_NAME));
        }
        break;

        case SID_STYLE_EDIT:
            pStyleSheet = pSSPool->Find( aStyleName, nFamily);
        break;

        case SID_STYLE_DELETE:
            pStyleSheet = pSSPool->Find( aStyleName, nFamily);
            if( pStyleSheet )
            {
                pSSPool->Remove( pStyleSheet );
                nRetMask = sal_uInt16(true);
                mrDoc.SetChanged();
            }
            else
            {
                nRetMask = sal_uInt16(false);
            }
        break;

        case SID_STYLE_HIDE:
        case SID_STYLE_SHOW:
            pStyleSheet = pSSPool->Find( aStyleName, nFamily);
            pStyleSheet->SetHidden( nSId == SID_STYLE_HIDE );
            nRetMask = sal_uInt16(true);
        break;

        case SID_STYLE_APPLY:
            // apply the template to the document
            pStyleSheet = pSSPool->Find( aStyleName, nFamily);

            // do not set presentation styles, they will be set implicit
            if ( pStyleSheet && pStyleSheet->GetFamily() != SfxStyleFamily::Pseudo )
            {
                SfxStyleSheet* pOldStyleSheet = mpView->GetStyleSheet();
                OUString aStr;

                if( // if the object had no style sheet, allow all
                    !pOldStyleSheet ||

                    // allow if old and new style sheet has same family
                    pStyleSheet->GetFamily() == pOldStyleSheet->GetFamily() ||

                    // allow if old was background objects and new is graphics
                    (pStyleSheet->GetFamily() == SfxStyleFamily::Para && pOldStyleSheet->GetHelpId( aStr ) == HID_PSEUDOSHEET_BACKGROUNDOBJECTS) ||

                    // allow if old was presentation and we are a drawing document
                    (pOldStyleSheet->GetFamily() == SfxStyleFamily::Page && mrDoc.GetDocumentType() == DocumentType::Draw) )
                {
                    mpView->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet));
                    mrDoc.SetChanged();
                    mrViewShell.GetViewFrame()->GetBindings().Invalidate( SID_STYLE_FAMILY2 );
                }
            }
        break;

        case SID_STYLE_WATERCAN:
        {
            if (SdModule* mod = SdModule::get(); !mod->GetWaterCan())
            {
                if (pArgs && pArgs->GetItemState( nSId ) == SfxItemState::SET)
                {
                    aStyleName = static_cast<const SfxStringItem &>( pArgs->Get( nSId ) ).GetValue();
                    mod->SetWaterCan(true);
                    pStyleSheet = pSSPool->Find( aStyleName, nFamily);
                }
                // no presentation object templates, they are only allowed implicitly
                if( pStyleSheet && pStyleSheet->GetFamily() != SfxStyleFamily::Pseudo )
                {
                    static_cast<SdStyleSheetPool*>( pSSPool )->SetActualStyleSheet( pStyleSheet );

                    // we switch explicitly into selection mode
                    mrViewShell.GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_SELECT,
                                        SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );

                }
                else
                    mod->SetWaterCan(false);
            }
            else
            {
                mod->SetWaterCan(false);
                // we have to re-enable to tools-bar
                mrViewShell.Invalidate();
            }
        }
        break;

        default:
        break;
    }

    switch( nSId )
    {
        case SID_STYLE_NEW:
        case SID_STYLE_EDIT:
        {
            PresentationObjects ePO = PresentationObjects::Outline_1;

            if( pStyleSheet )
            {
                ScopedVclPtr<SfxAbstractTabDialog> pStdDlg;
                ScopedVclPtr<SfxAbstractTabDialog> pPresDlg;
                SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();

                SfxStyleFamily eFamily = pStyleSheet->GetFamily();

                if (eFamily == SfxStyleFamily::Para)
                {
                    pStdDlg.disposeAndReset(pFact ? pFact->CreateSdTabTemplateDlg(mrViewShell.GetFrameWeld(), mrDoc.GetDocSh(), *pStyleSheet, &mrDoc, mpView) : nullptr);
                }
                else if (eFamily == SfxStyleFamily::Pseudo)
                {
                    OUString aName(pStyleSheet->GetName());
                    bool bBackground = false;
                    bool bOldDocInOtherLanguage = false;

                    if (aName == SdResId(STR_PSEUDOSHEET_TITLE))
                    {
                        ePO    = PresentationObjects::Title;
                    }
                    else if (aName == SdResId(STR_PSEUDOSHEET_SUBTITLE))
                    {
                        ePO    = PresentationObjects::Subtitle;
                    }
                    else if (aName ==
                             SdResId(STR_PSEUDOSHEET_BACKGROUND))
                    {
                        bBackground = true;
                        ePO    = PresentationObjects::Background;
                    }
                    else if (aName ==
                             SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS))
                    {
                        ePO    = PresentationObjects::BackgroundObjects;
                    }
                    else if (aName ==
                             SdResId(STR_PSEUDOSHEET_NOTES))
                    {
                        ePO    = PresentationObjects::Notes;
                    }
                    else if(aName.indexOf(SdResId(STR_PSEUDOSHEET_OUTLINE)) != -1)
                    {
                        OUString aOutlineStr(SdResId(STR_PSEUDOSHEET_OUTLINE));
                        // determine number, mind the blank between name and number
                        std::u16string_view aNumStr(aName.subView(aOutlineStr.getLength() + 1));
                        sal_uInt16 nLevel = static_cast<sal_uInt16>(o3tl::toInt32(aNumStr));
                        switch (nLevel)
                        {
                            case 1: ePO = PresentationObjects::Outline_1; break;
                            case 2: ePO = PresentationObjects::Outline_2; break;
                            case 3: ePO = PresentationObjects::Outline_3; break;
                            case 4: ePO = PresentationObjects::Outline_4; break;
                            case 5: ePO = PresentationObjects::Outline_5; break;
                            case 6: ePO = PresentationObjects::Outline_6; break;
                            case 7: ePO = PresentationObjects::Outline_7; break;
                            case 8: ePO = PresentationObjects::Outline_8; break;
                            case 9: ePO = PresentationObjects::Outline_9; break;
                        }
                    }
                    else
                    {
                        OSL_FAIL("StyleSheet from older version with different language");
                        bOldDocInOtherLanguage = true;
                    }

                    if( !bOldDocInOtherLanguage )
                    {
                        pPresDlg.disposeAndReset(pFact ? pFact->CreateSdPresLayoutTemplateDlg(mpDocSh,  mrViewShell.GetFrameWeld(), bBackground, *pStyleSheet, ePO, pSSPool ) : nullptr);
                    }
                }

                sal_uInt16 nResult = RET_CANCEL;
                const SfxItemSet* pOutSet = nullptr;
                if (pStdDlg)
                {
                    nResult = pStdDlg->Execute();
                    pOutSet = pStdDlg->GetOutputItemSet();
                }
                else if( pPresDlg )
                {
                    nResult = pPresDlg->Execute();
                    pOutSet = pPresDlg->GetOutputItemSet();
                }

                switch( nResult )
                {
                    case RET_OK:
                    {
                        nRetMask = static_cast<sal_uInt16>(pStyleSheet->GetMask());

                        if (eFamily == SfxStyleFamily::Pseudo)
                        {
                            SfxItemSet aTempSet(*pOutSet);
                            /* Extract SvxBrushItem out of set and insert SvxColorItem */
                            const SvxBrushItem* pBrushItem = aTempSet.GetItem<SvxBrushItem>( SID_ATTR_BRUSH_CHAR );

                            if ( pBrushItem )
                            {
                                SvxColorItem aBackColorItem(pBrushItem->GetColor(), EE_CHAR_BKGCOLOR);
                                aTempSet.ClearItem( EE_CHAR_BKGCOLOR );
                                aTempSet.Put( aBackColorItem );
                            }
                            static_cast<SdStyleSheet*>(pStyleSheet)->AdjustToFontHeight(aTempSet);

                            /* Special treatment: reset the INVALIDS to
                               NULL-Pointer (otherwise INVALIDs or pointer point
                               to DefaultItems in the template; both would
                               prevent the attribute inheritance) */
                            aTempSet.ClearInvalidItems();

                            // EE_PARA_NUMBULLET item is only valid in first outline template
                            if( (ePO >= PresentationObjects::Outline_2) && (ePO <= PresentationObjects::Outline_9) )
                            {
                                const SvxNumBulletItem* pBulletItem = nullptr;
                                if (aTempSet.GetItemState(EE_PARA_NUMBULLET, true, &pBulletItem) == SfxItemState::SET)
                                {
                                    SvxNumRule aRule(pBulletItem->GetNumRule());

                                    OUString sStyleName(SdResId(STR_PSEUDOSHEET_OUTLINE) + " 1");
                                    SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( sStyleName, SfxStyleFamily::Pseudo);

                                    if(pFirstStyleSheet)
                                    {
                                        pFirstStyleSheet->GetItemSet().Put( SvxNumBulletItem( aRule, EE_PARA_NUMBULLET ));
                                        SdStyleSheet* pRealSheet = static_cast<SdStyleSheet*>(pFirstStyleSheet)->GetRealStyleSheet();
                                        pRealSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
                                    }

                                    aTempSet.ClearItem( EE_PARA_NUMBULLET );
                                }
                            }

                            pStyleSheet->GetItemSet().Put(aTempSet);
                            SdStyleSheet::BroadcastSdStyleSheetChange(pStyleSheet, ePO, pSSPool);
                        }

                        SfxItemSet& rAttr = pStyleSheet->GetItemSet();

                        sdr::properties::CleanupFillProperties( rAttr );

                        // check for unique names of named items for xml
                        const SfxPoolItem* pOldItem = nullptr;
                        if( rAttr.GetItemState( XATTR_FILLBITMAP, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillBitmapItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }
                        if( rAttr.GetItemState( XATTR_LINEDASH, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XLineDashItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }
                        if( rAttr.GetItemState( XATTR_LINESTART, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XLineStartItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }
                        if( rAttr.GetItemState( XATTR_LINEEND, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XLineEndItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }
                        if( rAttr.GetItemState( XATTR_FILLGRADIENT, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillGradientItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }
                        if( rAttr.GetItemState( XATTR_FILLFLOATTRANSPARENCE, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillFloatTransparenceItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }
                        if( rAttr.GetItemState( XATTR_FILLHATCH, true, &pOldItem ) == SfxItemState::SET )
                        {
                            std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillHatchItem*>(pOldItem)->checkForUniqueItem( mrDoc );
                            if( pNewItem )
                            {
                                rAttr.Put( std::move(pNewItem) );
                            }
                        }

                        static_cast<SfxStyleSheet*>( pStyleSheet )->Broadcast( SfxHint( SfxHintId::DataChanged ) );

                        DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( &mrViewShell );
                        if( pDrawViewShell )
                        {
                            PageKind ePageKind = pDrawViewShell->GetPageKind();
                            if( ePageKind == PageKind::Notes || ePageKind == PageKind::Handout )
                            {
                                SdPage* pPage = mrViewShell.GetActualPage();

                                if(pDrawViewShell->GetEditMode() == EditMode::MasterPage)
                                {
                                    pPage = static_cast<SdPage*>((&(pPage->TRG_GetMasterPage())));
                                }

                                if( pPage )
                                {
                                    SdrObjListIter aIter( pPage );
                                    while( aIter.IsMore() )
                                    {
                                        SdrObject* pObj = aIter.Next();
                                        if( dynamic_cast< const SdrPageObj *>( pObj ) !=  nullptr )
                                        {
                                            // repaint only
                                            pObj->ActionChanged();
                                            // pObj->SendRepaintBroadcast();
                                        }
                                    }
                                }
                            }
                        }

                        if( mrDoc.GetOnlineSpell() )
                        {
                            if( SfxItemState::SET == rAttr.GetItemState(EE_CHAR_LANGUAGE, false ) ||
                                SfxItemState::SET == rAttr.GetItemState(EE_CHAR_LANGUAGE_CJK, false ) ||
                                SfxItemState::SET == rAttr.GetItemState(EE_CHAR_LANGUAGE_CTL, false ) )
                            {
                                mrDoc.StopOnlineSpelling();
                                mrDoc.StartOnlineSpelling();
                            }
                        }

                        mrDoc.SetChanged();
                    }
                    break;

                    default:
                    {
                        if( nSId == SID_STYLE_NEW )
                            pSSPool->Remove( pStyleSheet );
                    }
                    return; // Cancel
                }
            }
        }
        break;

        case SID_STYLE_NEW_BY_EXAMPLE:
        {
            if( pStyleSheet )
            {
                nRetMask = static_cast<sal_uInt16>(pStyleSheet->GetMask());
                SfxItemSet aCoreSet( mrDoc.GetPool() );
                mpView->GetAttributes( aCoreSet, true );

                // if the object had a template, this becomes parent of the new template
                SfxStyleSheet* pOldStyle = mpView->GetStyleSheet();

                // if pOldStyle == pStyleSheet -> recursion
                if( pOldStyle != pStyleSheet )
                {
                    if (pOldStyle)
                    {
                        pStyleSheet->SetParent(pOldStyle->GetName());
                    }

                    SfxItemSet* pStyleSet = &pStyleSheet->GetItemSet();
                    pStyleSet->Put(aCoreSet);

                    /* apply template (but not when somebody is editing a text.
                       To do this, the edit engine had to be capable to use
                       templates on a character level. */
                    if (!mpView->GetTextEditObject())
                    {
                        mpView->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet));
                    }

                    static_cast<SfxStyleSheet*>( pStyleSheet )->Broadcast( SfxHint( SfxHintId::DataChanged ) );
                    mrDoc.SetChanged();

                    mrViewShell.GetViewFrame()->GetBindings().Invalidate( SID_STYLE_FAMILY2 );
                }
            }
        }
        break;

        case SID_STYLE_UPDATE_BY_EXAMPLE:
        {
            const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
            if ((rMarkList.GetMarkCount() != 0 && rMarkList.GetMarkCount() == 1) ||
                 dynamic_cast< const OutlineView *>( mpView ) !=  nullptr)
            {
                pStyleSheet = mpView->GetStyleSheet();

                if( pStyleSheet )
                {
                    nRetMask = static_cast<sal_uInt16>(pStyleSheet->GetMask());
                    SfxItemSet aCoreSet( mrDoc.GetPool() );
                    mpView->GetAttributes( aCoreSet );

                    SfxItemSet* pStyleSet = &pStyleSheet->GetItemSet();
                    pStyleSet->Put( aCoreSet );

                    mpView->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet));

                    static_cast<SfxStyleSheet*>( pStyleSheet )->Broadcast( SfxHint( SfxHintId::DataChanged ) );
                    mrDoc.SetChanged();
                    mrViewShell.GetViewFrame()->GetBindings().Invalidate( SID_STYLE_FAMILY2 );
                }
            }
        }
        break;

    }
    if( nRetMask != static_cast<sal_uInt16>(SfxStyleSearchBits::All) )
        rReq.SetReturnValue( SfxUInt16Item( nSId, nRetMask ) );
}

void FuTemplate::Activate()
{
}

void FuTemplate::Deactivate()
{
}

} // end of namespace sd

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
