Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1316 insertions, 0 deletions

diff --git a/svx/source/form/fmtextcontrolshell.cxx b/svx/source/form/fmtextcontrolshell.cxx
new file mode 100644
index 000000000..1177e6eb3
--- /dev/null
+++ b/svx/source/form/fmtextcontrolshell.cxx
@@ -0,0 +1,1316 @@
+/* -*- 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 <fmprop.hxx>
+#include <fmtextcontroldialogs.hxx>
+#include <fmtextcontrolfeature.hxx>
+#include <fmtextcontrolshell.hxx>
+#include <editeng/crossedoutitem.hxx>
+#include <editeng/editeng.hxx>
+#include <editeng/scriptspaceitem.hxx>
+#include <svx/svxids.hrc>
+#include <editeng/udlnitem.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/awt/XFocusListener.hpp>
+#include <com/sun/star/awt/XMouseListener.hpp>
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/msgpool.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/sfxuno.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <svl/eitem.hxx>
+#include <svl/itempool.hxx>
+#include <svl/languageoptions.hxx>
+#include <svtools/stringtransfer.hxx>
+#include <svl/whiter.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <tools/debug.hxx>
+#include <tools/diagnose_ex.h>
+#include <sal/log.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/window.hxx>
+
+#include <memory>
+
+
+namespace svx
+{
+
+
+    using namespace ::com::sun::star;
+    using namespace ::com::sun::star::uno;
+    using namespace ::com::sun::star::form;
+    using namespace ::com::sun::star::form::runtime;
+    using namespace ::com::sun::star::lang;
+    using namespace ::com::sun::star::frame;
+    using namespace ::com::sun::star::util;
+    using namespace ::com::sun::star::beans;
+    using namespace ::com::sun::star::container;
+
+
+    typedef sal_uInt16 WhichId;
+
+
+    static SfxSlotId pTextControlSlots[] =
+    {
+        SID_CLIPBOARD_FORMAT_ITEMS,
+        SID_CUT,
+        SID_COPY,
+        SID_PASTE,
+        SID_SELECTALL,
+//        SID_ATTR_TABSTOP,           /* 2 */
+        SID_ATTR_CHAR_FONT,
+        SID_ATTR_CHAR_POSTURE,
+        SID_ATTR_CHAR_WEIGHT,
+        SID_ATTR_CHAR_SHADOWED,
+        SID_ATTR_CHAR_WORDLINEMODE,
+        SID_ATTR_CHAR_CONTOUR,
+        SID_ATTR_CHAR_STRIKEOUT,
+        SID_ATTR_CHAR_UNDERLINE,
+        SID_ATTR_CHAR_FONTHEIGHT,
+        SID_ATTR_CHAR_COLOR,
+        SID_ATTR_CHAR_KERNING,
+        SID_ATTR_CHAR_LANGUAGE,     /* 20 */
+        SID_ATTR_CHAR_ESCAPEMENT,
+        SID_ATTR_PARA_ADJUST,       /* 28 */
+        SID_ATTR_PARA_ADJUST_LEFT,
+        SID_ATTR_PARA_ADJUST_RIGHT,
+        SID_ATTR_PARA_ADJUST_CENTER,
+        SID_ATTR_PARA_ADJUST_BLOCK,
+        SID_ATTR_PARA_LINESPACE,    /* 33 */
+        SID_ATTR_PARA_LINESPACE_10,
+        SID_ATTR_PARA_LINESPACE_15,
+        SID_ATTR_PARA_LINESPACE_20,
+        SID_ATTR_LRSPACE,           /* 48 */
+        SID_ATTR_ULSPACE,           /* 49 */
+        SID_ATTR_CHAR_AUTOKERN,
+        SID_SET_SUPER_SCRIPT,
+        SID_SET_SUB_SCRIPT,
+        SID_CHAR_DLG,
+        SID_PARA_DLG,
+//        SID_TEXTDIRECTION_LEFT_TO_RIGHT, /* 907 */
+//        SID_TEXTDIRECTION_TOP_TO_BOTTOM,
+        SID_ATTR_CHAR_SCALEWIDTH,       /* 911 */
+        SID_ATTR_CHAR_RELIEF,
+        SID_ATTR_PARA_LEFT_TO_RIGHT,    /* 950 */
+        SID_ATTR_PARA_RIGHT_TO_LEFT,
+        SID_ATTR_CHAR_OVERLINE,
+        0
+    };
+
+    // slots which we are not responsible for on the SfxShell level, but
+    // need to handle during the "paragraph attributes" and/or "character
+    // attributes" dialogs
+    static SfxSlotId pDialogSlots[] =
+    {
+        SID_ATTR_TABSTOP,
+        SID_ATTR_PARA_HANGPUNCTUATION,
+        SID_ATTR_PARA_FORBIDDEN_RULES,
+        SID_ATTR_PARA_SCRIPTSPACE,
+        SID_ATTR_CHAR_LATIN_LANGUAGE,
+        SID_ATTR_CHAR_CJK_LANGUAGE,
+        SID_ATTR_CHAR_CTL_LANGUAGE,
+        SID_ATTR_CHAR_LATIN_FONT,
+        SID_ATTR_CHAR_CJK_FONT,
+        SID_ATTR_CHAR_CTL_FONT,
+        SID_ATTR_CHAR_LATIN_FONTHEIGHT,
+        SID_ATTR_CHAR_CJK_FONTHEIGHT,
+        SID_ATTR_CHAR_CTL_FONTHEIGHT,
+        SID_ATTR_CHAR_LATIN_WEIGHT,
+        SID_ATTR_CHAR_CJK_WEIGHT,
+        SID_ATTR_CHAR_CTL_WEIGHT,
+        SID_ATTR_CHAR_LATIN_POSTURE,
+        SID_ATTR_CHAR_CJK_POSTURE,
+        SID_ATTR_CHAR_CTL_POSTURE,
+        SID_ATTR_CHAR_EMPHASISMARK,
+        0
+    };
+
+    typedef ::cppu::WeakImplHelper <   css::awt::XFocusListener
+                                    >   FmFocusListenerAdapter_Base;
+    class FmFocusListenerAdapter : public FmFocusListenerAdapter_Base
+    {
+    private:
+        IFocusObserver*         m_pObserver;
+        Reference< css::awt::XWindow >    m_xWindow;
+
+    public:
+        FmFocusListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IFocusObserver* _pObserver );
+
+        // clean up the instance
+        void    dispose();
+
+    protected:
+        virtual ~FmFocusListenerAdapter() override;
+
+    protected:
+        virtual void SAL_CALL focusGained( const css::awt::FocusEvent& e ) override;
+        virtual void SAL_CALL focusLost( const css::awt::FocusEvent& e ) override;
+        virtual void SAL_CALL disposing( const EventObject& Source ) override;
+    };
+
+
+    FmFocusListenerAdapter::FmFocusListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IFocusObserver* _pObserver )
+        :m_pObserver( _pObserver )
+        ,m_xWindow( _rxControl, UNO_QUERY )
+    {
+
+        DBG_ASSERT( m_xWindow.is(), "FmFocusListenerAdapter::FmFocusListenerAdapter: invalid control!" );
+        osl_atomic_increment( &m_refCount );
+        {
+            try
+            {
+                if ( m_xWindow.is() )
+                    m_xWindow->addFocusListener( this );
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION("svx");
+            }
+        }
+        osl_atomic_decrement( &m_refCount );
+    }
+
+
+    FmFocusListenerAdapter::~FmFocusListenerAdapter()
+    {
+        acquire();
+        dispose();
+
+    }
+
+
+    void FmFocusListenerAdapter::dispose()
+    {
+        if ( m_xWindow.is() )
+        {
+            m_xWindow->removeFocusListener( this );
+            m_xWindow.clear();
+        }
+    }
+
+
+    void SAL_CALL FmFocusListenerAdapter::focusGained( const css::awt::FocusEvent& e )
+    {
+        if ( m_pObserver )
+            m_pObserver->focusGained( e );
+    }
+
+
+    void SAL_CALL FmFocusListenerAdapter::focusLost( const css::awt::FocusEvent& e )
+    {
+        if ( m_pObserver )
+            m_pObserver->focusLost( e );
+    }
+
+
+    void SAL_CALL FmFocusListenerAdapter::disposing( const EventObject& Source )
+    {
+        DBG_ASSERT( Source.Source == m_xWindow, "FmFocusListenerAdapter::disposing: where did this come from?" );
+        m_xWindow.clear();
+    }
+
+    typedef ::cppu::WeakImplHelper <   css::awt::XMouseListener
+                                    >   FmMouseListenerAdapter_Base;
+    class FmMouseListenerAdapter : public FmMouseListenerAdapter_Base
+    {
+    private:
+        IContextRequestObserver*  m_pObserver;
+        Reference< css::awt::XWindow >    m_xWindow;
+
+    public:
+        FmMouseListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IContextRequestObserver* _pObserver );
+
+        // clean up the instance
+        void    dispose();
+
+    protected:
+        virtual ~FmMouseListenerAdapter() override;
+
+    protected:
+        virtual void SAL_CALL mousePressed( const css::awt::MouseEvent& e ) override;
+        virtual void SAL_CALL mouseReleased( const css::awt::MouseEvent& e ) override;
+        virtual void SAL_CALL mouseEntered( const css::awt::MouseEvent& e ) override;
+        virtual void SAL_CALL mouseExited( const css::awt::MouseEvent& e ) override;
+        virtual void SAL_CALL disposing( const EventObject& Source ) override;
+    };
+
+    FmMouseListenerAdapter::FmMouseListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IContextRequestObserver* _pObserver )
+        :m_pObserver( _pObserver )
+        ,m_xWindow( _rxControl, UNO_QUERY )
+    {
+
+        DBG_ASSERT( m_xWindow.is(), "FmMouseListenerAdapter::FmMouseListenerAdapter: invalid control!" );
+        osl_atomic_increment( &m_refCount );
+        {
+            try
+            {
+                if ( m_xWindow.is() )
+                    m_xWindow->addMouseListener( this );
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION("svx");
+            }
+        }
+        osl_atomic_decrement( &m_refCount );
+    }
+
+
+    FmMouseListenerAdapter::~FmMouseListenerAdapter()
+    {
+        acquire();
+        dispose();
+
+    }
+
+
+    void FmMouseListenerAdapter::dispose()
+    {
+        if ( m_xWindow.is() )
+        {
+            m_xWindow->removeMouseListener( this );
+            m_xWindow.clear();
+        }
+    }
+
+
+    void SAL_CALL FmMouseListenerAdapter::mousePressed( const css::awt::MouseEvent& _rEvent )
+    {
+        SolarMutexGuard aGuard;
+        // is this a request for a context menu?
+        if ( _rEvent.PopupTrigger )
+        {
+            if ( m_pObserver )
+                m_pObserver->contextMenuRequested();
+        }
+    }
+
+
+    void SAL_CALL FmMouseListenerAdapter::mouseReleased( const css::awt::MouseEvent& /*e*/ )
+    {
+        // not interested in
+    }
+
+
+    void SAL_CALL FmMouseListenerAdapter::mouseEntered( const css::awt::MouseEvent& /*e*/ )
+    {
+        // not interested in
+    }
+
+
+    void SAL_CALL FmMouseListenerAdapter::mouseExited( const css::awt::MouseEvent& /*e*/ )
+    {
+        // not interested in
+    }
+
+
+    void SAL_CALL FmMouseListenerAdapter::disposing( const EventObject& Source )
+    {
+        DBG_ASSERT( Source.Source == m_xWindow, "FmMouseListenerAdapter::disposing: where did this come from?" );
+        m_xWindow.clear();
+    }
+
+
+    //= FmTextControlShell
+
+
+    namespace
+    {
+
+        void lcl_translateUnoStateToItem( SfxSlotId _nSlot, const Any& _rUnoState, SfxItemSet& _rSet )
+        {
+            WhichId nWhich = _rSet.GetPool()->GetWhich( _nSlot );
+            if ( !_rUnoState.hasValue() )
+            {
+                if  ( ( _nSlot != SID_CUT )
+                   && ( _nSlot != SID_COPY )
+                   && ( _nSlot != SID_PASTE )
+                    )
+                {
+                    _rSet.InvalidateItem( nWhich );
+                }
+            }
+            else
+            {
+                switch ( _rUnoState.getValueType().getTypeClass() )
+                {
+                case TypeClass_BOOLEAN:
+                {
+                    bool bState = false;
+                    _rUnoState >>= bState;
+                    if ( _nSlot == SID_ATTR_PARA_SCRIPTSPACE )
+                        _rSet.Put( SvxScriptSpaceItem( bState, nWhich ) );
+                    else
+                        _rSet.Put( SfxBoolItem( nWhich, bState ) );
+                }
+                break;
+
+                default:
+                {
+                    Sequence< PropertyValue > aComplexState;
+                    if ( _rUnoState >>= aComplexState )
+                    {
+                        if ( !aComplexState.hasElements() )
+                            _rSet.InvalidateItem( nWhich );
+                        else
+                        {
+                            SfxAllItemSet aAllItems( _rSet );
+                            TransformParameters( _nSlot, aComplexState, aAllItems );
+                            const SfxPoolItem* pTransformed = aAllItems.GetItem( nWhich );
+                            OSL_ENSURE( pTransformed, "lcl_translateUnoStateToItem: non-empty parameter sequence leading to empty item?" );
+                            if ( pTransformed )
+                                _rSet.Put( *pTransformed );
+                            else
+                                _rSet.InvalidateItem( nWhich );
+                        }
+                    }
+                    else
+                    {
+                        OSL_FAIL( "lcl_translateUnoStateToItem: invalid state!" );
+                    }
+                }
+                }
+            }
+        }
+
+
+        OUString lcl_getUnoSlotName( SfxSlotId _nSlotId )
+        {
+            OUString sSlotUnoName;
+
+            SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool();
+            const SfxSlot* pSlot = rSlotPool.GetSlot( _nSlotId );
+
+            const char* pAsciiUnoName = nullptr;
+            if ( pSlot )
+            {
+                pAsciiUnoName = pSlot->GetUnoName();
+            }
+            else
+            {
+                // some hard-coded slots, which do not have a UNO name at SFX level, but which
+                // we nevertheless need to transport via UNO mechanisms, so we need a name
+                switch ( _nSlotId )
+                {
+                case SID_ATTR_PARA_HANGPUNCTUATION: pAsciiUnoName = "AllowHangingPunctuation"; break;
+                case SID_ATTR_PARA_FORBIDDEN_RULES: pAsciiUnoName = "ApplyForbiddenCharacterRules"; break;
+                case SID_ATTR_PARA_SCRIPTSPACE: pAsciiUnoName = "UseScriptSpacing"; break;
+                }
+            }
+
+            if ( pAsciiUnoName )
+            {
+                sSlotUnoName = ".uno:" + OUString::createFromAscii( pAsciiUnoName );
+            }
+            else
+            {
+                SAL_WARN( "svx", "lcl_getUnoSlotName: invalid slot id, or invalid slot, or no UNO name! "
+                        "(slot id: " << _nSlotId << ")");
+            }
+            return sSlotUnoName;
+        }
+
+
+        bool lcl_determineReadOnly( const Reference< css::awt::XControl >& _rxControl )
+        {
+            bool bIsReadOnlyModel = true;
+            try
+            {
+                Reference< XPropertySet > xModelProps;
+                if ( _rxControl.is() )
+                    xModelProps.set(_rxControl->getModel(), css::uno::UNO_QUERY);
+                Reference< XPropertySetInfo > xModelPropInfo;
+                if ( xModelProps.is() )
+                    xModelPropInfo = xModelProps->getPropertySetInfo();
+
+                if ( !xModelPropInfo.is() || !xModelPropInfo->hasPropertyByName( FM_PROP_READONLY ) )
+                    bIsReadOnlyModel = true;
+                else
+                {
+                    bool bReadOnly = true;
+                    xModelProps->getPropertyValue( FM_PROP_READONLY ) >>= bReadOnly;
+                    bIsReadOnlyModel = bReadOnly;
+                }
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION("svx");
+            }
+            return bIsReadOnlyModel;
+        }
+
+
+        vcl::Window* lcl_getWindow( const Reference< css::awt::XControl >& _rxControl )
+        {
+            vcl::Window* pWindow = nullptr;
+            try
+            {
+                Reference< css::awt::XWindowPeer > xControlPeer;
+                if ( _rxControl.is() )
+                    xControlPeer = _rxControl->getPeer();
+                if ( xControlPeer.is() )
+                    pWindow = VCLUnoHelper::GetWindow( xControlPeer ).get();
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION("svx");
+            }
+
+            return pWindow;
+        }
+
+
+        bool lcl_isRichText( const Reference< css::awt::XControl >& _rxControl )
+        {
+            if ( !_rxControl.is() )
+                return false;
+
+            bool bIsRichText = false;
+            try
+            {
+                Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY );
+                Reference< XPropertySetInfo > xPSI;
+                if ( xModelProps.is() )
+                    xPSI = xModelProps->getPropertySetInfo();
+                OUString sRichTextPropertyName = "RichText";
+                if ( xPSI.is() && xPSI->hasPropertyByName( sRichTextPropertyName ) )
+                {
+                    OSL_VERIFY( xModelProps->getPropertyValue( sRichTextPropertyName ) >>= bIsRichText );
+                }
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION("svx");
+            }
+            return bIsRichText;
+        }
+    }
+
+
+    FmTextControlShell::FmTextControlShell( SfxViewFrame* _pFrame )
+        :m_bActiveControl( false )
+        ,m_bActiveControlIsReadOnly( true )
+        ,m_bActiveControlIsRichText( false )
+        ,m_pViewFrame( _pFrame )
+        ,m_rBindings( _pFrame->GetBindings() )
+        ,m_bNeedClipboardInvalidation( true )
+    {
+        m_aClipboardInvalidation.SetInvokeHandler( LINK( this, FmTextControlShell, OnInvalidateClipboard ) );
+        m_aClipboardInvalidation.SetTimeout( 200 );
+    }
+
+
+    FmTextControlShell::~FmTextControlShell()
+    {
+        dispose();
+    }
+
+
+    IMPL_LINK_NOARG( FmTextControlShell, OnInvalidateClipboard, Timer*, void )
+    {
+        if ( m_bNeedClipboardInvalidation )
+        {
+            SAL_INFO("svx.form", "invalidating clipboard slots" );
+            m_rBindings.Invalidate( SID_CUT );
+            m_rBindings.Invalidate( SID_COPY );
+            m_rBindings.Invalidate( SID_PASTE );
+            m_bNeedClipboardInvalidation = false;
+        }
+    }
+
+
+    void FmTextControlShell::transferFeatureStatesToItemSet( ControlFeatures& _rDispatchers, SfxAllItemSet& _rSet, bool _bTranslateLatin )
+    {
+        SfxItemPool& rPool = *_rSet.GetPool();
+
+        for (const auto& rFeature : _rDispatchers)
+        {
+            SfxSlotId nSlotId( rFeature.first );
+#if OSL_DEBUG_LEVEL > 0
+            OUString sUnoSlotName;
+            if ( SfxGetpApp() )
+                sUnoSlotName = lcl_getUnoSlotName( nSlotId );
+            else
+                sUnoSlotName = "<unknown>";
+            OString sUnoSlotNameAscii = "\"" +
+                OString( sUnoSlotName.getStr(), sUnoSlotName.getLength(), RTL_TEXTENCODING_ASCII_US ) +
+                "\"";
+#endif
+
+            if ( _bTranslateLatin )
+            {
+                // A rich text control offers a dispatcher for the "Font" slot/feature.
+                // Sadly, the semantics of the dispatches is that the feature "Font" depends
+                // on the current cursor position: If it's on latin text, it's the "latin font"
+                // which is set up at the control. If it's on CJK text, it's the "CJK font", and
+                // equivalent for "CTL font".
+                // The same holds for some other font related features/slots.
+                // Thus, we have separate dispatches for "Latin Font", "Latin Font Size", etc,
+                // which are only "virtual", in a sense that there exist no item with this id.
+                // So when we encounter such a dispatcher for, say, "Latin Font", we need to
+                // put an item into the set which has the "Font" id.
+
+                switch ( nSlotId )
+                {
+                case SID_ATTR_CHAR_LATIN_FONT:      nSlotId = SID_ATTR_CHAR_FONT; break;
+                case SID_ATTR_CHAR_LATIN_FONTHEIGHT:nSlotId = SID_ATTR_CHAR_FONTHEIGHT; break;
+                case SID_ATTR_CHAR_LATIN_LANGUAGE:  nSlotId = SID_ATTR_CHAR_LANGUAGE; break;
+                case SID_ATTR_CHAR_LATIN_POSTURE:   nSlotId = SID_ATTR_CHAR_POSTURE; break;
+                case SID_ATTR_CHAR_LATIN_WEIGHT:    nSlotId = SID_ATTR_CHAR_WEIGHT; break;
+                }
+            }
+
+            WhichId nWhich = rPool.GetWhich( nSlotId );
+            bool bIsInPool = rPool.IsInRange( nWhich );
+            if ( bIsInPool )
+            {
+#if OSL_DEBUG_LEVEL > 0
+                bool bFeatureIsEnabled = rFeature.second->isFeatureEnabled();
+                OString sMessage =  "found a feature state for "  + sUnoSlotNameAscii;
+                if ( !bFeatureIsEnabled )
+                    sMessage += " (disabled)";
+                SAL_INFO("svx.form", sMessage );
+#endif
+
+                lcl_translateUnoStateToItem( nSlotId, rFeature.second->getFeatureState(), _rSet );
+            }
+#if OSL_DEBUG_LEVEL > 0
+            else
+            {
+                SAL_WARN("svx.form", "found a feature state for " << sUnoSlotNameAscii << ", but could not translate it into an item!" );
+            }
+#endif
+        }
+    }
+
+
+    void FmTextControlShell::executeAttributeDialog( AttributeSet _eSet, SfxRequest& rReq )
+    {
+        const SvxFontListItem* pFontList = dynamic_cast<const SvxFontListItem*>( m_pViewFrame->GetObjectShell()->GetItem( SID_ATTR_CHAR_FONTLIST )  );
+        DBG_ASSERT( pFontList, "FmTextControlShell::executeAttributeDialog: no font list item!" );
+        if ( !pFontList )
+            return;
+
+        SfxItemPool* pPool = EditEngine::CreatePool();
+        pPool->FreezeIdRanges();
+        std::unique_ptr< SfxItemSet > xPureItems( new SfxItemSet( *pPool ) );
+
+        // put the current states of the items into the set
+        std::unique_ptr<SfxAllItemSet> xCurrentItems( new SfxAllItemSet( *xPureItems ) );
+        transferFeatureStatesToItemSet( m_aControlFeatures, *xCurrentItems, false );
+
+        // additional items, which we are not responsible for at the SfxShell level,
+        // but which need to be forwarded to the dialog, anyway
+        ControlFeatures aAdditionalFestures;
+        fillFeatureDispatchers( m_xActiveControl, pDialogSlots, aAdditionalFestures );
+        transferFeatureStatesToItemSet( aAdditionalFestures, *xCurrentItems, true );
+
+        std::unique_ptr<SfxTabDialogController> xDialog;
+        if (_eSet == eCharAttribs)
+            xDialog = std::make_unique<TextControlCharAttribDialog>(rReq.GetFrameWeld(), *xCurrentItems, *pFontList);
+        else
+            xDialog = std::make_unique<TextControlParaAttribDialog>(rReq.GetFrameWeld(), *xCurrentItems);
+        if ( RET_OK == xDialog->run() )
+        {
+            const SfxItemSet& rModifiedItems = *xDialog->GetOutputItemSet();
+            for ( WhichId nWhich = pPool->GetFirstWhich(); nWhich <= pPool->GetLastWhich(); ++nWhich )
+            {
+                if ( rModifiedItems.GetItemState( nWhich ) == SfxItemState::SET )
+                {
+                    SfxSlotId nSlotForItemSet = pPool->GetSlotId( nWhich );
+                    const SfxPoolItem* pModifiedItem = rModifiedItems.GetItem( nWhich );
+
+
+                    SfxSlotId nSlotForDispatcher = nSlotForItemSet;
+                    switch ( nSlotForDispatcher )
+                    {
+                        case SID_ATTR_CHAR_FONT:      nSlotForDispatcher = SID_ATTR_CHAR_LATIN_FONT; break;
+                        case SID_ATTR_CHAR_FONTHEIGHT:nSlotForDispatcher = SID_ATTR_CHAR_LATIN_FONTHEIGHT; break;
+                        case SID_ATTR_CHAR_LANGUAGE:  nSlotForDispatcher = SID_ATTR_CHAR_LATIN_LANGUAGE; break;
+                        case SID_ATTR_CHAR_POSTURE:   nSlotForDispatcher = SID_ATTR_CHAR_LATIN_POSTURE; break;
+                        case SID_ATTR_CHAR_WEIGHT:    nSlotForDispatcher = SID_ATTR_CHAR_LATIN_WEIGHT; break;
+                    }
+
+                    // do we already have a dispatcher for this slot/feature?
+                    ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlotForDispatcher );
+                    bool bFound = aFeaturePos != m_aControlFeatures.end( );
+
+                    if ( !bFound )
+                    {
+                        aFeaturePos = aAdditionalFestures.find( nSlotForDispatcher );
+                        bFound = aFeaturePos != aAdditionalFestures.end( );
+                    }
+
+                    if ( bFound )
+                    {
+                        Sequence< PropertyValue > aArgs;
+                        // temporarily put the modified item into a "clean" set,
+                        // and let TransformItems calc the respective UNO parameters
+                        xPureItems->Put( *pModifiedItem );
+                        TransformItems( nSlotForItemSet, *xPureItems, aArgs );
+                        xPureItems->ClearItem( nWhich );
+
+                        if  (   ( nSlotForItemSet == SID_ATTR_PARA_HANGPUNCTUATION )
+                            ||  ( nSlotForItemSet == SID_ATTR_PARA_FORBIDDEN_RULES )
+                            ||  ( nSlotForItemSet == SID_ATTR_PARA_SCRIPTSPACE )
+                            )
+                        {
+                            // these are no UNO slots, they need special handling since TransformItems cannot
+                            // handle them
+                            DBG_ASSERT( !aArgs.hasElements(), "FmTextControlShell::executeAttributeDialog: these are no UNO slots - are they?" );
+
+                            const SfxBoolItem* pBoolItem = dynamic_cast<const SfxBoolItem*>( pModifiedItem  );
+                            DBG_ASSERT( pBoolItem, "FmTextControlShell::executeAttributeDialog: no bool item?!" );
+                            if ( pBoolItem )
+                            {
+                                aArgs.realloc( 1 );
+                                aArgs[ 0 ].Name = "Enable";
+                                aArgs[ 0 ].Value <<= pBoolItem->GetValue();
+                            }
+                        }
+
+                        // dispatch this
+                        aFeaturePos->second->dispatch( aArgs );
+                    }
+                #if OSL_DEBUG_LEVEL > 0
+                    else
+                    {
+                        OUString sUnoSlotName = lcl_getUnoSlotName( nSlotForItemSet );
+                        if ( sUnoSlotName.isEmpty() )
+                            sUnoSlotName = "unknown (no SfxSlot)";
+                        SAL_WARN( "svx", "FmTextControShell::executeAttributeDialog: Could not handle the following item:"
+                                "\n  SlotID: " << nSlotForItemSet
+                                << "\n  WhichID: " << nWhich
+                                << "\n  UNO name: " << sUnoSlotName );
+                    }
+                #endif
+                }
+            }
+            rReq.Done( rModifiedItems );
+        }
+
+        xDialog.reset();
+        xCurrentItems.reset();
+        xPureItems.reset();
+        SfxItemPool::Free(pPool);
+    }
+
+
+    void FmTextControlShell::executeSelectAll( )
+    {
+        try
+        {
+            if ( m_xActiveTextComponent.is() )
+            {
+                sal_Int32 nTextLen = m_xActiveTextComponent->getText().getLength();
+                m_xActiveTextComponent->setSelection( css::awt::Selection( 0, nTextLen ) );
+            }
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+    }
+
+
+    void FmTextControlShell::executeClipboardSlot( SfxSlotId _nSlot )
+    {
+        try
+        {
+            if ( m_xActiveTextComponent.is() )
+            {
+                switch ( _nSlot )
+                {
+                case SID_COPY:
+                case SID_CUT:
+                {
+                    OUString sSelectedText( m_xActiveTextComponent->getSelectedText() );
+                    ::svt::OStringTransfer::CopyString( sSelectedText, lcl_getWindow( m_xActiveControl ) );
+                    if ( SID_CUT == _nSlot )
+                    {
+                        css::awt::Selection aSelection( m_xActiveTextComponent->getSelection() );
+                        m_xActiveTextComponent->insertText( aSelection, OUString() );
+                    }
+                }
+                break;
+                case SID_PASTE:
+                {
+                    OUString sClipboardContent;
+                    OSL_VERIFY( ::svt::OStringTransfer::PasteString( sClipboardContent, lcl_getWindow( m_xActiveControl ) ) );
+                    css::awt::Selection aSelection( m_xActiveTextComponent->getSelection() );
+                    m_xActiveTextComponent->insertText( aSelection, sClipboardContent );
+                }
+                break;
+                default:
+                    OSL_FAIL( "FmTextControlShell::executeClipboardSlot: invalid slot!" );
+                }
+            }
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+    }
+
+
+    void FmTextControlShell::ExecuteTextAttribute( SfxRequest& _rReq )
+    {
+        SfxSlotId nSlot = _rReq.GetSlot();
+
+        ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlot );
+        if ( aFeaturePos == m_aControlFeatures.end() )
+        {
+            // special slots
+            switch ( nSlot )
+            {
+            case SID_CHAR_DLG:
+                executeAttributeDialog( eCharAttribs, _rReq );
+                break;
+
+            case SID_PARA_DLG:
+                executeAttributeDialog( eParaAttribs, _rReq );
+                break;
+
+            case SID_SELECTALL:
+                executeSelectAll();
+                break;
+
+            case SID_CUT:
+            case SID_COPY:
+            case SID_PASTE:
+                executeClipboardSlot( nSlot );
+                break;
+
+            default:
+                DBG_ASSERT( aFeaturePos != m_aControlFeatures.end(), "FmTextControShell::ExecuteTextAttribute: I have no such dispatcher, and cannot handle it at all!" );
+                return;
+            }
+        }
+        else
+        {
+            // slots which are dispatched to the control
+
+            switch ( nSlot )
+            {
+            case SID_ATTR_CHAR_STRIKEOUT:
+            case SID_ATTR_CHAR_UNDERLINE:
+            case SID_ATTR_CHAR_OVERLINE:
+            {
+                SfxItemSet aToggled( *_rReq.GetArgs() );
+
+                lcl_translateUnoStateToItem( nSlot, aFeaturePos->second->getFeatureState(), aToggled );
+                WhichId nWhich = aToggled.GetPool()->GetWhich( nSlot );
+                const SfxPoolItem* pItem = aToggled.GetItem( nWhich );
+                if ( ( SID_ATTR_CHAR_UNDERLINE == nSlot ) || ( SID_ATTR_CHAR_OVERLINE == nSlot ) )
+                {
+                    const SvxTextLineItem* pTextLine = dynamic_cast<const SvxTextLineItem*>( pItem  );
+                    DBG_ASSERT( pTextLine, "FmTextControlShell::ExecuteTextAttribute: ooops - no underline/overline item!" );
+                    if ( pTextLine )
+                    {
+                        FontLineStyle eTL = pTextLine->GetLineStyle();
+                        if ( SID_ATTR_CHAR_UNDERLINE == nSlot ) {
+                            aToggled.Put( SvxUnderlineItem( eTL == LINESTYLE_SINGLE ? LINESTYLE_NONE : LINESTYLE_SINGLE, nWhich ) );
+                        } else {
+                            aToggled.Put( SvxOverlineItem( eTL == LINESTYLE_SINGLE ? LINESTYLE_NONE : LINESTYLE_SINGLE, nWhich ) );
+                        }
+                    }
+                }
+                else
+                {
+                    const SvxCrossedOutItem* pCrossedOut = dynamic_cast<const SvxCrossedOutItem*>( pItem  );
+                    DBG_ASSERT( pCrossedOut, "FmTextControlShell::ExecuteTextAttribute: ooops - no CrossedOut item!" );
+                    if ( pCrossedOut )
+                    {
+                        FontStrikeout eFS = pCrossedOut->GetStrikeout();
+                        aToggled.Put( SvxCrossedOutItem( eFS == STRIKEOUT_SINGLE ? STRIKEOUT_NONE : STRIKEOUT_SINGLE, nWhich ) );
+                    }
+                }
+
+                Sequence< PropertyValue > aArguments;
+                TransformItems( nSlot, aToggled, aArguments );
+                aFeaturePos->second->dispatch( aArguments );
+            }
+            break;
+
+            case SID_ATTR_CHAR_FONTHEIGHT:
+            case SID_ATTR_CHAR_FONT:
+            case SID_ATTR_CHAR_POSTURE:
+            case SID_ATTR_CHAR_WEIGHT:
+            case SID_ATTR_CHAR_SHADOWED:
+            case SID_ATTR_CHAR_CONTOUR:
+            case SID_SET_SUPER_SCRIPT:
+            case SID_SET_SUB_SCRIPT:
+            {
+                const SfxItemSet* pArgs = _rReq.GetArgs();
+                Sequence< PropertyValue > aArgs;
+                if ( pArgs )
+                    TransformItems( nSlot, *pArgs, aArgs );
+                aFeaturePos->second->dispatch( aArgs );
+            }
+            break;
+
+            default:
+                if ( aFeaturePos->second->isFeatureEnabled() )
+                    aFeaturePos->second->dispatch();
+                break;
+            }
+        }
+        _rReq.Done();
+    }
+
+
+    void FmTextControlShell::GetTextAttributeState( SfxItemSet& _rSet )
+    {
+        SfxWhichIter aIter( _rSet );
+        sal_uInt16 nSlot = aIter.FirstWhich();
+        while ( nSlot )
+        {
+            if  (   ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT )
+                ||  ( nSlot == SID_ATTR_PARA_RIGHT_TO_LEFT )
+                )
+            {
+                if ( !SvtLanguageOptions().IsCTLFontEnabled() )
+                {
+                    _rSet.DisableItem( nSlot );
+                    nSlot = aIter.NextWhich();
+                    continue;
+                }
+            }
+
+            ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlot );
+            if ( aFeaturePos != m_aControlFeatures.end() )
+            {
+                if ( aFeaturePos->second->isFeatureEnabled() )
+                    lcl_translateUnoStateToItem( nSlot, aFeaturePos->second->getFeatureState(), _rSet );
+                else
+                    _rSet.DisableItem( nSlot );
+            }
+            else
+            {
+                bool bDisable = false;
+
+                bool bNeedWriteableControl = false;
+                bool bNeedTextComponent = false;
+                bool bNeedSelection = false;
+
+                switch ( nSlot )
+                {
+                case SID_CHAR_DLG:
+                case SID_PARA_DLG:
+                    bDisable |= m_aControlFeatures.empty();
+                    bNeedWriteableControl = true;
+                    break;
+
+                case SID_CUT:
+                    bNeedSelection = true;
+                    bNeedTextComponent = true;
+                    bNeedWriteableControl = true;
+                    SAL_INFO("svx.form", "need to invalidate again" );
+                    m_bNeedClipboardInvalidation = true;
+                    break;
+
+                case SID_PASTE:
+                {
+                    vcl::Window* pActiveControlVCLWindow = lcl_getWindow( m_xActiveControl );
+                    if ( pActiveControlVCLWindow )
+                    {
+                        TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pActiveControlVCLWindow) );
+                        bDisable |= !aDataHelper.HasFormat( SotClipboardFormatId::STRING );
+                    }
+                    else
+                        bDisable = true;
+
+                    bNeedTextComponent = true;
+                    bNeedWriteableControl = true;
+                }
+                break;
+
+                case SID_COPY:
+                    bNeedTextComponent = true;
+                    bNeedSelection = true;
+                    break;
+
+                case SID_SELECTALL:
+                    bNeedTextComponent = true;
+                    break;
+
+                default:
+                    // slot is unknown at all
+                    bDisable = true;
+                    break;
+                }
+                SAL_WARN_IF( bNeedSelection && !bNeedTextComponent, "svx.form", "FmTextControlShell::GetTextAttributeState: bNeedSelection should imply bNeedTextComponent!" );
+
+                if ( !bDisable && bNeedWriteableControl )
+                    bDisable |= !IsActiveControl( ) || m_bActiveControlIsReadOnly;
+
+                if ( !bDisable && bNeedTextComponent )
+                    bDisable |= !m_xActiveTextComponent.is();
+
+                if ( !bDisable && bNeedSelection )
+                {
+                    css::awt::Selection aSelection = m_xActiveTextComponent->getSelection();
+                    bDisable |= aSelection.Min == aSelection.Max;
+                }
+
+                if ( bDisable )
+                    _rSet.DisableItem( nSlot );
+            }
+
+            nSlot = aIter.NextWhich();
+        }
+    }
+
+
+    bool FmTextControlShell::IsActiveControl( bool _bCountRichTextOnly ) const
+    {
+        if ( _bCountRichTextOnly && !m_bActiveControlIsRichText )
+            return false;
+
+        return m_bActiveControl;
+    }
+
+
+    void FmTextControlShell::dispose()
+    {
+        if ( IsActiveControl() )
+            controlDeactivated();
+        if ( isControllerListening() )
+            stopControllerListening();
+    }
+
+
+    void FmTextControlShell::designModeChanged()
+    {
+        m_rBindings.Invalidate( pTextControlSlots );
+    }
+
+
+    void FmTextControlShell::formActivated( const Reference< runtime::XFormController >& _rxController )
+    {
+#if OSL_DEBUG_LEVEL > 0
+        SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(_rxController.get()), 16 ));
+#endif
+
+        DBG_ASSERT( _rxController.is(), "FmTextControlShell::formActivated: invalid controller!" );
+        if ( !_rxController.is() )
+            return;
+
+        // sometimes, a form controller notifies activations, even if it's already activated
+        if ( m_xActiveController == _rxController )
+            return;
+
+        try
+        {
+            startControllerListening( _rxController );
+            controlActivated( _rxController->getCurrentControl() );
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+    }
+
+
+    void FmTextControlShell::formDeactivated( const Reference< runtime::XFormController >& _rxController )
+    {
+        SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(_rxController.get()), 16 ));
+
+        if ( IsActiveControl() )
+            controlDeactivated();
+        if ( isControllerListening() )
+            stopControllerListening();
+    }
+
+
+    void FmTextControlShell::startControllerListening( const Reference< runtime::XFormController >& _rxController )
+    {
+        OSL_PRECOND( _rxController.is(), "FmTextControlShell::startControllerListening: invalid controller!" );
+        if ( !_rxController.is() )
+            return;
+
+        OSL_PRECOND( !isControllerListening(), "FmTextControlShell::startControllerListening: already listening!" );
+        if ( isControllerListening() )
+            stopControllerListening( );
+        DBG_ASSERT( !isControllerListening(), "FmTextControlShell::startControllerListening: inconsistence!" );
+
+        try
+        {
+            Sequence< Reference< css::awt::XControl > > aControls( _rxController->getControls() );
+            m_aControlObservers.resize( 0 );
+            m_aControlObservers.reserve( aControls.getLength() );
+
+            std::transform(aControls.begin(), aControls.end(), std::back_inserter(m_aControlObservers),
+                [this](const Reference< css::awt::XControl >& rControl) -> FocusListenerAdapter {
+                    return FocusListenerAdapter( new FmFocusListenerAdapter( rControl, this ) ); });
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+
+        m_xActiveController = _rxController;
+    }
+
+
+    void FmTextControlShell::stopControllerListening( )
+    {
+        OSL_PRECOND( isControllerListening(), "FmTextControlShell::stopControllerListening: inconsistence!" );
+
+        // dispose all listeners associated with the controls of the active controller
+        for (auto& rpObserver : m_aControlObservers)
+        {
+            rpObserver->dispose();
+        }
+
+        FocusListenerAdapters aEmpty;
+        m_aControlObservers.swap( aEmpty );
+
+        m_xActiveController.clear();
+    }
+
+
+    void FmTextControlShell::implClearActiveControlRef()
+    {
+        // no more features for this control
+        for (auto& rFeature : m_aControlFeatures)
+        {
+            rFeature.second->dispose();
+        }
+
+        ControlFeatures aEmpty;
+        m_aControlFeatures.swap( aEmpty );
+
+        if ( m_aContextMenuObserver )
+        {
+            m_aContextMenuObserver->dispose();
+            m_aContextMenuObserver = MouseListenerAdapter();
+        }
+
+        if ( m_xActiveTextComponent.is() )
+        {
+            SAL_INFO("svx.form", "stopping timer for clipboard invalidation" );
+            m_aClipboardInvalidation.Stop();
+        }
+        // no more active control
+        m_xActiveControl.clear();
+        m_xActiveTextComponent.clear();
+        m_bActiveControlIsReadOnly = true;
+        m_bActiveControlIsRichText = false;
+        m_bActiveControl = false;
+    }
+
+
+    void FmTextControlShell::controlDeactivated( )
+    {
+        DBG_ASSERT( IsActiveControl(), "FmTextControlShell::controlDeactivated: no active control!" );
+
+        m_bActiveControl = false;
+
+        m_rBindings.Invalidate( pTextControlSlots );
+    }
+
+
+    void FmTextControlShell::controlActivated( const Reference< css::awt::XControl >& _rxControl )
+    {
+        // ensure that all knittings with the previously active control are lost
+        if ( m_xActiveControl.is() )
+            implClearActiveControlRef();
+        DBG_ASSERT( m_aControlFeatures.empty(), "FmTextControlShell::controlActivated: should have no dispatchers when I'm here!" );
+
+#if OSL_DEBUG_LEVEL > 0
+        {
+            Sequence< Reference< css::awt::XControl > > aActiveControls;
+            if ( m_xActiveController.is() )
+                aActiveControls = m_xActiveController->getControls();
+
+            bool bFoundThisControl = false;
+
+            const Reference< css::awt::XControl >* pControls = aActiveControls.getConstArray();
+            const Reference< css::awt::XControl >* pControlsEnd = pControls + aActiveControls.getLength();
+            for ( ; ( pControls != pControlsEnd ) && !bFoundThisControl; ++pControls )
+            {
+                if ( *pControls == _rxControl )
+                    bFoundThisControl = true;
+            }
+            DBG_ASSERT( bFoundThisControl, "FmTextControlShell::controlActivated: only controls which belong to the active controller can be activated!" );
+        }
+#endif
+        // ask the control for dispatchers for our text-related slots
+        fillFeatureDispatchers( _rxControl, pTextControlSlots, m_aControlFeatures );
+
+        // remember this control
+        m_xActiveControl = _rxControl;
+        m_xActiveTextComponent.set(_rxControl, css::uno::UNO_QUERY);
+        m_bActiveControlIsReadOnly = lcl_determineReadOnly( m_xActiveControl );
+        m_bActiveControlIsRichText = lcl_isRichText( m_xActiveControl );
+
+        // if we found a rich text control, we need context menu support
+        if ( m_bActiveControlIsRichText )
+        {
+            DBG_ASSERT( nullptr == m_aContextMenuObserver.get(), "FmTextControlShell::controlActivated: already have an observer!" );
+            m_aContextMenuObserver = MouseListenerAdapter( new FmMouseListenerAdapter( _rxControl, this ) );
+        }
+
+        if ( m_xActiveTextComponent.is() )
+        {
+            SAL_INFO("svx.form", "starting timer for clipboard invalidation" );
+            m_aClipboardInvalidation.Start();
+        }
+
+        m_bActiveControl = true;
+
+        m_rBindings.Invalidate( pTextControlSlots );
+
+        if ( m_pViewFrame )
+            m_pViewFrame->UIFeatureChanged();
+
+        // don't call the activation handler if we don't have any slots we can serve
+        // The activation handler is used to put the shell on the top of the dispatcher stack,
+        // so it's preferred when slots are distributed.
+        // Note that this is a slight hack, to prevent that we grab slots from the SfxDispatcher
+        // which should be served by other shells (e.g. Cut/Copy/Paste).
+        // A real solution would be a forwarding-mechanism for slots: We should be on the top
+        // if we're active, but if we cannot handle the slot, then we need to tell the dispatcher
+        // to skip our shell, and pass the slot to the next one. However, this mechanism is not
+        // not in place in SFX.
+        // Another possibility would be to have dedicated shells for the slots which we might
+        // or might not be able to serve. However, this could probably increase the number of
+        // shells too much (In theory, nearly every slot could have an own shell then).
+
+        // #i51621# / 2005-08-19 / frank.schoenheit@sun.com
+        // bool bHaveAnyServeableSlots = m_xActiveTextComponent.is() || !m_aControlFeatures.empty();
+        // LEM: not calling m_aControlActivatonHandler causes fdo#63695, so disable this hack for now.
+        m_aControlActivationHandler.Call( nullptr );
+
+        m_bNeedClipboardInvalidation = true;
+    }
+
+
+    void FmTextControlShell::fillFeatureDispatchers(const Reference< css::awt::XControl >& _rxControl, SfxSlotId* _pZeroTerminatedSlots,
+            ControlFeatures& _rDispatchers)
+    {
+        Reference< XDispatchProvider > xProvider( _rxControl, UNO_QUERY );
+        SfxApplication* pApplication = SfxGetpApp();
+        DBG_ASSERT( pApplication, "FmTextControlShell::fillFeatureDispatchers: no SfxApplication!" );
+        if ( xProvider.is() && pApplication )
+        {
+            SfxSlotId* pSlots = _pZeroTerminatedSlots;
+            while ( *pSlots )
+            {
+                FmTextControlFeature* pDispatcher = implGetFeatureDispatcher( xProvider, pApplication, *pSlots );
+                if ( pDispatcher )
+                    _rDispatchers.emplace( *pSlots, ControlFeature( pDispatcher ) );
+
+                ++pSlots;
+            }
+        }
+    }
+
+
+    FmTextControlFeature* FmTextControlShell::implGetFeatureDispatcher( const Reference< XDispatchProvider >& _rxProvider, SfxApplication const * _pApplication, SfxSlotId _nSlot )
+    {
+        OSL_PRECOND( _rxProvider.is() && _pApplication, "FmTextControlShell::implGetFeatureDispatcher: invalid arg(s)!" );
+        URL aFeatureURL;
+        aFeatureURL.Complete = lcl_getUnoSlotName( _nSlot );
+        try
+        {
+            if ( !m_xURLTransformer.is() )
+            {
+                m_xURLTransformer = util::URLTransformer::create( ::comphelper::getProcessComponentContext() );
+            }
+            if ( m_xURLTransformer.is() )
+                m_xURLTransformer->parseStrict( aFeatureURL );
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+        Reference< XDispatch > xDispatcher = _rxProvider->queryDispatch( aFeatureURL, OUString(), 0xFF );
+        if ( xDispatcher.is() )
+            return new FmTextControlFeature( xDispatcher, aFeatureURL, _nSlot, this );
+        return nullptr;
+    }
+
+
+    void FmTextControlShell::Invalidate( SfxSlotId _nSlot )
+    {
+        m_rBindings.Invalidate( _nSlot );
+        // despite this method being called "Invalidate", we also update here - this gives more immediate
+        // feedback in the UI
+        m_rBindings.Update( _nSlot );
+    }
+
+
+    void FmTextControlShell::focusGained( const css::awt::FocusEvent& _rEvent )
+    {
+        Reference< css::awt::XControl > xControl( _rEvent.Source, UNO_QUERY );
+
+#if OSL_DEBUG_LEVEL > 0
+        SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(xControl.get()), 16 ));
+#endif
+
+        DBG_ASSERT( xControl.is(), "FmTextControlShell::focusGained: suspicious focus event!" );
+        if ( xControl.is() )
+            controlActivated( xControl );
+    }
+
+
+    void FmTextControlShell::focusLost( const css::awt::FocusEvent& _rEvent )
+    {
+        Reference< css::awt::XControl > xControl( _rEvent.Source, UNO_QUERY );
+
+#if OSL_DEBUG_LEVEL > 0
+        SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(xControl.get()), 16 ));
+#endif
+
+        m_bActiveControl = false;
+    }
+
+
+    void FmTextControlShell::ForgetActiveControl()
+    {
+        implClearActiveControlRef();
+    }
+
+
+    void FmTextControlShell::contextMenuRequested()
+    {
+        m_rBindings.GetDispatcher()->ExecutePopup( "formrichtext" );
+    }
+
+
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */