diff options
Diffstat (limited to 'forms/source/richtext')
28 files changed, 5431 insertions, 0 deletions
diff --git a/forms/source/richtext/attributedispatcher.cxx b/forms/source/richtext/attributedispatcher.cxx new file mode 100644 index 000000000..29dbbf616 --- /dev/null +++ b/forms/source/richtext/attributedispatcher.cxx @@ -0,0 +1,115 @@ +/* -*- 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 "attributedispatcher.hxx" + +#include <editeng/editview.hxx> +#include <sal/log.hxx> +#include <osl/diagnose.h> + + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::beans; + + OAttributeDispatcher::OAttributeDispatcher( EditView& _rView, AttributeId _nAttributeId, const URL& _rURL, + IMultiAttributeDispatcher* _pMasterDispatcher ) + :ORichTextFeatureDispatcher( _rView, _rURL ) + ,m_pMasterDispatcher( _pMasterDispatcher ) + ,m_nAttributeId( _nAttributeId ) + { + OSL_ENSURE( m_pMasterDispatcher, "OAttributeDispatcher::OAttributeDispatcher: invalid master dispatcher!" ); + } + + + OAttributeDispatcher::~OAttributeDispatcher( ) + { + acquire(); + dispose(); + } + + + void OAttributeDispatcher::disposing( ::osl::ClearableMutexGuard& _rClearBeforeNotify ) + { + m_pMasterDispatcher = nullptr; + ORichTextFeatureDispatcher::disposing( _rClearBeforeNotify ); + } + + + void OAttributeDispatcher::fillFeatureEventFromAttributeState( FeatureStateEvent& _rEvent, const AttributeState& _rState ) const + { + if ( _rState.eSimpleState == eChecked ) + _rEvent.State <<= true; + else if ( _rState.eSimpleState == eUnchecked ) + _rEvent.State <<= false; + } + + + FeatureStateEvent OAttributeDispatcher::buildStatusEvent() const + { + FeatureStateEvent aEvent( ORichTextFeatureDispatcher::buildStatusEvent() ); + aEvent.IsEnabled = getEditView() && !getEditView()->IsReadOnly(); + + AttributeState aState; + if ( m_pMasterDispatcher ) + aState = m_pMasterDispatcher->getState( m_nAttributeId ); + + fillFeatureEventFromAttributeState( aEvent, aState ); + + return aEvent; + } + + + void SAL_CALL OAttributeDispatcher::dispatch( const URL& _rURL, const Sequence< PropertyValue >& _rArguments ) + { + ::osl::MutexGuard aGuard( m_aMutex ); + + checkDisposed(); + + OSL_ENSURE( _rURL.Complete == getFeatureURL().Complete, "OAttributeDispatcher::dispatch: invalid URL!" ); + SAL_WARN_IF( _rArguments.hasElements(), "forms.richtext", + "OAttributeDispatcher::dispatch: found arguments, but can't handle arguments at all" + " (URL: " << _rURL.Complete << ")"); + + if ( m_pMasterDispatcher ) + m_pMasterDispatcher->executeAttribute( m_nAttributeId, nullptr ); + } + + + void OAttributeDispatcher::onAttributeStateChanged( AttributeId _nAttributeId ) + { + OSL_ENSURE( _nAttributeId == m_nAttributeId, "OAttributeDispatcher::onAttributeStateChanged: wrong attribute!" ); + + FeatureStateEvent aEvent( buildStatusEvent() ); + ::comphelper::OInterfaceIteratorHelper3 aIter( getStatusListeners() ); + while ( aIter.hasMoreElements() ) + doNotify( aIter.next(), aEvent ); + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/attributedispatcher.hxx b/forms/source/richtext/attributedispatcher.hxx new file mode 100644 index 000000000..9c6769b60 --- /dev/null +++ b/forms/source/richtext/attributedispatcher.hxx @@ -0,0 +1,79 @@ +/* -*- 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 . + */ +#pragma once + +#include "featuredispatcher.hxx" +#include "rtattributes.hxx" +#include "textattributelistener.hxx" + + +namespace frm +{ + + class OAttributeDispatcher :public ORichTextFeatureDispatcher + ,public ITextAttributeListener + { + protected: + IMultiAttributeDispatcher* m_pMasterDispatcher; + AttributeId m_nAttributeId; + + public: + /** ctor + @param _nAttributeId + the id of the attribute which this instance is responsible for + @param _rURL + the URL of the feature which this instance is responsible for + @param _pMasterDispatcher + the dispatcher which can execute the given attribute + @param _pConverter + an instance which is able to convert between SfxPoolItems and XDispatch-Parameters + If not <NULL/>, the parametrized version of IMultiAttributeDispatcher::executeAttribute + will be used. + */ + OAttributeDispatcher( + EditView& _rView, + AttributeId _nAttributeId, + const css::util::URL& _rURL, + IMultiAttributeDispatcher* _pMasterDispatcher + ); + + protected: + virtual ~OAttributeDispatcher( ) override; + + // XDispatch + virtual void SAL_CALL dispatch( const css::util::URL& URL, const css::uno::Sequence< css::beans::PropertyValue >& Arguments ) override; + + // ITextAttributeListener + virtual void onAttributeStateChanged( AttributeId _nAttributeId ) override; + + // ORichTextFeatureDispatcher + virtual void disposing( ::osl::ClearableMutexGuard& _rClearBeforeNotify ) override; + + // ORichTextFeatureDispatcher + virtual css::frame::FeatureStateEvent buildStatusEvent() const override; + + // own overridables + virtual void fillFeatureEventFromAttributeState( css::frame::FeatureStateEvent& _rEvent, const AttributeState& _rState ) const; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/clipboarddispatcher.cxx b/forms/source/richtext/clipboarddispatcher.cxx new file mode 100644 index 000000000..70313edb3 --- /dev/null +++ b/forms/source/richtext/clipboarddispatcher.cxx @@ -0,0 +1,191 @@ +/* -*- 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 "clipboarddispatcher.hxx" +#include <editeng/editview.hxx> + +#include <com/sun/star/lang/DisposedException.hpp> +#include <svtools/cliplistener.hxx> +#include <vcl/transfer.hxx> +#include <osl/diagnose.h> + + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::beans; + + + namespace + { + URL createClipboardURL( OClipboardDispatcher::ClipboardFunc _eFunc ) + { + URL aURL; + switch ( _eFunc ) + { + case OClipboardDispatcher::eCut: + aURL.Complete = ".uno:Cut"; + break; + case OClipboardDispatcher::eCopy: + aURL.Complete = ".uno:Copy"; + break; + case OClipboardDispatcher::ePaste: + aURL.Complete = ".uno:Paste"; + break; + } + return aURL; + } + } + + OClipboardDispatcher::OClipboardDispatcher( EditView& _rView, ClipboardFunc _eFunc ) + :ORichTextFeatureDispatcher( _rView, createClipboardURL( _eFunc ) ) + ,m_eFunc( _eFunc ) + ,m_bLastKnownEnabled( true ) + { + } + + + bool OClipboardDispatcher::implIsEnabled( ) const + { + bool bEnabled = false; + switch ( m_eFunc ) + { + case eCut: + bEnabled = !getEditView()->IsReadOnly() && getEditView()->HasSelection(); + break; + + case eCopy: + bEnabled = getEditView()->HasSelection(); + break; + + case ePaste: + bEnabled = !getEditView()->IsReadOnly(); + break; + } + return bEnabled; + } + + + FeatureStateEvent OClipboardDispatcher::buildStatusEvent() const + { + FeatureStateEvent aEvent( ORichTextFeatureDispatcher::buildStatusEvent() ); + aEvent.IsEnabled = implIsEnabled(); + return aEvent; + } + + + void OClipboardDispatcher::invalidateFeatureState_Broadcast() + { + bool bEnabled = implIsEnabled(); + if ( m_bLastKnownEnabled == bEnabled ) + // nothing changed -> no notification + return; + m_bLastKnownEnabled = bEnabled; + + ORichTextFeatureDispatcher::invalidateFeatureState_Broadcast(); + } + + + void SAL_CALL OClipboardDispatcher::dispatch( const URL& /*_rURL*/, const Sequence< PropertyValue >& /*Arguments*/ ) + { + ::osl::MutexGuard aGuard( m_aMutex ); + if ( !getEditView() ) + throw DisposedException(); + + switch ( m_eFunc ) + { + case eCut: + getEditView()->Cut(); + break; + + case eCopy: + getEditView()->Copy(); + break; + + case ePaste: + getEditView()->Paste(); + break; + } + } + + OPasteClipboardDispatcher::OPasteClipboardDispatcher( EditView& _rView ) + :OClipboardDispatcher( _rView, ePaste ) + ,m_bPastePossible( false ) + { + m_pClipListener = new TransferableClipboardListener( LINK( this, OPasteClipboardDispatcher, OnClipboardChanged ) ); + m_pClipListener->AddListener( _rView.GetWindow() ); + + // initial state + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( _rView.GetWindow() ) ); + m_bPastePossible = ( aDataHelper.HasFormat( SotClipboardFormatId::STRING ) || + aDataHelper.HasFormat( SotClipboardFormatId::RTF ) || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) ); + } + + + OPasteClipboardDispatcher::~OPasteClipboardDispatcher() + { + if ( !isDisposed() ) + { + acquire(); + dispose(); + } + } + + + IMPL_LINK( OPasteClipboardDispatcher, OnClipboardChanged, TransferableDataHelper*, _pDataHelper, void ) + { + OSL_ENSURE( _pDataHelper, "OPasteClipboardDispatcher::OnClipboardChanged: ooops!" ); + m_bPastePossible = _pDataHelper->HasFormat( SotClipboardFormatId::STRING ) + || _pDataHelper->HasFormat( SotClipboardFormatId::RTF ) + || _pDataHelper->HasFormat( SotClipboardFormatId::RICHTEXT ); + + invalidate(); + } + + + void OPasteClipboardDispatcher::disposing( ::osl::ClearableMutexGuard& _rClearBeforeNotify ) + { + OSL_ENSURE( getEditView() && getEditView()->GetWindow(), "OPasteClipboardDispatcher::disposing: EditView should not (yet) be disfunctional here!" ); + if (m_pClipListener.is()) + { + if (getEditView() && getEditView()->GetWindow()) + m_pClipListener->RemoveListener( getEditView()->GetWindow() ); + + m_pClipListener.clear(); + } + + OClipboardDispatcher::disposing( _rClearBeforeNotify ); + } + + + bool OPasteClipboardDispatcher::implIsEnabled( ) const + { + return m_bPastePossible && OClipboardDispatcher::implIsEnabled(); + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/clipboarddispatcher.hxx b/forms/source/richtext/clipboarddispatcher.hxx new file mode 100644 index 000000000..47e561c67 --- /dev/null +++ b/forms/source/richtext/clipboarddispatcher.hxx @@ -0,0 +1,91 @@ +/* -*- 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 . + */ + +#pragma once + +#include "featuredispatcher.hxx" +#include <tools/link.hxx> +#include <rtl/ref.hxx> + +class TransferableClipboardListener; +class TransferableDataHelper; + +namespace frm +{ + + class OClipboardDispatcher : public ORichTextFeatureDispatcher + { + public: + enum ClipboardFunc + { + eCut, + eCopy, + ePaste + }; + + private: + ClipboardFunc m_eFunc; + bool m_bLastKnownEnabled; + + public: + OClipboardDispatcher( EditView& _rView, ClipboardFunc _eFunc ); + + protected: + // XDispatch + virtual void SAL_CALL dispatch( const css::util::URL& URL, const css::uno::Sequence< css::beans::PropertyValue >& Arguments ) override; + + // ORichTextFeatureDispatcher + virtual void invalidateFeatureState_Broadcast() override; + virtual css::frame::FeatureStateEvent + buildStatusEvent() const override; + + protected: + /** determines whether our functionality is currently available + to be overridden for ePaste + */ + virtual bool implIsEnabled( ) const; + }; + + class OPasteClipboardDispatcher : public OClipboardDispatcher + { + private: + rtl::Reference<TransferableClipboardListener> m_pClipListener; + bool m_bPastePossible; + + public: + explicit OPasteClipboardDispatcher( EditView& _rView ); + + protected: + virtual ~OPasteClipboardDispatcher() override; + + // OClipboardDispatcher + virtual bool implIsEnabled( ) const override; + + // ORichTextFeatureDispatcher + virtual void disposing( ::osl::ClearableMutexGuard& _rClearBeforeNotify ) override; + + private: + DECL_LINK( OnClipboardChanged, TransferableDataHelper*, void ); + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/featuredispatcher.cxx b/forms/source/richtext/featuredispatcher.cxx new file mode 100644 index 000000000..93f163d43 --- /dev/null +++ b/forms/source/richtext/featuredispatcher.cxx @@ -0,0 +1,138 @@ +/* -*- 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 "featuredispatcher.hxx" +#include <osl/diagnose.h> +#include <tools/diagnose_ex.h> + + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::util; + + ORichTextFeatureDispatcher::ORichTextFeatureDispatcher( EditView& _rView, const URL& _rURL ) + :m_aFeatureURL( _rURL ) + ,m_aStatusListeners( m_aMutex ) + ,m_pEditView( &_rView ) + ,m_bDisposed( false ) + { + } + + + ORichTextFeatureDispatcher::~ORichTextFeatureDispatcher( ) + { + if ( !m_bDisposed ) + { + acquire(); + dispose(); + } + } + + + void ORichTextFeatureDispatcher::dispose() + { + EventObject aEvent( *this ); + m_aStatusListeners.disposeAndClear( aEvent ); + + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + m_bDisposed = true; + disposing( aGuard ); + } + + + void ORichTextFeatureDispatcher::disposing( ::osl::ClearableMutexGuard& /*_rClearBeforeNotify*/ ) + { + m_pEditView = nullptr; + } + + + void SAL_CALL ORichTextFeatureDispatcher::addStatusListener( const Reference< XStatusListener >& _rxControl, const URL& _rURL ) + { + OSL_ENSURE( !m_bDisposed, "ORichTextFeatureDispatcher::addStatusListener: already disposed!" ); + if ( m_bDisposed ) + throw DisposedException(); + + OSL_ENSURE( _rURL.Complete == getFeatureURL().Complete, "ORichTextFeatureDispatcher::addStatusListener: invalid URL!" ); + if ( _rURL.Complete == getFeatureURL().Complete ) + if ( _rxControl.is() ) + { + m_aStatusListeners.addInterface( _rxControl ); + doNotify( _rxControl, buildStatusEvent() ); + } + } + + + void SAL_CALL ORichTextFeatureDispatcher::removeStatusListener( const Reference< XStatusListener >& _rxControl, const URL& /*_rURL*/ ) + { + m_aStatusListeners.removeInterface( _rxControl ); + } + + + void ORichTextFeatureDispatcher::invalidate() + { + invalidateFeatureState_Broadcast(); + } + + + FeatureStateEvent ORichTextFeatureDispatcher::buildStatusEvent() const + { + FeatureStateEvent aEvent; + aEvent.IsEnabled = false; + aEvent.Source = *const_cast< ORichTextFeatureDispatcher* >( this ); + aEvent.FeatureURL = getFeatureURL(); + aEvent.Requery = false; + return aEvent; + } + + + void ORichTextFeatureDispatcher::invalidateFeatureState_Broadcast() + { + FeatureStateEvent aEvent( buildStatusEvent() ); + ::comphelper::OInterfaceIteratorHelper3 aIter( getStatusListeners() ); + while ( aIter.hasMoreElements() ) + doNotify( aIter.next(), aEvent ); + } + + + void ORichTextFeatureDispatcher::doNotify( const Reference< XStatusListener >& _rxListener, const FeatureStateEvent& _rEvent ) + { + OSL_PRECOND( _rxListener.is(), "ORichTextFeatureDispatcher::doNotify: invalid listener!" ); + if ( _rxListener.is() ) + { + try + { + _rxListener->statusChanged( _rEvent ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "forms.richtext", "ORichTextFeatureDispatcher::doNotify" ); + } + } + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/featuredispatcher.hxx b/forms/source/richtext/featuredispatcher.hxx new file mode 100644 index 000000000..53be887a4 --- /dev/null +++ b/forms/source/richtext/featuredispatcher.hxx @@ -0,0 +1,89 @@ +/* -*- 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 . + */ + +#pragma once + +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <comphelper/interfacecontainer3.hxx> +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/basemutex.hxx> + +class EditView; + +namespace frm +{ + + typedef ::cppu::WeakImplHelper < css::frame::XDispatch + > ORichTextFeatureDispatcher_Base; + + class ORichTextFeatureDispatcher :public ::cppu::BaseMutex + ,public ORichTextFeatureDispatcher_Base + { + private: + css::util::URL m_aFeatureURL; + ::comphelper::OInterfaceContainerHelper3<css::frame::XStatusListener> m_aStatusListeners; + EditView* m_pEditView; + bool m_bDisposed; + + protected: + EditView* getEditView() { return m_pEditView; } + const EditView* getEditView() const { return m_pEditView; } + + protected: + const css::util::URL& getFeatureURL() const { return m_aFeatureURL; } + ::comphelper::OInterfaceContainerHelper3<css::frame::XStatusListener>& getStatusListeners() { return m_aStatusListeners; } + bool isDisposed() const { return m_bDisposed; } + void checkDisposed() const { if ( isDisposed() ) throw css::lang::DisposedException(); } + + protected: + ORichTextFeatureDispatcher( EditView& _rView, const css::util::URL& _rURL ); + virtual ~ORichTextFeatureDispatcher( ) override; + + public: + /// clean up resources associated with this instance + void dispose(); + + // invalidate the feature, re-retrieve it's state, and broadcast changes, if necessary + void invalidate(); + + protected: + // overridables + virtual void disposing( ::osl::ClearableMutexGuard& _rClearBeforeNotify ); + virtual void invalidateFeatureState_Broadcast(); + + // to be overridden, and filled with the info special do your derived class + virtual css::frame::FeatureStateEvent + buildStatusEvent() const; + + static void doNotify( + const css::uno::Reference< css::frame::XStatusListener >& _rxListener, + const css::frame::FeatureStateEvent& _rEvent + ); + + // XDispatch + virtual void SAL_CALL addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& _rxControl, const css::util::URL& _rURL ) override; + virtual void SAL_CALL removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& _rxControl, const css::util::URL& _rURL ) override; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/parametrizedattributedispatcher.cxx b/forms/source/richtext/parametrizedattributedispatcher.cxx new file mode 100644 index 000000000..d6666e2b0 --- /dev/null +++ b/forms/source/richtext/parametrizedattributedispatcher.cxx @@ -0,0 +1,129 @@ +/* -*- 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 "parametrizedattributedispatcher.hxx" +#include <editeng/editids.hrc> +#include <editeng/editview.hxx> +#include <svl/itemset.hxx> +#include <svl/itempool.hxx> +#include <osl/diagnose.h> + +#include <sfx2/sfxuno.hxx> +#include <com/sun/star/uno/Sequence.hxx> +#include <com/sun/star/beans/PropertyValue.hpp> + + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::beans; + + OParametrizedAttributeDispatcher::OParametrizedAttributeDispatcher( EditView& _rView, AttributeId _nAttributeId, const URL& _rURL, IMultiAttributeDispatcher* _pMasterDispatcher ) + :OAttributeDispatcher( _rView, _nAttributeId, _rURL, _pMasterDispatcher ) + { + } + + + OParametrizedAttributeDispatcher::~OParametrizedAttributeDispatcher() + { + acquire(); + dispose(); + } + + + namespace + { + SfxSlotId lcl_normalizeLatinScriptSlotId( SfxSlotId _nSlotId ) + { + switch ( _nSlotId ) + { + case SID_ATTR_CHAR_LATIN_FONT: return SID_ATTR_CHAR_FONT; + case SID_ATTR_CHAR_LATIN_LANGUAGE: return SID_ATTR_CHAR_LANGUAGE; + case SID_ATTR_CHAR_LATIN_POSTURE: return SID_ATTR_CHAR_POSTURE; + case SID_ATTR_CHAR_LATIN_WEIGHT: return SID_ATTR_CHAR_WEIGHT; + case SID_ATTR_CHAR_LATIN_FONTHEIGHT:return SID_ATTR_CHAR_FONTHEIGHT; + } + return _nSlotId; + } + } + + + void OParametrizedAttributeDispatcher::fillFeatureEventFromAttributeState( FeatureStateEvent& _rEvent, const AttributeState& _rState ) const + { + OSL_ENSURE( getEditView(), "OParametrizedAttributeDispatcher::notifyState: already disposed!" ); + if ( !getEditView() ) + return; + + SfxItemSet aEmptySet(getEditView()->GetEmptyItemSet()); + Sequence< PropertyValue > aUnoStateDescription; + if ( _rState.getItem() ) + { + aEmptySet.Put( *_rState.getItem() ); + SfxSlotId nSlotId = aEmptySet.GetPool()->GetSlotId( _rState.getItem()->Which() ); + TransformItems( nSlotId, aEmptySet, aUnoStateDescription ); + _rEvent.State <<= aUnoStateDescription; + } + else + OAttributeDispatcher::fillFeatureEventFromAttributeState( _rEvent, _rState ); + } + + + const SfxPoolItem* OParametrizedAttributeDispatcher::convertDispatchArgsToItem( const Sequence< PropertyValue >& _rArguments ) + { + // get the real slot id. This may differ from our attribute id: for instance, both + // SID_ATTR_CHAR_HEIGHT and SID_ATTR_CHAR_LATIN_HEIGHT are mapped to the same which id + SfxSlotId nSlotId = lcl_normalizeLatinScriptSlotId( static_cast<SfxSlotId>(m_nAttributeId) ); + + SfxAllItemSet aParameterSet( getEditView()->GetEmptyItemSet() ); + TransformParameters( nSlotId, _rArguments, aParameterSet ); + + const SfxPoolItem* pArgument = nullptr; + if ( aParameterSet.Count() ) + { + OSL_ENSURE( aParameterSet.Count() == 1, "OParametrizedAttributeDispatcher::convertDispatchArgsToItem: Arguments which form more than 1 item? How this?" ); + WhichId nAttributeWhich = aParameterSet.GetPool()->GetWhich( nSlotId ); + pArgument = aParameterSet.GetItem( nAttributeWhich ); + OSL_ENSURE( pArgument, "OParametrizedAttributeDispatcher::convertDispatchArgsToItem: suspicious: there were arguments, but they're not for my slot!" ); + } + + return pArgument; + } + + + void SAL_CALL OParametrizedAttributeDispatcher::dispatch( const URL& _rURL, const Sequence< PropertyValue >& _rArguments ) + { + ::osl::MutexGuard aGuard( m_aMutex ); + OSL_ENSURE( _rURL.Complete == getFeatureURL().Complete, "OParametrizedAttributeDispatcher::dispatch: invalid URL!" ); + if ( m_pMasterDispatcher ) + { + const SfxPoolItem* pConvertedArgument = convertDispatchArgsToItem( _rArguments ); + m_pMasterDispatcher->executeAttribute( m_nAttributeId, pConvertedArgument ); + } + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/parametrizedattributedispatcher.hxx b/forms/source/richtext/parametrizedattributedispatcher.hxx new file mode 100644 index 000000000..698447316 --- /dev/null +++ b/forms/source/richtext/parametrizedattributedispatcher.hxx @@ -0,0 +1,61 @@ +/* -*- 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 . + */ + +#pragma once + +#include "attributedispatcher.hxx" + +class SfxPoolItem; + +namespace frm +{ + + class OParametrizedAttributeDispatcher :public OAttributeDispatcher + { + public: + OParametrizedAttributeDispatcher( + EditView& _rView, + AttributeId _nAttributeId, + const css::util::URL& _rURL, + IMultiAttributeDispatcher* _pMasterDispatcher + ); + + protected: + virtual ~OParametrizedAttributeDispatcher() override; + + // XDispatch + virtual void SAL_CALL dispatch( const css::util::URL& URL, const css::uno::Sequence< css::beans::PropertyValue >& Arguments ) override; + + // OAttributeDispatcher + virtual void fillFeatureEventFromAttributeState( css::frame::FeatureStateEvent& _rEvent, const AttributeState& _rState ) const override; + + protected: + // own overridables + /** convert the arguments as got in a XDispatch::dispatch call into an SfxPoolItem, which can + be used with a IMultiAttributeDispatcher::executeAttribute + */ + virtual const SfxPoolItem* convertDispatchArgsToItem( + const css::uno::Sequence< css::beans::PropertyValue >& _rArguments ); + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextcontrol.cxx b/forms/source/richtext/richtextcontrol.cxx new file mode 100644 index 000000000..408199dac --- /dev/null +++ b/forms/source/richtext/richtextcontrol.cxx @@ -0,0 +1,652 @@ +/* -*- 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 "richtextcontrol.hxx" +#include <frm_strings.hxx> +#include <services.hxx> + +#include "richtextmodel.hxx" +#include "richtextvclcontrol.hxx" +#include "clipboarddispatcher.hxx" +#include "parametrizedattributedispatcher.hxx" +#include "specialdispatchers.hxx" + +#include <com/sun/star/awt/PosSize.hpp> + +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <sal/log.hxx> +#include <vcl/svapp.hxx> + +#include <svx/svxids.hrc> +#include <editeng/editview.hxx> +#include <svl/itemset.hxx> +#include <svl/itempool.hxx> +#include <sfx2/msgpool.hxx> +#include <sfx2/msg.hxx> + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::awt; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::frame; + + ORichTextControl::ORichTextControl() + { + } + + + ORichTextControl::~ORichTextControl() + { + } + + + IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextControl, UnoEditControl, ORichTextControl_Base ) + + + Any SAL_CALL ORichTextControl::queryAggregation( const Type& _rType ) + { + Any aReturn = UnoEditControl::queryAggregation( _rType ); + + if ( !aReturn.hasValue() ) + aReturn = ORichTextControl_Base::queryInterface( _rType ); + + return aReturn; + } + + + namespace + { + + void implAdjustTriStateFlag( const Reference< XPropertySet >& _rxProps, const OUString& _rPropertyName, + WinBits& _rAllBits, WinBits _nPositiveFlag, WinBits nNegativeFlag ) + { + bool bFlagValue = false; + if ( _rxProps->getPropertyValue( _rPropertyName ) >>= bFlagValue ) + _rAllBits |= ( bFlagValue ? _nPositiveFlag : nNegativeFlag ); + } + + + void implAdjustTwoStateFlag( const Any& _rValue, WinBits& _rAllBits, WinBits _nFlag, bool _bInvert ) + { + bool bFlagValue = false; + if ( _rValue >>= bFlagValue ) + { + if ( _bInvert ) + bFlagValue = !bFlagValue; + if ( bFlagValue ) + _rAllBits |= _nFlag; + else + _rAllBits &= ~_nFlag; + } + } + + + void implAdjustTwoStateFlag( const Reference< XPropertySet >& _rxProps, const OUString& _rPropertyName, + WinBits& _rAllBits, WinBits _nFlag, bool _bInvert = false ) + { + implAdjustTwoStateFlag( _rxProps->getPropertyValue( _rPropertyName ), _rAllBits, _nFlag, _bInvert ); + } + + + void adjustTwoStateWinBit( vcl::Window* _pWindow, const Any& _rValue, WinBits _nFlag, bool _bInvert = false ) + { + WinBits nBits = _pWindow->GetStyle(); + implAdjustTwoStateFlag( _rValue, nBits, _nFlag, _bInvert ); + _pWindow->SetStyle( nBits ); + } + + + WinBits getWinBits( const Reference< XControlModel >& _rxModel ) + { + WinBits nBits = 0; + try + { + Reference< XPropertySet > xProps( _rxModel, UNO_QUERY ); + if ( xProps.is() ) + { + sal_Int16 nBorder = 0; + xProps->getPropertyValue( PROPERTY_BORDER ) >>= nBorder; + if ( nBorder ) + nBits |= WB_BORDER; + + implAdjustTriStateFlag( xProps, PROPERTY_TABSTOP, nBits, WB_TABSTOP, WB_NOTABSTOP ); + implAdjustTwoStateFlag( xProps, PROPERTY_HSCROLL, nBits, WB_HSCROLL ); + implAdjustTwoStateFlag( xProps, PROPERTY_VSCROLL, nBits, WB_VSCROLL ); + implAdjustTwoStateFlag( xProps, PROPERTY_HARDLINEBREAKS, nBits, WB_WORDBREAK, true ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.richtext"); + } + return nBits; + } + } + + + void SAL_CALL ORichTextControl::createPeer( const Reference< XToolkit >& _rToolkit, const Reference< XWindowPeer >& _rParentPeer ) + { + bool bReallyActAsRichText = false; + try + { + Reference< XPropertySet > xModelProps( getModel(), UNO_QUERY_THROW ); + xModelProps->getPropertyValue( PROPERTY_RICH_TEXT ) >>= bReallyActAsRichText; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.richtext"); + } + + if ( !bReallyActAsRichText ) + { + UnoEditControl::createPeer( _rToolkit, _rParentPeer ); + return; + } + + SolarMutexGuard aGuard; + + if (getPeer().is()) + return; + + mbCreatingPeer = true; + + // determine the VCL window for the parent + vcl::Window* pParentWin = nullptr; + if ( _rParentPeer.is() ) + { + VCLXWindow* pParentXWin = comphelper::getFromUnoTunnel<VCLXWindow>( _rParentPeer ); + if ( pParentXWin ) + pParentWin = pParentXWin->GetWindow(); + DBG_ASSERT( pParentWin, "ORichTextControl::createPeer: could not obtain the VCL-level parent window!" ); + } + + // create the peer + Reference< XControlModel > xModel( getModel() ); + rtl::Reference<ORichTextPeer> pPeer = ORichTextPeer::Create( xModel, pParentWin, getWinBits( xModel ) ); + DBG_ASSERT( pPeer, "ORichTextControl::createPeer: invalid peer returned!" ); + if ( pPeer ) + { + // announce the peer to the base class + setPeer( pPeer ); + + // initialize ourself (and thus the peer) with the model properties + updateFromModel(); + + Reference< XView > xPeerView( getPeer(), UNO_QUERY ); + if ( xPeerView.is() ) + { + xPeerView->setZoom( maComponentInfos.nZoomX, maComponentInfos.nZoomY ); + xPeerView->setGraphics( mxGraphics ); + } + + // a lot of initial settings from our component infos + setPosSize( maComponentInfos.nX, maComponentInfos.nY, maComponentInfos.nWidth, maComponentInfos.nHeight, PosSize::POSSIZE ); + + pPeer->setVisible ( maComponentInfos.bVisible && !mbDesignMode ); + pPeer->setEnable ( maComponentInfos.bEnable ); + pPeer->setDesignMode( mbDesignMode ); + + peerCreated(); + } + + mbCreatingPeer = false; + } + + OUString SAL_CALL ORichTextControl::getImplementationName() + { + return "com.sun.star.comp.form.ORichTextControl"; + } + + Sequence< OUString > SAL_CALL ORichTextControl::getSupportedServiceNames() + { + return { "com.sun.star.awt.UnoControl", + "com.sun.star.awt.UnoControlEdit", + FRM_SUN_CONTROL_RICHTEXTCONTROL }; + } + + Reference< XDispatch > SAL_CALL ORichTextControl::queryDispatch( const css::util::URL& _rURL, const OUString& _rTargetFrameName, sal_Int32 _nSearchFlags ) + { + Reference< XDispatch > aReturn; + Reference< XDispatchProvider > xTypedPeer( getPeer(), UNO_QUERY ); + if ( xTypedPeer.is() ) + { + aReturn = xTypedPeer->queryDispatch( _rURL, _rTargetFrameName, _nSearchFlags ); + } + return aReturn; + } + + Sequence< Reference< XDispatch > > SAL_CALL ORichTextControl::queryDispatches( const Sequence< DispatchDescriptor >& _rRequests ) + { + Reference<XDispatchProvider> xTypedPeer(getPeer(), UNO_QUERY); + if (xTypedPeer.is()) + return xTypedPeer->queryDispatches(_rRequests); + return Sequence<Reference<XDispatch>>(); + } + + bool ORichTextControl::requiresNewPeer( const OUString& _rPropertyName ) const + { + return UnoControl::requiresNewPeer( _rPropertyName ) || _rPropertyName == PROPERTY_RICH_TEXT; + } + + // ORichTextPeer + rtl::Reference<ORichTextPeer> ORichTextPeer::Create( const Reference< XControlModel >& _rxModel, vcl::Window* _pParentWindow, WinBits _nStyle ) + { + DBG_TESTSOLARMUTEX(); + + // the EditEngine of the model + RichTextEngine* pEngine = ORichTextModel::getEditEngine( _rxModel ); + OSL_ENSURE( pEngine, "ORichTextPeer::Create: could not obtaine the edit engine from the model!" ); + if ( !pEngine ) + return nullptr; + + // the peer itself + rtl::Reference<ORichTextPeer> pPeer(new ORichTextPeer); + + // the VCL control for the peer + VclPtrInstance<RichTextControl> pRichTextControl( pEngine, _pParentWindow, _nStyle, nullptr, pPeer.get() ); + + // some knittings + pRichTextControl->SetComponentInterface( pPeer ); + + // outta here + return pPeer; + } + + + ORichTextPeer::ORichTextPeer() + { + } + + + ORichTextPeer::~ORichTextPeer() + { + } + + + void ORichTextPeer::dispose( ) + { + { + SolarMutexGuard aGuard; + VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >(); + + if ( pRichTextControl ) + { + for (auto const& dispatcher : m_aDispatchers) + { + pRichTextControl->disableAttributeNotification(dispatcher.first); + dispatcher.second->dispose(); + } + } + + AttributeDispatchers().swap(m_aDispatchers); + } + + VCLXWindow::dispose(); + } + + + void SAL_CALL ORichTextPeer::draw( sal_Int32 _nX, sal_Int32 _nY ) + { + SolarMutexGuard aGuard; + + VclPtr< RichTextControl > pControl = GetAs< RichTextControl >(); + if ( !pControl ) + return; + + OutputDevice* pTargetDevice = VCLUnoHelper::GetOutputDevice( getGraphics() ); + OSL_ENSURE( pTargetDevice != nullptr, "ORichTextPeer::draw: no graphics -> no drawing!" ); + if ( !pTargetDevice ) + return; + + const MapUnit eTargetUnit = pTargetDevice->GetMapMode().GetMapUnit(); + ::Point aPos( _nX, _nY ); + // the XView::draw API talks about pixels, always ... + if ( eTargetUnit != MapUnit::MapPixel ) + aPos = pTargetDevice->PixelToLogic( aPos ); + + pControl->Draw( pTargetDevice, aPos, SystemTextColorFlags::NoControls ); + } + + + void SAL_CALL ORichTextPeer::setProperty( const OUString& _rPropertyName, const Any& _rValue ) + { + SolarMutexGuard g; + + if ( !GetWindow() ) + { + VCLXWindow::setProperty( _rPropertyName, _rValue ); + return; + } + + if ( _rPropertyName == PROPERTY_BACKGROUNDCOLOR ) + { + VclPtr< RichTextControl > pControl = GetAs< RichTextControl >(); + if ( !_rValue.hasValue() ) + { + pControl->SetBackgroundColor( ); + } + else + { + Color nColor = COL_TRANSPARENT; + _rValue >>= nColor; + pControl->SetBackgroundColor( nColor ); + } + } + else if ( _rPropertyName == PROPERTY_HSCROLL ) + { + adjustTwoStateWinBit( GetWindow(), _rValue, WB_HSCROLL ); + } + else if ( _rPropertyName == PROPERTY_VSCROLL ) + { + adjustTwoStateWinBit( GetWindow(), _rValue, WB_VSCROLL ); + } + else if ( _rPropertyName == PROPERTY_HARDLINEBREAKS ) + { + adjustTwoStateWinBit( GetWindow(), _rValue, WB_WORDBREAK, true ); + } + else if ( _rPropertyName == PROPERTY_READONLY ) + { + VclPtr< RichTextControl > pControl = GetAs< RichTextControl >(); + bool bReadOnly( pControl->IsReadOnly() ); + OSL_VERIFY( _rValue >>= bReadOnly ); + pControl->SetReadOnly( bReadOnly ); + + // update the dispatchers + for (auto const& dispatcher : m_aDispatchers) + { + dispatcher.second->invalidate(); + } + } + else if ( _rPropertyName == PROPERTY_HIDEINACTIVESELECTION ) + { + VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >(); + bool bHide = pRichTextControl->GetHideInactiveSelection(); + OSL_VERIFY( _rValue >>= bHide ); + pRichTextControl->SetHideInactiveSelection( bHide ); + } + else + VCLXWindow::setProperty( _rPropertyName, _rValue ); + } + + + IMPLEMENT_FORWARD_XINTERFACE2( ORichTextPeer, VCLXWindow, ORichTextPeer_Base ) + + + IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextPeer, VCLXWindow, ORichTextPeer_Base ) + + + namespace + { + SfxSlotId lcl_translateConflictingSlot( SfxSlotId _nIDFromPool ) + { + // HACK HACK HACK + // unfortunately, some of our applications have some conflicting slots, + // i.e. slots which have the same UNO name as an existing other (common) + // slot. + // For instance, both the slots SID_SET_SUPER_SCRIPT (from SVX) and FN_SET_SUPER_SCRIPT + // (from SW) have the UNO name "SuperScript". + // Now, if the controls lives in a text document, and asks the SfxSlotPool for + // the id belonging to "SuperScript", it gets the FN_SET_SUPER_SCRIPT - which + // is completely unknown to the EditEngine. + // So, we need to translate such conflicting ids. + + // Note that the real solution would be to fix the applications to + // *not* define conflicting slots. Alternatively, if SFX would provide a slot pool + // which is *static* (i.e. independent on the active application), then we + // would also never encounter such a conflict. + SfxSlotId nReturn( _nIDFromPool ); + switch ( _nIDFromPool ) + { + case 20411: /* FM_SET_SUPER_SCRIPT, originating in SW */ + nReturn = SID_SET_SUPER_SCRIPT; + break; + case 20412: /* FN_SET_SUB_SCRIPT, originating in SW */ + nReturn = SID_SET_SUB_SCRIPT; + break; + } + return nReturn; + } + } + + + ORichTextPeer::SingleAttributeDispatcher ORichTextPeer::implCreateDispatcher( SfxSlotId _nSlotId, const css::util::URL& _rURL ) + { + VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >(); + OSL_PRECOND( pRichTextControl, "ORichTextPeer::implCreateDispatcher: invalid window!" ); + if ( !pRichTextControl ) + return SingleAttributeDispatcher( nullptr ); + + rtl::Reference<ORichTextFeatureDispatcher> pDispatcher; + rtl::Reference<OAttributeDispatcher> pAttributeDispatcher; + switch ( _nSlotId ) + { + case SID_CUT: + pDispatcher = new OClipboardDispatcher( pRichTextControl->getView(), OClipboardDispatcher::eCut ); + break; + + case SID_COPY: + pDispatcher = new OClipboardDispatcher( pRichTextControl->getView(), OClipboardDispatcher::eCopy ); + break; + + case SID_PASTE: + pDispatcher = new OPasteClipboardDispatcher( pRichTextControl->getView() ); + break; + + case SID_SELECTALL: + pDispatcher = new OSelectAllDispatcher( pRichTextControl->getView(), _rURL ); + break; + + case SID_ATTR_PARA_LEFT_TO_RIGHT: + case SID_ATTR_PARA_RIGHT_TO_LEFT: + pAttributeDispatcher = new OParagraphDirectionDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); + break; + + case SID_TEXTDIRECTION_TOP_TO_BOTTOM: + case SID_TEXTDIRECTION_LEFT_TO_RIGHT: + pDispatcher = new OTextDirectionDispatcher( pRichTextControl->getView(), _rURL ); + break; + + case SID_ATTR_PARA_HANGPUNCTUATION: + case SID_ATTR_PARA_FORBIDDEN_RULES: + case SID_ATTR_PARA_SCRIPTSPACE: + pAttributeDispatcher = new OAsianFontLayoutDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); + break; + + default: + { + const SfxItemPool& rPool = *pRichTextControl->getView().GetEmptyItemSet().GetPool(); + bool bSupportedSlot = rPool.IsInRange( rPool.GetWhich( _nSlotId ) ); + + if ( !bSupportedSlot ) + bSupportedSlot = RichTextControl::isMappableSlot( _nSlotId ); + + if ( bSupportedSlot ) + { // it's really a slot which is supported by the EditEngine + + bool bNeedParametrizedDispatcher = true; + if ( ( _nSlotId == SID_ATTR_CHAR_POSTURE ) + || ( _nSlotId == SID_ATTR_CHAR_CJK_POSTURE ) + || ( _nSlotId == SID_ATTR_CHAR_CTL_POSTURE ) + || ( _nSlotId == SID_ATTR_CHAR_LATIN_POSTURE ) + || ( _nSlotId == SID_ATTR_CHAR_WEIGHT ) + || ( _nSlotId == SID_ATTR_CHAR_CJK_WEIGHT ) + || ( _nSlotId == SID_ATTR_CHAR_CTL_WEIGHT ) + || ( _nSlotId == SID_ATTR_CHAR_LATIN_WEIGHT ) + || ( _nSlotId == SID_ATTR_CHAR_LANGUAGE ) + || ( _nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE ) + || ( _nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE ) + || ( _nSlotId == SID_ATTR_CHAR_LATIN_LANGUAGE ) + || ( _nSlotId == SID_ATTR_CHAR_CONTOUR ) + || ( _nSlotId == SID_ATTR_CHAR_SHADOWED ) + || ( _nSlotId == SID_ATTR_CHAR_WORDLINEMODE ) + || ( _nSlotId == SID_ATTR_CHAR_COLOR ) + || ( _nSlotId == SID_ATTR_CHAR_RELIEF ) + || ( _nSlotId == SID_ATTR_CHAR_KERNING ) + || ( _nSlotId == SID_ATTR_CHAR_AUTOKERN ) + || ( _nSlotId == SID_ATTR_CHAR_SCALEWIDTH ) + ) + { + bNeedParametrizedDispatcher = true; + } + else + { + SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool(); + const SfxSlot* pSlot = rSlotPool.GetSlot( _nSlotId ); + const SfxType* pType = pSlot ? pSlot->GetType() : nullptr; + if ( pType ) + { + bNeedParametrizedDispatcher = ( pType->nAttribs > 0 ); + } + } + + if ( bNeedParametrizedDispatcher ) + { + pAttributeDispatcher = new OParametrizedAttributeDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); + } + else + { + pAttributeDispatcher = new OAttributeDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); + } + } + else + { + SAL_WARN("forms.richtext", "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " + << _rURL.Complete); + } + } + break; + } + + SingleAttributeDispatcher xDispatcher( pDispatcher ); + if ( pAttributeDispatcher ) + { + xDispatcher = SingleAttributeDispatcher( pAttributeDispatcher ); + pRichTextControl->enableAttributeNotification( _nSlotId, pAttributeDispatcher.get() ); + } + + return xDispatcher; + } + + + namespace + { + SfxSlotId lcl_getSlotFromUnoName( SfxSlotPool const & _rSlotPool, const OUString& _rUnoSlotName ) + { + const SfxSlot* pSlot = _rSlotPool.GetUnoSlot( _rUnoSlotName ); + if ( pSlot ) + { + // okay, there's a slot with the given UNO name + return lcl_translateConflictingSlot( pSlot->GetSlotId() ); + } + + // 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 + if ( _rUnoSlotName == "AllowHangingPunctuation" ) + return SID_ATTR_PARA_HANGPUNCTUATION; + if ( _rUnoSlotName == "ApplyForbiddenCharacterRules" ) + return SID_ATTR_PARA_FORBIDDEN_RULES; + if ( _rUnoSlotName == "UseScriptSpacing" ) + return SID_ATTR_PARA_SCRIPTSPACE; + + OSL_ENSURE( pSlot, "lcl_getSlotFromUnoName: unknown UNO slot name!" ); + return 0; + } + } + + + Reference< XDispatch > SAL_CALL ORichTextPeer::queryDispatch( const css::util::URL& _rURL, const OUString& /*_rTargetFrameName*/, sal_Int32 /*_nSearchFlags*/ ) + { + Reference< XDispatch > xReturn; + if ( !GetWindow() ) + { + OSL_FAIL( "ORichTextPeer::queryDispatch: already disposed?" ); + return xReturn; + } + + // is it a UNO slot? + static constexpr std::u16string_view sUnoProtocolPrefix( u".uno:" ); + if ( _rURL.Complete.startsWith( sUnoProtocolPrefix ) ) + { + OUString sUnoSlotName = _rURL.Complete.copy( sUnoProtocolPrefix.size() ); + SfxSlotId nSlotId = lcl_getSlotFromUnoName( SfxSlotPool::GetSlotPool(), sUnoSlotName ); + if ( nSlotId > 0 ) + { + // do we already have a dispatcher for this? + AttributeDispatchers::const_iterator aDispatcherPos = m_aDispatchers.find( nSlotId ); + if ( aDispatcherPos == m_aDispatchers.end() ) + { + SingleAttributeDispatcher pDispatcher = implCreateDispatcher( nSlotId, _rURL ); + if ( pDispatcher.is() ) + { + aDispatcherPos = m_aDispatchers.emplace( nSlotId, pDispatcher ).first; + } + } + + if ( aDispatcherPos != m_aDispatchers.end() ) + xReturn = aDispatcherPos->second.get(); + } + } + + return xReturn; + } + + + Sequence< Reference< XDispatch > > SAL_CALL ORichTextPeer::queryDispatches( const Sequence< DispatchDescriptor >& _rRequests ) + { + Sequence< Reference< XDispatch > > aReturn( _rRequests.getLength() ); + Reference< XDispatch >* pReturn = aReturn.getArray(); + + const DispatchDescriptor* pRequest = _rRequests.getConstArray(); + const DispatchDescriptor* pRequestEnd = pRequest + _rRequests.getLength(); + for ( ; pRequest != pRequestEnd; ++pRequest, ++pReturn ) + { + *pReturn = queryDispatch( pRequest->FeatureURL, pRequest->FrameName, pRequest->SearchFlags ); + } + return aReturn; + } + + + void ORichTextPeer::onSelectionChanged() + { + AttributeDispatchers::iterator aDispatcherPos = m_aDispatchers.find( SID_COPY ); + if ( aDispatcherPos != m_aDispatchers.end() ) + aDispatcherPos->second->invalidate(); + + aDispatcherPos = m_aDispatchers.find( SID_CUT ); + if ( aDispatcherPos != m_aDispatchers.end() ) + aDispatcherPos->second->invalidate(); + } + + +} // namespace frm + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +com_sun_star_comp_form_ORichTextControl_get_implementation(css::uno::XComponentContext*, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new frm::ORichTextControl()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextcontrol.hxx b/forms/source/richtext/richtextcontrol.hxx new file mode 100644 index 000000000..9cda83bb5 --- /dev/null +++ b/forms/source/richtext/richtextcontrol.hxx @@ -0,0 +1,128 @@ +/* -*- 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 . + */ + +#pragma once + +#include <toolkit/controls/unocontrols.hxx> +#include <toolkit/awt/vclxwindow.hxx> + +#include <com/sun/star/frame/XDispatchProvider.hpp> +#include <comphelper/uno3.hxx> +#include <cppuhelper/implbase1.hxx> +#include <rtl/ref.hxx> +#include <tools/wintypes.hxx> +#include "rtattributes.hxx" +#include "textattributelistener.hxx" + +#include <map> + + +namespace frm +{ + + class ORichTextFeatureDispatcher; + + typedef ::cppu::ImplHelper1 < css::frame::XDispatchProvider + > ORichTextControl_Base; + class ORichTextControl :public UnoEditControl + ,public ORichTextControl_Base + { + public: + ORichTextControl(); + + protected: + virtual ~ORichTextControl() override; + + // UNO + DECLARE_UNO3_AGG_DEFAULTS( ORichTextControl, UnoEditControl ) + virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override; + + // XControl + virtual void SAL_CALL createPeer( const css::uno::Reference< css::awt::XToolkit >& _rToolkit, const css::uno::Reference< css::awt::XWindowPeer >& _rParent ) override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + // XTypeProvider + DECLARE_XTYPEPROVIDER() + + // XDispatchProvider + virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL queryDispatch( const css::util::URL& _rURL, const OUString& _rTargetFrameName, sal_Int32 _rSearchFlags ) override; + virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& Requests ) override; + + // UnoControl + virtual bool requiresNewPeer( const OUString& _rPropertyName ) const override; + }; + + typedef ::cppu::ImplHelper1 < css::frame::XDispatchProvider + > ORichTextPeer_Base; + class ORichTextPeer final :public VCLXWindow + ,public ORichTextPeer_Base + ,public ITextSelectionListener + { + private: + typedef rtl::Reference<ORichTextFeatureDispatcher> SingleAttributeDispatcher; + typedef ::std::map< SfxSlotId, SingleAttributeDispatcher > AttributeDispatchers; + AttributeDispatchers m_aDispatchers; + + public: + /** factory method + */ + static rtl::Reference<ORichTextPeer> Create( + const css::uno::Reference< css::awt::XControlModel >& _rxModel, + vcl::Window* _pParentWindow, + WinBits _nStyle + ); + + // XInterface + DECLARE_XINTERFACE( ) + + private: + ORichTextPeer(); + virtual ~ORichTextPeer() override; + + // XView + void SAL_CALL draw( sal_Int32 nX, sal_Int32 nY ) override; + + // XVclWindowPeer + virtual void SAL_CALL setProperty( const OUString& _rPropertyName, const css::uno::Any& _rValue ) override; + + // XTypeProvider + DECLARE_XTYPEPROVIDER( ) + + // XComponent + virtual void SAL_CALL dispose( ) override; + + // XDispatchProvider + virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL queryDispatch( const css::util::URL& _rURL, const OUString& _rTargetFrameName, sal_Int32 _rSearchFlags ) override; + virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& Requests ) override; + + // ITextSelectionListener + virtual void onSelectionChanged() override; + + private: + SingleAttributeDispatcher implCreateDispatcher( SfxSlotId _nSlotId, const css::util::URL& _rURL ); + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextengine.cxx b/forms/source/richtext/richtextengine.cxx new file mode 100644 index 000000000..14f50a6fc --- /dev/null +++ b/forms/source/richtext/richtextengine.cxx @@ -0,0 +1,138 @@ +/* -*- 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 "richtextengine.hxx" +#include <svl/itempool.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/editobj.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/langitem.hxx> +#include <vcl/svapp.hxx> +#include <tools/mapunit.hxx> +#include <vcl/mapmod.hxx> +#include <vcl/outdev.hxx> +#include <vcl/settings.hxx> +#include <unotools/lingucfg.hxx> +#include <osl/diagnose.h> + +#include <algorithm> +#include <memory> + +namespace frm +{ + //= RichTextEngine + + + RichTextEngine* RichTextEngine::Create() + { + SolarMutexGuard g; + + rtl::Reference<SfxItemPool> pPool = EditEngine::CreatePool(); + pPool->FreezeIdRanges(); + + RichTextEngine* pReturn = new RichTextEngine( pPool.get() ); + OutputDevice* pOutputDevice = pReturn->GetRefDevice(); + const MapMode& aDeviceMapMode( pOutputDevice->GetMapMode() ); + + pReturn->SetStatusEventHdl( LINK( pReturn, RichTextEngine, EditEngineStatusChanged ) ); + + pPool->SetDefaultMetric(aDeviceMapMode.GetMapUnit()); + + // defaults + vcl::Font aFont = Application::GetSettings().GetStyleSettings().GetAppFont(); + aFont.SetFamilyName( "Times New Roman" ); + pPool->SetPoolDefaultItem( SvxFontItem( aFont.GetFamilyType(), aFont.GetFamilyName(), OUString(), aFont.GetPitch(), aFont.GetCharSet(), EE_CHAR_FONTINFO ) ); + + // 12 pt font size + MapMode aPointMapMode( MapUnit::MapPoint ); + Size a12PointSize( OutputDevice::LogicToLogic( Size( 12, 0 ), aPointMapMode, aDeviceMapMode ) ); + pPool->SetPoolDefaultItem( SvxFontHeightItem( a12PointSize.Width(), 100, EE_CHAR_FONTHEIGHT ) ); + + // font languages + SvtLinguOptions aLinguOpt; + pPool->SetPoolDefaultItem( SvxLanguageItem( aLinguOpt.nDefaultLanguage, EE_CHAR_LANGUAGE ) ); + pPool->SetPoolDefaultItem( SvxLanguageItem( aLinguOpt.nDefaultLanguage_CJK, EE_CHAR_LANGUAGE_CJK ) ); + pPool->SetPoolDefaultItem( SvxLanguageItem( aLinguOpt.nDefaultLanguage_CTL, EE_CHAR_LANGUAGE_CTL ) ); + + return pReturn; + } + + + RichTextEngine* RichTextEngine::Clone() + { + RichTextEngine* pClone( nullptr ); + { + SolarMutexGuard aGuard; + std::unique_ptr<EditTextObject> pMyText(CreateTextObject()); + OSL_ENSURE( pMyText, "RichTextEngine::Clone: CreateTextObject returned nonsense!" ); + + pClone = Create(); + + if ( pMyText ) + pClone->SetText( *pMyText ); + } + + return pClone; + } + + + RichTextEngine::RichTextEngine( SfxItemPool* _pPool ) + :EditEngine( _pPool ) + { + } + + + RichTextEngine::~RichTextEngine( ) + { + } + + + void RichTextEngine::registerEngineStatusListener( IEngineStatusListener* _pListener ) + { + OSL_ENSURE( _pListener, "RichTextEngine::registerEngineStatusListener: invalid listener!" ); + if ( _pListener ) + m_aStatusListeners.push_back( _pListener ); + } + + + void RichTextEngine::revokeEngineStatusListener( IEngineStatusListener const * _pListener ) + { + ::std::vector< IEngineStatusListener* >::iterator aPos = ::std::find( + m_aStatusListeners.begin(), + m_aStatusListeners.end(), + _pListener + ); + OSL_ENSURE( aPos != m_aStatusListeners.end(), "RichTextEngine::revokeEngineStatusListener: listener not registered!" ); + if ( aPos != m_aStatusListeners.end() ) + m_aStatusListeners.erase( aPos ); + } + + + IMPL_LINK( RichTextEngine, EditEngineStatusChanged, EditStatus&, _rStatus, void ) + { + for (auto const& statusListener : m_aStatusListeners) + statusListener->EditEngineStatusChanged( _rStatus ); + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextengine.hxx b/forms/source/richtext/richtextengine.hxx new file mode 100644 index 000000000..c9413e6bd --- /dev/null +++ b/forms/source/richtext/richtextengine.hxx @@ -0,0 +1,71 @@ +/* -*- 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 . + */ +#pragma once + +#include <editeng/editeng.hxx> +#include <tools/link.hxx> + +#include <vector> + +class SfxItemPool; +class EditStatus; + +namespace frm +{ + + class IEngineStatusListener + { + public: + virtual void EditEngineStatusChanged( const EditStatus& _rStatus ) = 0; + + protected: + ~IEngineStatusListener() {} + }; + + class RichTextEngine final : public EditEngine + { + private: + ::std::vector< IEngineStatusListener* > m_aStatusListeners; + + public: + static RichTextEngine* Create(); + RichTextEngine* Clone(); + + virtual ~RichTextEngine( ) override; + + // for multiplexing the StatusChanged events of the edit engine + void registerEngineStatusListener( IEngineStatusListener* _pListener ); + void revokeEngineStatusListener( IEngineStatusListener const * _pListener ); + + private: + /** constructs a new RichTextEngine. The instances takes the ownership of the given SfxItemPool + */ + explicit RichTextEngine( SfxItemPool* _pPool ); + + RichTextEngine( const RichTextEngine& ) = delete; + RichTextEngine& operator=( const RichTextEngine& ) = delete; + + DECL_LINK( EditEngineStatusChanged, EditStatus&, void ); + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextimplcontrol.cxx b/forms/source/richtext/richtextimplcontrol.cxx new file mode 100644 index 000000000..c51a3a877 --- /dev/null +++ b/forms/source/richtext/richtextimplcontrol.cxx @@ -0,0 +1,654 @@ +/* -*- 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 "richtextimplcontrol.hxx" +#include "textattributelistener.hxx" +#include "richtextengine.hxx" +#include <sal/log.hxx> +#include <osl/diagnose.h> +#include <i18nlangtag/languagetag.hxx> +#include <editeng/editids.hrc> +#include <editeng/editview.hxx> +#include <editeng/editstat.hxx> +#include <editeng/scripttypeitem.hxx> + +#include <svl/itempool.hxx> +#include <svl/itemset.hxx> +#include <tools/mapunit.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <vcl/commandevent.hxx> + +#define EMPTY_PAPER_SIZE 0x7FFFFFFF + + +namespace frm +{ + + RichTextControlImpl::RichTextControlImpl( Control* _pAntiImpl, RichTextEngine* _pEngine, ITextAttributeListener* _pTextAttrListener, ITextSelectionListener* _pSelectionListener ) + :m_pAntiImpl ( _pAntiImpl ) + ,m_pViewport ( nullptr ) + ,m_pHScroll ( nullptr ) + ,m_pVScroll ( nullptr ) + ,m_pScrollCorner ( nullptr ) + ,m_pEngine ( _pEngine ) + ,m_pTextAttrListener ( _pTextAttrListener ) + ,m_pSelectionListener ( _pSelectionListener ) + ,m_bHasEverBeenShown ( false ) + { + OSL_ENSURE( m_pAntiImpl, "RichTextControlImpl::RichTextControlImpl: invalid window!" ); + OSL_ENSURE( m_pEngine, "RichTextControlImpl::RichTextControlImpl: invalid edit engine! This will *definitely* crash!" ); + + m_pViewport = VclPtr<RichTextViewPort>::Create( m_pAntiImpl ); + m_pViewport->setAttributeInvalidationHandler( LINK( this, RichTextControlImpl, OnInvalidateAllAttributes ) ); + m_pViewport->Show(); + + // ensure that both the window and the reference device have the same map unit + MapMode aRefDeviceMapMode( m_pEngine->GetRefDevice()->GetMapMode() ); + m_pAntiImpl->SetMapMode( aRefDeviceMapMode ); + m_pViewport->SetMapMode( aRefDeviceMapMode ); + + m_pView.reset(new EditView( m_pEngine, m_pViewport )); + m_pEngine->InsertView( m_pView.get() ); + m_pViewport->setView( *m_pView ); + + m_pEngine->registerEngineStatusListener( this ); + + { + EVControlBits nViewControlWord = m_pView->GetControlWord(); + nViewControlWord |= EVControlBits::AUTOSCROLL; + m_pView->SetControlWord( nViewControlWord ); + } + + // ensure that it's initially scrolled to the upper left + m_pView->SetVisArea( tools::Rectangle( Point( ), m_pViewport->GetOutDev()->GetOutputSize() ) ); + + ensureScrollbars(); + + m_pAntiImpl->SetBackground( Wallpaper( m_pAntiImpl->GetSettings().GetStyleSettings().GetFieldColor() ) ); + } + + + RichTextControlImpl::~RichTextControlImpl( ) + { + m_pEngine->RemoveView( m_pView.get() ); + m_pEngine->revokeEngineStatusListener( this ); + m_pView.reset(); + m_pViewport.disposeAndClear(); + m_pHScroll.disposeAndClear(); + m_pVScroll.disposeAndClear(); + m_pScrollCorner.disposeAndClear(); + } + + + void RichTextControlImpl::implUpdateAttribute( const AttributeHandlerPool::const_iterator& _pHandler ) + { + if ( ( _pHandler->first == sal_uInt16(SID_ATTR_CHAR_WEIGHT) ) + || ( _pHandler->first == sal_uInt16(SID_ATTR_CHAR_POSTURE) ) + || ( _pHandler->first == sal_uInt16(SID_ATTR_CHAR_FONT) ) + || ( _pHandler->first == sal_uInt16(SID_ATTR_CHAR_FONTHEIGHT) ) + ) + { + // these are attributes whose value depends on the current script type. + // I.e., in real, there are *three* items in the ItemSet: One for each script + // type (Latin, Asian, Complex). However, if we have an observer who is interested + // in the state of this attribute, we have to kind of *merge* the three attributes + // to only one. + // This is useful in case the observer is for instance a toolbox which contains only + // an, e.g., "bold" slot, and thus not interested in the particular script type of the + // current selection. + SvxScriptSetItem aNormalizedSet( static_cast<WhichId>(_pHandler->first), *m_pView->GetAttribs().GetPool() ); + normalizeScriptDependentAttribute( aNormalizedSet ); + + implCheckUpdateCache( _pHandler->first, _pHandler->second->getState( aNormalizedSet.GetItemSet() ) ); + } + else + implCheckUpdateCache( _pHandler->first, _pHandler->second->getState( m_pView->GetAttribs() ) ); + } + + + void RichTextControlImpl::updateAttribute( AttributeId _nAttribute ) + { + AttributeHandlerPool::const_iterator pHandler = m_aAttributeHandlers.find( _nAttribute ); + if ( pHandler != m_aAttributeHandlers.end() ) + implUpdateAttribute( pHandler ); + } + + + void RichTextControlImpl::updateAllAttributes( ) + { + for ( AttributeHandlerPool::const_iterator pHandler = m_aAttributeHandlers.begin(); + pHandler != m_aAttributeHandlers.end(); + ++pHandler + ) + { + implUpdateAttribute( pHandler ); + } + + // notify changes of the selection, if necessary + if ( m_pSelectionListener && m_pView ) + { + ESelection aCurrentSelection = m_pView->GetSelection(); + if ( aCurrentSelection != m_aLastKnownSelection ) + { + m_aLastKnownSelection = aCurrentSelection; + m_pSelectionListener->onSelectionChanged(); + } + } + } + + + AttributeState RichTextControlImpl::getAttributeState( AttributeId _nAttributeId ) const + { + StateCache::const_iterator aCachedStatePos = m_aLastKnownStates.find( _nAttributeId ); + if ( aCachedStatePos == m_aLastKnownStates.end() ) + { + OSL_FAIL( "RichTextControlImpl::getAttributeState: Don't ask for the state of an attribute which I never encountered!" ); + return AttributeState( eIndetermined ); + } + return aCachedStatePos->second; + } + + + bool RichTextControlImpl::executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rAttribs, AttributeId _nAttribute, const SfxPoolItem* _pArgument, SvtScriptType _nForScriptType ) + { + // let's see whether we have a handler for this attribute + AttributeHandlerPool::const_iterator aHandlerPos = m_aAttributeHandlers.find( _nAttribute ); + if ( aHandlerPos != m_aAttributeHandlers.end() ) + { + aHandlerPos->second->executeAttribute( _rCurrentAttribs, _rAttribs, _pArgument, _nForScriptType ); + return true; + } + return false; + } + + + void RichTextControlImpl::enableAttributeNotification( AttributeId _nAttributeId, ITextAttributeListener* _pListener ) + { + AttributeHandlerPool::const_iterator aHandlerPos = m_aAttributeHandlers.find( _nAttributeId ); + if ( aHandlerPos == m_aAttributeHandlers.end() ) + { + ::rtl::Reference< AttributeHandler > aHandler = AttributeHandlerFactory::getHandlerFor( _nAttributeId, *m_pEngine->GetEmptyItemSet().GetPool() ); + OSL_ENSURE( aHandler.is(), "RichTextControlImpl::enableAttributeNotification: no handler available for this attribute!" ); + if ( !aHandler.is() ) + return; + SAL_WARN_IF( _nAttributeId != aHandler->getAttributeId(), "forms.richtext", "RichTextControlImpl::enableAttributeNotification: suspicious handler!" ); + + aHandlerPos = m_aAttributeHandlers.emplace( _nAttributeId , aHandler ).first; + } + + // remember the listener + if ( _pListener ) + m_aAttributeListeners.emplace( _nAttributeId, _pListener ); + + // update (and broadcast) the state of this attribute + updateAttribute( _nAttributeId ); + } + + + void RichTextControlImpl::disableAttributeNotification( AttributeId _nAttributeId ) + { + // forget the handler for this attribute + AttributeHandlerPool::iterator aHandlerPos = m_aAttributeHandlers.find( _nAttributeId ); + if ( aHandlerPos != m_aAttributeHandlers.end() ) + m_aAttributeHandlers.erase( aHandlerPos ); + + // as well as the listener + AttributeListenerPool::iterator aListenerPos = m_aAttributeListeners.find( _nAttributeId ); + if ( aListenerPos != m_aAttributeListeners.end() ) + m_aAttributeListeners.erase( aListenerPos ); + } + + + void RichTextControlImpl::normalizeScriptDependentAttribute( SvxScriptSetItem& _rScriptSetItem ) + { + _rScriptSetItem.GetItemSet().Put( m_pView->GetAttribs(), false ); + const SfxPoolItem* pNormalizedItem = _rScriptSetItem.GetItemOfScript( getSelectedScriptType() ); + + WhichId nNormalizedWhichId = _rScriptSetItem.GetItemSet().GetPool()->GetWhich( _rScriptSetItem.Which() ); + if ( pNormalizedItem ) + { + _rScriptSetItem.GetItemSet().Put( pNormalizedItem->CloneSetWhich(nNormalizedWhichId) ); + } + else + _rScriptSetItem.GetItemSet().InvalidateItem( nNormalizedWhichId ); + } + + + void RichTextControlImpl::implCheckUpdateCache( AttributeId _nAttribute, const AttributeState& _rState ) + { + StateCache::iterator aCachePos = m_aLastKnownStates.find( _nAttribute ); + if ( aCachePos == m_aLastKnownStates.end() ) + { // nothing known about this attribute, yet + m_aLastKnownStates.emplace( _nAttribute, _rState ); + } + else + { + if ( aCachePos->second == _rState ) + { + // nothing to do + return; + } + aCachePos->second = _rState; + } + + // is there a dedicated listener for this particular attribute? + AttributeListenerPool::const_iterator aListenerPos = m_aAttributeListeners.find( _nAttribute ); + if ( aListenerPos != m_aAttributeListeners.end( ) ) + aListenerPos->second->onAttributeStateChanged( _nAttribute ); + + // call our global listener, if there is one + if ( m_pTextAttrListener ) + m_pTextAttrListener->onAttributeStateChanged( _nAttribute ); + } + + + SvtScriptType RichTextControlImpl::getSelectedScriptType() const + { + SvtScriptType nScript = m_pView->GetSelectedScriptType(); + if ( nScript == SvtScriptType::NONE ) + nScript = SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() ); + return nScript; + } + + + void RichTextControlImpl::EditEngineStatusChanged( const EditStatus& _rStatus ) + { + EditStatusFlags nStatusWord( _rStatus.GetStatusWord() ); + if ( ( nStatusWord & EditStatusFlags::TEXTWIDTHCHANGED ) + || ( nStatusWord & EditStatusFlags::TextHeightChanged ) + ) + { + if ( ( nStatusWord & EditStatusFlags::TextHeightChanged ) && windowHasAutomaticLineBreak() ) + m_pEngine->SetPaperSize( Size( m_pEngine->GetPaperSize().Width(), m_pEngine->GetTextHeight() ) ); + + updateScrollbars(); + } + + bool bHScroll = bool( nStatusWord & EditStatusFlags::HSCROLL ); + bool bVScroll = bool( nStatusWord & EditStatusFlags::VSCROLL ); + + // In case of *no* automatic line breaks, we also need to check for the *range* here. + // Normally, we would do this only after an EditStatusFlags::TEXTWIDTHCHANGED. However, due to a bug + // in the EditEngine (I believe so) this is not fired when the engine does not have + // the AutoPaperSize bits set. + // So in order to be properly notified, we would need the AutoPaperSize. But, with + // AutoPaperSize, other things do not work anymore: Either, when we set a MaxAutoPaperSize, + // then the view does automatic soft line breaks at the paper end - which we definitely do + // want. Or, if we did not set a MaxAutoPaperSize, then the view does not automatically scroll + // anymore in horizontal direction. + // So this is some kind of lose-lose situation ... :( + if ( !windowHasAutomaticLineBreak() && bHScroll ) + { + updateScrollbars(); + return; + } + + if ( bHScroll && m_pHScroll ) + m_pHScroll->SetThumbPos( m_pView->GetVisArea().Left() ); + if ( bVScroll && m_pVScroll ) + m_pVScroll->SetThumbPos( m_pView->GetVisArea().Top() ); + } + + + IMPL_LINK_NOARG( RichTextControlImpl, OnInvalidateAllAttributes, LinkParamNone*, void ) + { + updateAllAttributes(); + } + + + IMPL_LINK( RichTextControlImpl, OnHScroll, ScrollBar*, _pScrollbar, void ) + { + m_pView->Scroll( -_pScrollbar->GetDelta(), 0, ScrollRangeCheck::PaperWidthTextSize ); + } + + + IMPL_LINK( RichTextControlImpl, OnVScroll, ScrollBar*, _pScrollbar, void ) + { + m_pView->Scroll( 0, -_pScrollbar->GetDelta(), ScrollRangeCheck::PaperWidthTextSize ); + } + + + void RichTextControlImpl::ensureScrollbars() + { + bool bNeedVScroll = 0 != ( m_pAntiImpl->GetStyle() & WB_VSCROLL ); + bool bNeedHScroll = 0 != ( m_pAntiImpl->GetStyle() & WB_HSCROLL ); + + if ( ( bNeedVScroll == hasVScrollBar() ) && ( bNeedHScroll == hasHScrollBar( ) ) ) + // nothing to do + return; + + // create or delete the scrollbars, as necessary + if ( !bNeedVScroll ) + { + m_pVScroll.disposeAndClear(); + } + else + { + m_pVScroll = VclPtr<ScrollBar>::Create( m_pAntiImpl, WB_VSCROLL | WB_DRAG | WB_REPEAT ); + m_pVScroll->SetScrollHdl ( LINK( this, RichTextControlImpl, OnVScroll ) ); + m_pVScroll->Show(); + } + + if ( !bNeedHScroll ) + { + m_pHScroll.disposeAndClear(); + } + else + { + m_pHScroll = VclPtr<ScrollBar>::Create( m_pAntiImpl, WB_HSCROLL | WB_DRAG | WB_REPEAT ); + m_pHScroll->SetScrollHdl ( LINK( this, RichTextControlImpl, OnHScroll ) ); + m_pHScroll->Show(); + } + + if ( m_pHScroll && m_pVScroll ) + { + m_pScrollCorner.disposeAndClear(); + m_pScrollCorner = VclPtr<ScrollBarBox>::Create( m_pAntiImpl ); + m_pScrollCorner->Show(); + } + else + { + m_pScrollCorner.disposeAndClear(); + } + + layoutWindow(); + } + + + void RichTextControlImpl::ensureLineBreakSetting() + { + if ( !windowHasAutomaticLineBreak() ) + m_pEngine->SetPaperSize( Size( EMPTY_PAPER_SIZE, EMPTY_PAPER_SIZE ) ); + + layoutWindow(); + } + + + void RichTextControlImpl::layoutWindow() + { + if ( !m_bHasEverBeenShown ) + // no need to do anything. Especially, no need to set the paper size on the + // EditEngine to anything... + return; + + const StyleSettings& rStyleSettings = m_pAntiImpl->GetSettings().GetStyleSettings(); + + tools::Long nScrollBarWidth = m_pVScroll ? rStyleSettings.GetScrollBarSize() : 0; + tools::Long nScrollBarHeight = m_pHScroll ? rStyleSettings.GetScrollBarSize() : 0; + + if ( m_pAntiImpl->IsZoom() ) + { + nScrollBarWidth = m_pAntiImpl->CalcZoom( nScrollBarWidth ); + nScrollBarHeight = m_pAntiImpl->CalcZoom( nScrollBarHeight ); + } + + // the overall size we can use + Size aPlaygroundSizePixel( m_pAntiImpl->GetOutputSizePixel() ); + + // the size of the viewport - note that the viewport does *not* occupy all the place + // which is left when subtracting the scrollbar width/height + Size aViewportPlaygroundPixel( aPlaygroundSizePixel ); + aViewportPlaygroundPixel.setWidth( ::std::max( tools::Long( 10 ), tools::Long( aViewportPlaygroundPixel.Width() - nScrollBarWidth ) ) ); + aViewportPlaygroundPixel.setHeight( ::std::max( tools::Long( 10 ), tools::Long( aViewportPlaygroundPixel.Height() - nScrollBarHeight ) ) ); + Size aViewportPlaygroundLogic( m_pViewport->PixelToLogic( aViewportPlaygroundPixel ) ); + + const tools::Long nOffset = 2; + Size aViewportSizePixel( aViewportPlaygroundPixel.Width() - 2 * nOffset, aViewportPlaygroundPixel.Height() - 2 * nOffset ); + Size aViewportSizeLogic( m_pViewport->PixelToLogic( aViewportSizePixel ) ); + + // position the viewport + m_pViewport->SetPosSizePixel( Point( nOffset, nOffset ), aViewportSizePixel ); + // position the scrollbars + if ( m_pVScroll ) + m_pVScroll->SetPosSizePixel( Point( aViewportPlaygroundPixel.Width(), 0 ), Size( nScrollBarWidth, aViewportPlaygroundPixel.Height() ) ); + if ( m_pHScroll ) + m_pHScroll->SetPosSizePixel( Point( 0, aViewportPlaygroundPixel.Height() ), Size( aViewportPlaygroundPixel.Width(), nScrollBarHeight ) ); + if ( m_pScrollCorner ) + m_pScrollCorner->SetPosSizePixel( Point( aViewportPlaygroundPixel.Width(), aViewportPlaygroundPixel.Height() ), Size( nScrollBarWidth, nScrollBarHeight ) ); + + // paper size + if ( windowHasAutomaticLineBreak() ) + m_pEngine->SetPaperSize( Size( aViewportSizeLogic.Width(), m_pEngine->GetTextHeight() ) ); + + // output area of the view + m_pView->SetOutputArea( tools::Rectangle( Point( ), aViewportSizeLogic ) ); + m_pView->SetVisArea( tools::Rectangle( Point( ), aViewportSizeLogic ) ); + + if ( m_pVScroll ) + { + m_pVScroll->SetVisibleSize( aViewportPlaygroundLogic.Height() ); + + // the default height of a text line... + tools::Long nFontHeight = m_pEngine->GetStandardFont(0).GetFontSize().Height(); + // ... is the scroll size for the vertical scrollbar + m_pVScroll->SetLineSize( nFontHeight ); + // the viewport width, minus one line, is the page scroll size + m_pVScroll->SetPageSize( ::std::max( nFontHeight, aViewportPlaygroundLogic.Height() - nFontHeight ) ); + } + + // the font width + if ( m_pHScroll ) + { + m_pHScroll->SetVisibleSize( aViewportPlaygroundLogic.Width() ); + + tools::Long nFontWidth = m_pEngine->GetStandardFont(0).GetFontSize().Width(); + if ( !nFontWidth ) + { + m_pViewport->GetOutDev()->Push( vcl::PushFlags::FONT ); + m_pViewport->SetFont( m_pEngine->GetStandardFont(0) ); + nFontWidth = m_pViewport->GetTextWidth( "x" ); + m_pViewport->GetOutDev()->Pop(); + } + // ... is the scroll size for the horizontal scrollbar + m_pHScroll->SetLineSize( 5 * nFontWidth ); + // the viewport height, minus one character, is the page scroll size + m_pHScroll->SetPageSize( ::std::max( nFontWidth, aViewportPlaygroundLogic.Width() - nFontWidth ) ); + } + + // update range and position of the scrollbars + updateScrollbars(); + } + + + void RichTextControlImpl::updateScrollbars() + { + if ( m_pVScroll ) + { + tools::Long nOverallTextHeight = m_pEngine->GetTextHeight(); + m_pVScroll->SetRange( Range( 0, nOverallTextHeight ) ); + m_pVScroll->SetThumbPos( m_pView->GetVisArea().Top() ); + } + + if ( m_pHScroll ) + { + Size aPaperSize( m_pEngine->GetPaperSize() ); + tools::Long nOverallTextWidth = ( aPaperSize.Width() == EMPTY_PAPER_SIZE ) ? m_pEngine->CalcTextWidth() : aPaperSize.Width(); + m_pHScroll->SetRange( Range( 0, nOverallTextWidth ) ); + m_pHScroll->SetThumbPos( m_pView->GetVisArea().Left() ); + } + } + + + void RichTextControlImpl::notifyInitShow() + { + if ( !m_bHasEverBeenShown ) + { + m_bHasEverBeenShown = true; + layoutWindow(); + } + } + + + void RichTextControlImpl::notifyStyleChanged() + { + ensureScrollbars(); + ensureLineBreakSetting(); + } + + + void RichTextControlImpl::notifyZoomChanged() + { + const Fraction& rZoom = m_pAntiImpl->GetZoom(); + + MapMode aMapMode( m_pAntiImpl->GetMapMode() ); + aMapMode.SetScaleX( rZoom ); + aMapMode.SetScaleY( rZoom ); + m_pAntiImpl->SetMapMode( aMapMode ); + + m_pViewport->SetZoom( rZoom ); + m_pViewport->SetMapMode( aMapMode ); + + layoutWindow(); + } + + + bool RichTextControlImpl::windowHasAutomaticLineBreak() + { + return ( m_pAntiImpl->GetStyle() & WB_WORDBREAK ) != 0; + } + + + void RichTextControlImpl::SetReadOnly( bool _bReadOnly ) + { + m_pView->SetReadOnly( _bReadOnly ); + } + + + bool RichTextControlImpl::IsReadOnly() const + { + return m_pView->IsReadOnly( ); + } + + + namespace + { + void lcl_inflate( tools::Rectangle& _rRect, tools::Long _nInflateX, tools::Long _nInflateY ) + { + _rRect.AdjustLeft( -_nInflateX ); + _rRect.AdjustRight(_nInflateX ); + _rRect.AdjustTop( -_nInflateY ); + _rRect.AdjustBottom(_nInflateY ); + } + } + + bool RichTextControlImpl::HandleCommand( const CommandEvent& _rEvent ) + { + if ( ( _rEvent.GetCommand() == CommandEventId::Wheel ) + || ( _rEvent.GetCommand() == CommandEventId::StartAutoScroll ) + || ( _rEvent.GetCommand() == CommandEventId::AutoScroll ) + ) + { + m_pAntiImpl->HandleScrollCommand( _rEvent, m_pHScroll, m_pVScroll ); + return true; + } + return false; + } + + + void RichTextControlImpl::Draw( OutputDevice* _pDev, const Point& _rPos, const Size& _rSize ) + { + // need to normalize the map mode of the device - every paint operation on any device needs + // to use the same map mode + _pDev->Push( vcl::PushFlags::MAPMODE | vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR ); + + // enforce our "normalize map mode" on the device + MapMode aRefMapMode( m_pEngine->GetRefDevice()->GetMapMode() ); + MapMode aOriginalMapMode( _pDev->GetMapMode() ); + MapMode aNormalizedMapMode( aRefMapMode.GetMapUnit(), aRefMapMode.GetOrigin(), aOriginalMapMode.GetScaleX(), aOriginalMapMode.GetScaleY() ); + _pDev->SetMapMode( aNormalizedMapMode ); + + // translate coordinates + Point aPos( _rPos ); + Size aSize( _rSize ); + if ( aOriginalMapMode.GetMapUnit() == MapUnit::MapPixel ) + { + aPos = _pDev->PixelToLogic( _rPos, aNormalizedMapMode ); + aSize = _pDev->PixelToLogic( _rSize, aNormalizedMapMode ); + } + else + { + aPos = OutputDevice::LogicToLogic( _rPos, aOriginalMapMode, aNormalizedMapMode ); + aSize = OutputDevice::LogicToLogic( _rSize, aOriginalMapMode, aNormalizedMapMode ); + } + + tools::Rectangle aPlayground( aPos, aSize ); + Size aOnePixel( _pDev->PixelToLogic( Size( 1, 1 ) ) ); + aPlayground.AdjustRight( -(aOnePixel.Width()) ); + aPlayground.AdjustBottom( -(aOnePixel.Height()) ); + + // background + _pDev->SetLineColor(); + _pDev->DrawRect( aPlayground ); + + // do we need to draw a border? + bool bBorder = ( m_pAntiImpl->GetStyle() & WB_BORDER ); + if ( bBorder ) + _pDev->SetLineColor( m_pAntiImpl->GetSettings().GetStyleSettings().GetMonoColor() ); + else + _pDev->SetLineColor(); + _pDev->SetFillColor( m_pAntiImpl->GetBackground().GetColor() ); + _pDev->DrawRect( aPlayground ); + + if ( bBorder ) + // don't draw the text over the border + lcl_inflate( aPlayground, -aOnePixel.Width(), -aOnePixel.Height() ); + + // leave a space of two pixels between the "surroundings" of the control + // and the content + lcl_inflate( aPlayground, -aOnePixel.Width(), -aOnePixel.Height() ); + lcl_inflate( aPlayground, -aOnePixel.Width(), -aOnePixel.Height() ); + + // actually draw the content + m_pEngine->Draw(*_pDev, aPlayground, Point(), true); + + _pDev->Pop(); + } + + + void RichTextControlImpl::SetBackgroundColor( ) + { + SetBackgroundColor( Application::GetSettings().GetStyleSettings().GetFieldColor() ); + } + + + void RichTextControlImpl::SetBackgroundColor( const Color& _rColor ) + { + Wallpaper aWallpaper( _rColor ); + m_pAntiImpl->SetBackground( aWallpaper ); + m_pViewport->SetBackground( aWallpaper ); + } + + + void RichTextControlImpl::SetHideInactiveSelection( bool _bHide ) + { + m_pViewport->SetHideInactiveSelection( _bHide ); + } + + + bool RichTextControlImpl::GetHideInactiveSelection() const + { + return m_pViewport->GetHideInactiveSelection( ); + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextimplcontrol.hxx b/forms/source/richtext/richtextimplcontrol.hxx new file mode 100644 index 000000000..d4fef2f66 --- /dev/null +++ b/forms/source/richtext/richtextimplcontrol.hxx @@ -0,0 +1,184 @@ +/* -*- 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 . + */ +#pragma once + +#include "rtattributehandler.hxx" +#include "richtextviewport.hxx" +#include "richtextengine.hxx" +#include <vcl/scrbar.hxx> +#include <editeng/editdata.hxx> + +#include <map> + +class EditView; +class EditStatus; +namespace vcl { class Window; } +class SvxScriptSetItem; + +namespace frm +{ + + + class ITextAttributeListener; + class ITextSelectionListener; + class RichTextViewPort; + + class RichTextControlImpl : public IEngineStatusListener + { + typedef ::std::map< AttributeId, AttributeState > StateCache; + typedef ::std::map< AttributeId, ::rtl::Reference< AttributeHandler > > AttributeHandlerPool; + typedef ::std::map< AttributeId, ITextAttributeListener* > AttributeListenerPool; + + StateCache m_aLastKnownStates; + AttributeHandlerPool m_aAttributeHandlers; + AttributeListenerPool m_aAttributeListeners; + + ESelection m_aLastKnownSelection; + + VclPtr<Control> m_pAntiImpl; + VclPtr<RichTextViewPort> m_pViewport; + VclPtr<ScrollBar> m_pHScroll; + VclPtr<ScrollBar> m_pVScroll; + VclPtr<ScrollBarBox> m_pScrollCorner; + RichTextEngine* m_pEngine; + std::unique_ptr<EditView> m_pView; + ITextAttributeListener* m_pTextAttrListener; + ITextSelectionListener* m_pSelectionListener; + bool m_bHasEverBeenShown; + + public: + struct GrantAccess { friend class RichTextControl; private: GrantAccess() { } }; + EditView* getView( const GrantAccess& ) const { return m_pView.get(); } + RichTextEngine* getEngine( const GrantAccess& ) const { return m_pEngine; } + vcl::Window* getViewport( const GrantAccess& ) const { return m_pViewport; } + + public: + RichTextControlImpl( Control* _pAntiImpl, RichTextEngine* _pEngine, + ITextAttributeListener* _pTextAttrListener, ITextSelectionListener* _pSelectionListener ); + virtual ~RichTextControlImpl(); + + /** updates the cache with the state of all attribute values from the given set, notifies + the listener if the state changed + */ + void updateAllAttributes( ); + + /** updates the cache with the state of the attribute given by which id, notifies + the listener if the state changed + */ + void updateAttribute( AttributeId _nAttribute ); + + /// enables the callback for a particular attribute + void enableAttributeNotification( AttributeId _nAttributeId, ITextAttributeListener* _pListener ); + + /// disables the change notifications for a particular attribute + void disableAttributeNotification( AttributeId _nAttributeId ); + + /// executes a toggle of the given attribute + bool executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, AttributeId _nAttribute, const SfxPoolItem* _pArgument, SvtScriptType _nForScriptType ); + + /// retrieves the state of the given attribute from the cache + AttributeState getAttributeState( AttributeId _nAttributeId ) const; + + /** normalizes the given item so that the state of script dependent attributes + is correct considering the current script type + + There are some attributes which are script dependent, e.g. the CharPosture. This means + that in real, there are 3 attributes for this, one for every possible script type (latin, + asian, complex). However, to the out world, we behave as if there is only one attribute: + E.g., if the outer world asks for the state of the "CharPosture" attribute, we return + the state of either CharPostureLatin, CharPostureAsian, or CharPostureComplex, depending + on the script type of the current selection. (In real, it may be more complex since + the current selection may contain more than one script type.) + + This method normalizes a script dependent attribute, so that it's state takes into account + the currently selected script type. + */ + void normalizeScriptDependentAttribute( SvxScriptSetItem& _rScriptSetItem ); + + // gets the script type of the selection in our edit view (with fallback) + SvtScriptType getSelectedScriptType() const; + + /** re-arranges the view and the scrollbars + */ + void layoutWindow(); + + /** to be called when the style of our window changed + */ + void notifyStyleChanged(); + + /** to be called when the zoom of our window changed + */ + void notifyZoomChanged(); + + /** to be called when the StateChangedType::InitShow event arrives + */ + void notifyInitShow(); + + // VCL "overrides" + void SetBackgroundColor( ); + void SetBackgroundColor( const Color& _rColor ); + + void SetReadOnly( bool _bReadOnly ); + bool IsReadOnly() const; + + void SetHideInactiveSelection( bool _bHide ); + bool GetHideInactiveSelection() const; + + /// draws the control onto a given output device + void Draw( OutputDevice* _pDev, const Point& _rPos, const Size& _rSize ); + + /// handles command events arrived at the anti-impl control + bool HandleCommand( const CommandEvent& _rEvent ); + + private: + // updates the cache with the state provided by the given attribute handler + void implUpdateAttribute( const AttributeHandlerPool::const_iterator& _pHandler ); + + // updates the cache with the given state, and calls listeners (if necessary) + void implCheckUpdateCache( AttributeId _nAttribute, const AttributeState& _rState ); + + // updates range and position of our scrollbars + void updateScrollbars(); + + // determines whether automatic (soft) line breaks are ON + bool windowHasAutomaticLineBreak(); + + /// hides or shows our scrollbars, according to the current WinBits of the window + void ensureScrollbars(); + + /// ensures that our "automatic line break" setting matches the current WinBits of the window + void ensureLineBreakSetting(); + + bool hasVScrollBar( ) const { return m_pVScroll != nullptr; } + bool hasHScrollBar( ) const { return m_pHScroll != nullptr; } + + // IEngineStatusListener overridables + virtual void EditEngineStatusChanged( const EditStatus& _rStatus ) override; + + private: + DECL_LINK( OnInvalidateAllAttributes, LinkParamNone*, void ); + DECL_LINK( OnHScroll, ScrollBar*, void ); + DECL_LINK( OnVScroll, ScrollBar*, void ); + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextmodel.cxx b/forms/source/richtext/richtextmodel.cxx new file mode 100644 index 000000000..9f4266be1 --- /dev/null +++ b/forms/source/richtext/richtextmodel.cxx @@ -0,0 +1,637 @@ +/* -*- 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/beans/PropertyAttribute.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/text/WritingMode2.hpp> +#include <com/sun/star/style/VerticalAlignment.hpp> + +#include <comphelper/guarding.hxx> +#include <comphelper/servicehelper.hxx> +#include <toolkit/awt/vclxdevice.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/debug.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 ); + + rtl::Reference<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() + { + registerProperty( PROPERTY_DEFAULTCONTROL, PROPERTY_ID_DEFAULTCONTROL, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_sDefaultControl, cppu::UnoType<decltype(m_sDefaultControl)>::get() ); + registerProperty( PROPERTY_HELPTEXT, PROPERTY_ID_HELPTEXT, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_sHelpText, cppu::UnoType<decltype(m_sHelpText)>::get() ); + registerProperty( PROPERTY_HELPURL, PROPERTY_ID_HELPURL, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_sHelpURL, cppu::UnoType<decltype(m_sHelpURL)>::get() ); + registerProperty( PROPERTY_ENABLED, PROPERTY_ID_ENABLED, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bEnabled, cppu::UnoType<decltype(m_bEnabled)>::get() ); + registerProperty( PROPERTY_ENABLEVISIBLE, PROPERTY_ID_ENABLEVISIBLE, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bEnableVisible, cppu::UnoType<decltype(m_bEnableVisible)>::get() ); + registerProperty( PROPERTY_BORDER, PROPERTY_ID_BORDER, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_nBorder, cppu::UnoType<decltype(m_nBorder)>::get() ); + registerProperty( PROPERTY_HARDLINEBREAKS, PROPERTY_ID_HARDLINEBREAKS, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bHardLineBreaks, cppu::UnoType<decltype(m_bHardLineBreaks)>::get() ); + registerProperty( PROPERTY_HSCROLL, PROPERTY_ID_HSCROLL, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bHScroll, cppu::UnoType<decltype(m_bHScroll)>::get() ); + registerProperty( PROPERTY_VSCROLL, PROPERTY_ID_VSCROLL, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bVScroll, cppu::UnoType<decltype(m_bVScroll)>::get() ); + registerProperty( PROPERTY_READONLY, PROPERTY_ID_READONLY, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bReadonly, cppu::UnoType<decltype(m_bReadonly)>::get() ); + registerProperty( PROPERTY_PRINTABLE, PROPERTY_ID_PRINTABLE, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bPrintable, cppu::UnoType<decltype(m_bPrintable)>::get() ); + registerProperty( PROPERTY_REFERENCE_DEVICE, PROPERTY_ID_REFERENCE_DEVICE, PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT, + &m_xReferenceDevice, cppu::UnoType<decltype(m_xReferenceDevice)>::get() ); + registerProperty( PROPERTY_RICH_TEXT, PROPERTY_ID_RICH_TEXT, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bReallyActAsRichText, cppu::UnoType<decltype(m_bReallyActAsRichText)>::get() ); + registerProperty( PROPERTY_HIDEINACTIVESELECTION, PROPERTY_ID_HIDEINACTIVESELECTION, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bHideInactiveSelection, cppu::UnoType<decltype(m_bHideInactiveSelection)>::get() ); + + registerMayBeVoidProperty( PROPERTY_TABSTOP, PROPERTY_ID_TABSTOP, PropertyAttribute::MAYBEVOID | PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_aTabStop, cppu::UnoType<sal_Bool>::get() ); + registerMayBeVoidProperty( PROPERTY_BACKGROUNDCOLOR, PROPERTY_ID_BACKGROUNDCOLOR, PropertyAttribute::MAYBEVOID | PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_aBackgroundColor, cppu::UnoType<sal_Int32>::get() ); + registerMayBeVoidProperty( PROPERTY_BORDERCOLOR, PROPERTY_ID_BORDERCOLOR, PropertyAttribute::MAYBEVOID | PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_aBorderColor, cppu::UnoType<sal_Int32>::get() ); + registerMayBeVoidProperty( PROPERTY_VERTICAL_ALIGN, PROPERTY_ID_VERTICAL_ALIGN, PropertyAttribute::MAYBEVOID | PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_aVerticalAlignment, cppu::UnoType<VerticalAlignment>::get() ); + + // properties which exist only for compatibility with the css.swt.UnoControlEditModel, + // since we replace the default implementation for this service + registerProperty( PROPERTY_ECHO_CHAR, PROPERTY_ID_ECHO_CHAR, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_nEchoChar, cppu::UnoType<decltype(m_nEchoChar)>::get() ); + registerProperty( PROPERTY_MAXTEXTLEN, PROPERTY_ID_MAXTEXTLEN, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_nMaxTextLength, cppu::UnoType<decltype(m_nMaxTextLength)>::get() ); + registerProperty( PROPERTY_MULTILINE, PROPERTY_ID_MULTILINE, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_bMultiLine, cppu::UnoType<decltype(m_bMultiLine)>::get() ); + registerProperty( PROPERTY_TEXT, PROPERTY_ID_TEXT, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_sLastKnownEngineText, cppu::UnoType<decltype(m_sLastKnownEngineText)>::get() ); + registerProperty( PROPERTY_LINEEND_FORMAT, PROPERTY_ID_LINEEND_FORMAT, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_nLineEndFormat, cppu::UnoType<decltype(m_nLineEndFormat)>::get() ); + registerProperty( PROPERTY_WRITING_MODE, PROPERTY_ID_WRITING_MODE, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_nTextWritingMode, cppu::UnoType<decltype(m_nTextWritingMode)>::get() ); + + registerProperty( PROPERTY_CONTEXT_WRITING_MODE, PROPERTY_ID_CONTEXT_WRITING_MODE, PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT | + PropertyAttribute::TRANSIENT, &m_nContextWritingMode, cppu::UnoType<decltype(m_nContextWritingMode)>::get() ); + + registerMayBeVoidProperty( PROPERTY_ALIGN, PROPERTY_ID_ALIGN, PropertyAttribute::MAYBEVOID | PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT, + &m_aAlign, cppu::UnoType<sal_Int16>::get() ); + } + + + ORichTextModel::~ORichTextModel( ) + { + if ( !OComponentHelper::rBHelper.bDisposed ) + { + acquire(); + dispose(); + } + if (m_pEngine) + { + SolarMutexGuard g; + m_pEngine.reset(); + } + } + + + 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) + ); + } + + css::uno::Reference< css::util::XCloneable > SAL_CALL ORichTextModel::createClone() +{ + rtl::Reference<ORichTextModel> pClone = new ORichTextModel(this, getContext()); + pClone->clonedFrom(this); + return pClone; +} + + + void SAL_CALL ORichTextModel::disposing() + { + m_aModifyListeners.disposeAndClear( EventObject( *this ) ); + OControlModel::disposing(); + } + + + namespace + { + void lcl_removeProperty( Sequence< Property >& _rSeq, std::u16string_view _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 + { + OControlModel::describeFixedProperties( _rProps ); + sal_Int32 nOldCount = _rProps.getLength(); + _rProps.realloc( nOldCount + 1); + css::beans::Property* pProperties = _rProps.getArray() + nOldCount; + *pProperties++ = css::beans::Property(PROPERTY_TABINDEX, PROPERTY_ID_TABINDEX, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT); + DBG_ASSERT( pProperties == _rProps.getArray() + _rProps.getLength(), "<...>::describeFixedProperties/getInfoHelper: forgot to adjust the count ?"); + + // 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 = comphelper::getSomething_cast<RichTextEngine>(xTunnel->getSomething(getUnoTunnelId())); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "forms.richtext", "ORichTextModel::getEditEngine" ); + } + } + return pEngine; + } + + + const Sequence<sal_Int8> & ORichTextModel::getUnoTunnelId() + { + static const comphelper::UnoIdInit aId; + return aId.getSeq(); + } + + + 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 ) + { + if (comphelper::isUnoTunnelId<ORichTextModel>(_rId)) + return comphelper::getSomething_cast(m_pEngine.get()); // Note returning a different type + + 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: */ diff --git a/forms/source/richtext/richtextmodel.hxx b/forms/source/richtext/richtextmodel.hxx new file mode 100644 index 000000000..cf0bae7db --- /dev/null +++ b/forms/source/richtext/richtextmodel.hxx @@ -0,0 +1,186 @@ +/* -*- 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 . + */ +#pragma once + +#include <FormComponent.hxx> +#include <formcontrolfont.hxx> +#include "richtextunowrapper.hxx" +#include <comphelper/interfacecontainer3.hxx> +#include <comphelper/propertycontainerhelper.hxx> + +#include <com/sun/star/awt/XDevice.hpp> +#include <com/sun/star/util/XModifyBroadcaster.hpp> +#include <cppuhelper/implbase3.hxx> +#include <tools/link.hxx> +#include <memory> + +class EditEngine; + +namespace frm +{ + + + class RichTextEngine; + + //= ORichTextModel + + typedef ::cppu::ImplHelper3 < css::awt::XControlModel + , css::lang::XUnoTunnel + , css::util::XModifyBroadcaster + > ORichTextModel_BASE; + + class ORichTextModel + :public OControlModel + ,public FontControlModel + ,public IEngineTextChangeListener + ,public ::comphelper::OPropertyContainerHelper + ,public ORichTextModel_BASE + { + public: + ORichTextModel( + const css::uno::Reference< css::uno::XComponentContext>& _rxFactory + ); + ORichTextModel( + const ORichTextModel* _pOriginal, + const css::uno::Reference< css::uno::XComponentContext>& _rxFactory + ); + virtual ~ORichTextModel() override; + + private: + // <properties> + css::uno::Reference< css::awt::XDevice > + m_xReferenceDevice; + css::uno::Any m_aTabStop; + css::uno::Any m_aBackgroundColor; + css::uno::Any m_aBorderColor; + css::uno::Any m_aVerticalAlignment; + OUString m_sDefaultControl; + OUString m_sHelpText; + OUString m_sHelpURL; + OUString m_sLastKnownEngineText; + sal_Int16 m_nLineEndFormat; + sal_Int16 m_nTextWritingMode; + sal_Int16 m_nContextWritingMode; + sal_Int16 m_nBorder; + bool m_bEnabled; + bool m_bEnableVisible; + bool m_bHardLineBreaks; + bool m_bHScroll; + bool m_bVScroll; + bool m_bReadonly; + bool m_bPrintable; + bool m_bReallyActAsRichText; // despite the class name, the RichTextControl later on + // will create "ordinary" text peers depending on this property + bool m_bHideInactiveSelection; + // </properties> + + // <properties_for_awt_edit_compatibility> + css::uno::Any m_aAlign; + sal_Int16 m_nEchoChar; + sal_Int16 m_nMaxTextLength; + bool m_bMultiLine; + // </properties_for_awt_edit_compatibility> + + ::std::unique_ptr<RichTextEngine> + m_pEngine; + bool m_bSettingEngineText; + + ::comphelper::OInterfaceContainerHelper3<css::util::XModifyListener> + m_aModifyListeners; + + public: + static RichTextEngine* getEditEngine( const css::uno::Reference< css::awt::XControlModel >& _rxModel ); + + // UNO + DECLARE_UNO3_AGG_DEFAULTS( ORichTextModel, OControlModel ) + virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual ::css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + // XPersistObject + virtual OUString SAL_CALL getServiceName() override; + + // XTypeProvider + DECLARE_XTYPEPROVIDER() + + // XCloneable + virtual css::uno::Reference< css::util::XCloneable > SAL_CALL createClone( ) override; + + // XUnoTunnel + virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& aIdentifier ) override; + static const css::uno::Sequence<sal_Int8> & getUnoTunnelId(); + + // XModifyBroadcaster + virtual void SAL_CALL addModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override; + virtual void SAL_CALL removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override; + + // XPropertySet and friends + virtual void SAL_CALL getFastPropertyValue(css::uno::Any& rValue, sal_Int32 nHandle ) const override; + virtual sal_Bool SAL_CALL convertFastPropertyValue(css::uno::Any& rConvertedValue, css::uno::Any& rOldValue, + sal_Int32 nHandle, const css::uno::Any& rValue ) override; + virtual void SAL_CALL setFastPropertyValue_NoBroadcast(sal_Int32 nHandle, const css::uno::Any& rValue) override; + virtual css::uno::Any getPropertyDefaultByHandle( sal_Int32 nHandle ) const override; + + // OControlModel's property handling + virtual void describeFixedProperties( + css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps + ) const override; + virtual void describeAggregateProperties( + css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps + ) const override; + + // prevent method hiding + using OControlModel::disposing; + using OControlModel::getFastPropertyValue; + + // OComponentHelper + virtual void SAL_CALL disposing() override; + + // IEngineTextChangeListener + virtual void potentialTextChange( ) override; + + private: + void implInit(); + void implDoAggregation(); + void implRegisterProperties(); + + /** propagates a new text to the EditEngine + + This method needs to lock the global solar mutex, so our own mutex must not + be locked when calling. + + @precond + our mutex is not locked + */ + void impl_smlock_setEngineText( const OUString& _rText ); + + DECL_LINK( OnEngineContentModified, LinkParamNone*, void ); + + private: + ORichTextModel( const ORichTextModel& ) = delete; + ORichTextModel& operator=( const ORichTextModel& ) = delete; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextunowrapper.cxx b/forms/source/richtext/richtextunowrapper.cxx new file mode 100644 index 000000000..d9c426921 --- /dev/null +++ b/forms/source/richtext/richtextunowrapper.cxx @@ -0,0 +1,117 @@ +/* -*- 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 "richtextunowrapper.hxx" + +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <editeng/unofored.hxx> +#include <editeng/editview.hxx> +#include <editeng/unoipset.hxx> +#include <svx/svdpool.hxx> +#include <svx/svdobj.hxx> +#include <editeng/unoprnms.hxx> + + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::container; + + + namespace + { + const SvxItemPropertySet* getTextEnginePropertySet() + { + // property map for an outliner text + static const SfxItemPropertyMapEntry aTextEnginePropertyMap[] = + { + SVX_UNOEDIT_CHAR_PROPERTIES, + SVX_UNOEDIT_FONT_PROPERTIES, + SVX_UNOEDIT_PARA_PROPERTIES, + { u"TextUserDefinedAttributes", EE_CHAR_XMLATTRIBS, cppu::UnoType<XNameContainer>::get(), 0, 0 }, + { u"ParaUserDefinedAttributes", EE_PARA_XMLATTRIBS, cppu::UnoType<XNameContainer>::get(), 0, 0 }, + { u"", 0, css::uno::Type(), 0, 0 } + }; + static SvxItemPropertySet aTextEnginePropertySet( aTextEnginePropertyMap, SdrObject::GetGlobalDrawObjectItemPool() ); + return &aTextEnginePropertySet; + } + } + + ORichTextUnoWrapper::ORichTextUnoWrapper( EditEngine& _rEngine, IEngineTextChangeListener* _pTextChangeListener ) + :SvxUnoText( getTextEnginePropertySet() ) + { + SetEditSource( new RichTextEditSource( _rEngine, _pTextChangeListener ) ); + } + + + ORichTextUnoWrapper::~ORichTextUnoWrapper() noexcept + { + } + + RichTextEditSource::RichTextEditSource( EditEngine& _rEngine, IEngineTextChangeListener* _pTextChangeListener ) + :m_rEngine ( _rEngine ) + ,m_pTextForwarder ( new SvxEditEngineForwarder( _rEngine ) ) + ,m_pTextChangeListener ( _pTextChangeListener ) + { + } + + + RichTextEditSource::~RichTextEditSource() + { + } + + + std::unique_ptr<SvxEditSource> RichTextEditSource::Clone() const + { + return std::unique_ptr<SvxEditSource>(new RichTextEditSource( m_rEngine, m_pTextChangeListener )); + } + + + SvxTextForwarder* RichTextEditSource::GetTextForwarder() + { + return m_pTextForwarder.get(); + } + + + void RichTextEditSource::UpdateData() + { + // this means that the content of the EditEngine changed via the UNO API + // to reflect this in the views, we need to update them + sal_uInt16 viewCount = m_rEngine.GetViewCount(); + for ( sal_uInt16 view = 0; view < viewCount; ++view ) + { + EditView* pView = m_rEngine.GetView( view ); + if ( pView ) + pView->ForceLayoutCalculation(); + } + + if ( m_pTextChangeListener ) + m_pTextChangeListener->potentialTextChange(); + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextunowrapper.hxx b/forms/source/richtext/richtextunowrapper.hxx new file mode 100644 index 000000000..0acb3c53d --- /dev/null +++ b/forms/source/richtext/richtextunowrapper.hxx @@ -0,0 +1,81 @@ +/* -*- 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 . + */ + +#pragma once + +#include <memory> +#include <editeng/unotext.hxx> +#include <editeng/unoedsrc.hxx> + + +namespace frm +{ + + class IEngineTextChangeListener + { + public: + virtual void potentialTextChange( ) = 0; + + protected: + ~IEngineTextChangeListener() {} + }; + + class ORichTextUnoWrapper : public SvxUnoText + { + public: + ORichTextUnoWrapper( EditEngine& _rEngine, IEngineTextChangeListener* _pTextChangeListener ); + + protected: + virtual ~ORichTextUnoWrapper() noexcept override; + + + private: + ORichTextUnoWrapper( const ORichTextUnoWrapper& ) = delete; + ORichTextUnoWrapper& operator=( const ORichTextUnoWrapper& ) = delete; + }; + + class RichTextEditSource : public SvxEditSource + { + private: + EditEngine& m_rEngine; + std::unique_ptr<SvxTextForwarder> + m_pTextForwarder; + IEngineTextChangeListener* m_pTextChangeListener; + + public: + RichTextEditSource( EditEngine& _rEngine, IEngineTextChangeListener* _pTextChangeListener ); + + // SvxEditSource + virtual std::unique_ptr<SvxEditSource> Clone() const override; + virtual SvxTextForwarder* GetTextForwarder() override; + virtual void UpdateData() override; + + protected: + virtual ~RichTextEditSource() override; + + private: + RichTextEditSource( const RichTextEditSource& _rSource ) = delete; + RichTextEditSource& operator=( const RichTextEditSource& ) = delete; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextvclcontrol.cxx b/forms/source/richtext/richtextvclcontrol.cxx new file mode 100644 index 000000000..cb4d613e3 --- /dev/null +++ b/forms/source/richtext/richtextvclcontrol.cxx @@ -0,0 +1,353 @@ +/* -*- 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 "richtextvclcontrol.hxx" +#include "richtextimplcontrol.hxx" +#include <svl/itemset.hxx> +#if OSL_DEBUG_LEVEL > 0 + #include <unotools/ucbstreamhelper.hxx> + #include <sfx2/filedlghelper.hxx> + #include <tools/urlobj.hxx> + #include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#endif +#include <editeng/editeng.hxx> +#include <editeng/editview.hxx> +#include <editeng/editids.hrc> +#include <svx/svxids.hrc> +#include <osl/diagnose.h> +#include <vcl/event.hxx> + +namespace frm +{ + + RichTextControl::RichTextControl( RichTextEngine* _pEngine, vcl::Window* _pParent, WinBits _nStyle, + ITextAttributeListener* _pTextAttribListener, ITextSelectionListener* _pSelectionListener ) + :Control( _pParent, implInitStyle( _nStyle ) ) + { + implInit( _pEngine, _pTextAttribListener, _pSelectionListener ); + } + + + void RichTextControl::implInit( RichTextEngine* _pEngine, ITextAttributeListener* _pTextAttribListener, ITextSelectionListener* _pSelectionListener ) + { + m_pImpl.reset( new RichTextControlImpl( this, _pEngine, _pTextAttribListener, _pSelectionListener ) ); + SetCompoundControl( true ); + } + + + RichTextControl::~RichTextControl( ) + { + disposeOnce(); + } + + void RichTextControl::dispose() + { + m_pImpl.reset(); + Control::dispose(); + } + + + AttributeState RichTextControl::getState( AttributeId _nAttributeId ) const + { + return m_pImpl->getAttributeState( _nAttributeId ); + } + + + void RichTextControl::executeAttribute( AttributeId _nAttributeId, const SfxPoolItem* _pArgument ) + { + SfxItemSet aToApplyAttributes( getView().GetEmptyItemSet() ); + if ( !m_pImpl->executeAttribute( getView().GetAttribs(), aToApplyAttributes, _nAttributeId, _pArgument, m_pImpl->getSelectedScriptType() ) ) + { + OSL_FAIL( "RichTextControl::executeAttribute: cannot handle the given attribute!" ); + return; + } + + applyAttributes( aToApplyAttributes ); + } + + + void RichTextControl::applyAttributes( const SfxItemSet& _rAttributesToApply ) + { + // apply + if ( HasChildPathFocus() ) + getView().HideCursor(); + + // TODO: guard? + bool bOldUpdateMode = getEngine().SetUpdateLayout( false ); + + getView().SetAttribs( _rAttributesToApply ); + + getEngine().SetUpdateLayout( bOldUpdateMode ); + getView().Invalidate(); + + if ( HasChildPathFocus() ) + getView().ShowCursor(); + + m_pImpl->updateAllAttributes(); + // TODO: maybe we should have a list of attributes which need to be updated + // (the handler for the just executed attribute should know) + } + + + void RichTextControl::enableAttributeNotification( AttributeId _nAttributeId, ITextAttributeListener* _pListener ) + { + m_pImpl->enableAttributeNotification( _nAttributeId, _pListener ); + } + + + void RichTextControl::disableAttributeNotification( AttributeId _nAttributeId ) + { + m_pImpl->disableAttributeNotification( _nAttributeId ); + } + + + bool RichTextControl::isMappableSlot( SfxSlotId _nSlotId ) + { + switch ( _nSlotId ) + { + case SID_ATTR_PARA_ADJUST_LEFT: + case SID_ATTR_PARA_ADJUST_CENTER: + case SID_ATTR_PARA_ADJUST_RIGHT: + case SID_ATTR_PARA_ADJUST_BLOCK: + case SID_SET_SUPER_SCRIPT: + case SID_SET_SUB_SCRIPT: + case SID_ATTR_PARA_LINESPACE_10: + case SID_ATTR_PARA_LINESPACE_15: + case SID_ATTR_PARA_LINESPACE_20: + case SID_ATTR_PARA_LEFT_TO_RIGHT: + case SID_ATTR_PARA_RIGHT_TO_LEFT: + case SID_TEXTDIRECTION_TOP_TO_BOTTOM: + case SID_TEXTDIRECTION_LEFT_TO_RIGHT: + case SID_ATTR_CHAR_LATIN_FONT: + case SID_ATTR_CHAR_LATIN_FONTHEIGHT: + case SID_ATTR_CHAR_LATIN_LANGUAGE: + case SID_ATTR_CHAR_LATIN_POSTURE: + case SID_ATTR_CHAR_LATIN_WEIGHT: + return true; + } + return false; + } + + + void RichTextControl::Resize() + { + m_pImpl->layoutWindow(); + Invalidate(); + } + + + void RichTextControl::GetFocus() + { + m_pImpl->getViewport( RichTextControlImpl::GrantAccess() )->GrabFocus(); + } + + + WinBits RichTextControl::implInitStyle( WinBits nStyle ) + { + if ( !( nStyle & WB_NOTABSTOP ) ) + nStyle |= WB_TABSTOP; + return nStyle; + } + + + void RichTextControl::StateChanged( StateChangedType _nStateChange ) + { + if ( _nStateChange == StateChangedType::Style ) + { + SetStyle( implInitStyle( GetStyle() ) ); + m_pImpl->notifyStyleChanged(); + } + else if ( _nStateChange == StateChangedType::Zoom ) + { + m_pImpl->notifyZoomChanged(); + } + else if ( _nStateChange == StateChangedType::InitShow ) + { + m_pImpl->notifyInitShow(); + } + Control::StateChanged( _nStateChange ); + } + + + bool RichTextControl::PreNotify( NotifyEvent& _rNEvt ) + { + if ( IsWindowOrChild( _rNEvt.GetWindow() ) ) + { + if ( MouseNotifyEvent::KEYINPUT == _rNEvt.GetType() ) + { + const ::KeyEvent* pKeyEvent = _rNEvt.GetKeyEvent(); + + sal_uInt16 nCode = pKeyEvent->GetKeyCode().GetCode(); + bool bShift = pKeyEvent->GetKeyCode().IsShift(); + bool bCtrl = pKeyEvent->GetKeyCode().IsMod1(); + bool bAlt = pKeyEvent->GetKeyCode().IsMod2(); + if ( ( KEY_TAB == nCode ) && bCtrl && !bAlt ) + { + // Ctrl-Tab is used to step out of the control + // -> build a new key event without the Ctrl-key, and let the very base class handle it + vcl::KeyCode aNewCode( KEY_TAB, bShift, false, false, false ); + ::KeyEvent aNewEvent( pKeyEvent->GetCharCode(), aNewCode ); + Control::KeyInput( aNewEvent ); + return true; // handled + } + +#if OSL_DEBUG_LEVEL > 0 + if ( ( ( KEY_F12 == nCode ) + || ( KEY_F11 == nCode ) + ) + && bCtrl + && bAlt + ) + { + bool bLoad = KEY_F11 == nCode; + static struct + { + const char* pDescription; + const char* pExtension; + EETextFormat eFormat; + } const aExportFormats[] = + { + { "OASIS OpenDocument (*.xml)", "*.xml", EETextFormat::Xml }, + { "HyperText Markup Language (*.html)", "*.html", EETextFormat::Html }, + { "Rich Text format (*.rtf)", "*.rtf", EETextFormat::Rtf }, + { "Text (*.txt)", "*.txt", EETextFormat::Text } + }; + + ::sfx2::FileDialogHelper aFP( bLoad ? css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE : css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION, FileDialogFlags::NONE, GetFrameWeld() ); + + for (auto & aExportFormat : aExportFormats) + { + aFP.AddFilter( + OUString::createFromAscii( aExportFormat.pDescription ), + OUString::createFromAscii( aExportFormat.pExtension ) ); + } + ErrCode nResult = aFP.Execute(); + if ( nResult == ERRCODE_NONE ) + { + OUString sFileName = aFP.GetPath(); + std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( + sFileName, ( bLoad ? StreamMode::READ : StreamMode::WRITE | StreamMode::TRUNC ) | StreamMode::SHARE_DENYALL + ); + if ( pStream ) + { + EETextFormat eFormat = EETextFormat::Xml; + OUString sFilter = aFP.GetCurrentFilter(); + for (auto & aExportFormat : aExportFormats) + { + if ( sFilter.equalsAscii( aExportFormat.pDescription ) ) + { + eFormat = aExportFormat.eFormat; + break; + } + } + if ( bLoad ) + { + INetURLObject aURL( sFileName ); + aURL.removeSegment(); + getEngine().Read( *pStream, aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), eFormat ); + } + else + { + getEngine().Write( *pStream, eFormat ); + } + } + } + return true; // handled + } +#endif + } + } + return Control::PreNotify( _rNEvt ); + } + + + bool RichTextControl::EventNotify( NotifyEvent& _rNEvt ) + { + bool bDone = false; + if ( _rNEvt.GetType() == MouseNotifyEvent::COMMAND ) + { + const CommandEvent& rEvent = *_rNEvt.GetCommandEvent(); + bDone = m_pImpl->HandleCommand( rEvent ); + } + return bDone || Control::EventNotify(_rNEvt); + } + + void RichTextControl::Draw( OutputDevice* _pDev, const Point& _rPos, SystemTextColorFlags /*_nFlags*/ ) + { + m_pImpl->Draw( _pDev, _rPos, _pDev->PixelToLogic(GetSizePixel()) ); + } + + EditView& RichTextControl::getView() + { + return *m_pImpl->getView( RichTextControlImpl::GrantAccess() ); + } + + + const EditView& RichTextControl::getView() const + { + return *m_pImpl->getView( RichTextControlImpl::GrantAccess() ); + } + + + EditEngine& RichTextControl::getEngine() const + { + return *m_pImpl->getEngine( RichTextControlImpl::GrantAccess() ); + } + + + void RichTextControl::SetReadOnly( bool _bReadOnly ) + { + m_pImpl->SetReadOnly( _bReadOnly ); + } + + + bool RichTextControl::IsReadOnly() const + { + return m_pImpl->IsReadOnly(); + } + + + void RichTextControl::SetBackgroundColor( ) + { + m_pImpl->SetBackgroundColor( ); + } + + + void RichTextControl::SetBackgroundColor( const Color& _rColor ) + { + m_pImpl->SetBackgroundColor( _rColor ); + } + + + void RichTextControl::SetHideInactiveSelection( bool _bHide ) + { + m_pImpl->SetHideInactiveSelection( _bHide ); + } + + + bool RichTextControl::GetHideInactiveSelection() const + { + return m_pImpl->GetHideInactiveSelection( ); + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextvclcontrol.hxx b/forms/source/richtext/richtextvclcontrol.hxx new file mode 100644 index 000000000..92d0c047d --- /dev/null +++ b/forms/source/richtext/richtextvclcontrol.hxx @@ -0,0 +1,122 @@ +/* -*- 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 . + */ +#pragma once + +#include <vcl/ctrl.hxx> +#include "rtattributes.hxx" +#include "textattributelistener.hxx" +#include <memory> + +class EditView; +class EditEngine; +class SfxItemSet; + +namespace frm +{ + + class RichTextControlImpl; + class RichTextEngine; + + class RichTextControl : public Control, public IMultiAttributeDispatcher + { + private: + std::unique_ptr<RichTextControlImpl> m_pImpl; + + public: + RichTextControl( + RichTextEngine* _pEngine, + vcl::Window* _pParent, + WinBits _nStyle, + ITextAttributeListener* _pTextAttribListener, + ITextSelectionListener* _pSelectionListener + ); + + virtual ~RichTextControl( ) override; + virtual void dispose() override; + + /* enables the change notifications for a particular attribute + + If you want to be notified of any changes in the state of an attribute, you need to call enableAttributeNotification. + + If you provide a dedicated listener for this attribute, this listener is called for every change in the state of + the attribute. + + No matter whether you provide such a dedicated listener, the "global" listener which you specified + in the constructor of the control is also called for all changes in the attribute state. + + If you previously already enabled the notification for this attribute, and specified a different listener, + then the previous listener will be replaced with the new listener, provided the latter is not <NULL/>. + */ + void enableAttributeNotification( AttributeId _nAttributeId, ITextAttributeListener* _pListener ); + + /** disables the change notifications for a particular attribute + + If there was a listener dedicated to this attribute, it will not be referenced and used anymore + after this method had been called + */ + void disableAttributeNotification( AttributeId _nAttributeId ); + + /** determines whether a given slot can be mapped to an aspect of an attribute of the EditEngine + + E.g. SID_ATTR_PARA_ADJUST_LEFT can, though it's not part of the EditEngine pool, be mapped + to the SID_ATTR_PARA_ADJUST slot, which in fact *is* usable with the EditEngine. + */ + static bool isMappableSlot( SfxSlotId _nSlotId ); + + // IMultiAttributeDispatcher + virtual AttributeState getState( AttributeId _nAttributeId ) const override; + virtual void executeAttribute( AttributeId _nAttributeId, const SfxPoolItem* _pArgument ) override; + + void SetBackgroundColor( ); + void SetBackgroundColor( const Color& _rColor ); + + void SetReadOnly( bool _bReadOnly ); + bool IsReadOnly() const; + + void SetHideInactiveSelection( bool _bHide ); + bool GetHideInactiveSelection() const; + + const EditView& getView() const; + EditView& getView(); + + // Window overridables + virtual void Draw( OutputDevice* _pDev, const Point& _rPos, SystemTextColorFlags _nFlags ) override; + + protected: + // Window overridables + virtual void Resize() override; + virtual void GetFocus() override; + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual bool PreNotify( NotifyEvent& _rNEvt ) override; + virtual bool EventNotify( NotifyEvent& _rNEvt ) override; + + private: + void applyAttributes( const SfxItemSet& _rAttributesToApply ); + void implInit( RichTextEngine* _pEngine, ITextAttributeListener* _pTextAttribListener, ITextSelectionListener* _pSelectionListener ); + static WinBits implInitStyle( WinBits nStyle ); + + private: + EditEngine& getEngine() const; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextviewport.cxx b/forms/source/richtext/richtextviewport.cxx new file mode 100644 index 000000000..b4fda6652 --- /dev/null +++ b/forms/source/richtext/richtextviewport.cxx @@ -0,0 +1,102 @@ +/* -*- 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 "richtextviewport.hxx" +#include <editeng/editview.hxx> + +namespace frm +{ + RichTextViewPort::RichTextViewPort( vcl::Window* _pParent ) + : Control ( _pParent ) + , m_pView(nullptr) + , m_bHideInactiveSelection( true ) + { + } + + void RichTextViewPort::setView( EditView& _rView ) + { + m_pView = &_rView; + SetPointer( _rView.GetPointer() ); + } + + void RichTextViewPort::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& _rRect ) + { + m_pView->Paint(_rRect, &rRenderContext); + } + + void RichTextViewPort::GetFocus() + { + Control::GetFocus(); + if (m_pView) + { + m_pView->SetSelectionMode( EESelectionMode::Std ); + m_pView->ShowCursor(); + } + } + + void RichTextViewPort::LoseFocus() + { + if (m_pView) + { + m_pView->HideCursor(); + m_pView->SetSelectionMode( m_bHideInactiveSelection ? EESelectionMode::Hidden : EESelectionMode::Std ); + } + Control::LoseFocus(); + } + + void RichTextViewPort::KeyInput( const KeyEvent& _rKEvt ) + { + if ( !m_pView->PostKeyEvent( _rKEvt ) ) + Control::KeyInput( _rKEvt ); + else + implInvalidateAttributes(); + } + + void RichTextViewPort::MouseMove( const MouseEvent& _rMEvt ) + { + Control::MouseMove( _rMEvt ); + m_pView->MouseMove( _rMEvt ); + } + + void RichTextViewPort::MouseButtonDown( const MouseEvent& _rMEvt ) + { + Control::MouseButtonDown( _rMEvt ); + m_pView->MouseButtonDown( _rMEvt ); + GrabFocus(); + } + + void RichTextViewPort::MouseButtonUp( const MouseEvent& _rMEvt ) + { + Control::MouseButtonUp( _rMEvt ); + m_pView->MouseButtonUp( _rMEvt ); + implInvalidateAttributes(); + } + + void RichTextViewPort::SetHideInactiveSelection( bool _bHide ) + { + if ( m_bHideInactiveSelection == _bHide ) + return; + m_bHideInactiveSelection = _bHide; + if ( !HasFocus() ) + m_pView->SetSelectionMode( m_bHideInactiveSelection ? EESelectionMode::Hidden : EESelectionMode::Std ); + } + +} // namespace frm + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/richtextviewport.hxx b/forms/source/richtext/richtextviewport.hxx new file mode 100644 index 000000000..90df8cb0b --- /dev/null +++ b/forms/source/richtext/richtextviewport.hxx @@ -0,0 +1,64 @@ +/* -*- 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 . + */ +#pragma once + +#include <vcl/ctrl.hxx> + +class EditView; + +namespace frm +{ + class RichTextViewPort : public Control + { + private: + EditView* m_pView; + Link<LinkParamNone*,void> m_aInvalidationHandler; + bool m_bHideInactiveSelection; + + public: + explicit RichTextViewPort( vcl::Window* _pParent ); + + void setView( EditView& _rView ); + + void setAttributeInvalidationHandler( const Link<LinkParamNone*,void>& _rHandler ) { m_aInvalidationHandler = _rHandler; } + + void SetHideInactiveSelection( bool _bHide ); + bool GetHideInactiveSelection() const { return m_bHideInactiveSelection; } + + protected: + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void KeyInput( const KeyEvent& _rKEvt ) override; + virtual void MouseMove( const MouseEvent& _rMEvt ) override; + virtual void MouseButtonDown( const MouseEvent& _rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& _rMEvt ) override; + + private: + void implInvalidateAttributes() const + { + m_aInvalidationHandler.Call( nullptr ); + } + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/rtattributehandler.cxx b/forms/source/richtext/rtattributehandler.cxx new file mode 100644 index 000000000..582b451a8 --- /dev/null +++ b/forms/source/richtext/rtattributehandler.cxx @@ -0,0 +1,441 @@ +/* -*- 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 "rtattributehandler.hxx" + +#include <osl/diagnose.h> +#include <svx/svxids.hrc> +#include <editeng/eeitem.hxx> +#include <svl/itemset.hxx> +#include <svl/itempool.hxx> +#include <tools/mapunit.hxx> +#include <vcl/mapmod.hxx> +#include <vcl/outdev.hxx> + +#include <editeng/adjustitem.hxx> +#include <editeng/escapementitem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/frmdiritem.hxx> +#include <editeng/scripttypeitem.hxx> + + +namespace frm +{ + + + AttributeHandler::AttributeHandler( AttributeId _nAttributeId, WhichId _nWhichId ) + :m_nAttribute( _nAttributeId ) + ,m_nWhich ( _nWhichId ) + { + } + + + AttributeHandler::~AttributeHandler() + { + } + + + AttributeId AttributeHandler::getAttributeId( ) const + { + return getAttribute(); + } + + + AttributeCheckState AttributeHandler::implGetCheckState( const SfxPoolItem& /*_rItem*/ ) const + { + OSL_FAIL( "AttributeHandler::implGetCheckState: not to be called!" ); + return eIndetermined; + } + + + void AttributeHandler::putItemForScript( SfxItemSet& _rAttribs, const SfxPoolItem& _rItem, SvtScriptType _nForScriptType ) const + { + SvxScriptSetItem aSetItem( static_cast<WhichId>(getAttributeId()), *_rAttribs.GetPool() ); + aSetItem.PutItemForScriptType( _nForScriptType, _rItem ); + _rAttribs.Put( aSetItem.GetItemSet(), false ); + } + + + AttributeCheckState AttributeHandler::getCheckState( const SfxItemSet& _rAttribs ) const + { + AttributeCheckState eSimpleState( eIndetermined ); + const SfxPoolItem* pItem = _rAttribs.GetItem( getWhich() ); + if ( pItem ) + eSimpleState = implGetCheckState( *pItem ); + return eSimpleState; + } + + + AttributeState AttributeHandler::getState( const SfxItemSet& _rAttribs ) const + { + AttributeState aState( eIndetermined ); + aState.eSimpleState = getCheckState( _rAttribs ); + return aState; + } + + + //= AttributeHandlerFactory + + + namespace + { + WhichId lcl_implGetWhich( const SfxItemPool& _rPool, AttributeId _nAttributeId ) + { + WhichId nWhich = 0; + switch ( _nAttributeId ) + { + case SID_ATTR_CHAR_LATIN_FONTHEIGHT:nWhich = EE_CHAR_FONTHEIGHT;break; + case SID_ATTR_CHAR_LATIN_FONT: nWhich = EE_CHAR_FONTINFO; break; + case SID_ATTR_CHAR_LATIN_LANGUAGE: nWhich = EE_CHAR_LANGUAGE; break; + case SID_ATTR_CHAR_LATIN_POSTURE: nWhich = EE_CHAR_ITALIC; break; + case SID_ATTR_CHAR_LATIN_WEIGHT: nWhich = EE_CHAR_WEIGHT; break; + + default: + nWhich = _rPool.GetWhich( static_cast<SfxSlotId>(_nAttributeId) ); + } + return nWhich; + } + } + + ::rtl::Reference< AttributeHandler > AttributeHandlerFactory::getHandlerFor( AttributeId _nAttributeId, const SfxItemPool& _rEditEnginePool ) + { + ::rtl::Reference< AttributeHandler > pReturn; + switch ( _nAttributeId ) + { + case SID_ATTR_PARA_ADJUST_LEFT : + case SID_ATTR_PARA_ADJUST_CENTER: + case SID_ATTR_PARA_ADJUST_RIGHT : + case SID_ATTR_PARA_ADJUST_BLOCK : + pReturn = new ParaAlignmentHandler( _nAttributeId ); + break; + + case SID_ATTR_PARA_LINESPACE_10: + case SID_ATTR_PARA_LINESPACE_15: + case SID_ATTR_PARA_LINESPACE_20: + pReturn = new LineSpacingHandler( _nAttributeId ); + break; + + case SID_SET_SUPER_SCRIPT: + case SID_SET_SUB_SCRIPT: + pReturn = new EscapementHandler( _nAttributeId ); + break; + + case SID_ATTR_CHAR_FONTHEIGHT: + case SID_ATTR_CHAR_CTL_FONTHEIGHT: + case SID_ATTR_CHAR_CJK_FONTHEIGHT: + case SID_ATTR_CHAR_LATIN_FONTHEIGHT: + pReturn = new FontSizeHandler( _nAttributeId, lcl_implGetWhich( _rEditEnginePool, _nAttributeId ) ); + break; + + case SID_ATTR_PARA_LEFT_TO_RIGHT: + case SID_ATTR_PARA_RIGHT_TO_LEFT: + pReturn = new ParagraphDirectionHandler( _nAttributeId ); + break; + + case SID_ATTR_PARA_HANGPUNCTUATION: + case SID_ATTR_PARA_FORBIDDEN_RULES: + case SID_ATTR_PARA_SCRIPTSPACE: + pReturn = new BooleanHandler( _nAttributeId, lcl_implGetWhich( _rEditEnginePool, _nAttributeId ) ); + break; + + default: + pReturn = new SlotHandler( static_cast<SfxSlotId>(_nAttributeId), lcl_implGetWhich( _rEditEnginePool, _nAttributeId ) ); + break; + + } + + return pReturn; + } + + ParaAlignmentHandler::ParaAlignmentHandler( AttributeId _nAttributeId ) + :AttributeHandler( _nAttributeId, EE_PARA_JUST ) + ,m_eAdjust( SvxAdjust::Center ) + { + switch ( getAttribute() ) + { + case SID_ATTR_PARA_ADJUST_LEFT : m_eAdjust = SvxAdjust::Left; break; + case SID_ATTR_PARA_ADJUST_CENTER: m_eAdjust = SvxAdjust::Center; break; + case SID_ATTR_PARA_ADJUST_RIGHT : m_eAdjust = SvxAdjust::Right; break; + case SID_ATTR_PARA_ADJUST_BLOCK : m_eAdjust = SvxAdjust::Block; break; + default: + OSL_FAIL( "ParaAlignmentHandler::ParaAlignmentHandler: invalid slot!" ); + break; + } + } + + + AttributeCheckState ParaAlignmentHandler::implGetCheckState( const SfxPoolItem& _rItem ) const + { + assert( dynamic_cast<const SvxAdjustItem*>( &_rItem) && "ParaAlignmentHandler::implGetCheckState: invalid pool item!" ); + SvxAdjust eAdjust = static_cast< const SvxAdjustItem& >( _rItem ).GetAdjust(); + return ( eAdjust == m_eAdjust ) ? eChecked : eUnchecked; + } + + + void ParaAlignmentHandler::executeAttribute( const SfxItemSet& /*_rCurrentAttribs*/, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType /*_nForScriptType*/ ) const + { + OSL_ENSURE( !_pAdditionalArg, "ParaAlignmentHandler::executeAttribute: this is a simple toggle attribute - no args possible!" ); + _rNewAttribs.Put( SvxAdjustItem( m_eAdjust, getWhich() ) ); + } + + LineSpacingHandler::LineSpacingHandler( AttributeId _nAttributeId ) + :AttributeHandler( _nAttributeId, EE_PARA_SBL ) + ,m_nLineSpace( 100 ) + { + switch ( getAttribute() ) + { + case SID_ATTR_PARA_LINESPACE_10: m_nLineSpace = 100; break; + case SID_ATTR_PARA_LINESPACE_15: m_nLineSpace = 150; break; + case SID_ATTR_PARA_LINESPACE_20: m_nLineSpace = 200; break; + default: + OSL_FAIL( "LineSpacingHandler::LineSpacingHandler: invalid slot!" ); + break; + } + } + + + AttributeCheckState LineSpacingHandler::implGetCheckState( const SfxPoolItem& _rItem ) const + { + assert( dynamic_cast<const SvxLineSpacingItem*>( &_rItem) && "LineSpacingHandler::implGetCheckState: invalid pool item!" ); + sal_uInt16 nLineSpace = static_cast< const SvxLineSpacingItem& >( _rItem ).GetPropLineSpace(); + return ( nLineSpace == m_nLineSpace ) ? eChecked : eUnchecked; + } + + + void LineSpacingHandler::executeAttribute( const SfxItemSet& /*_rCurrentAttribs*/, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType /*_nForScriptType*/ ) const + { + OSL_ENSURE( !_pAdditionalArg, "LineSpacingHandler::executeAttribute: this is a simple toggle attribute - no args possible!" ); + + SvxLineSpacingItem aLineSpacing( m_nLineSpace, getWhich() ); + aLineSpacing.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + if ( 100 == m_nLineSpace ) + aLineSpacing.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + else + aLineSpacing.SetPropLineSpace( m_nLineSpace ); + + _rNewAttribs.Put( aLineSpacing ); + } + + EscapementHandler::EscapementHandler( AttributeId _nAttributeId ) + :AttributeHandler( _nAttributeId, EE_CHAR_ESCAPEMENT ) + ,m_eEscapement( SvxEscapement::Off ) + { + switch ( getAttribute() ) + { + case SID_SET_SUPER_SCRIPT : m_eEscapement = SvxEscapement::Superscript; break; + case SID_SET_SUB_SCRIPT : m_eEscapement = SvxEscapement::Subscript; break; + default: + OSL_FAIL( "EscapementHandler::EscapementHandler: invalid slot!" ); + break; + } + } + + + AttributeCheckState EscapementHandler::implGetCheckState( const SfxPoolItem& _rItem ) const + { + assert( dynamic_cast<const SvxEscapementItem*>( &_rItem) && "EscapementHandler::getState: invalid pool item!" ); + SvxEscapement eEscapement = static_cast< const SvxEscapementItem& >( _rItem ).GetEscapement(); + return ( eEscapement == m_eEscapement ) ? eChecked : eUnchecked; + } + + + void EscapementHandler::executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType /*_nForScriptType*/ ) const { + OSL_ENSURE( !_pAdditionalArg, "EscapementHandler::executeAttribute: this is a simple toggle attribute - no args possible!" ); + // well, in theory we could allow an SvxEscapementItem here, but this is not needed + + bool bIsChecked = getCheckState( _rCurrentAttribs ) == eChecked; + _rNewAttribs.Put( SvxEscapementItem( bIsChecked ? SvxEscapement::Off : m_eEscapement, getWhich() ) ); + } + + SlotHandler::SlotHandler( AttributeId _nAttributeId, WhichId _nWhichId ) + :AttributeHandler( _nAttributeId, _nWhichId ) + ,m_bScriptDependent( false ) + { + m_bScriptDependent = ( sal_uInt16(SID_ATTR_CHAR_WEIGHT) == _nAttributeId ) + || ( sal_uInt16(SID_ATTR_CHAR_POSTURE) == _nAttributeId ) + || ( sal_uInt16(SID_ATTR_CHAR_FONT) == _nAttributeId ); + } + + + AttributeState SlotHandler::getState( const SfxItemSet& _rAttribs ) const + { + AttributeState aState( eIndetermined ); + + const SfxPoolItem* pItem = _rAttribs.GetItem( getWhich() ); + if ( pItem ) + aState.setItem( pItem ); + + return aState; + } + + + void SlotHandler::executeAttribute( const SfxItemSet& /*_rCurrentAttribs*/, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const + { + if ( _pAdditionalArg ) + { + std::unique_ptr<SfxPoolItem> pCorrectWich(_pAdditionalArg->CloneSetWhich(getWhich())); + + if ( m_bScriptDependent ) + putItemForScript( _rNewAttribs, *pCorrectWich, _nForScriptType ); + else + _rNewAttribs.Put( std::move(pCorrectWich) ); + } + else + OSL_FAIL( "SlotHandler::executeAttribute: need attributes to do something!" ); + } + + FontSizeHandler::FontSizeHandler( AttributeId _nAttributeId, WhichId _nWhichId ) + :AttributeHandler( _nAttributeId, _nWhichId ) + { + OSL_ENSURE( ( _nAttributeId == SID_ATTR_CHAR_FONTHEIGHT ) || ( _nAttributeId == SID_ATTR_CHAR_CTL_FONTHEIGHT ) + || ( _nAttributeId == SID_ATTR_CHAR_CJK_FONTHEIGHT ) || ( _nAttributeId == SID_ATTR_CHAR_LATIN_FONTHEIGHT ), + "FontSizeHandler::FontSizeHandler: invalid attribute id!" ); + } + + + AttributeState FontSizeHandler::getState( const SfxItemSet& _rAttribs ) const + { + AttributeState aState( eIndetermined ); + + const SfxPoolItem* pItem = _rAttribs.GetItem( getWhich() ); + const SvxFontHeightItem* pFontHeightItem = dynamic_cast<const SvxFontHeightItem*>( pItem ); + OSL_ENSURE( pFontHeightItem || !pItem, "FontSizeHandler::getState: invalid item!" ); + if ( pFontHeightItem ) + { + // by definition, the item should have the unit twip + sal_uLong nHeight = pFontHeightItem->GetHeight(); + if ( _rAttribs.GetPool()->GetMetric( getWhich() ) != MapUnit::MapTwip ) + { + nHeight = OutputDevice::LogicToLogic( + Size( 0, nHeight ), + MapMode( _rAttribs.GetPool()->GetMetric( getWhich() ) ), + MapMode( MapUnit::MapTwip ) + ).Height(); + } + + SvxFontHeightItem* pNewItem = new SvxFontHeightItem( nHeight, 100, getWhich() ); + pNewItem->SetProp( pFontHeightItem->GetProp(), pFontHeightItem->GetPropUnit() ); + aState.setItem( pNewItem ); + } + + return aState; + } + + + void FontSizeHandler::executeAttribute( const SfxItemSet& /*_rCurrentAttribs*/, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const + { + const SvxFontHeightItem* pFontHeightItem = dynamic_cast<const SvxFontHeightItem*>( _pAdditionalArg ); + OSL_ENSURE( pFontHeightItem, "FontSizeHandler::executeAttribute: need a FontHeightItem!" ); + + if ( !pFontHeightItem ) + return; + + sal_uLong nHeight = pFontHeightItem->GetHeight(); + if ( _rNewAttribs.GetPool()->GetMetric( getWhich() ) != MapUnit::MapTwip ) + { + nHeight = OutputDevice::LogicToLogic( + Size( 0, nHeight ), + MapMode( MapUnit::MapTwip ), + MapMode( _rNewAttribs.GetPool()->GetMetric( getWhich() ) ) + ).Height(); + } + + SvxFontHeightItem aNewItem( nHeight, 100, getWhich() ); + aNewItem.SetProp( pFontHeightItem->GetProp(), pFontHeightItem->GetPropUnit() ); + + if ( ( getAttributeId() == SID_ATTR_CHAR_FONTHEIGHT ) && _nForScriptType != SvtScriptType::NONE) + putItemForScript( _rNewAttribs, aNewItem, _nForScriptType ); + else + _rNewAttribs.Put( aNewItem ); + } + + ParagraphDirectionHandler::ParagraphDirectionHandler( AttributeId _nAttributeId ) + :AttributeHandler( _nAttributeId, EE_PARA_WRITINGDIR ) + ,m_eParagraphDirection( SvxFrameDirection::Horizontal_LR_TB ) + ,m_eDefaultAdjustment( SvxAdjust::Right ) + ,m_eOppositeDefaultAdjustment( SvxAdjust::Left ) + { + switch ( getAttributeId() ) + { + case SID_ATTR_PARA_LEFT_TO_RIGHT: m_eParagraphDirection = SvxFrameDirection::Horizontal_LR_TB; m_eDefaultAdjustment = SvxAdjust::Left; break; + case SID_ATTR_PARA_RIGHT_TO_LEFT: m_eParagraphDirection = SvxFrameDirection::Horizontal_RL_TB; m_eDefaultAdjustment = SvxAdjust::Right; break; + default: + OSL_FAIL( "ParagraphDirectionHandler::ParagraphDirectionHandler: invalid attribute id!" ); + } + + if ( SvxAdjust::Right == m_eDefaultAdjustment ) + m_eOppositeDefaultAdjustment = SvxAdjust::Left; + else + m_eOppositeDefaultAdjustment = SvxAdjust::Right; + } + + + AttributeCheckState ParagraphDirectionHandler::implGetCheckState( const SfxPoolItem& _rItem ) const + { + assert( dynamic_cast<const SvxFrameDirectionItem*>( &_rItem) && "ParagraphDirectionHandler::implGetCheckState: invalid pool item!" ); + SvxFrameDirection eDirection = static_cast< const SvxFrameDirectionItem& >( _rItem ).GetValue(); + return ( eDirection == m_eParagraphDirection ) ? eChecked : eUnchecked; + } + + + void ParagraphDirectionHandler::executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* /*_pAdditionalArg*/, SvtScriptType /*_nForScriptType*/ ) const + { + _rNewAttribs.Put( SvxFrameDirectionItem( m_eParagraphDirection, getWhich() ) ); + + // if the current adjustment of the was the default adjustment for the *previous* text direction, + // then we toggle the adjustment, too + SvxAdjust eCurrentAdjustment = SvxAdjust::Left; + if ( const SvxAdjustItem* pCurrentAdjustment = _rCurrentAttribs.GetItemIfSet( EE_PARA_JUST ) ) + eCurrentAdjustment = pCurrentAdjustment->GetAdjust(); + + if ( eCurrentAdjustment == m_eOppositeDefaultAdjustment ) + _rNewAttribs.Put( SvxAdjustItem( m_eDefaultAdjustment, EE_PARA_JUST ) ); + } + + BooleanHandler::BooleanHandler( AttributeId _nAttributeId, WhichId _nWhichId ) + :AttributeHandler( _nAttributeId, _nWhichId ) + { + } + + + AttributeCheckState BooleanHandler::implGetCheckState( const SfxPoolItem& _rItem ) const + { + OSL_ENSURE( dynamic_cast<const SfxBoolItem*>( &_rItem) != nullptr, "BooleanHandler::implGetCheckState: invalid item!" ); + if ( auto pBoolItem = dynamic_cast<const SfxBoolItem*>( &_rItem) ) + return pBoolItem->GetValue() ? eChecked : eUnchecked; + + return eIndetermined; + } + + + void BooleanHandler::executeAttribute( const SfxItemSet& /*_rCurrentAttribs*/, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType /*_nForScriptType*/ ) const + { + OSL_ENSURE( dynamic_cast<const SfxBoolItem*>( _pAdditionalArg) != nullptr, "BooleanHandler::executeAttribute: invalid argument!" ); + if ( _pAdditionalArg ) + { + _rNewAttribs.Put( _pAdditionalArg->CloneSetWhich(getWhich()) ); + } + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/rtattributehandler.hxx b/forms/source/richtext/rtattributehandler.hxx new file mode 100644 index 000000000..0f2badd64 --- /dev/null +++ b/forms/source/richtext/rtattributehandler.hxx @@ -0,0 +1,163 @@ +/* -*- 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 . + */ + +#pragma once + +#include "rtattributes.hxx" +#include <rtl/ref.hxx> +#include <svl/languageoptions.hxx> +#include <editeng/svxenum.hxx> +#include <editeng/frmdir.hxx> +#include <salhelper/simplereferenceobject.hxx> + +class SfxItemSet; +class SfxPoolItem; +class SfxItemPool; + +namespace frm +{ + + class AttributeHandler : public salhelper::SimpleReferenceObject + { + private: + AttributeId m_nAttribute; + WhichId m_nWhich; + + protected: + AttributeId getAttribute() const { return m_nAttribute; } + WhichId getWhich() const { return m_nWhich; } + + public: + AttributeHandler( AttributeId _nAttributeId, WhichId _nWhichId ); + + AttributeId getAttributeId( ) const; + virtual AttributeState getState( const SfxItemSet& _rAttribs ) const; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const = 0; + + protected: + /// helper method calling implGetCheckState + AttributeCheckState getCheckState( const SfxItemSet& _rAttribs ) const; + + /// helper method putting an item into a set, respecting a script type + void putItemForScript( SfxItemSet& _rAttribs, const SfxPoolItem& _rItem, SvtScriptType _nForScriptType ) const; + + // pseudo-abstract + virtual AttributeCheckState implGetCheckState( const SfxPoolItem& _rItem ) const; + + protected: + virtual ~AttributeHandler() override; + }; + + namespace AttributeHandlerFactory + { + ::rtl::Reference< AttributeHandler > getHandlerFor( AttributeId _nAttributeId, const SfxItemPool& _rEditEnginePool ); + } + + class ParaAlignmentHandler : public AttributeHandler + { + private: + SvxAdjust m_eAdjust; + + public: + explicit ParaAlignmentHandler( AttributeId _nAttributeId ); + + public: + virtual AttributeCheckState implGetCheckState( const SfxPoolItem& _rItem ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + class LineSpacingHandler : public AttributeHandler + { + private: + sal_uInt16 m_nLineSpace; + + public: + explicit LineSpacingHandler( AttributeId _nAttributeId ); + + public: + virtual AttributeCheckState implGetCheckState( const SfxPoolItem& _rItem ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + class EscapementHandler : public AttributeHandler + { + private: + SvxEscapement m_eEscapement; + + public: + explicit EscapementHandler( AttributeId _nAttributeId ); + + public: + virtual AttributeCheckState implGetCheckState( const SfxPoolItem& _rItem ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + class SlotHandler : public AttributeHandler + { + private: + bool m_bScriptDependent; + + public: + SlotHandler( AttributeId _nAttributeId, WhichId _nWhichId ); + + public: + virtual AttributeState getState( const SfxItemSet& _rAttribs ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + class BooleanHandler : public AttributeHandler + { + public: + BooleanHandler( AttributeId _nAttributeId, WhichId _nWhichId ); + + public: + virtual AttributeCheckState implGetCheckState( const SfxPoolItem& _rItem ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + class FontSizeHandler : public AttributeHandler + { + public: + FontSizeHandler( AttributeId _nAttributeId, WhichId _nWhichId ); + + public: + virtual AttributeState getState( const SfxItemSet& _rAttribs ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + class ParagraphDirectionHandler : public AttributeHandler + { + private: + SvxFrameDirection m_eParagraphDirection; + SvxAdjust m_eDefaultAdjustment; + SvxAdjust m_eOppositeDefaultAdjustment; + + public: + explicit ParagraphDirectionHandler( AttributeId _nAttributeId ); + + public: + virtual AttributeCheckState implGetCheckState( const SfxPoolItem& _rItem ) const override; + virtual void executeAttribute( const SfxItemSet& _rCurrentAttribs, SfxItemSet& _rNewAttribs, const SfxPoolItem* _pAdditionalArg, SvtScriptType _nForScriptType ) const override; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/rtattributes.hxx b/forms/source/richtext/rtattributes.hxx new file mode 100644 index 000000000..b60ac6518 --- /dev/null +++ b/forms/source/richtext/rtattributes.hxx @@ -0,0 +1,130 @@ +/* -*- 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 . + */ + +#pragma once + +#include <sal/types.h> +#include <svl/poolitem.hxx> + +namespace frm +{ + + /// the id of an attribute + typedef sal_Int32 AttributeId; + /// the "which id" of an item in an SfxItemSet + typedef sal_uInt16 WhichId; + /// a SFX slot id + typedef sal_uInt16 SfxSlotId; + + enum AttributeCheckState + { + eChecked, + eUnchecked, + eIndetermined + }; + + struct AttributeState + { + private: + std::unique_ptr<SfxPoolItem> pItemHandleItem; + + public: + AttributeCheckState eSimpleState; + + inline AttributeState( ); + inline explicit AttributeState( AttributeCheckState _eCheckState ); + inline AttributeState( const AttributeState& _rSource ); + + inline AttributeState& operator=( const AttributeState& _rSource ); + + inline bool operator==( const AttributeState& _rRHS ); + + inline const SfxPoolItem* getItem() const; + inline void setItem( const SfxPoolItem* _pItem ); + }; + + inline AttributeState::AttributeState( ) + :eSimpleState( eIndetermined ) + { + } + + inline AttributeState::AttributeState( AttributeCheckState _eCheckState ) + :eSimpleState( _eCheckState ) + { + } + + inline AttributeState::AttributeState( const AttributeState& _rSource ) + :eSimpleState( eIndetermined ) + { + operator=( _rSource ); + } + + inline AttributeState& AttributeState::operator=( const AttributeState& _rSource ) + { + if ( &_rSource == this ) + return *this; + + eSimpleState = _rSource.eSimpleState; + setItem( _rSource.getItem() ); + return *this; + } + + inline const SfxPoolItem* AttributeState::getItem() const + { + return pItemHandleItem.get(); + } + + inline void AttributeState::setItem( const SfxPoolItem* _pItem ) + { + if ( _pItem ) + pItemHandleItem.reset(_pItem->Clone()); + else + pItemHandleItem.reset(); + } + + inline bool AttributeState::operator==( const AttributeState& _rRHS ) + { + if ( eSimpleState != _rRHS.eSimpleState ) + return false; + + if ( pItemHandleItem && !_rRHS.pItemHandleItem ) + return false; + + if ( !pItemHandleItem && _rRHS.pItemHandleItem ) + return false; + + if ( pItemHandleItem == _rRHS.pItemHandleItem ) + return true; + + return *pItemHandleItem == *_rRHS.pItemHandleItem; + } + + class IMultiAttributeDispatcher + { + public: + virtual AttributeState getState( AttributeId _nAttributeId ) const = 0; + virtual void executeAttribute( AttributeId _nAttributeId, const SfxPoolItem* _pArgument ) = 0; + + protected: + ~IMultiAttributeDispatcher() {} + }; + +} // namespace frm + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/specialdispatchers.cxx b/forms/source/richtext/specialdispatchers.cxx new file mode 100644 index 000000000..db7ef6807 --- /dev/null +++ b/forms/source/richtext/specialdispatchers.cxx @@ -0,0 +1,171 @@ +/* -*- 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 "specialdispatchers.hxx" +#include <editeng/editeng.hxx> +#include <editeng/editids.hrc> +#include <editeng/editview.hxx> +#include <editeng/scriptspaceitem.hxx> +#include <osl/diagnose.h> + + +namespace frm +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::beans; + + OSelectAllDispatcher::OSelectAllDispatcher( EditView& _rView, const URL& _rURL ) + :ORichTextFeatureDispatcher( _rView, _rURL ) + { + } + + + OSelectAllDispatcher::~OSelectAllDispatcher( ) + { + if ( !isDisposed() ) + { + acquire(); + dispose(); + } + } + + + void SAL_CALL OSelectAllDispatcher::dispatch( const URL& _rURL, const Sequence< PropertyValue >& /*_rArguments*/ ) + { + ::osl::MutexGuard aGuard( m_aMutex ); + OSL_ENSURE( _rURL.Complete == getFeatureURL().Complete, "OSelectAllDispatcher::dispatch: invalid URL!" ); + + checkDisposed(); + + EditEngine* pEngine = getEditView() ? getEditView()->GetEditEngine() : nullptr; + OSL_ENSURE( pEngine, "OSelectAllDispatcher::dispatch: no edit engine - but not yet disposed?" ); + if ( !pEngine ) + return; + + sal_Int32 nParagraphs = pEngine->GetParagraphCount(); + if ( nParagraphs ) + { + sal_Int32 nLastParaNumber = nParagraphs - 1; + sal_Int32 nParaLen = pEngine->GetTextLen( nLastParaNumber ); + getEditView()->SetSelection( ESelection( 0, 0, nLastParaNumber, nParaLen ) ); + } + } + + + FeatureStateEvent OSelectAllDispatcher::buildStatusEvent() const + { + FeatureStateEvent aEvent( ORichTextFeatureDispatcher::buildStatusEvent() ); + aEvent.IsEnabled = true; + return aEvent; + } + + OParagraphDirectionDispatcher::OParagraphDirectionDispatcher( EditView& _rView, AttributeId _nAttributeId, const URL& _rURL, + IMultiAttributeDispatcher* _pMasterDispatcher ) + :OAttributeDispatcher( _rView, _nAttributeId, _rURL, _pMasterDispatcher ) + { + } + + + FeatureStateEvent OParagraphDirectionDispatcher::buildStatusEvent() const + { + FeatureStateEvent aEvent( OAttributeDispatcher::buildStatusEvent() ); + + EditEngine* pEngine = getEditView() ? getEditView()->GetEditEngine() : nullptr; + OSL_ENSURE( pEngine, "OParagraphDirectionDispatcher::dispatch: no edit engine - but not yet disposed?" ); + if ( pEngine && pEngine->IsEffectivelyVertical() ) + aEvent.IsEnabled = false; + + return aEvent; + } + + OTextDirectionDispatcher::OTextDirectionDispatcher( EditView& _rView, const URL& _rURL ) + :ORichTextFeatureDispatcher( _rView, _rURL ) + { + } + + + void SAL_CALL OTextDirectionDispatcher::dispatch( const URL& _rURL, const Sequence< PropertyValue >& /*_rArguments*/ ) + { + ::osl::MutexGuard aGuard( m_aMutex ); + OSL_ENSURE( _rURL.Complete == getFeatureURL().Complete, "OTextDirectionDispatcher::dispatch: invalid URL!" ); + + checkDisposed(); + + EditEngine* pEngine = getEditView() ? getEditView()->GetEditEngine() : nullptr; + OSL_ENSURE( pEngine, "OTextDirectionDispatcher::dispatch: no edit engine - but not yet disposed?" ); + if ( !pEngine ) + return; + + pEngine->SetVertical( !pEngine->IsEffectivelyVertical() ); + } + + + FeatureStateEvent OTextDirectionDispatcher::buildStatusEvent() const + { + FeatureStateEvent aEvent( ORichTextFeatureDispatcher::buildStatusEvent() ); + + EditEngine* pEngine = getEditView() ? getEditView()->GetEditEngine() : nullptr; + OSL_ENSURE( pEngine, "OTextDirectionDispatcher::dispatch: no edit engine - but not yet disposed?" ); + + aEvent.IsEnabled = true; + aEvent.State <<= pEngine && pEngine->IsEffectivelyVertical(); + + return aEvent; + } + + OAsianFontLayoutDispatcher::OAsianFontLayoutDispatcher( EditView& _rView, AttributeId _nAttributeId, const URL& _rURL, IMultiAttributeDispatcher* _pMasterDispatcher ) + :OParametrizedAttributeDispatcher( _rView, _nAttributeId, _rURL, _pMasterDispatcher ) + { + } + + + const SfxPoolItem* OAsianFontLayoutDispatcher::convertDispatchArgsToItem( const Sequence< PropertyValue >& _rArguments ) + { + // look for the "Enable" parameter + const PropertyValue* pLookup = _rArguments.getConstArray(); + const PropertyValue* pLookupEnd = _rArguments.getConstArray() + _rArguments.getLength(); + while ( pLookup != pLookupEnd ) + { + if ( pLookup->Name == "Enable" ) + break; + ++pLookup; + } + if ( pLookup != pLookupEnd ) + { + bool bEnable = true; + OSL_VERIFY( pLookup->Value >>= bEnable ); + if ( m_nAttributeId == SID_ATTR_PARA_SCRIPTSPACE ) + return new SvxScriptSpaceItem( bEnable, static_cast<WhichId>(m_nAttributeId) ); + return new SfxBoolItem( static_cast<WhichId>(m_nAttributeId), bEnable ); + } + + OSL_FAIL( "OAsianFontLayoutDispatcher::convertDispatchArgsToItem: did not find the one and only argument!" ); + return nullptr; + } + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/specialdispatchers.hxx b/forms/source/richtext/specialdispatchers.hxx new file mode 100644 index 000000000..9b4bfa1b7 --- /dev/null +++ b/forms/source/richtext/specialdispatchers.hxx @@ -0,0 +1,91 @@ +/* -*- 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 . + */ + +#pragma once + +#include "parametrizedattributedispatcher.hxx" + + +namespace frm +{ + + class OSelectAllDispatcher : public ORichTextFeatureDispatcher + { + public: + OSelectAllDispatcher( EditView& _rView, const css::util::URL& _rURL ); + + protected: + virtual ~OSelectAllDispatcher() override; + + // XDispatch + virtual void SAL_CALL dispatch( const css::util::URL& URL, const css::uno::Sequence< css::beans::PropertyValue >& Arguments ) override; + + // ORichTextFeatureDispatcher + virtual css::frame::FeatureStateEvent buildStatusEvent() const override; + }; + + class OParagraphDirectionDispatcher : public OAttributeDispatcher + { + public: + OParagraphDirectionDispatcher( + EditView& _rView, + AttributeId _nAttributeId, + const css::util::URL& _rURL, + IMultiAttributeDispatcher* _pMasterDispatcher + ); + + protected: + // ORichTextFeatureDispatcher + virtual css::frame::FeatureStateEvent buildStatusEvent() const override; + }; + + class OTextDirectionDispatcher : public ORichTextFeatureDispatcher + { + public: + OTextDirectionDispatcher( EditView& _rView, const css::util::URL& _rURL ); + + protected: + // XDispatch + virtual void SAL_CALL dispatch( const css::util::URL& URL, const css::uno::Sequence< css::beans::PropertyValue >& Arguments ) override; + + // ORichTextFeatureDispatcher + virtual css::frame::FeatureStateEvent buildStatusEvent() const override; + }; + + class OAsianFontLayoutDispatcher : public OParametrizedAttributeDispatcher + { + public: + OAsianFontLayoutDispatcher( + EditView& _rView, + AttributeId _nAttributeId, + const css::util::URL& _rURL, + IMultiAttributeDispatcher* _pMasterDispatcher + ); + + protected: + // OParametrizedAttributeDispatcher + virtual const SfxPoolItem* convertDispatchArgsToItem( + const css::uno::Sequence< css::beans::PropertyValue >& _rArguments ) override; + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/forms/source/richtext/textattributelistener.hxx b/forms/source/richtext/textattributelistener.hxx new file mode 100644 index 000000000..3025d7b5d --- /dev/null +++ b/forms/source/richtext/textattributelistener.hxx @@ -0,0 +1,53 @@ +/* -*- 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 . + */ +#pragma once + +#include "rtattributes.hxx" + +struct ESelection; + +namespace frm +{ + + class ITextAttributeListener + { + public: + virtual void onAttributeStateChanged( AttributeId _nAttributeId ) = 0; + + protected: + ~ITextAttributeListener() {} + }; + + + //= ITextAttributeListener + + class ITextSelectionListener + { + public: + virtual void onSelectionChanged() = 0; + + protected: + ~ITextSelectionListener() {} + }; + + +} // namespace frm + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |