| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include "fmprop.hrc" |
| #include "svx/fmresids.hrc" |
| #include "fmtextcontroldialogs.hxx" |
| #include "fmtextcontrolfeature.hxx" |
| #include "fmtextcontrolshell.hxx" |
| #include "editeng/crsditem.hxx" |
| #include "svx/dialmgr.hxx" |
| #include "editeng/editeng.hxx" |
| #include "editeng/eeitem.hxx" |
| #include "svx/fmglob.hxx" |
| #include "editeng/scriptspaceitem.hxx" |
| #include "svx/svxids.hrc" |
| #include "editeng/udlnitem.hxx" |
| |
| /** === begin UNO includes === **/ |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/awt/FontDescriptor.hpp> |
| #include <com/sun/star/frame/XDispatchProvider.hpp> |
| #include <com/sun/star/form/XForm.hpp> |
| #include <com/sun/star/container/XChild.hpp> |
| #include <com/sun/star/awt/XFocusListener.hpp> |
| #include <com/sun/star/awt/XMouseListener.hpp> |
| /** === end UNO includes === **/ |
| |
| #include <comphelper/componentcontext.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include <cppuhelper/implbase1.hxx> |
| #include <sfx2/app.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/msgpool.hxx> |
| #include <sfx2/objsh.hxx> |
| #include <sfx2/request.hxx> |
| #include <sfx2/sfxuno.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <svl/eitem.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/itempool.hxx> |
| #include <svl/languageoptions.hxx> |
| #include <svtools/stringtransfer.hxx> |
| #include <svl/whiter.hxx> |
| #include <toolkit/helper/vclunohelper.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <vcl/msgbox.hxx> |
| #include <vcl/outdev.hxx> |
| #include <vos/mutex.hxx> |
| |
| #include <memory> |
| |
| //........................................................................ |
| namespace svx |
| { |
| //........................................................................ |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::awt; |
| using namespace ::com::sun::star::form; |
| using namespace ::com::sun::star::form::runtime; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::frame; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::container; |
| |
| //==================================================================== |
| typedef sal_uInt16 WhichId; |
| |
| //==================================================================== |
| static SfxSlotId pTextControlSlots[] = |
| { |
| SID_CLIPBOARD_FORMAT_ITEMS, |
| SID_CUT, |
| SID_COPY, |
| SID_PASTE, |
| SID_SELECTALL, |
| // SID_ATTR_TABSTOP, /* 2 */ |
| SID_ATTR_CHAR_FONT, |
| SID_ATTR_CHAR_POSTURE, |
| SID_ATTR_CHAR_WEIGHT, |
| SID_ATTR_CHAR_SHADOWED, |
| SID_ATTR_CHAR_WORDLINEMODE, |
| SID_ATTR_CHAR_CONTOUR, |
| SID_ATTR_CHAR_STRIKEOUT, |
| SID_ATTR_CHAR_UNDERLINE, |
| SID_ATTR_CHAR_FONTHEIGHT, |
| SID_ATTR_CHAR_COLOR, |
| SID_ATTR_CHAR_KERNING, |
| SID_ATTR_CHAR_LANGUAGE, /* 20 */ |
| SID_ATTR_CHAR_ESCAPEMENT, |
| SID_ATTR_PARA_ADJUST, /* 28 */ |
| SID_ATTR_PARA_ADJUST_LEFT, |
| SID_ATTR_PARA_ADJUST_RIGHT, |
| SID_ATTR_PARA_ADJUST_CENTER, |
| SID_ATTR_PARA_ADJUST_BLOCK, |
| SID_ATTR_PARA_LINESPACE, /* 33 */ |
| SID_ATTR_PARA_LINESPACE_10, |
| SID_ATTR_PARA_LINESPACE_15, |
| SID_ATTR_PARA_LINESPACE_20, |
| SID_ATTR_LRSPACE, /* 48 */ |
| SID_ATTR_ULSPACE, /* 49 */ |
| SID_ATTR_CHAR_AUTOKERN, |
| SID_SET_SUPER_SCRIPT, |
| SID_SET_SUB_SCRIPT, |
| SID_CHAR_DLG, |
| SID_PARA_DLG, |
| // SID_TEXTDIRECTION_LEFT_TO_RIGHT, /* 907 */ |
| // SID_TEXTDIRECTION_TOP_TO_BOTTOM, |
| SID_ATTR_CHAR_SCALEWIDTH, /* 911 */ |
| SID_ATTR_CHAR_RELIEF, |
| SID_ATTR_PARA_LEFT_TO_RIGHT, /* 950 */ |
| SID_ATTR_PARA_RIGHT_TO_LEFT, |
| SID_ATTR_CHAR_OVERLINE, |
| 0 |
| }; |
| |
| // slots which we are not responsible for on the SfxShell level, but |
| // need to handle during the "paragraph attributes" and/or "character |
| // attributes" dialogs |
| static SfxSlotId pDialogSlots[] = |
| { |
| SID_ATTR_TABSTOP, |
| SID_ATTR_PARA_HANGPUNCTUATION, |
| SID_ATTR_PARA_FORBIDDEN_RULES, |
| SID_ATTR_PARA_SCRIPTSPACE, |
| SID_ATTR_CHAR_LATIN_LANGUAGE, |
| SID_ATTR_CHAR_CJK_LANGUAGE, |
| SID_ATTR_CHAR_CTL_LANGUAGE, |
| SID_ATTR_CHAR_LATIN_FONT, |
| SID_ATTR_CHAR_CJK_FONT, |
| SID_ATTR_CHAR_CTL_FONT, |
| SID_ATTR_CHAR_LATIN_FONTHEIGHT, |
| SID_ATTR_CHAR_CJK_FONTHEIGHT, |
| SID_ATTR_CHAR_CTL_FONTHEIGHT, |
| SID_ATTR_CHAR_LATIN_WEIGHT, |
| SID_ATTR_CHAR_CJK_WEIGHT, |
| SID_ATTR_CHAR_CTL_WEIGHT, |
| SID_ATTR_CHAR_LATIN_POSTURE, |
| SID_ATTR_CHAR_CJK_POSTURE, |
| SID_ATTR_CHAR_CTL_POSTURE, |
| SID_ATTR_CHAR_EMPHASISMARK, |
| 0 |
| }; |
| |
| //==================================================================== |
| //= FmFocusListenerAdapter |
| //==================================================================== |
| typedef ::cppu::WeakImplHelper1 < XFocusListener |
| > FmFocusListenerAdapter_Base; |
| class FmFocusListenerAdapter : public FmFocusListenerAdapter_Base |
| { |
| private: |
| IFocusObserver* m_pObserver; |
| Reference< XWindow > m_xWindow; |
| |
| public: |
| FmFocusListenerAdapter( const Reference< XControl >& _rxControl, IFocusObserver* _pObserver ); |
| |
| // clean up the instance |
| void dispose(); |
| |
| protected: |
| ~FmFocusListenerAdapter(); |
| |
| protected: |
| virtual void SAL_CALL focusGained( const FocusEvent& e ) throw (RuntimeException); |
| virtual void SAL_CALL focusLost( const FocusEvent& e ) throw (RuntimeException); |
| virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException); |
| }; |
| |
| //-------------------------------------------------------------------- |
| DBG_NAME( FmFocusListenerAdapter ) |
| //-------------------------------------------------------------------- |
| FmFocusListenerAdapter::FmFocusListenerAdapter( const Reference< XControl >& _rxControl, IFocusObserver* _pObserver ) |
| :m_pObserver( _pObserver ) |
| ,m_xWindow( _rxControl, UNO_QUERY ) |
| { |
| DBG_CTOR( FmFocusListenerAdapter, NULL ); |
| |
| DBG_ASSERT( m_xWindow.is(), "FmFocusListenerAdapter::FmFocusListenerAdapter: invalid control!" ); |
| osl_incrementInterlockedCount( &m_refCount ); |
| { |
| try |
| { |
| if ( m_xWindow.is() ) |
| m_xWindow->addFocusListener( this ); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| osl_decrementInterlockedCount( &m_refCount ); |
| } |
| |
| //-------------------------------------------------------------------- |
| FmFocusListenerAdapter::~FmFocusListenerAdapter() |
| { |
| acquire(); |
| dispose(); |
| |
| DBG_DTOR( FmFocusListenerAdapter, NULL ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void FmFocusListenerAdapter::dispose() |
| { |
| if ( m_xWindow.is() ) |
| { |
| m_xWindow->removeFocusListener( this ); |
| m_xWindow.clear(); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmFocusListenerAdapter::focusGained( const FocusEvent& e ) throw (RuntimeException) |
| { |
| if ( m_pObserver ) |
| m_pObserver->focusGained( e ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmFocusListenerAdapter::focusLost( const FocusEvent& e ) throw (RuntimeException) |
| { |
| if ( m_pObserver ) |
| m_pObserver->focusLost( e ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmFocusListenerAdapter::disposing( const EventObject& Source ) throw (RuntimeException) |
| { |
| (void)Source; |
| DBG_ASSERT( Source.Source == m_xWindow, "FmFocusListenerAdapter::disposing: where did this come from?" ); |
| m_xWindow.clear(); |
| } |
| |
| //==================================================================== |
| //= FmMouseListenerAdapter |
| //==================================================================== |
| typedef ::cppu::WeakImplHelper1 < XMouseListener |
| > FmMouseListenerAdapter_Base; |
| class FmMouseListenerAdapter : public FmMouseListenerAdapter_Base |
| { |
| private: |
| IContextRequestObserver* m_pObserver; |
| Reference< XWindow > m_xWindow; |
| |
| public: |
| FmMouseListenerAdapter( const Reference< XControl >& _rxControl, IContextRequestObserver* _pObserver ); |
| |
| // clean up the instance |
| void dispose(); |
| |
| protected: |
| ~FmMouseListenerAdapter(); |
| |
| protected: |
| virtual void SAL_CALL mousePressed( const awt::MouseEvent& e ) throw (RuntimeException); |
| virtual void SAL_CALL mouseReleased( const awt::MouseEvent& e ) throw (RuntimeException); |
| virtual void SAL_CALL mouseEntered( const awt::MouseEvent& e ) throw (RuntimeException); |
| virtual void SAL_CALL mouseExited( const awt::MouseEvent& e ) throw (RuntimeException); |
| virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException); |
| }; |
| |
| //==================================================================== |
| //= FmMouseListenerAdapter |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| DBG_NAME( FmMouseListenerAdapter ) |
| //-------------------------------------------------------------------- |
| FmMouseListenerAdapter::FmMouseListenerAdapter( const Reference< XControl >& _rxControl, IContextRequestObserver* _pObserver ) |
| :m_pObserver( _pObserver ) |
| ,m_xWindow( _rxControl, UNO_QUERY ) |
| { |
| DBG_CTOR( FmMouseListenerAdapter, NULL ); |
| |
| DBG_ASSERT( m_xWindow.is(), "FmMouseListenerAdapter::FmMouseListenerAdapter: invalid control!" ); |
| osl_incrementInterlockedCount( &m_refCount ); |
| { |
| try |
| { |
| if ( m_xWindow.is() ) |
| m_xWindow->addMouseListener( this ); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| osl_decrementInterlockedCount( &m_refCount ); |
| } |
| |
| //-------------------------------------------------------------------- |
| FmMouseListenerAdapter::~FmMouseListenerAdapter() |
| { |
| acquire(); |
| dispose(); |
| |
| DBG_DTOR( FmMouseListenerAdapter, NULL ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void FmMouseListenerAdapter::dispose() |
| { |
| if ( m_xWindow.is() ) |
| { |
| m_xWindow->removeMouseListener( this ); |
| m_xWindow.clear(); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmMouseListenerAdapter::mousePressed( const awt::MouseEvent& _rEvent ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| // is this a request for a context menu? |
| if ( _rEvent.PopupTrigger ) |
| { |
| if ( m_pObserver ) |
| m_pObserver->contextMenuRequested( _rEvent ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmMouseListenerAdapter::mouseReleased( const awt::MouseEvent& /*e*/ ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| // not interested in |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmMouseListenerAdapter::mouseEntered( const awt::MouseEvent& /*e*/ ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| // not interested in |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmMouseListenerAdapter::mouseExited( const awt::MouseEvent& /*e*/ ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| // not interested in |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL FmMouseListenerAdapter::disposing( const EventObject& Source ) throw (RuntimeException) |
| { |
| (void)Source; |
| DBG_ASSERT( Source.Source == m_xWindow, "FmMouseListenerAdapter::disposing: where did this come from?" ); |
| m_xWindow.clear(); |
| } |
| |
| //==================================================================== |
| //= FmTextControlShell |
| //==================================================================== |
| //------------------------------------------------------------------------ |
| namespace |
| { |
| //.................................................................... |
| void lcl_translateUnoStateToItem( SfxSlotId _nSlot, const Any& _rUnoState, SfxItemSet& _rSet ) |
| { |
| WhichId nWhich = _rSet.GetPool()->GetWhich( _nSlot ); |
| if ( !_rUnoState.hasValue() ) |
| { |
| if ( ( _nSlot != SID_CUT ) |
| && ( _nSlot != SID_COPY ) |
| && ( _nSlot != SID_PASTE ) |
| ) |
| { |
| _rSet.InvalidateItem( nWhich ); |
| } |
| } |
| else |
| { |
| switch ( _rUnoState.getValueType().getTypeClass() ) |
| { |
| case TypeClass_BOOLEAN: |
| { |
| sal_Bool bState = sal_False; |
| _rUnoState >>= bState; |
| if ( _nSlot == SID_ATTR_PARA_SCRIPTSPACE ) |
| _rSet.Put( SvxScriptSpaceItem( bState, nWhich ) ); |
| else |
| _rSet.Put( SfxBoolItem( nWhich, bState ) ); |
| } |
| break; |
| |
| default: |
| { |
| Sequence< PropertyValue > aComplexState; |
| if ( _rUnoState >>= aComplexState ) |
| { |
| if ( !aComplexState.getLength() ) |
| _rSet.InvalidateItem( nWhich ); |
| else |
| { |
| SfxAllItemSet aAllItems( _rSet ); |
| TransformParameters( _nSlot, aComplexState, aAllItems ); |
| const SfxPoolItem* pTransformed = aAllItems.GetItem( nWhich ); |
| OSL_ENSURE( pTransformed, "lcl_translateUnoStateToItem: non-empty parameter sequence leading to empty item?" ); |
| if ( pTransformed ) |
| _rSet.Put( *pTransformed ); |
| else |
| _rSet.InvalidateItem( nWhich ); |
| } |
| } |
| else |
| { |
| DBG_ERROR( "lcl_translateUnoStateToItem: invalid state!" ); |
| } |
| } |
| } |
| } |
| } |
| |
| //.................................................................... |
| ::rtl::OUString lcl_getUnoSlotName( SfxApplication&, SfxSlotId _nSlotId ) |
| { |
| ::rtl::OUString sSlotUnoName; |
| |
| SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool( NULL ); |
| const SfxSlot* pSlot = rSlotPool.GetSlot( _nSlotId ); |
| |
| const sal_Char* pAsciiUnoName = NULL; |
| if ( pSlot ) |
| { |
| pAsciiUnoName = pSlot->GetUnoName(); |
| } |
| else |
| { |
| // some hard-coded slots, which do not have a UNO name at SFX level, but which |
| // we nevertheless need to transport via UNO mechanisms, so we need a name |
| switch ( _nSlotId ) |
| { |
| case SID_ATTR_PARA_HANGPUNCTUATION: pAsciiUnoName = "AllowHangingPunctuation"; break; |
| case SID_ATTR_PARA_FORBIDDEN_RULES: pAsciiUnoName = "ApplyForbiddenCharacterRules"; break; |
| case SID_ATTR_PARA_SCRIPTSPACE: pAsciiUnoName = "UseScriptSpacing"; break; |
| } |
| } |
| |
| if ( pAsciiUnoName ) |
| { |
| sSlotUnoName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:" ) ); |
| sSlotUnoName += ::rtl::OUString::createFromAscii( pAsciiUnoName ); |
| } |
| #if OSL_DEBUG_LEVEL > 0 |
| else |
| { |
| ::rtl::OString sMessage( "lcl_getUnoSlotName: invalid slot id, or invalid slot, or no UNO name!\n" ); |
| sMessage += "(slot id: "; |
| sMessage += ::rtl::OString::valueOf( (sal_Int32)_nSlotId ); |
| sMessage += ")"; |
| DBG_ERROR( sMessage ); |
| } |
| #endif |
| return sSlotUnoName; |
| } |
| |
| //.................................................................... |
| bool lcl_determineReadOnly( const Reference< XControl >& _rxControl ) |
| { |
| bool bIsReadOnlyModel = true; |
| try |
| { |
| Reference< XPropertySet > xModelProps; |
| if ( _rxControl.is() ) |
| xModelProps = xModelProps.query( _rxControl->getModel() ); |
| Reference< XPropertySetInfo > xModelPropInfo; |
| if ( xModelProps.is() ) |
| xModelPropInfo = xModelProps->getPropertySetInfo(); |
| |
| if ( !xModelPropInfo.is() || !xModelPropInfo->hasPropertyByName( FM_PROP_READONLY ) ) |
| bIsReadOnlyModel = true; |
| else |
| { |
| sal_Bool bReadOnly = sal_True; |
| xModelProps->getPropertyValue( FM_PROP_READONLY ) >>= bReadOnly; |
| bIsReadOnlyModel = bReadOnly; |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return bIsReadOnlyModel; |
| } |
| |
| //.................................................................... |
| static Window* lcl_getWindow( const Reference< XControl >& _rxControl ) |
| { |
| Window* pWindow = NULL; |
| try |
| { |
| Reference< XWindowPeer > xControlPeer; |
| if ( _rxControl.is() ) |
| xControlPeer = _rxControl->getPeer(); |
| if ( xControlPeer.is() ) |
| pWindow = VCLUnoHelper::GetWindow( xControlPeer ); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| return pWindow; |
| } |
| |
| //.................................................................... |
| bool lcl_isRichText( const Reference< XControl >& _rxControl ) |
| { |
| if ( !_rxControl.is() ) |
| return false; |
| |
| bool bIsRichText = false; |
| try |
| { |
| Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY ); |
| Reference< XPropertySetInfo > xPSI; |
| if ( xModelProps.is() ) |
| xPSI = xModelProps->getPropertySetInfo(); |
| ::rtl::OUString sRichTextPropertyName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RichText" ) ); |
| if ( xPSI.is() && xPSI->hasPropertyByName( sRichTextPropertyName ) ) |
| { |
| OSL_VERIFY( xModelProps->getPropertyValue( sRichTextPropertyName ) >>= bIsRichText ); |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return bIsRichText; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| FmTextControlShell::FmTextControlShell( SfxViewFrame* _pFrame ) |
| :m_bActiveControl( false ) |
| ,m_bActiveControlIsReadOnly( true ) |
| ,m_bActiveControlIsRichText( false ) |
| ,m_pViewFrame( _pFrame ) |
| ,m_rBindings( _pFrame->GetBindings() ) |
| ,m_bNeedClipboardInvalidation( true ) |
| { |
| m_aClipboardInvalidation.SetTimeoutHdl( LINK( this, FmTextControlShell, OnInvalidateClipboard ) ); |
| m_aClipboardInvalidation.SetTimeout( 200 ); |
| } |
| |
| //------------------------------------------------------------------------ |
| FmTextControlShell::~FmTextControlShell() |
| { |
| dispose(); |
| } |
| |
| //------------------------------------------------------------------------ |
| IMPL_LINK( FmTextControlShell, OnInvalidateClipboard, void*, /*_pNotInterestedIn*/ ) |
| { |
| if ( m_bNeedClipboardInvalidation ) |
| { |
| DBG_TRACE( "FmTextControlShell::ClipBoard: invalidating clipboard slots" ); |
| m_rBindings.Invalidate( SID_CUT ); |
| m_rBindings.Invalidate( SID_COPY ); |
| m_rBindings.Invalidate( SID_PASTE ); |
| m_bNeedClipboardInvalidation = false; |
| } |
| return 0L; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::transferFeatureStatesToItemSet( ControlFeatures& _rDispatchers, SfxAllItemSet& _rSet, bool _bTranslateLatin ) |
| { |
| SfxItemPool& rPool = *_rSet.GetPool(); |
| |
| for ( ControlFeatures::const_iterator aFeature = _rDispatchers.begin(); |
| aFeature != _rDispatchers.end(); |
| ++aFeature |
| ) |
| { |
| SfxSlotId nSlotId( aFeature->first ); |
| #if OSL_DEBUG_LEVEL > 0 |
| ::rtl::OUString sUnoSlotName; |
| if ( SFX_APP() ) |
| sUnoSlotName = lcl_getUnoSlotName( *SFX_APP(), nSlotId ); |
| else |
| sUnoSlotName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "<unknown>" ) ); |
| ::rtl::OString sUnoSlotNameAscii( "\"" ); |
| sUnoSlotNameAscii += ::rtl::OString( sUnoSlotName.getStr(), sUnoSlotName.getLength(), RTL_TEXTENCODING_ASCII_US ); |
| sUnoSlotNameAscii += "\""; |
| #endif |
| |
| if ( _bTranslateLatin ) |
| { |
| // A rich text control offers a dispatcher for the "Font" slot/feature. |
| // Sadly, the semantics of the dispatches is that the feature "Font" depends |
| // on the current cursor position: If it's on latin text, it's the "latin font" |
| // which is set up at the control. If it's on CJK text, it's the "CJK font", and |
| // aequivalent for "CTL font". |
| // The same holds for some other font related features/slots. |
| // Thus, we have separate dispatches for "Latin Font", "Latin Font Size", etc, |
| // which are only "virtual", in a sense that there exist no item with this id. |
| // So when we encounter such a dispatcher for, say, "Latin Font", we need to |
| // put an item into the set which has the "Font" id. |
| |
| switch ( nSlotId ) |
| { |
| case SID_ATTR_CHAR_LATIN_FONT: nSlotId = SID_ATTR_CHAR_FONT; break; |
| case SID_ATTR_CHAR_LATIN_FONTHEIGHT:nSlotId = SID_ATTR_CHAR_FONTHEIGHT; break; |
| case SID_ATTR_CHAR_LATIN_LANGUAGE: nSlotId = SID_ATTR_CHAR_LANGUAGE; break; |
| case SID_ATTR_CHAR_LATIN_POSTURE: nSlotId = SID_ATTR_CHAR_POSTURE; break; |
| case SID_ATTR_CHAR_LATIN_WEIGHT: nSlotId = SID_ATTR_CHAR_WEIGHT; break; |
| } |
| } |
| |
| WhichId nWhich = rPool.GetWhich( nSlotId ); |
| bool bIsInPool = rPool.IsInRange( nWhich ); |
| if ( bIsInPool ) |
| { |
| #if OSL_DEBUG_LEVEL > 0 |
| bool bFeatureIsEnabled = aFeature->second->isFeatureEnabled(); |
| ::rtl::OString sMessage( "FmTextControlShell::transferFeatureStatesToItemSet: found a feature state for " ); |
| sMessage += sUnoSlotNameAscii; |
| if ( !bFeatureIsEnabled ) |
| sMessage += " (disabled)"; |
| DBG_TRACE( sMessage ); |
| #endif |
| |
| lcl_translateUnoStateToItem( nSlotId, aFeature->second->getFeatureState(), _rSet ); |
| } |
| #if OSL_DEBUG_LEVEL > 0 |
| else |
| { |
| ::rtl::OString sMessage( "FmTextControlShell::transferFeatureStatesToItemSet: found a feature state for " ); |
| sMessage += sUnoSlotNameAscii; |
| sMessage += ", but could not translate it into an item!"; |
| DBG_TRACE( sMessage ); |
| } |
| #endif |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::executeAttributeDialog( AttributeSet _eSet, SfxRequest& _rReq ) |
| { |
| const SvxFontListItem* pFontList = PTR_CAST( SvxFontListItem, m_pViewFrame->GetObjectShell()->GetItem( SID_ATTR_CHAR_FONTLIST ) ); |
| DBG_ASSERT( pFontList, "FmTextControlShell::executeAttributeDialog: no font list item!" ); |
| if ( !pFontList ) |
| return; |
| |
| SfxItemPool* pPool = EditEngine::CreatePool(); |
| pPool->FreezeIdRanges(); |
| ::std::auto_ptr< SfxItemSet > pPureItems( new SfxItemSet( *pPool ) ); |
| |
| // put the current states of the items into the set |
| ::std::auto_ptr< SfxAllItemSet > pCurrentItems( new SfxAllItemSet( *pPureItems ) ); |
| transferFeatureStatesToItemSet( m_aControlFeatures, *pCurrentItems ); |
| |
| // additional items, which we are not responsible for at the SfxShell level, |
| // but which need to be forwarded to the dialog, anyway |
| ControlFeatures aAdditionalFestures; |
| fillFeatureDispatchers( m_xActiveControl, pDialogSlots, aAdditionalFestures ); |
| transferFeatureStatesToItemSet( aAdditionalFestures, *pCurrentItems, true ); |
| |
| ::std::auto_ptr< SfxTabDialog > pDialog ( _eSet == eCharAttribs |
| ? static_cast< SfxTabDialog* >( new TextControlCharAttribDialog( NULL, *pCurrentItems, *pFontList ) ) |
| : static_cast< SfxTabDialog* >( new TextControlParaAttribDialog( NULL, *pCurrentItems ) ) ); |
| if ( RET_OK == pDialog->Execute() ) |
| { |
| const SfxItemSet& rModifiedItems = *pDialog->GetOutputItemSet(); |
| for ( WhichId nWhich = pPool->GetFirstWhich(); nWhich <= pPool->GetLastWhich(); ++nWhich ) |
| { |
| if ( rModifiedItems.GetItemState( nWhich ) == SFX_ITEM_SET ) |
| { |
| SfxSlotId nSlotForItemSet = pPool->GetSlotId( nWhich ); |
| const SfxPoolItem* pModifiedItem = rModifiedItems.GetItem( nWhich ); |
| |
| |
| SfxSlotId nSlotForDispatcher = nSlotForItemSet; |
| switch ( nSlotForDispatcher ) |
| { |
| case SID_ATTR_CHAR_FONT: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_FONT; break; |
| case SID_ATTR_CHAR_FONTHEIGHT:nSlotForDispatcher = SID_ATTR_CHAR_LATIN_FONTHEIGHT; break; |
| case SID_ATTR_CHAR_LANGUAGE: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_LANGUAGE; break; |
| case SID_ATTR_CHAR_POSTURE: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_POSTURE; break; |
| case SID_ATTR_CHAR_WEIGHT: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_WEIGHT; break; |
| } |
| |
| // do we already have a dispatcher for this slot/feature? |
| ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlotForDispatcher ); |
| bool bFound = aFeaturePos != m_aControlFeatures.end( ); |
| |
| if ( !bFound ) |
| { |
| aFeaturePos = aAdditionalFestures.find( nSlotForDispatcher ); |
| bFound = aFeaturePos != aAdditionalFestures.end( ); |
| } |
| |
| if ( bFound ) |
| { |
| Sequence< PropertyValue > aArgs; |
| // temporarily put the modified item into a "clean" set, |
| // and let TransformItems calc the respective UNO parameters |
| pPureItems->Put( *pModifiedItem ); |
| TransformItems( nSlotForItemSet, *pPureItems, aArgs ); |
| pPureItems->ClearItem( nWhich ); |
| |
| if ( ( nSlotForItemSet == SID_ATTR_PARA_HANGPUNCTUATION ) |
| || ( nSlotForItemSet == SID_ATTR_PARA_FORBIDDEN_RULES ) |
| || ( nSlotForItemSet == SID_ATTR_PARA_SCRIPTSPACE ) |
| ) |
| { |
| // these are no UNO slots, they need special handling since TransformItems cannot |
| // handle them |
| DBG_ASSERT( aArgs.getLength() == 0, "FmTextControlShell::executeAttributeDialog: these are no UNO slots - are they?" ); |
| |
| const SfxBoolItem* pBoolItem = PTR_CAST( SfxBoolItem, pModifiedItem ); |
| DBG_ASSERT( pBoolItem, "FmTextControlShell::executeAttributeDialog: no bool item?!" ); |
| if ( pBoolItem ) |
| { |
| aArgs.realloc( 1 ); |
| aArgs[ 0 ].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Enable" ) ); |
| aArgs[ 0 ].Value <<= (sal_Bool)pBoolItem->GetValue(); |
| } |
| } |
| |
| // dispatch this |
| aFeaturePos->second->dispatch( aArgs ); |
| } |
| #if OSL_DEBUG_LEVEL > 0 |
| else |
| { |
| ::rtl::OString sError( "FmTextControShell::executeAttributeDialog: Could not handle the following item:" ); |
| sError += "\n SlotID: "; sError += ::rtl::OString::valueOf( (sal_Int32)nSlotForItemSet ); |
| sError += "\n WhichID: "; sError += ::rtl::OString::valueOf( (sal_Int32)nWhich ); |
| sError += "\n UNO name: "; |
| |
| ::rtl::OUString sUnoSlotName = lcl_getUnoSlotName( *SFX_APP(), nSlotForItemSet ); |
| if ( sUnoSlotName.getLength() ) |
| sError += ::rtl::OString( sUnoSlotName.getStr(), sUnoSlotName.getLength(), RTL_TEXTENCODING_ASCII_US ); |
| else |
| sError += "unknown (no SfxSlot)"; |
| DBG_ERROR( sError.getStr() ); |
| } |
| #endif |
| } |
| } |
| _rReq.Done( rModifiedItems ); |
| } |
| |
| pDialog.reset(); |
| pCurrentItems.reset(); |
| pPureItems.reset(); |
| SfxItemPool::Free(pPool); |
| } |
| |
| //------------------------------------------------------------------------ |
| bool FmTextControlShell::executeSelectAll( ) |
| { |
| try |
| { |
| if ( m_xActiveTextComponent.is() ) |
| { |
| sal_Int32 nTextLen = m_xActiveTextComponent->getText().getLength(); |
| m_xActiveTextComponent->setSelection( awt::Selection( 0, nTextLen ) ); |
| return true; |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return false; // not handled |
| } |
| |
| //------------------------------------------------------------------------ |
| bool FmTextControlShell::executeClipboardSlot( SfxSlotId _nSlot ) |
| { |
| try |
| { |
| if ( m_xActiveTextComponent.is() ) |
| { |
| switch ( _nSlot ) |
| { |
| case SID_COPY: |
| case SID_CUT: |
| { |
| ::rtl::OUString sSelectedText( m_xActiveTextComponent->getSelectedText() ); |
| ::svt::OStringTransfer::CopyString( sSelectedText, lcl_getWindow( m_xActiveControl ) ); |
| if ( SID_CUT == _nSlot ) |
| { |
| awt::Selection aSelection( m_xActiveTextComponent->getSelection() ); |
| m_xActiveTextComponent->insertText( aSelection, ::rtl::OUString() ); |
| } |
| } |
| break; |
| case SID_PASTE: |
| { |
| ::rtl::OUString sClipboardContent; |
| OSL_VERIFY( ::svt::OStringTransfer::PasteString( sClipboardContent, lcl_getWindow( m_xActiveControl ) ) ); |
| awt::Selection aSelection( m_xActiveTextComponent->getSelection() ); |
| m_xActiveTextComponent->insertText( aSelection, sClipboardContent ); |
| } |
| break; |
| default: |
| OSL_ENSURE( sal_False, "FmTextControlShell::executeClipboardSlot: invalid slot!" ); |
| } |
| return true; |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return false; // not handled |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::ExecuteTextAttribute( SfxRequest& _rReq ) |
| { |
| SfxSlotId nSlot = _rReq.GetSlot(); |
| |
| ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlot ); |
| if ( aFeaturePos == m_aControlFeatures.end() ) |
| { |
| // special slots |
| switch ( nSlot ) |
| { |
| case SID_CHAR_DLG: |
| executeAttributeDialog( eCharAttribs, _rReq ); |
| break; |
| |
| case SID_PARA_DLG: |
| executeAttributeDialog( eParaAttribs, _rReq ); |
| break; |
| |
| case SID_SELECTALL: |
| executeSelectAll(); |
| break; |
| |
| case SID_CUT: |
| case SID_COPY: |
| case SID_PASTE: |
| executeClipboardSlot( nSlot ); |
| break; |
| |
| default: |
| DBG_ASSERT( aFeaturePos != m_aControlFeatures.end(), "FmTextControShell::ExecuteTextAttribute: I have no such dispatcher, and cannot handle it at all!" ); |
| return; |
| } |
| } |
| else |
| { |
| // slots which are dispatched to the control |
| |
| switch ( nSlot ) |
| { |
| case SID_ATTR_CHAR_STRIKEOUT: |
| case SID_ATTR_CHAR_UNDERLINE: |
| case SID_ATTR_CHAR_OVERLINE: |
| { |
| SfxItemSet aToggled( *_rReq.GetArgs() ); |
| |
| lcl_translateUnoStateToItem( nSlot, aFeaturePos->second->getFeatureState(), aToggled ); |
| WhichId nWhich = aToggled.GetPool()->GetWhich( nSlot ); |
| const SfxPoolItem* pItem = aToggled.GetItem( nWhich ); |
| if ( ( SID_ATTR_CHAR_UNDERLINE == nSlot ) || ( SID_ATTR_CHAR_OVERLINE == nSlot ) ) |
| { |
| const SvxOverlineItem* pTextLine = PTR_CAST( SvxOverlineItem, pItem ); |
| DBG_ASSERT( pTextLine, "FmTextControlShell::ExecuteTextAttribute: ooops - no underline/overline item!" ); |
| if ( pTextLine ) |
| { |
| FontUnderline eTL = pTextLine->GetLineStyle(); |
| if ( SID_ATTR_CHAR_UNDERLINE == nSlot ) { |
| aToggled.Put( SvxUnderlineItem( eTL == UNDERLINE_SINGLE ? UNDERLINE_NONE : UNDERLINE_SINGLE, nWhich ) ); |
| } else { |
| aToggled.Put( SvxOverlineItem( eTL == UNDERLINE_SINGLE ? UNDERLINE_NONE : UNDERLINE_SINGLE, nWhich ) ); |
| } |
| } |
| } |
| else |
| { |
| const SvxCrossedOutItem* pCrossedOut = PTR_CAST( SvxCrossedOutItem, pItem ); |
| DBG_ASSERT( pCrossedOut, "FmTextControlShell::ExecuteTextAttribute: ooops - no CrossedOut item!" ); |
| if ( pCrossedOut ) |
| { |
| FontStrikeout eFS = pCrossedOut->GetStrikeout(); |
| aToggled.Put( SvxCrossedOutItem( eFS == STRIKEOUT_SINGLE ? STRIKEOUT_NONE : STRIKEOUT_SINGLE, nWhich ) ); |
| } |
| } |
| |
| Sequence< PropertyValue > aArguments; |
| TransformItems( nSlot, aToggled, aArguments ); |
| aFeaturePos->second->dispatch( aArguments ); |
| } |
| break; |
| |
| case SID_ATTR_CHAR_FONTHEIGHT: |
| case SID_ATTR_CHAR_FONT: |
| case SID_ATTR_CHAR_POSTURE: |
| case SID_ATTR_CHAR_WEIGHT: |
| case SID_ATTR_CHAR_SHADOWED: |
| case SID_ATTR_CHAR_CONTOUR: |
| case SID_SET_SUPER_SCRIPT: |
| case SID_SET_SUB_SCRIPT: |
| { |
| const SfxItemSet* pArgs = _rReq.GetArgs(); |
| Sequence< PropertyValue > aArgs; |
| if ( pArgs ) |
| TransformItems( nSlot, *pArgs, aArgs ); |
| aFeaturePos->second->dispatch( aArgs ); |
| } |
| break; |
| |
| default: |
| if ( aFeaturePos->second->isFeatureEnabled() ) |
| aFeaturePos->second->dispatch(); |
| break; |
| } |
| } |
| _rReq.Done(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::GetTextAttributeState( SfxItemSet& _rSet ) |
| { |
| SfxWhichIter aIter( _rSet ); |
| sal_uInt16 nSlot = aIter.FirstWhich(); |
| while ( nSlot ) |
| { |
| if ( ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT ) |
| || ( nSlot == SID_ATTR_PARA_RIGHT_TO_LEFT ) |
| ) |
| { |
| if ( !SvtLanguageOptions().IsCTLFontEnabled() ) |
| { |
| _rSet.DisableItem( nSlot ); |
| nSlot = aIter.NextWhich(); |
| continue; |
| } |
| } |
| |
| ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlot ); |
| if ( aFeaturePos != m_aControlFeatures.end() ) |
| { |
| if ( aFeaturePos->second->isFeatureEnabled() ) |
| lcl_translateUnoStateToItem( nSlot, aFeaturePos->second->getFeatureState(), _rSet ); |
| else |
| _rSet.DisableItem( nSlot ); |
| } |
| else |
| { |
| bool bDisable = false; |
| |
| bool bNeedWriteableControl = false; |
| bool bNeedTextComponent = false; |
| bool bNeedSelection = false; |
| |
| switch ( nSlot ) |
| { |
| case SID_CHAR_DLG: |
| case SID_PARA_DLG: |
| bDisable |= m_aControlFeatures.empty(); |
| bNeedWriteableControl = true; |
| break; |
| |
| case SID_CUT: |
| bNeedSelection = true; |
| bNeedTextComponent = true; |
| bNeedWriteableControl = true; |
| DBG_TRACE( "FmTextControlShell::ClipBoard: need to invalidate again" ); |
| m_bNeedClipboardInvalidation = true; |
| break; |
| |
| case SID_PASTE: |
| { |
| Window* pActiveControlVCLWindow = lcl_getWindow( m_xActiveControl ); |
| if ( pActiveControlVCLWindow ) |
| { |
| TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pActiveControlVCLWindow) ); |
| bDisable |= !aDataHelper.HasFormat( SOT_FORMAT_STRING ); |
| } |
| else |
| bDisable |= true; |
| |
| bNeedTextComponent = true; |
| bNeedWriteableControl = true; |
| } |
| break; |
| |
| case SID_COPY: |
| bNeedTextComponent = true; |
| bNeedSelection = true; |
| break; |
| |
| case SID_SELECTALL: |
| bNeedTextComponent = true; |
| break; |
| |
| default: |
| // slot is unknown at all |
| bDisable |= true; |
| break; |
| } |
| OSL_POSTCOND( !bNeedSelection || bNeedTextComponent, "FmTextControlShell::GetTextAttributeState: bNeedSelection should imply bNeedTextComponent!" ); |
| |
| if ( !bDisable && bNeedWriteableControl ) |
| bDisable |= !IsActiveControl( ) || m_bActiveControlIsReadOnly; |
| |
| if ( !bDisable && bNeedTextComponent ) |
| bDisable |= !m_xActiveTextComponent.is(); |
| |
| if ( !bDisable && bNeedSelection ) |
| { |
| awt::Selection aSelection = m_xActiveTextComponent->getSelection(); |
| bDisable |= aSelection.Min == aSelection.Max; |
| } |
| |
| if ( bDisable ) |
| _rSet.DisableItem( nSlot ); |
| } |
| |
| nSlot = aIter.NextWhich(); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| bool FmTextControlShell::IsActiveControl( bool _bCountRichTextOnly ) const |
| { |
| if ( _bCountRichTextOnly && !m_bActiveControlIsRichText ) |
| return false; |
| |
| return m_bActiveControl; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::dispose() |
| { |
| if ( IsActiveControl() ) |
| controlDeactivated(); |
| if ( isControllerListening() ) |
| stopControllerListening(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::designModeChanged( bool /*_bNewDesignMode*/ ) |
| { |
| m_rBindings.Invalidate( pTextControlSlots ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::formActivated( const Reference< XFormController >& _rxController ) |
| { |
| #if OSL_DEBUG_LEVEL > 0 |
| ::rtl::OString sTrace( "FmTextControlShell::formActivated: 0x" ); |
| sTrace += ::rtl::OString::valueOf( (sal_IntPtr)_rxController.get(), 16 ); |
| DBG_TRACE( sTrace ); |
| #endif |
| |
| DBG_ASSERT( _rxController.is(), "FmTextControlShell::formActivated: invalid controller!" ); |
| if ( !_rxController.is() ) |
| return; |
| |
| // sometimes, a form controller notifies activations, even if it's already activated |
| if ( m_xActiveController == _rxController ) |
| return; |
| |
| try |
| { |
| startControllerListening( _rxController ); |
| controlActivated( _rxController->getCurrentControl() ); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::formDeactivated( const Reference< XFormController >& _rxController ) |
| { |
| #if OSL_DEBUG_LEVEL > 0 |
| ::rtl::OString sTrace( "FmTextControlShell::formDeactivated: 0x" ); |
| sTrace += ::rtl::OString::valueOf( (sal_IntPtr)_rxController.get(), 16 ); |
| DBG_TRACE( sTrace ); |
| #endif |
| (void)_rxController; |
| |
| if ( IsActiveControl() ) |
| controlDeactivated(); |
| if ( isControllerListening() ) |
| stopControllerListening(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::startControllerListening( const Reference< XFormController >& _rxController ) |
| { |
| OSL_PRECOND( _rxController.is(), "FmTextControlShell::startControllerListening: invalid controller!" ); |
| if ( !_rxController.is() ) |
| return; |
| |
| OSL_PRECOND( !isControllerListening(), "FmTextControlShell::startControllerListening: already listening!" ); |
| if ( isControllerListening() ) |
| stopControllerListening( ); |
| DBG_ASSERT( !isControllerListening(), "FmTextControlShell::startControllerListening: inconsistence!" ); |
| |
| try |
| { |
| Sequence< Reference< XControl > > aControls( _rxController->getControls() ); |
| m_aControlObservers.resize( 0 ); |
| m_aControlObservers.reserve( aControls.getLength() ); |
| |
| const Reference< XControl >* pControls = aControls.getConstArray(); |
| const Reference< XControl >* pControlsEnd = pControls + aControls.getLength(); |
| for ( ; pControls != pControlsEnd; ++pControls ) |
| { |
| m_aControlObservers.push_back( FocusListenerAdapter( new FmFocusListenerAdapter( *pControls, this ) ) ); |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| m_xActiveController = _rxController; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::stopControllerListening( ) |
| { |
| OSL_PRECOND( isControllerListening(), "FmTextControlShell::stopControllerListening: inconsistence!" ); |
| |
| // dispose all listeners associated with the controls of the active controller |
| for ( FocusListenerAdapters::iterator aLoop = m_aControlObservers.begin(); |
| aLoop != m_aControlObservers.end(); |
| ++aLoop |
| ) |
| { |
| (*aLoop)->dispose(); |
| } |
| |
| FocusListenerAdapters aEmpty; |
| m_aControlObservers.swap( aEmpty ); |
| |
| m_xActiveController.clear(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::implClearActiveControlRef() |
| { |
| // no more features for this control |
| for ( ControlFeatures::iterator aLoop = m_aControlFeatures.begin(); |
| aLoop != m_aControlFeatures.end(); |
| ++aLoop |
| ) |
| { |
| aLoop->second->dispose(); |
| } |
| |
| ControlFeatures aEmpty; |
| m_aControlFeatures.swap( aEmpty ); |
| |
| if ( m_aContextMenuObserver.get() ) |
| { |
| m_aContextMenuObserver->dispose(); |
| m_aContextMenuObserver = MouseListenerAdapter(); |
| } |
| |
| if ( m_xActiveTextComponent.is() ) |
| { |
| DBG_TRACE( "FmTextControlShell::ClipBoard: stopping timer for clipboard invalidation" ); |
| m_aClipboardInvalidation.Stop(); |
| } |
| // no more active control |
| m_xActiveControl.clear(); |
| m_xActiveTextComponent.clear(); |
| m_bActiveControlIsReadOnly = true; |
| m_bActiveControlIsRichText = false; |
| m_bActiveControl = false; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::controlDeactivated( ) |
| { |
| DBG_ASSERT( IsActiveControl(), "FmTextControlShell::controlDeactivated: no active control!" ); |
| |
| m_bActiveControl = false; |
| |
| m_rBindings.Invalidate( pTextControlSlots ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::controlActivated( const Reference< XControl >& _rxControl ) |
| { |
| // ensure that all knittings with the previously active control are lost |
| if ( m_xActiveControl.is() ) |
| implClearActiveControlRef(); |
| DBG_ASSERT( m_aControlFeatures.empty(), "FmTextControlShell::controlActivated: should have no dispatchers when I'm here!" ); |
| |
| #if OSL_DEBUG_LEVEL > 0 |
| { |
| Sequence< Reference< XControl > > aActiveControls; |
| if ( m_xActiveController.is() ) |
| aActiveControls = m_xActiveController->getControls(); |
| |
| bool bFoundThisControl = false; |
| |
| const Reference< XControl >* pControls = aActiveControls.getConstArray(); |
| const Reference< XControl >* pControlsEnd = pControls + aActiveControls.getLength(); |
| for ( ; ( pControls != pControlsEnd ) && !bFoundThisControl; ++pControls ) |
| { |
| if ( *pControls == _rxControl ) |
| bFoundThisControl = true; |
| } |
| DBG_ASSERT( bFoundThisControl, "FmTextControlShell::controlActivated: only controls which belong to the active controller can be activated!" ); |
| } |
| #endif |
| // ask the control for dispatchers for our text-related slots |
| fillFeatureDispatchers( _rxControl, pTextControlSlots, m_aControlFeatures ); |
| |
| // remember this control |
| m_xActiveControl = _rxControl; |
| m_xActiveTextComponent = m_xActiveTextComponent.query( _rxControl ); |
| m_bActiveControlIsReadOnly = lcl_determineReadOnly( m_xActiveControl ); |
| m_bActiveControlIsRichText = lcl_isRichText( m_xActiveControl ); |
| |
| // if we found a rich text control, we need context menu support |
| if ( m_bActiveControlIsRichText ) |
| { |
| DBG_ASSERT( NULL == m_aContextMenuObserver.get(), "FmTextControlShell::controlActivated: already have an observer!" ); |
| m_aContextMenuObserver = MouseListenerAdapter( new FmMouseListenerAdapter( _rxControl, this ) ); |
| } |
| |
| if ( m_xActiveTextComponent.is() ) |
| { |
| DBG_TRACE( "FmTextControlShell::ClipBoard: starting timer for clipboard invalidation" ); |
| m_aClipboardInvalidation.Start(); |
| } |
| |
| m_bActiveControl = true; |
| |
| m_rBindings.Invalidate( pTextControlSlots ); |
| |
| if ( m_pViewFrame ) |
| m_pViewFrame->UIFeatureChanged(); |
| |
| // don't call the activation handler if we don't have any slots we can serve |
| // The activation handler is used to put the shell on the top of the dispatcher stack, |
| // so it's preferred when slots are distributed. |
| // Note that this is a slight hack, to prevent that we grab slots from the SfxDispatcher |
| // which should be served by other shells (e.g. Cut/Copy/Paste). |
| // A real solution would be a forwarding-mechanism for slots: We should be on the top |
| // if we're active, but if we cannot handle the slot, then we need to tell the dispatcher |
| // to skip our shell, and pass the slot to the next one. However, this mechanism is not |
| // not in place in SFX. |
| // Another possibility would be to have dedicated shells for the slots which we might |
| // or might not be able to serve. However, this could probably increase the number of |
| // shells too much (In theory, nearly every slot could have an own shell then). |
| // |
| // #i51621# / 2005-08-19 / frank.schoenheit@sun.com |
| bool bHaveAnyServeableSlots = m_xActiveTextComponent.is() || !m_aControlFeatures.empty(); |
| if ( m_aControlActivationHandler.IsSet() && bHaveAnyServeableSlots ) |
| m_aControlActivationHandler.Call( NULL ); |
| |
| m_bNeedClipboardInvalidation = true; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::fillFeatureDispatchers( const Reference< XControl > _rxControl, SfxSlotId* _pZeroTerminatedSlots, |
| ControlFeatures& _rDispatchers ) |
| { |
| Reference< XDispatchProvider > xProvider( _rxControl, UNO_QUERY ); |
| SfxApplication* pApplication = SFX_APP(); |
| DBG_ASSERT( pApplication, "FmTextControlShell::fillFeatureDispatchers: no SfxApplication!" ); |
| if ( xProvider.is() && pApplication ) |
| { |
| SfxSlotId* pSlots = _pZeroTerminatedSlots; |
| while ( *pSlots ) |
| { |
| FmTextControlFeature* pDispatcher = implGetFeatureDispatcher( xProvider, pApplication, *pSlots ); |
| if ( pDispatcher ) |
| _rDispatchers.insert( ControlFeatures::value_type( *pSlots, ControlFeature( pDispatcher ) ) ); |
| |
| ++pSlots; |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::impl_parseURL_nothrow( URL& _rURL ) |
| { |
| try |
| { |
| if ( !m_xURLTransformer.is() ) |
| { |
| ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() ); |
| aContext.createComponent( "com.sun.star.util.URLTransformer", m_xURLTransformer ); |
| } |
| if ( m_xURLTransformer.is() ) |
| m_xURLTransformer->parseStrict( _rURL ); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| FmTextControlFeature* FmTextControlShell::implGetFeatureDispatcher( const Reference< XDispatchProvider >& _rxProvider, SfxApplication* _pApplication, SfxSlotId _nSlot ) |
| { |
| OSL_PRECOND( _rxProvider.is() && _pApplication, "FmTextControlShell::implGetFeatureDispatcher: invalid arg(s)!" ); |
| URL aFeatureURL; |
| aFeatureURL.Complete = lcl_getUnoSlotName( *_pApplication, _nSlot ); |
| impl_parseURL_nothrow( aFeatureURL ); |
| Reference< XDispatch > xDispatcher = _rxProvider->queryDispatch( aFeatureURL, ::rtl::OUString(), 0xFF ); |
| if ( xDispatcher.is() ) |
| return new FmTextControlFeature( xDispatcher, aFeatureURL, _nSlot, this ); |
| return NULL; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::Invalidate( SfxSlotId _nSlot ) |
| { |
| m_rBindings.Invalidate( _nSlot ); |
| // despite this method being called "Invalidate", we also update here - this gives more immediate |
| // feedback in the UI |
| m_rBindings.Update( _nSlot ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::focusGained( const ::com::sun::star::awt::FocusEvent& _rEvent ) |
| { |
| Reference< XControl > xControl( _rEvent.Source, UNO_QUERY ); |
| |
| #if OSL_DEBUG_LEVEL > 0 |
| ::rtl::OString sTrace( "FmTextControlShell::focusGained: 0x" ); |
| sTrace += ::rtl::OString::valueOf( (sal_IntPtr)xControl.get(), 16 ); |
| DBG_TRACE( sTrace ); |
| #endif |
| |
| DBG_ASSERT( xControl.is(), "FmTextControlShell::focusGained: suspicious focus event!" ); |
| if ( xControl.is() ) |
| controlActivated( xControl ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::focusLost( const ::com::sun::star::awt::FocusEvent& _rEvent ) |
| { |
| Reference< XControl > xControl( _rEvent.Source, UNO_QUERY ); |
| |
| #if OSL_DEBUG_LEVEL > 0 |
| ::rtl::OString sTrace( "FmTextControlShell::focusLost: 0x" ); |
| sTrace += ::rtl::OString::valueOf( (sal_IntPtr)xControl.get(), 16 ); |
| DBG_TRACE( sTrace ); |
| #endif |
| |
| m_bActiveControl = false; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::ForgetActiveControl() |
| { |
| implClearActiveControlRef(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmTextControlShell::contextMenuRequested( const awt::MouseEvent& /*_rEvent*/ ) |
| { |
| m_rBindings.GetDispatcher()->ExecutePopup( SVX_RES( RID_FM_TEXTATTRIBUTE_MENU ) ); |
| } |
| |
| //........................................................................ |
| } // namespace svx |
| //........................................................................ |
