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, 608 insertions, 0 deletions

diff --git a/forms/source/richtext/richtextmodel.cxx b/forms/source/richtext/richtextmodel.cxx
new file mode 100644
index 000000000..cd00e8032
--- /dev/null
+++ b/forms/source/richtext/richtextmodel.cxx
@@ -0,0 +1,608 @@
+/* -*- 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 "richtextmodel.hxx"
+#include "richtextengine.hxx"
+#include "richtextunowrapper.hxx"
+
+#include <property.hxx>
+#include <services.hxx>
+
+#include <com/sun/star/awt/LineEndFormat.hpp>
+#include <com/sun/star/form/FormComponentType.hpp>
+#include <com/sun/star/text/WritingMode2.hpp>
+#include <com/sun/star/style/VerticalAlignment.hpp>
+
+#include <cppuhelper/typeprovider.hxx>
+#include <comphelper/guarding.hxx>
+#include <svl/itempool.hxx>
+#include <toolkit/awt/vclxdevice.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <tools/diagnose_ex.h>
+#include <editeng/editstat.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/svapp.hxx>
+
+
+namespace frm
+{
+    using namespace ::com::sun::star::uno;
+    using namespace ::com::sun::star::awt;
+    using namespace ::com::sun::star::lang;
+    using namespace ::com::sun::star::io;
+    using namespace ::com::sun::star::beans;
+    using namespace ::com::sun::star::form;
+    using namespace ::com::sun::star::util;
+    using namespace ::com::sun::star::style;
+
+    namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
+
+    ORichTextModel::ORichTextModel( const Reference< XComponentContext >& _rxFactory )
+        :OControlModel       ( _rxFactory, OUString() )
+        ,FontControlModel    ( true                          )
+        ,m_pEngine           ( RichTextEngine::Create()      )
+        ,m_bSettingEngineText( false                         )
+        ,m_aModifyListeners  ( m_aMutex                      )
+    {
+        m_nClassId = FormComponentType::TEXTFIELD;
+
+        getPropertyDefaultByHandle( PROPERTY_ID_DEFAULTCONTROL          ) >>= m_sDefaultControl;
+        getPropertyDefaultByHandle( PROPERTY_ID_BORDER                  ) >>= m_nBorder;
+        getPropertyDefaultByHandle( PROPERTY_ID_ENABLED                 ) >>= m_bEnabled;
+        getPropertyDefaultByHandle( PROPERTY_ID_ENABLEVISIBLE           ) >>= m_bEnableVisible;
+        getPropertyDefaultByHandle( PROPERTY_ID_HARDLINEBREAKS          ) >>= m_bHardLineBreaks;
+        getPropertyDefaultByHandle( PROPERTY_ID_HSCROLL                 ) >>= m_bHScroll;
+        getPropertyDefaultByHandle( PROPERTY_ID_VSCROLL                 ) >>= m_bVScroll;
+        getPropertyDefaultByHandle( PROPERTY_ID_READONLY                ) >>= m_bReadonly;
+        getPropertyDefaultByHandle( PROPERTY_ID_PRINTABLE               ) >>= m_bPrintable;
+        m_aAlign = getPropertyDefaultByHandle( PROPERTY_ID_ALIGN );
+        getPropertyDefaultByHandle( PROPERTY_ID_ECHO_CHAR               ) >>= m_nEchoChar;
+        getPropertyDefaultByHandle( PROPERTY_ID_MAXTEXTLEN              ) >>= m_nMaxTextLength;
+        getPropertyDefaultByHandle( PROPERTY_ID_MULTILINE               ) >>= m_bMultiLine;
+        getPropertyDefaultByHandle( PROPERTY_ID_RICH_TEXT               ) >>= m_bReallyActAsRichText;
+        getPropertyDefaultByHandle( PROPERTY_ID_HIDEINACTIVESELECTION   ) >>= m_bHideInactiveSelection;
+        getPropertyDefaultByHandle( PROPERTY_ID_LINEEND_FORMAT          ) >>= m_nLineEndFormat;
+        getPropertyDefaultByHandle( PROPERTY_ID_WRITING_MODE            ) >>= m_nTextWritingMode;
+        getPropertyDefaultByHandle( PROPERTY_ID_CONTEXT_WRITING_MODE    ) >>= m_nContextWritingMode;
+
+        implInit();
+    }
+
+
+    ORichTextModel::ORichTextModel( const ORichTextModel* _pOriginal, const Reference< XComponentContext >& _rxFactory )
+        :OControlModel       ( _pOriginal, _rxFactory, false )
+        ,FontControlModel    ( _pOriginal                        )
+        ,m_bSettingEngineText( false                             )
+        ,m_aModifyListeners  ( m_aMutex                          )
+    {
+
+        m_aTabStop               = _pOriginal->m_aTabStop;
+        m_aBackgroundColor       = _pOriginal->m_aBackgroundColor;
+        m_aBorderColor           = _pOriginal->m_aBorderColor;
+        m_aVerticalAlignment     = _pOriginal->m_aVerticalAlignment;
+        m_sDefaultControl        = _pOriginal->m_sDefaultControl;
+        m_sHelpText              = _pOriginal->m_sHelpText;
+        m_sHelpURL               = _pOriginal->m_sHelpURL;
+        m_nBorder                = _pOriginal->m_nBorder;
+        m_bEnabled               = _pOriginal->m_bEnabled;
+        m_bEnableVisible         = _pOriginal->m_bEnableVisible;
+        m_bHardLineBreaks        = _pOriginal->m_bHardLineBreaks;
+        m_bHScroll               = _pOriginal->m_bHScroll;
+        m_bVScroll               = _pOriginal->m_bVScroll;
+        m_bReadonly              = _pOriginal->m_bReadonly;
+        m_bPrintable             = _pOriginal->m_bPrintable;
+        m_bReallyActAsRichText   = _pOriginal->m_bReallyActAsRichText;
+        m_bHideInactiveSelection = _pOriginal->m_bHideInactiveSelection;
+        m_nLineEndFormat         = _pOriginal->m_nLineEndFormat;
+        m_nTextWritingMode       = _pOriginal->m_nTextWritingMode;
+        m_nContextWritingMode    = _pOriginal->m_nContextWritingMode;
+
+        m_aAlign               = _pOriginal->m_aAlign;
+        m_nEchoChar            = _pOriginal->m_nEchoChar;
+        m_nMaxTextLength       = _pOriginal->m_nMaxTextLength;
+        m_bMultiLine           = _pOriginal->m_bMultiLine;
+
+        m_pEngine.reset(_pOriginal->m_pEngine->Clone());
+        m_sLastKnownEngineText = m_pEngine->GetText();
+
+        implInit();
+    }
+
+
+    void ORichTextModel::implInit()
+    {
+        OSL_ENSURE(m_pEngine, "ORichTextModel::implInit: where's the engine?");
+        if (m_pEngine)
+        {
+            m_pEngine->SetModifyHdl( LINK( this, ORichTextModel, OnEngineContentModified ) );
+
+            EEControlBits nEngineControlWord = m_pEngine->GetControlWord();
+            nEngineControlWord = nEngineControlWord & ~EEControlBits::AUTOPAGESIZE;
+            m_pEngine->SetControlWord( nEngineControlWord );
+
+            VCLXDevice* pUnoRefDevice = new VCLXDevice;
+            {
+                SolarMutexGuard g;
+                pUnoRefDevice->SetOutputDevice( m_pEngine->GetRefDevice() );
+            }
+            m_xReferenceDevice = pUnoRefDevice;
+        }
+
+        implDoAggregation();
+        implRegisterProperties();
+    }
+
+
+    void ORichTextModel::implDoAggregation()
+    {
+        osl_atomic_increment( &m_refCount );
+
+        {
+            m_xAggregate = new ORichTextUnoWrapper( *m_pEngine, this );
+            setAggregation( m_xAggregate );
+            doSetDelegator();
+        }
+
+        osl_atomic_decrement( &m_refCount );
+    }
+
+
+    void ORichTextModel::implRegisterProperties()
+    {
+        REGISTER_PROP_2( DEFAULTCONTROL,        m_sDefaultControl,          BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( HELPTEXT,              m_sHelpText,                BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( HELPURL,               m_sHelpURL,                 BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( ENABLED,               m_bEnabled,                 BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( ENABLEVISIBLE,               m_bEnableVisible,                 BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( BORDER,                m_nBorder,                  BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( HARDLINEBREAKS,        m_bHardLineBreaks,          BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( HSCROLL,               m_bHScroll,                 BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( VSCROLL,               m_bVScroll,                 BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( READONLY,              m_bReadonly,                BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( PRINTABLE,             m_bPrintable,               BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( REFERENCE_DEVICE,      m_xReferenceDevice,         BOUND, TRANSIENT    );
+        REGISTER_PROP_2( RICH_TEXT,             m_bReallyActAsRichText,     BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( HIDEINACTIVESELECTION, m_bHideInactiveSelection,   BOUND, MAYBEDEFAULT );
+
+        REGISTER_VOID_PROP_2( TABSTOP,          m_aTabStop,             sal_Bool,           BOUND, MAYBEDEFAULT );
+        REGISTER_VOID_PROP_2( BACKGROUNDCOLOR,  m_aBackgroundColor,     sal_Int32,          BOUND, MAYBEDEFAULT );
+        REGISTER_VOID_PROP_2( BORDERCOLOR,      m_aBorderColor,         sal_Int32,          BOUND, MAYBEDEFAULT );
+        REGISTER_VOID_PROP_2( VERTICAL_ALIGN,   m_aVerticalAlignment,   VerticalAlignment,  BOUND, MAYBEDEFAULT );
+
+        // properties which exist only for compatibility with the css.swt.UnoControlEditModel,
+        // since we replace the default implementation for this service
+        REGISTER_PROP_2( ECHO_CHAR,             m_nEchoChar,            BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( MAXTEXTLEN,            m_nMaxTextLength,       BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( MULTILINE,             m_bMultiLine,           BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( TEXT,                  m_sLastKnownEngineText, BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( LINEEND_FORMAT,        m_nLineEndFormat,       BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_2( WRITING_MODE,          m_nTextWritingMode,     BOUND, MAYBEDEFAULT );
+        REGISTER_PROP_3( CONTEXT_WRITING_MODE,  m_nContextWritingMode,  BOUND, MAYBEDEFAULT, TRANSIENT );
+
+        REGISTER_VOID_PROP_2( ALIGN,        m_aAlign,           sal_Int16, BOUND, MAYBEDEFAULT );
+    }
+
+
+    ORichTextModel::~ORichTextModel( )
+    {
+        if ( !OComponentHelper::rBHelper.bDisposed )
+        {
+            acquire();
+            dispose();
+        }
+        if (m_pEngine)
+        {
+            SolarMutexGuard g;
+            SfxItemPool* pPool = m_pEngine->getPool();
+            m_pEngine.reset();
+            SfxItemPool::Free(pPool);
+        }
+
+
+    }
+
+
+    Any SAL_CALL ORichTextModel::queryAggregation( const Type& _rType )
+    {
+        Any aReturn = ORichTextModel_BASE::queryInterface( _rType );
+
+        if ( !aReturn.hasValue() )
+            aReturn = OControlModel::queryAggregation( _rType );
+
+        return aReturn;
+    }
+
+
+    IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextModel, OControlModel, ORichTextModel_BASE )
+
+    OUString SAL_CALL ORichTextModel::getImplementationName()
+    {
+        return "com.sun.star.comp.forms.ORichTextModel";
+    }
+
+    Sequence< OUString > SAL_CALL ORichTextModel::getSupportedServiceNames()
+    {
+        Sequence< OUString > aOwnNames {
+            FRM_SUN_COMPONENT_RICHTEXTCONTROL,
+            "com.sun.star.text.TextRange",
+            "com.sun.star.style.CharacterProperties",
+            "com.sun.star.style.ParagraphProperties",
+            "com.sun.star.style.CharacterPropertiesAsian",
+            "com.sun.star.style.CharacterPropertiesComplex",
+            "com.sun.star.style.ParagraphPropertiesAsian",
+            "com.sun.star.style.ParagraphPropertiesComplex" };
+
+        return ::comphelper::combineSequences(
+            getAggregateServiceNames(),
+            ::comphelper::concatSequences(
+                OControlModel::getSupportedServiceNames_Static(),
+                aOwnNames)
+        );
+    }
+
+    IMPLEMENT_DEFAULT_CLONING( ORichTextModel )
+
+
+    void SAL_CALL ORichTextModel::disposing()
+    {
+        m_aModifyListeners.disposeAndClear( EventObject( *this ) );
+        OControlModel::disposing();
+    }
+
+
+    namespace
+    {
+        void lcl_removeProperty( Sequence< Property >& _rSeq, const OUString& _rPropertyName )
+        {
+            Property* pLoop = _rSeq.getArray();
+            Property* pEnd = _rSeq.getArray() + _rSeq.getLength();
+            while ( pLoop != pEnd )
+            {
+                if ( pLoop->Name == _rPropertyName )
+                {
+                    ::std::copy( pLoop + 1, pEnd, pLoop );
+                    _rSeq.realloc( _rSeq.getLength() - 1 );
+                    break;
+                }
+                ++pLoop;
+            }
+        }
+    }
+
+    void ORichTextModel::describeFixedProperties( Sequence< Property >& _rProps ) const
+    {
+        BEGIN_DESCRIBE_PROPERTIES( 1, OControlModel )
+            DECL_PROP2( TABINDEX,       sal_Int16,  BOUND,    MAYBEDEFAULT );
+        END_DESCRIBE_PROPERTIES();
+
+        // properties which the OPropertyContainerHelper is responsible for
+        Sequence< Property > aContainedProperties;
+        describeProperties( aContainedProperties );
+
+        // properties which the FontControlModel is responsible for
+        Sequence< Property > aFontProperties;
+        describeFontRelatedProperties( aFontProperties );
+
+        _rProps = concatSequences( aContainedProperties, aFontProperties, _rProps );
+    }
+
+
+    void ORichTextModel::describeAggregateProperties( Sequence< Property >& _rAggregateProps ) const
+    {
+        OControlModel::describeAggregateProperties( _rAggregateProps );
+
+        // our aggregate (the SvxUnoText) declares a FontDescriptor property, as does
+        // our FormControlFont base class. We remove it from the base class' sequence
+        // here, and later on care for both instances being in sync
+        lcl_removeProperty( _rAggregateProps, PROPERTY_FONT );
+
+        // similar, the WritingMode property is declared in our aggregate, too, but we override
+        // it, since the aggregate does no proper PropertyState handling.
+        lcl_removeProperty( _rAggregateProps, PROPERTY_WRITING_MODE );
+    }
+
+
+    void SAL_CALL ORichTextModel::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const
+    {
+        if ( isRegisteredProperty( _nHandle ) )
+        {
+            OPropertyContainerHelper::getFastPropertyValue( _rValue, _nHandle );
+        }
+        else if ( isFontRelatedProperty( _nHandle ) )
+        {
+            FontControlModel::getFastPropertyValue( _rValue, _nHandle );
+        }
+        else
+        {
+            OControlModel::getFastPropertyValue( _rValue, _nHandle );
+        }
+    }
+
+
+    sal_Bool SAL_CALL ORichTextModel::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
+    {
+        bool bModified = false;
+
+        if ( isRegisteredProperty( _nHandle ) )
+        {
+            bModified = OPropertyContainerHelper::convertFastPropertyValue( _rConvertedValue, _rOldValue, _nHandle, _rValue );
+        }
+        else if ( isFontRelatedProperty( _nHandle ) )
+        {
+            bModified = FontControlModel::convertFastPropertyValue( _rConvertedValue, _rOldValue, _nHandle, _rValue );
+        }
+        else
+        {
+            bModified = OControlModel::convertFastPropertyValue( _rConvertedValue, _rOldValue, _nHandle, _rValue );
+        }
+
+        return bModified;
+    }
+
+
+    void SAL_CALL ORichTextModel::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue )
+    {
+        if ( isRegisteredProperty( _nHandle ) )
+        {
+            OPropertyContainerHelper::setFastPropertyValue( _nHandle, _rValue );
+
+            switch ( _nHandle )
+            {
+            case PROPERTY_ID_REFERENCE_DEVICE:
+            {
+            #if OSL_DEBUG_LEVEL > 0
+                MapMode aOldMapMode = m_pEngine->GetRefDevice()->GetMapMode();
+            #endif
+
+                OutputDevice* pRefDevice = VCLUnoHelper::GetOutputDevice( m_xReferenceDevice );
+                OSL_ENSURE( pRefDevice, "ORichTextModel::setFastPropertyValue_NoBroadcast: empty reference device?" );
+                m_pEngine->SetRefDevice( pRefDevice );
+
+            #if OSL_DEBUG_LEVEL > 0
+                MapMode aNewMapMode = m_pEngine->GetRefDevice()->GetMapMode();
+                OSL_ENSURE( aNewMapMode.GetMapUnit() == aOldMapMode.GetMapUnit(),
+                    "ORichTextModel::setFastPropertyValue_NoBroadcast: You should not tamper with the MapUnit of the ref device!" );
+                // if this assertion here is triggered, then we would need to adjust all
+                // items in all text portions in all paragraphs in the attributes of the EditEngine,
+                // as long as they are MapUnit-dependent. This holds at least for the FontSize.
+            #endif
+            }
+            break;
+
+            case PROPERTY_ID_TEXT:
+            {
+                MutexRelease aReleaseMutex( m_aMutex );
+                impl_smlock_setEngineText( m_sLastKnownEngineText );
+            }
+            break;
+            }   // switch ( _nHandle )
+        }
+        else if ( isFontRelatedProperty( _nHandle ) )
+        {
+            FontControlModel::setFastPropertyValue_NoBroadcast_impl(
+                    *this, &ORichTextModel::setDependentFastPropertyValue,
+                    _nHandle, _rValue);
+        }
+        else
+        {
+            switch ( _nHandle )
+            {
+            case PROPERTY_ID_WRITING_MODE:
+            {
+                // forward to our aggregate, so the EditEngine knows about it
+                if ( m_xAggregateSet.is() )
+                    m_xAggregateSet->setPropertyValue( "WritingMode", _rValue );
+            }
+            break;
+
+            default:
+                OControlModel::setFastPropertyValue_NoBroadcast( _nHandle, _rValue );
+                break;
+            }
+        }
+    }
+
+
+    Any ORichTextModel::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const
+    {
+        Any aDefault;
+
+        switch ( _nHandle )
+        {
+        case PROPERTY_ID_WRITING_MODE:
+        case PROPERTY_ID_CONTEXT_WRITING_MODE:
+            aDefault <<= WritingMode2::CONTEXT;
+            break;
+
+        case PROPERTY_ID_LINEEND_FORMAT:
+            aDefault <<= sal_Int16(LineEndFormat::LINE_FEED);
+            break;
+
+        case PROPERTY_ID_ECHO_CHAR:
+        case PROPERTY_ID_ALIGN:
+        case PROPERTY_ID_MAXTEXTLEN:
+            aDefault <<= sal_Int16(0);
+            break;
+
+        case PROPERTY_ID_TABSTOP:
+        case PROPERTY_ID_BACKGROUNDCOLOR:
+        case PROPERTY_ID_BORDERCOLOR:
+        case PROPERTY_ID_VERTICAL_ALIGN:
+            /* void */
+            break;
+
+        case PROPERTY_ID_ENABLED:
+        case PROPERTY_ID_ENABLEVISIBLE:
+        case PROPERTY_ID_PRINTABLE:
+        case PROPERTY_ID_HIDEINACTIVESELECTION:
+            aDefault <<= true;
+            break;
+
+        case PROPERTY_ID_HARDLINEBREAKS:
+        case PROPERTY_ID_HSCROLL:
+        case PROPERTY_ID_VSCROLL:
+        case PROPERTY_ID_READONLY:
+        case PROPERTY_ID_MULTILINE:
+        case PROPERTY_ID_RICH_TEXT:
+            aDefault <<= false;
+            break;
+
+        case PROPERTY_ID_DEFAULTCONTROL:
+            aDefault <<= OUString(FRM_SUN_CONTROL_RICHTEXTCONTROL);
+            break;
+
+        case PROPERTY_ID_HELPTEXT:
+        case PROPERTY_ID_HELPURL:
+        case PROPERTY_ID_TEXT:
+            aDefault <<= OUString();
+            break;
+
+        case PROPERTY_ID_BORDER:
+            aDefault <<= sal_Int16(1);
+            break;
+
+        default:
+            if ( isFontRelatedProperty( _nHandle ) )
+                aDefault = FontControlModel::getPropertyDefaultByHandle( _nHandle );
+            else
+                aDefault = OControlModel::getPropertyDefaultByHandle( _nHandle );
+        }
+
+        return aDefault;
+    }
+
+
+    void ORichTextModel::impl_smlock_setEngineText( const OUString& _rText )
+    {
+        if (m_pEngine)
+        {
+            SolarMutexGuard aSolarGuard;
+            m_bSettingEngineText = true;
+            m_pEngine->SetText( _rText );
+            m_bSettingEngineText = false;
+        }
+    }
+
+
+    OUString SAL_CALL ORichTextModel::getServiceName()
+    {
+        return FRM_SUN_COMPONENT_RICHTEXTCONTROL;
+    }
+
+
+    RichTextEngine* ORichTextModel::getEditEngine( const Reference< XControlModel >& _rxModel )
+    {
+        RichTextEngine* pEngine = nullptr;
+
+        Reference< XUnoTunnel > xTunnel( _rxModel, UNO_QUERY );
+        OSL_ENSURE( xTunnel.is(), "ORichTextModel::getEditEngine: invalid model!" );
+        if ( xTunnel.is() )
+        {
+            try
+            {
+                pEngine = reinterpret_cast< RichTextEngine* >( xTunnel->getSomething( getEditEngineTunnelId() ) );
+            }
+            catch( const Exception& )
+            {
+                TOOLS_WARN_EXCEPTION( "forms.richtext", "ORichTextModel::getEditEngine" );
+            }
+        }
+        return pEngine;
+    }
+
+
+    Sequence< sal_Int8 > ORichTextModel::getEditEngineTunnelId()
+    {
+        static cppu::OImplementationId aId;
+        return aId.getImplementationId();
+    }
+
+
+    IMPL_LINK_NOARG( ORichTextModel, OnEngineContentModified, LinkParamNone*, void )
+    {
+        if ( !m_bSettingEngineText )
+        {
+            m_aModifyListeners.notifyEach( &XModifyListener::modified, EventObject( *this ) );
+
+            potentialTextChange();
+                // is this a good idea? It may become expensive in case of larger texts,
+                // and this method here is called for every single changed character ...
+                // On the other hand, the API *requires* us to notify changes in the "Text"
+                // property immediately ...
+        }
+    }
+
+
+    sal_Int64 SAL_CALL ORichTextModel::getSomething( const Sequence< sal_Int8 >& _rId )
+    {
+        Sequence< sal_Int8 > aEditEngineAccessId( getEditEngineTunnelId() );
+        if  (   ( _rId.getLength() == aEditEngineAccessId.getLength() )
+            &&  ( 0 == memcmp( aEditEngineAccessId.getConstArray(),  _rId.getConstArray(), _rId.getLength() ) )
+            )
+            return reinterpret_cast< sal_Int64 >( m_pEngine.get() );
+
+        Reference< XUnoTunnel > xAggTunnel;
+        if ( query_aggregation( m_xAggregate, xAggTunnel ) )
+            return xAggTunnel->getSomething( _rId );
+
+        return 0;
+    }
+
+
+    void SAL_CALL ORichTextModel::addModifyListener( const Reference< XModifyListener >& _rxListener )
+    {
+        m_aModifyListeners.addInterface( _rxListener );
+    }
+
+
+    void SAL_CALL ORichTextModel::removeModifyListener( const Reference< XModifyListener >& _rxListener )
+    {
+        m_aModifyListeners.removeInterface( _rxListener );
+    }
+
+
+    void ORichTextModel::potentialTextChange( )
+    {
+        OUString sCurrentEngineText;
+        if (m_pEngine)
+            sCurrentEngineText = m_pEngine->GetText();
+
+        if ( sCurrentEngineText != m_sLastKnownEngineText )
+        {
+            sal_Int32 nHandle = PROPERTY_ID_TEXT;
+            Any aOldValue; aOldValue <<= m_sLastKnownEngineText;
+            Any aNewValue; aNewValue <<= sCurrentEngineText;
+            fire( &nHandle, &aNewValue, &aOldValue, 1, false );
+
+            m_sLastKnownEngineText = sCurrentEngineText;
+        }
+    }
+
+
+} // namespace frm
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_comp_forms_ORichTextModel_get_implementation(css::uno::XComponentContext* context,
+                                                          css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new frm::ORichTextModel(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */