/* -*- 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 <comphelper/string.hxx>

#include <scitems.hxx>

#include <i18nutil/transliteration.hxx>

#include <editeng/adjustitem.hxx>

#include <svx/clipfmtitem.hxx>

#include <editeng/colritem.hxx>

#include <editeng/contouritem.hxx>

#include <editeng/crossedoutitem.hxx>

#include <editeng/eeitem.hxx>

#include <editeng/editeng.hxx>

#include <editeng/editview.hxx>

#include <editeng/escapementitem.hxx>

#include <editeng/flditem.hxx>

#include <editeng/flstitem.hxx>

#include <editeng/fontitem.hxx>

#include <editeng/frmdiritem.hxx>

#include <editeng/lrspitem.hxx>

#include <editeng/lspcitem.hxx>

#include <editeng/ulspitem.hxx>

#include <editeng/urlfieldhelper.hxx>

#include <editeng/editund2.hxx>

#include <svx/hlnkitem.hxx>

#include <svx/svdoutl.hxx>

#include <svx/sdooitm.hxx>

#include <editeng/postitem.hxx>

#include <editeng/scriptsetitem.hxx>

#include <editeng/shdditem.hxx>

#include <editeng/udlnitem.hxx>

#include <editeng/wghtitem.hxx>

#include <editeng/writingmodeitem.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/namedcolor.hxx>

#include <sfx2/objface.hxx>

#include <sfx2/objsh.hxx>

#include <sfx2/request.hxx>

#include <sfx2/viewfrm.hxx>

#include <svtools/cliplistener.hxx>

#include <vcl/transfer.hxx>

#include <svl/stritem.hxx>

#include <svl/whiter.hxx>

#include <svl/languageoptions.hxx>

#include <svl/cjkoptions.hxx>

#include <svl/ctloptions.hxx>

#include <svx/svxdlg.hxx>

#include <vcl/EnumContext.hxx>

#include <vcl/unohelp2.hxx>

#include <sc.hrc>

#include <globstr.hrc>

#include <scresid.hxx>

#include <scmod.hxx>

#include <drtxtob.hxx>

#include <viewdata.hxx>

#include <document.hxx>

#include <drawview.hxx>

#include <viewutil.hxx>

#include <tabvwsh.hxx>

#include <gridwin.hxx>

#define ShellClass_ScDrawTextObjectBar

#include <scslots.hxx>

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

SFX_IMPL_INTERFACE(ScDrawTextObjectBar, SfxShell)

void ScDrawTextObjectBar::InitInterface_Impl()

{

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT,

                                            SfxVisibilityFlags::Standard | SfxVisibilityFlags::Server,

                                            ToolbarId::Text_Toolbox_Sc);

    GetStaticInterface()->RegisterPopupMenu(u"drawtext"_ustr);

    GetStaticInterface()->RegisterChildWindow(ScGetFontWorkId());

}

// disable not wanted accelerators

void ScDrawTextObjectBar::StateDisableItems( SfxItemSet &rSet )

{

    SfxWhichIter aIter(rSet);

    sal_uInt16 nWhich = aIter.FirstWhich();

    while (nWhich)

    {

        rSet.DisableItem( nWhich );

        nWhich = aIter.NextWhich();

    }

}

ScDrawTextObjectBar::ScDrawTextObjectBar(ScViewData& rData) :

    SfxShell(rData.GetViewShell()),

    mrViewData(rData),

    bPastePossible(false)

{

    SetPool( mrViewData.GetScDrawView()->GetDefaultAttr().GetPool() );

    //  At the switching-over the UndoManager is changed to edit mode

    SfxUndoManager* pMgr = mrViewData.GetSfxDocShell().GetUndoManager();

    SetUndoManager( pMgr );

    if ( !mrViewData.GetDocument().IsUndoEnabled() )

    {

        pMgr->SetMaxUndoActionCount( 0 );

    }

    SetName(u"DrawText"_ustr);

    SfxShell::SetContextName(vcl::EnumContext::GetContextName(vcl::EnumContext::Context::DrawText));

}

ScDrawTextObjectBar::~ScDrawTextObjectBar()

{

    if ( mxClipEvtLstnr.is() )

    {

        mxClipEvtLstnr->RemoveListener( mrViewData.GetActiveWin() );

        //  The listener may just now be waiting for the SolarMutex and call the link

        //  afterwards, in spite of RemoveListener. So the link has to be reset, too.

        mxClipEvtLstnr->ClearCallbackLink();

    }

}

//          Functions

void ScDrawTextObjectBar::Execute( SfxRequest &rReq )

{

    ScDrawView* pView = mrViewData.GetScDrawView();

    OutlinerView* pOutView = pView->GetTextEditOutlinerView();

    Outliner* pOutliner = pView->GetTextEditOutliner();

    if (!pOutView || !pOutliner)

    {

        ExecuteGlobal( rReq );              // on whole objects

        return;

    }

    const SfxItemSet* pReqArgs = rReq.GetArgs();

    sal_uInt16 nSlot = rReq.GetSlot();

    switch ( nSlot )

    {

        case SID_COPY:

            pOutView->Copy();

            break;

        case SID_CUT:

            pOutView->Cut();

            break;

        case SID_PASTE:

            pOutView->PasteSpecial();

            break;

        case SID_CLIPBOARD_FORMAT_ITEMS:

            {

                SotClipboardFormatId nFormat = SotClipboardFormatId::NONE;

                const SfxPoolItem* pItem;

                if ( pReqArgs && pReqArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET )

                    if (auto pIntItem = dynamic_cast<const SfxUInt32Item*>( pItem))

                        nFormat = static_cast<SotClipboardFormatId>(pIntItem->GetValue());

                if ( nFormat != SotClipboardFormatId::NONE )

                {

                    if (nFormat == SotClipboardFormatId::STRING)

                        pOutView->Paste();

                    else

                        pOutView->PasteSpecial(nFormat);

                }

            }

            break;

        case SID_PASTE_SPECIAL:

            ExecutePasteContents( rReq );

            break;

        case SID_PASTE_UNFORMATTED:

            pOutView->Paste();

            break;

        case SID_SELECTALL:

            {

                sal_Int32 nCount = pOutliner->GetParagraphCount();

                ESelection aSel( 0,0,nCount,0 );

                pOutView->SetSelection( aSel );

            }

            break;

        case SID_CHARMAP:

            {

                auto const attribs = pOutView->GetAttribs();

                const SvxFontItem& rItem = attribs.Get(EE_CHAR_FONTINFO);

                OUString aString;

                std::shared_ptr<SvxFontItem> aNewItem(std::make_shared<SvxFontItem>(EE_CHAR_FONTINFO));

                const SfxItemSet *pArgs = rReq.GetArgs();

                const SfxPoolItem* pItem = nullptr;

                if( pArgs )

                    pArgs->GetItemState(SID_CHARMAP, false, &pItem);

                if ( pItem )

                {

                    aString = static_cast<const SfxStringItem*>(pItem)->GetValue();

                    const SfxStringItem* pFontItem = pArgs->GetItemIfSet( SID_ATTR_SPECIALCHAR, false);

                    if ( pFontItem )

                    {

                        const OUString& aFontName(pFontItem->GetValue());

                        vcl::Font aFont(aFontName, Size(1,1)); // Size only because of CTOR

                        aNewItem = std::make_shared<SvxFontItem>(

                            aFont.GetFamilyTypeMaybeAskConfig(), aFont.GetFamilyName(),

                            aFont.GetStyleName(), aFont.GetPitchMaybeAskConfig(),

                            aFont.GetCharSet(), ATTR_FONT);

                    }

                    else

                    {

                        aNewItem.reset(rItem.Clone());

                    }

                }

                else

                    ScViewUtil::ExecuteCharMap(rItem, *mrViewData.GetViewShell());

                if ( !aString.isEmpty() )

                {

                    SfxItemSet aSet( pOutliner->GetEmptyItemSet() );

                    // tdf#125054 set and force to needed WhichID

                    aSet.PutAsTargetWhich( *aNewItem, EE_CHAR_FONTINFO );

                    //  If nothing is selected, then SetAttribs of the View selects a word

                    pOutView->GetOutliner().QuickSetAttribs( aSet, pOutView->GetSelection() );

                    pOutView->InsertText(aString);

                }

                Invalidate( SID_ATTR_CHAR_FONT );

            }

            break;

        case SID_HYPERLINK_SETLINK:

            if( pReqArgs )

            {

                if ( const SvxHyperlinkItem* pHyper = pReqArgs->GetItemIfSet( SID_HYPERLINK_SETLINK) )

                {

                    const OUString& rName = pHyper->GetName();

                    const OUString& rURL      = pHyper->GetURL();

                    const OUString& rTarget   = pHyper->GetTargetFrame();

                    SvxLinkInsertMode eMode = pHyper->GetInsertMode();

                    bool bDone = false;

                    if (eMode == HLINK_DEFAULT || eMode == HLINK_FIELD)

                    {

                        pOutView->SelectFieldAtCursor();

                        //  insert new field

                        SvxURLField aURLField( rURL, rName, SvxURLFormat::Repr );

                        aURLField.SetTargetFrame( rTarget );

                        SvxFieldItem aURLItem( aURLField, EE_FEATURE_FIELD );

                        pOutView->InsertField( aURLItem );

                        bDone = true;

                    }

                    if (!bDone)

                        ExecuteGlobal( rReq );      // normal at View

                    //  If "text" is received by InsertURL of ViewShell, then the DrawShell is turned off !!!

                }

            }

            break;

        case SID_OPEN_HYPERLINK:

            {

                const SvxFieldItem* pFieldItem

                    = pOutView->GetFieldAtSelection(/*AlsoCheckBeforeCursor=*/true);

                const SvxFieldData* pField = pFieldItem ? pFieldItem->GetField() : nullptr;

                if (const SvxURLField* pURLField = dynamic_cast<const SvxURLField*>(pField))

                {

                    ScGlobal::OpenURL(pURLField->GetURL(), pURLField->GetTargetFrame(), true);

                }

            }

            break;

        case SID_INSERT_HYPERLINK:

            mrViewData.GetViewShell()->GetViewFrame().GetDispatcher()->Execute(SID_HYPERLINK_DIALOG);

            break;

        case SID_EDIT_HYPERLINK:

            {

                // Ensure the field is selected first

                pOutView->SelectFieldAtCursor();

                mrViewData.GetViewShell()->GetViewFrame().GetDispatcher()->Execute(SID_HYPERLINK_DIALOG);

            }

            break;

        case SID_COPY_HYPERLINK_LOCATION:

            {

                const SvxFieldItem* pFieldItem

                    = pOutView->GetFieldAtSelection(/*AlsoCheckBeforeCursor=*/true);

                const SvxFieldData* pField = pFieldItem ? pFieldItem->GetField() : nullptr;

                if (const SvxURLField* pURLField = dynamic_cast<const SvxURLField*>(pField))

                {

                    uno::Reference<datatransfer::clipboard::XClipboard> xClipboard

                        = pOutView->GetWindow()->GetClipboard();

                    vcl::unohelper::TextDataObject::CopyStringTo(pURLField->GetURL(), xClipboard);

                }

            }

            break;

        case SID_REMOVE_HYPERLINK:

            {

                URLFieldHelper::RemoveURLField(pOutView->GetEditView());

            }

            break;

        case SID_ENABLE_HYPHENATION:

        case SID_TEXTDIRECTION_LEFT_TO_RIGHT:

        case SID_TEXTDIRECTION_TOP_TO_BOTTOM:

            pView->ScEndTextEdit(); // end text edit before switching direction

            ExecuteGlobal( rReq );

            // restore consistent state between shells and functions:

            mrViewData.GetDispatcher().Execute(SID_OBJECT_SELECT, SfxCallMode::SLOT | SfxCallMode::RECORD);

            break;

        case SID_THES:

            {

                OUString aReplaceText;

                const SfxStringItem* pItem2 = rReq.GetArg(FN_PARAM_THES_WORD_REPLACE);

                if (pItem2)

                    aReplaceText = pItem2->GetValue();

                if (!aReplaceText.isEmpty())

                    ReplaceTextWithSynonym( pOutView->GetEditView(), aReplaceText );

            }

            break;

        case SID_THESAURUS:

            {

                pOutView->StartThesaurus(rReq.GetFrameWeld());

            }

            break;

    }

}

void ScDrawTextObjectBar::GetState( SfxItemSet& rSet )

{

    SfxViewFrame& rViewFrm = mrViewData.GetViewShell()->GetViewFrame();

    bool bHasFontWork = rViewFrm.HasChildWindow(SID_FONTWORK);

    bool bDisableFontWork = false;

    if (IsNoteEdit())

    {

        // #i21255# notes now support rich text formatting (#i74140# but not fontwork)

        bDisableFontWork = true;

    }

    if ( bDisableFontWork )

        rSet.DisableItem( SID_FONTWORK  );

    else

        rSet.Put(SfxBoolItem(SID_FONTWORK, bHasFontWork));

    if ( rSet.GetItemState( SID_HYPERLINK_GETLINK ) != SfxItemState::UNKNOWN )

    {

        SvxHyperlinkItem aHLinkItem;

        aHLinkItem.SetShowName(false);

        SdrView* pView = mrViewData.GetScDrawView();

        OutlinerView* pOutView = pView->GetTextEditOutlinerView();

        if ( pOutView )

        {

            bool bField = false;

            const SvxFieldItem* pFieldItem = pOutView->GetFieldAtSelection();

            const SvxFieldData* pField = pFieldItem ? pFieldItem->GetField() : nullptr;

            if (const SvxURLField* pURLField = dynamic_cast<const SvxURLField*>(pField))

            {

                aHLinkItem.SetName( pURLField->GetRepresentation() );

                aHLinkItem.SetURL( pURLField->GetURL() );

                aHLinkItem.SetTargetFrame( pURLField->GetTargetFrame() );

                bField = true;

            }

            if (!bField)

            {

                // use selected text as name for urls

                OUString sReturn = pOutView->GetSelected();

                sal_Int32 nLen = std::min<sal_Int32>(sReturn.getLength(), 255);

                sReturn = sReturn.copy(0, nLen);

                aHLinkItem.SetName(comphelper::string::stripEnd(sReturn, ' '));

            }

        }

        rSet.Put(aHLinkItem);

    }

    if (rSet.GetItemState(SID_OPEN_HYPERLINK) != SfxItemState::UNKNOWN

        || rSet.GetItemState(SID_INSERT_HYPERLINK) != SfxItemState::UNKNOWN

        || rSet.GetItemState(SID_EDIT_HYPERLINK) != SfxItemState::UNKNOWN

        || rSet.GetItemState(SID_COPY_HYPERLINK_LOCATION) != SfxItemState::UNKNOWN

        || rSet.GetItemState(SID_REMOVE_HYPERLINK) != SfxItemState::UNKNOWN)

    {

        OutlinerView* pOutView = mrViewData.GetScDrawView()->GetTextEditOutlinerView();

        if (!URLFieldHelper::IsCursorAtURLField(pOutView, /*AlsoCheckBeforeCursor=*/true))

        {

            rSet.DisableItem( SID_OPEN_HYPERLINK );

            rSet.DisableItem( SID_EDIT_HYPERLINK );

            rSet.DisableItem( SID_COPY_HYPERLINK_LOCATION );

            rSet.DisableItem( SID_REMOVE_HYPERLINK );

        }

        else

        {

            rSet.DisableItem( SID_INSERT_HYPERLINK );

        }

    }

    if( rSet.GetItemState( SID_TRANSLITERATE_HALFWIDTH ) != SfxItemState::UNKNOWN )

        ScViewUtil::HideDisabledSlot( rSet, rViewFrm.GetBindings(), SID_TRANSLITERATE_HALFWIDTH );

    if( rSet.GetItemState( SID_TRANSLITERATE_FULLWIDTH ) != SfxItemState::UNKNOWN )

        ScViewUtil::HideDisabledSlot( rSet, rViewFrm.GetBindings(), SID_TRANSLITERATE_FULLWIDTH );

    if( rSet.GetItemState( SID_TRANSLITERATE_HIRAGANA ) != SfxItemState::UNKNOWN )

        ScViewUtil::HideDisabledSlot( rSet, rViewFrm.GetBindings(), SID_TRANSLITERATE_HIRAGANA );

    if( rSet.GetItemState( SID_TRANSLITERATE_KATAKANA ) != SfxItemState::UNKNOWN )

        ScViewUtil::HideDisabledSlot( rSet, rViewFrm.GetBindings(), SID_TRANSLITERATE_KATAKANA );

    if ( rSet.GetItemState( SID_ENABLE_HYPHENATION ) != SfxItemState::UNKNOWN )

    {

        SdrView* pView = mrViewData.GetScDrawView();

        SfxItemSet aAttrs(pView->GetModel().GetItemPool());

        pView->GetAttributes( aAttrs );

        if( aAttrs.GetItemState( EE_PARA_HYPHENATE ) >= SfxItemState::DEFAULT )

        {

            bool bValue = aAttrs.Get( EE_PARA_HYPHENATE ).GetValue();

            rSet.Put( SfxBoolItem( SID_ENABLE_HYPHENATION, bValue ) );

        }

    }

    if ( rSet.GetItemState( SID_THES ) != SfxItemState::UNKNOWN  ||

         rSet.GetItemState( SID_THESAURUS ) != SfxItemState::UNKNOWN )

    {

        SdrView * pView = mrViewData.GetScDrawView();

        OutlinerView* pOutView = pView->GetTextEditOutlinerView();

        OUString        aStatusVal;

        LanguageType    nLang = LANGUAGE_NONE;

        bool bIsLookUpWord = false;

        if ( pOutView )

        {

            EditView& rEditView = pOutView->GetEditView();

            bIsLookUpWord = GetStatusValueForThesaurusFromContext( aStatusVal, nLang, rEditView );

        }

        rSet.Put( SfxStringItem( SID_THES, aStatusVal ) );

        // disable thesaurus main menu and context menu entry if there is nothing to look up

        bool bCanDoThesaurus = ScModule::HasThesaurusLanguage( nLang );

        if (!bIsLookUpWord || !bCanDoThesaurus)

            rSet.DisableItem( SID_THES );

        if (!bCanDoThesaurus)

            rSet.DisableItem( SID_THESAURUS );

    }

    if (GetObjectShell()->isContentExtractionLocked())

    {

        rSet.DisableItem(SID_COPY);

        rSet.DisableItem(SID_CUT);

    }

}

IMPL_LINK( ScDrawTextObjectBar, ClipboardChanged, TransferableDataHelper*, pDataHelper, void )

{

    bPastePossible = ( pDataHelper->HasFormat( SotClipboardFormatId::STRING ) || pDataHelper->HasFormat( SotClipboardFormatId::RTF )

        || pDataHelper->HasFormat( SotClipboardFormatId::RICHTEXT ) );

    SfxBindings& rBindings = mrViewData.GetBindings();

    rBindings.Invalidate( SID_PASTE );

    rBindings.Invalidate( SID_PASTE_SPECIAL );

    rBindings.Invalidate( SID_PASTE_UNFORMATTED );

    rBindings.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS );

}

void ScDrawTextObjectBar::GetClipState( SfxItemSet& rSet )

{

    SdrView* pView = mrViewData.GetScDrawView();

    if ( !pView->GetTextEditOutlinerView() )

    {

        GetGlobalClipState( rSet );

        return;

    }

    if ( !mxClipEvtLstnr.is() )

    {

        // create listener

        mxClipEvtLstnr = new TransferableClipboardListener( LINK( this, ScDrawTextObjectBar, ClipboardChanged ) );

        vcl::Window* pWin = mrViewData.GetActiveWin();

        mxClipEvtLstnr->AddListener( pWin );

        // get initial state

        TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( mrViewData.GetActiveWin() ) );

        bPastePossible = ( aDataHelper.HasFormat( SotClipboardFormatId::STRING ) || aDataHelper.HasFormat( SotClipboardFormatId::RTF )

            || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) );

    }

    SfxWhichIter aIter( rSet );

    sal_uInt16 nWhich = aIter.FirstWhich();

    while (nWhich)

    {

        switch (nWhich)

        {

            case SID_PASTE:

            case SID_PASTE_SPECIAL:

            case SID_PASTE_UNFORMATTED:

                if( !bPastePossible )

                    rSet.DisableItem( nWhich );

                break;

            case SID_CLIPBOARD_FORMAT_ITEMS:

                if ( bPastePossible )

                {

                    SvxClipboardFormatItem aFormats( SID_CLIPBOARD_FORMAT_ITEMS );

                    TransferableDataHelper aDataHelper(

                            TransferableDataHelper::CreateFromSystemClipboard( mrViewData.GetActiveWin() ) );

                    if ( aDataHelper.HasFormat( SotClipboardFormatId::STRING ) )

                        aFormats.AddClipbrdFormat( SotClipboardFormatId::STRING );

                    if ( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) )

                        aFormats.AddClipbrdFormat( SotClipboardFormatId::RTF );

                    if ( aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) )

                        aFormats.AddClipbrdFormat( SotClipboardFormatId::RICHTEXT );

                    if (aDataHelper.HasFormat(SotClipboardFormatId::HTML_SIMPLE))

                        aFormats.AddClipbrdFormat(SotClipboardFormatId::HTML_SIMPLE);

                    rSet.Put( aFormats );

                }

                else

                    rSet.DisableItem( nWhich );

                break;

        }

        nWhich = aIter.NextWhich();

    }

}

//          Attributes

void ScDrawTextObjectBar::ExecuteToggle( SfxRequest &rReq )

{

    //  Underline

    SdrView* pView = mrViewData.GetScDrawView();

    sal_uInt16 nSlot = rReq.GetSlot();

    SfxItemSet aSet( pView->GetDefaultAttr() );

    SfxItemSet aViewAttr(pView->GetModel().GetItemPool());

    pView->GetAttributes(aViewAttr);

    //  Underline

    FontLineStyle eOld = aViewAttr.Get(EE_CHAR_UNDERLINE).GetLineStyle();

    FontLineStyle eNew = eOld;

    switch (nSlot)

    {

        case SID_ULINE_VAL_NONE:

            eNew = LINESTYLE_NONE;

            break;

        case SID_ULINE_VAL_SINGLE:

            eNew = ( eOld == LINESTYLE_SINGLE ) ? LINESTYLE_NONE : LINESTYLE_SINGLE;

            break;

        case SID_ULINE_VAL_DOUBLE:

            eNew = ( eOld == LINESTYLE_DOUBLE ) ? LINESTYLE_NONE : LINESTYLE_DOUBLE;

            break;

        case SID_ULINE_VAL_DOTTED:

            eNew = ( eOld == LINESTYLE_DOTTED ) ? LINESTYLE_NONE : LINESTYLE_DOTTED;

            break;

        default:

            break;

    }

    aSet.Put( SvxUnderlineItem( eNew, EE_CHAR_UNDERLINE ) );

    pView->SetAttributes( aSet );

    rReq.Done();

    mrViewData.GetScDrawView()->InvalidateDrawTextAttrs();

}

static void lcl_RemoveFields( OutlinerView& rOutView )

{

    //! Outliner should have RemoveFields with a selection

    Outliner& rOutliner = rOutView.GetOutliner();

    ESelection aOldSel = rOutView.GetSelection();

    ESelection aSel = aOldSel;

    aSel.Adjust();

    sal_Int32 nNewEnd = aSel.end.nIndex;

    bool bUpdate = rOutliner.IsUpdateLayout();

    bool bChanged = false;

    //! GetPortions and GetAttribs should be const!

    EditEngine& rEditEng = const_cast<EditEngine&>(rOutliner.GetEditEngine());

    sal_Int32 nParCount = rOutliner.GetParagraphCount();

    for (sal_Int32 nPar=0; nPar<nParCount; nPar++)

        if (nPar >= aSel.start.nPara && nPar <= aSel.end.nPara)

        {

            std::vector<sal_Int32> aPortions;

            rEditEng.GetPortions( nPar, aPortions );

            for ( size_t nPos = aPortions.size(); nPos; )

            {

                --nPos;

                sal_Int32 nEnd = aPortions[ nPos ];

                sal_Int32 nStart = nPos ? aPortions[ nPos - 1 ] : 0;

                // fields are single characters

                if ( nEnd == nStart+1 &&

                     ( nPar > aSel.start.nPara || nStart >= aSel.start.nIndex ) &&

                     ( nPar < aSel.end.nPara   || nEnd   <= aSel.end.nIndex ) )

                {

                    ESelection aFieldSel( nPar, nStart, nPar, nEnd );

                    SfxItemSet aSet = rEditEng.GetAttribs( aFieldSel );

                    if ( aSet.GetItemState( EE_FEATURE_FIELD ) == SfxItemState::SET )

                    {

                        if (!bChanged)

                        {

                            if (bUpdate)

                                rOutliner.SetUpdateLayout( false );

                            OUString aName = ScResId( STR_UNDO_DELETECONTENTS );

                            ViewShellId nViewShellId(-1);

                            if (ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell())

                                nViewShellId = pViewSh->GetViewShellId();

                            rOutliner.GetUndoManager().EnterListAction( aName, aName, 0, nViewShellId );

                            bChanged = true;

                        }

                        OUString aFieldText = rEditEng.GetText( aFieldSel );

                        rOutliner.QuickInsertText( aFieldText, aFieldSel );

                        if (nPar == aSel.end.nPara)

                        {

                            nNewEnd = nNewEnd + aFieldText.getLength();

                            --nNewEnd;

                        }

                    }

                }

            }

        }

    if (bUpdate && bChanged)

    {

        rOutliner.GetUndoManager().LeaveListAction();

        rOutliner.SetUpdateLayout( true );

    }

    if ( aOldSel == aSel )          // aSel is adjusted

        aOldSel.end.nIndex = nNewEnd;

    else

        aOldSel.start.nIndex = nNewEnd;        // if aOldSel is backwards

    rOutView.SetSelection( aOldSel );

}

void ScDrawTextObjectBar::ExecuteAttr( SfxRequest &rReq )

{

    SdrView*            pView = mrViewData.GetScDrawView();

    const SfxItemSet*   pArgs = rReq.GetArgs();

    sal_uInt16          nSlot = rReq.GetSlot();

    SfxItemSet aEditAttr( pView->GetModel().GetItemPool() );

    pView->GetAttributes( aEditAttr );

    SfxItemSet  aNewAttr( *aEditAttr.GetPool(), aEditAttr.GetRanges() );

    bool bSet = true;

    switch ( nSlot )

    {

        case SID_ALIGNLEFT:

        case SID_ALIGN_ANY_LEFT:

        case SID_ATTR_PARA_ADJUST_LEFT:

            aNewAttr.Put( SvxAdjustItem( SvxAdjust::Left, EE_PARA_JUST ) );

            break;

        case SID_ALIGNCENTERHOR:

        case SID_ALIGN_ANY_HCENTER:

        case SID_ATTR_PARA_ADJUST_CENTER:

            aNewAttr.Put( SvxAdjustItem( SvxAdjust::Center, EE_PARA_JUST ) );

            break;

        case SID_ALIGNRIGHT:

        case SID_ALIGN_ANY_RIGHT:

        case SID_ATTR_PARA_ADJUST_RIGHT:

            aNewAttr.Put( SvxAdjustItem( SvxAdjust::Right, EE_PARA_JUST ) );

            break;

        case SID_ALIGNBLOCK:

        case SID_ALIGN_ANY_JUSTIFIED:

        case SID_ATTR_PARA_ADJUST_BLOCK:

            aNewAttr.Put( SvxAdjustItem( SvxAdjust::Block, EE_PARA_JUST ) );

            break;

        case SID_ATTR_PARA_LINESPACE_10:

            {

                SvxLineSpacingItem aItem( LINE_SPACE_DEFAULT_HEIGHT, EE_PARA_SBL );

                aItem.SetPropLineSpace( 100 );

                aNewAttr.Put( aItem );

            }

            break;

        case SID_ATTR_PARA_LINESPACE_15:

            {

                SvxLineSpacingItem aItem( LINE_SPACE_DEFAULT_HEIGHT, EE_PARA_SBL );

                aItem.SetPropLineSpace( 150 );

                aNewAttr.Put( aItem );

            }

            break;

        case SID_ATTR_PARA_LINESPACE_20:

            {

                SvxLineSpacingItem aItem( LINE_SPACE_DEFAULT_HEIGHT, EE_PARA_SBL );

                aItem.SetPropLineSpace( 200 );

                aNewAttr.Put( aItem );

            }

            break;

        case SID_SET_SUPER_SCRIPT:

            {

                SvxEscapementItem aItem(EE_CHAR_ESCAPEMENT);

                SvxEscapement eEsc = aEditAttr.Get(EE_CHAR_ESCAPEMENT).GetEscapement();

                if( eEsc == SvxEscapement::Superscript )

                    aItem.SetEscapement( SvxEscapement::Off );

                else

                    aItem.SetEscapement( SvxEscapement::Superscript );

                aNewAttr.Put( aItem );

            }

            break;

        case SID_SET_SUB_SCRIPT:

            {

                SvxEscapementItem aItem(EE_CHAR_ESCAPEMENT);

                SvxEscapement eEsc = aEditAttr.Get(EE_CHAR_ESCAPEMENT).GetEscapement();

                if( eEsc == SvxEscapement::Subscript )

                    aItem.SetEscapement( SvxEscapement::Off );

                else

                    aItem.SetEscapement( SvxEscapement::Subscript );

                aNewAttr.Put( aItem );

            }

            break;

        case SID_TABLE_VERT_NONE:

        case SID_TABLE_VERT_CENTER:

        case SID_TABLE_VERT_BOTTOM:

            {

                SdrTextVertAdjust eTVA = SDRTEXTVERTADJUST_TOP;

                if (nSlot == SID_TABLE_VERT_CENTER)

                    eTVA = SDRTEXTVERTADJUST_CENTER;

                else if (nSlot == SID_TABLE_VERT_BOTTOM)

                    eTVA = SDRTEXTVERTADJUST_BOTTOM;

                aNewAttr.Put(SdrTextVertAdjustItem(eTVA));

            }

            break;

        case SID_PARASPACE_INCREASE:

        case SID_PARASPACE_DECREASE:

        {

            SvxULSpaceItem aULSpace( aEditAttr.Get( EE_PARA_ULSPACE ) );

            sal_uInt16 nUpper = aULSpace.GetUpper();

            sal_uInt16 nLower = aULSpace.GetLower();

            if ( nSlot == SID_PARASPACE_INCREASE )

            {

                nUpper += 100;

                nLower += 100;

            }

            else

            {

                nUpper = std::max< sal_Int16 >( nUpper - 100, 0 );

                nLower = std::max< sal_Int16 >( nLower - 100, 0 );

            }

            aULSpace.SetUpper( nUpper );

            aULSpace.SetLower( nLower );

            aNewAttr.Put( aULSpace );

        }

        break;

        default:

            bSet = false;

    }

    bool bDone = true;

    bool bArgsInReq = ( pArgs != nullptr );

    if ( !bArgsInReq )

    {

        switch ( nSlot )

        {

            case SID_CELL_FORMAT_RESET:

            case SID_TEXT_STANDARD:

            {

                OutlinerView* pOutView = pView->IsTextEdit() ?

                                pView->GetTextEditOutlinerView() : nullptr;

                if ( pOutView )

                    pOutView->DrawText_ToEditView( tools::Rectangle() );

                SfxItemSetFixed<EE_ITEMS_START, EE_ITEMS_END> aEmptyAttr( *aEditAttr.GetPool() );

                SfxItemSetFixed<SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_MINFRAMEHEIGHT,

                                SDRATTR_TEXT_MAXFRAMEHEIGHT, SDRATTR_TEXT_MAXFRAMEWIDTH> aSizeAttr(*aEditAttr.GetPool());

                aSizeAttr.Put(pView->GetAttrFromMarked(true));

                pView->SetAttributes( aEmptyAttr, true );

                if (IsNoteEdit())

                {

                    pView->SetAttributes(aSizeAttr, false);

                    pView->GetTextEditObject()->AdjustTextFrameWidthAndHeight();

                }

                if ( pOutView )

                {

                    lcl_RemoveFields( *pOutView );

                    pOutView->ShowCursor();

                }

                rReq.Done( aEmptyAttr );

                mrViewData.GetScDrawView()->InvalidateDrawTextAttrs();

                bDone = false; // already happened here

            }

            break;

            case SID_GROW_FONT_SIZE:

            case SID_SHRINK_FONT_SIZE:

            {

                OutlinerView* pOutView = pView->IsTextEdit() ?

                    pView->GetTextEditOutlinerView() : nullptr;

                if ( pOutView )

                {

                    if (SfxObjectShell* pObjSh = SfxObjectShell::Current())

                    {

                        const SvxFontListItem* pFontListItem = static_cast< const SvxFontListItem* >

                                ( pObjSh->GetItem( SID_ATTR_CHAR_FONTLIST ) );

                        const FontList* pFontList = pFontListItem ? pFontListItem->GetFontList() : nullptr;

                        pOutView->GetEditView().ChangeFontSize( nSlot == SID_GROW_FONT_SIZE, pFontList );

                        mrViewData.GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT );

                    }

                    bDone = false;

                }

            }

            break;

            case SID_CHAR_DLG_EFFECT:

            case SID_CHAR_DLG:                      // dialog button

            case SID_ATTR_CHAR_FONT:                // Controller not shown

            case SID_ATTR_CHAR_FONTHEIGHT:

                bDone = ExecuteCharDlg( aEditAttr, aNewAttr , nSlot);