| /************************************************************** |
| * |
| * 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_sc.hxx" |
| #include <svl/smplhint.hxx> |
| |
| |
| #include <editeng/eeitem.hxx> |
| |
| #include <editeng/editeng.hxx> |
| #include <editeng/editobj.hxx> |
| #include <editeng/flditem.hxx> |
| #include <rtl/uuid.h> |
| |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <com/sun/star/text/TextContentAnchorType.hpp> |
| #include <com/sun/star/text/WrapTextMode.hpp> |
| #include <com/sun/star/text/FilenameDisplayFormat.hpp> |
| |
| #include "fielduno.hxx" |
| #include "textuno.hxx" |
| #include "miscuno.hxx" |
| #include "docsh.hxx" |
| #include "hints.hxx" |
| #include "editsrc.hxx" |
| #include "cellsuno.hxx" |
| #include "servuno.hxx" // fuer IDs |
| #include "unoguard.hxx" |
| #include "unonames.hxx" |
| #include "editutil.hxx" |
| |
| using namespace com::sun::star; |
| |
| //------------------------------------------------------------------------ |
| |
| // alles ohne Which-ID, Map nur fuer PropertySetInfo |
| |
| const SfxItemPropertySet* lcl_GetURLPropertySet() |
| { |
| static SfxItemPropertyMapEntry aURLPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ANCTYPE), 0, &getCppuType((text::TextContentAnchorType*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ANCTYPES), 0, &getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_REPR), 0, &getCppuType((rtl::OUString*)0), 0, 0}, |
| {MAP_CHAR_LEN(SC_UNONAME_TARGET), 0, &getCppuType((rtl::OUString*)0), 0, 0}, |
| {MAP_CHAR_LEN(SC_UNONAME_TEXTWRAP), 0, &getCppuType((text::WrapTextMode*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_URL), 0, &getCppuType((rtl::OUString*)0), 0, 0}, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aURLPropertySet_Impl( aURLPropertyMap_Impl ); |
| return &aURLPropertySet_Impl; |
| } |
| |
| const SfxItemPropertySet* lcl_GetHeaderFieldPropertySet() |
| { |
| static SfxItemPropertyMapEntry aHeaderFieldPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ANCTYPE), 0, &getCppuType((text::TextContentAnchorType*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ANCTYPES), 0, &getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TEXTWRAP), 0, &getCppuType((text::WrapTextMode*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aHeaderFieldPropertySet_Impl( aHeaderFieldPropertyMap_Impl ); |
| return &aHeaderFieldPropertySet_Impl; |
| } |
| |
| const SfxItemPropertySet* lcl_GetFileFieldPropertySet() |
| { |
| static SfxItemPropertyMapEntry aFileFieldPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ANCTYPE), 0, &getCppuType((text::TextContentAnchorType*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ANCTYPES), 0, &getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_FILEFORM), 0, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TEXTWRAP), 0, &getCppuType((text::WrapTextMode*)0), beans::PropertyAttribute::READONLY, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aFileFieldPropertySet_Impl( aFileFieldPropertyMap_Impl ); |
| return &aFileFieldPropertySet_Impl; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| #define SCTEXTFIELD_SERVICE "com.sun.star.text.TextField" |
| #define SCTEXTCONTENT_SERVICE "com.sun.star.text.TextContent" |
| |
| SC_SIMPLE_SERVICE_INFO( ScCellFieldsObj, "ScCellFieldsObj", "com.sun.star.text.TextFields" ) |
| SC_SIMPLE_SERVICE_INFO( ScHeaderFieldsObj, "ScHeaderFieldsObj", "com.sun.star.text.TextFields" ) |
| |
| //------------------------------------------------------------------------ |
| |
| // ScUnoEditEngine nur um aus einer EditEngine die Felder herauszubekommen... |
| |
| enum ScUnoCollectMode |
| { |
| SC_UNO_COLLECT_NONE, |
| SC_UNO_COLLECT_COUNT, |
| SC_UNO_COLLECT_FINDINDEX, |
| SC_UNO_COLLECT_FINDPOS |
| }; |
| |
| class ScUnoEditEngine : public ScEditEngineDefaulter |
| { |
| ScUnoCollectMode eMode; |
| sal_uInt16 nFieldCount; |
| TypeId aFieldType; |
| SvxFieldData* pFound; // lokale Kopie |
| sal_uInt16 nFieldPar; |
| xub_StrLen nFieldPos; |
| sal_uInt16 nFieldIndex; |
| |
| public: |
| ScUnoEditEngine(ScEditEngineDefaulter* pSource); |
| ~ScUnoEditEngine(); |
| |
| //! nPos should be xub_StrLen |
| virtual String CalcFieldValue( const SvxFieldItem& rField, sal_uInt16 nPara, sal_uInt16 nPos, |
| Color*& rTxtColor, Color*& rFldColor ); |
| |
| sal_uInt16 CountFields(TypeId aType); |
| SvxFieldData* FindByIndex(sal_uInt16 nIndex, TypeId aType); |
| SvxFieldData* FindByPos(sal_uInt16 nPar, xub_StrLen nPos, TypeId aType); |
| |
| sal_uInt16 GetFieldPar() const { return nFieldPar; } |
| xub_StrLen GetFieldPos() const { return nFieldPos; } |
| }; |
| |
| ScUnoEditEngine::ScUnoEditEngine(ScEditEngineDefaulter* pSource) : |
| ScEditEngineDefaulter( *pSource ), |
| eMode( SC_UNO_COLLECT_NONE ), |
| nFieldCount( 0 ), |
| aFieldType( NULL ), |
| pFound( NULL ) |
| { |
| if (pSource) |
| { |
| EditTextObject* pData = pSource->CreateTextObject(); |
| SetText( *pData ); |
| delete pData; |
| } |
| } |
| |
| ScUnoEditEngine::~ScUnoEditEngine() |
| { |
| delete pFound; |
| } |
| |
| String ScUnoEditEngine::CalcFieldValue( const SvxFieldItem& rField, |
| sal_uInt16 nPara, sal_uInt16 nPos, Color*& rTxtColor, Color*& rFldColor ) |
| { |
| String aRet(EditEngine::CalcFieldValue( rField, nPara, nPos, rTxtColor, rFldColor )); |
| if (eMode != SC_UNO_COLLECT_NONE) |
| { |
| const SvxFieldData* pFieldData = rField.GetField(); |
| if ( pFieldData ) |
| { |
| if ( !aFieldType || pFieldData->Type() == aFieldType ) |
| { |
| if ( eMode == SC_UNO_COLLECT_FINDINDEX && !pFound && nFieldCount == nFieldIndex ) |
| { |
| pFound = pFieldData->Clone(); |
| nFieldPar = nPara; |
| nFieldPos = nPos; |
| } |
| if ( eMode == SC_UNO_COLLECT_FINDPOS && !pFound && |
| nPara == nFieldPar && nPos == nFieldPos ) |
| { |
| pFound = pFieldData->Clone(); |
| nFieldIndex = nFieldCount; |
| } |
| ++nFieldCount; |
| } |
| } |
| } |
| return aRet; |
| } |
| |
| sal_uInt16 ScUnoEditEngine::CountFields(TypeId aType) |
| { |
| eMode = SC_UNO_COLLECT_COUNT; |
| aFieldType = aType; |
| nFieldCount = 0; |
| UpdateFields(); |
| aFieldType = NULL; |
| eMode = SC_UNO_COLLECT_NONE; |
| |
| return nFieldCount; |
| } |
| |
| SvxFieldData* ScUnoEditEngine::FindByIndex(sal_uInt16 nIndex, TypeId aType) |
| { |
| eMode = SC_UNO_COLLECT_FINDINDEX; |
| nFieldIndex = nIndex; |
| aFieldType = aType; |
| nFieldCount = 0; |
| UpdateFields(); |
| aFieldType = NULL; |
| eMode = SC_UNO_COLLECT_NONE; |
| |
| return pFound; |
| } |
| |
| SvxFieldData* ScUnoEditEngine::FindByPos(sal_uInt16 nPar, xub_StrLen nPos, TypeId aType) |
| { |
| eMode = SC_UNO_COLLECT_FINDPOS; |
| nFieldPar = nPar; |
| nFieldPos = nPos; |
| aFieldType = aType; |
| nFieldCount = 0; |
| UpdateFields(); |
| aFieldType = NULL; |
| eMode = SC_UNO_COLLECT_NONE; |
| |
| return pFound; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScCellFieldsObj::ScCellFieldsObj(ScDocShell* pDocSh, const ScAddress& rPos) : |
| pDocShell( pDocSh ), |
| aCellPos( rPos ), |
| mpRefreshListeners( NULL ) |
| { |
| pDocShell->GetDocument()->AddUnoObject(*this); |
| |
| pEditSource = new ScCellEditSource( pDocShell, aCellPos ); |
| } |
| |
| ScCellFieldsObj::~ScCellFieldsObj() |
| { |
| if (pDocShell) |
| pDocShell->GetDocument()->RemoveUnoObject(*this); |
| |
| delete pEditSource; |
| |
| // increment refcount to prevent double call off dtor |
| osl_incrementInterlockedCount( &m_refCount ); |
| |
| if (mpRefreshListeners) |
| { |
| lang::EventObject aEvent; |
| aEvent.Source.set(static_cast<cppu::OWeakObject*>(this)); |
| if (mpRefreshListeners) |
| { |
| mpRefreshListeners->disposeAndClear(aEvent); |
| DELETEZ( mpRefreshListeners ); |
| } |
| } |
| } |
| |
| void ScCellFieldsObj::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| if ( rHint.ISA( ScUpdateRefHint ) ) |
| { |
| // const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; |
| |
| //! Ref-Update |
| } |
| else if ( rHint.ISA( SfxSimpleHint ) && |
| ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) |
| { |
| pDocShell = NULL; // ungueltig geworden |
| } |
| |
| // EditSource hat sich selber als Listener angemeldet |
| } |
| |
| // XIndexAccess (via XTextFields) |
| |
| ScCellFieldObj* ScCellFieldsObj::GetObjectByIndex_Impl(sal_Int32 Index) const |
| { |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| if ( aTempEngine.FindByIndex( (sal_uInt16)Index, NULL ) ) // in der Zelle ist der Typ egal |
| { |
| sal_uInt16 nPar = aTempEngine.GetFieldPar(); |
| xub_StrLen nPos = aTempEngine.GetFieldPos(); |
| ESelection aSelection( nPar, nPos, nPar, nPos+1 ); // Feld ist 1 Zeichen |
| return new ScCellFieldObj( pDocShell, aCellPos, aSelection ); |
| } |
| return NULL; |
| } |
| |
| sal_Int32 SAL_CALL ScCellFieldsObj::getCount() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| return aTempEngine.CountFields(NULL); // Felder zaehlen, in Zelle ist der Typ egal |
| } |
| |
| uno::Any SAL_CALL ScCellFieldsObj::getByIndex( sal_Int32 nIndex ) |
| throw(lang::IndexOutOfBoundsException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex)); |
| if (xField.is()) |
| return uno::makeAny(xField); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| // return uno::Any(); |
| } |
| |
| uno::Type SAL_CALL ScCellFieldsObj::getElementType() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return getCppuType((uno::Reference<text::XTextField>*)0); |
| } |
| |
| sal_Bool SAL_CALL ScCellFieldsObj::hasElements() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ( getCount() != 0 ); |
| } |
| |
| uno::Reference<container::XEnumeration> SAL_CALL ScCellFieldsObj::createEnumeration() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextFieldEnumeration"))); |
| } |
| |
| void SAL_CALL ScCellFieldsObj::addContainerListener( |
| const uno::Reference<container::XContainerListener>& /* xListener */ ) |
| throw(uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScCellFieldsObj::removeContainerListener( |
| const uno::Reference<container::XContainerListener>& /* xListener */ ) |
| throw(uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| // XRefreshable |
| void SAL_CALL ScCellFieldsObj::refresh( ) |
| throw (uno::RuntimeException) |
| { |
| if (mpRefreshListeners) |
| { |
| // Call all listeners. |
| uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements()); |
| sal_uInt32 nLength(aListeners.getLength()); |
| if (nLength) |
| { |
| const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray(); |
| if (pInterfaces) |
| { |
| lang::EventObject aEvent; |
| aEvent.Source.set(uno::Reference< util::XRefreshable >(const_cast<ScCellFieldsObj*>(this))); |
| sal_uInt32 i(0); |
| while (i < nLength) |
| { |
| try |
| { |
| while(i < nLength) |
| { |
| static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent); |
| ++pInterfaces; |
| ++i; |
| } |
| } |
| catch(uno::RuntimeException&) |
| { |
| // DBG_ERROR("a object is gone without to remove from Broadcaster"); |
| ++pInterfaces; |
| ++i; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void SAL_CALL ScCellFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener ) |
| throw (uno::RuntimeException) |
| { |
| if (xListener.is()) |
| { |
| ScUnoGuard aGuard; |
| if (!mpRefreshListeners) |
| mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex); |
| mpRefreshListeners->addInterface(xListener); |
| } |
| } |
| |
| void SAL_CALL ScCellFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener ) |
| throw (uno::RuntimeException) |
| { |
| if (xListener.is()) |
| { |
| ScUnoGuard aGuard; |
| if (mpRefreshListeners) |
| mpRefreshListeners->removeInterface(xListener); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| // Default-ctor wird fuer SMART_REFLECTION_IMPLEMENTATION gebraucht |
| |
| |
| //UNUSED2008-05 ScCellFieldObj::ScCellFieldObj() : |
| //UNUSED2008-05 OComponentHelper( getMutex() ), |
| //UNUSED2008-05 aPropSet( lcl_GetURLPropertyMap() ), |
| //UNUSED2008-05 pDocShell( NULL ) |
| //UNUSED2008-05 { |
| //UNUSED2008-05 pEditSource = NULL; |
| //UNUSED2008-05 } |
| |
| ScCellFieldObj::ScCellFieldObj(ScDocShell* pDocSh, const ScAddress& rPos, |
| const ESelection& rSel) : |
| OComponentHelper( getMutex() ), |
| pPropSet( lcl_GetURLPropertySet() ), |
| pDocShell( pDocSh ), |
| aCellPos( rPos ), |
| aSelection( rSel ) |
| { |
| // pDocShell ist Null, wenn per ServiceProvider erzeugt |
| |
| if (pDocShell) |
| { |
| pDocShell->GetDocument()->AddUnoObject(*this); |
| pEditSource = new ScCellEditSource( pDocShell, aCellPos ); |
| } |
| else |
| pEditSource = NULL; |
| } |
| |
| uno::Any SAL_CALL ScCellFieldObj::queryAggregation( const uno::Type& rType ) |
| throw(uno::RuntimeException) |
| { |
| SC_QUERYINTERFACE( text::XTextField ) |
| SC_QUERYINTERFACE( text::XTextContent ) // parent of XTextField |
| SC_QUERYINTERFACE( beans::XPropertySet ) |
| SC_QUERYINTERFACE( lang::XUnoTunnel ) |
| SC_QUERYINTERFACE( lang::XServiceInfo ) |
| |
| return OComponentHelper::queryAggregation( rType ); // XComponent |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScCellFieldObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> aParentTypes(OComponentHelper::getTypes()); |
| long nParentLen = aParentTypes.getLength(); |
| const uno::Type* pParentPtr = aParentTypes.getConstArray(); |
| |
| aTypes.realloc( nParentLen + 4 ); |
| uno::Type* pPtr = aTypes.getArray(); |
| pPtr[nParentLen + 0] = getCppuType((const uno::Reference<text::XTextField>*)0); |
| pPtr[nParentLen + 1] = getCppuType((const uno::Reference<beans::XPropertySet>*)0); |
| pPtr[nParentLen + 2] = getCppuType((const uno::Reference<lang::XUnoTunnel>*)0); |
| pPtr[nParentLen + 3] = getCppuType((const uno::Reference<lang::XServiceInfo>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> SAL_CALL ScCellFieldObj::getImplementationId() |
| throw(uno::RuntimeException) |
| { |
| static uno::Sequence< sal_Int8 > aId; |
| if( aId.getLength() == 0 ) |
| { |
| aId.realloc( 16 ); |
| rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); |
| } |
| return aId; |
| } |
| |
| uno::Any SAL_CALL ScCellFieldObj::queryInterface( const uno::Type& rType ) |
| throw(uno::RuntimeException) |
| { |
| return OComponentHelper::queryInterface( rType ); |
| } |
| |
| void SAL_CALL ScCellFieldObj::acquire() throw() |
| { |
| OComponentHelper::acquire(); |
| } |
| |
| void SAL_CALL ScCellFieldObj::release() throw() |
| { |
| OComponentHelper::release(); |
| } |
| |
| void ScCellFieldObj::InitDoc( ScDocShell* pDocSh, const ScAddress& rPos, |
| const ESelection& rSel ) |
| { |
| if ( pDocSh && !pEditSource ) |
| { |
| aCellPos = rPos; |
| aSelection = rSel; |
| pDocShell = pDocSh; |
| |
| pDocShell->GetDocument()->AddUnoObject(*this); |
| pEditSource = new ScCellEditSource( pDocShell, aCellPos ); |
| } |
| } |
| |
| ScCellFieldObj::~ScCellFieldObj() |
| { |
| if (pDocShell) |
| pDocShell->GetDocument()->RemoveUnoObject(*this); |
| |
| delete pEditSource; |
| } |
| |
| void ScCellFieldObj::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| //! Updates fuer aSelection (muessen erst noch erzeugt werden) !!!!!! |
| |
| if ( rHint.ISA( ScUpdateRefHint ) ) |
| { |
| // const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; |
| |
| //! Ref-Update |
| } |
| else if ( rHint.ISA( SfxSimpleHint ) && |
| ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) |
| { |
| pDocShell = NULL; // ungueltig geworden |
| } |
| |
| // EditSource hat sich selber als Listener angemeldet |
| } |
| |
| // per getImplementation gerufen: |
| |
| SvxFieldItem ScCellFieldObj::CreateFieldItem() |
| { |
| DBG_ASSERT( !pEditSource, "CreateFieldItem mit eingefuegtem Feld" ); |
| |
| SvxURLField aField; |
| aField.SetFormat(SVXURLFORMAT_APPDEFAULT); |
| aField.SetURL( aUrl ); |
| aField.SetRepresentation( aRepresentation ); |
| aField.SetTargetFrame( aTarget ); |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| |
| void ScCellFieldObj::DeleteField() |
| { |
| if (pEditSource) |
| { |
| SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder(); |
| // pEditEngine->QuickDelete( aSelection ); |
| pForwarder->QuickInsertText( String(), aSelection ); |
| pEditSource->UpdateData(); |
| |
| aSelection.nEndPara = aSelection.nStartPara; |
| aSelection.nEndPos = aSelection.nStartPos; |
| |
| //! Broadcast, um Selektion in anderen Objekten anzupassen |
| //! (auch bei anderen Aktionen) |
| } |
| } |
| |
| // XTextField |
| |
| rtl::OUString SAL_CALL ScCellFieldObj::getPresentation( sal_Bool bShowCommand ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| String aRet; |
| |
| if (pEditSource) |
| { |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| // Typ egal (in Zellen gibts nur URLs) |
| SvxFieldData* pField = aTempEngine.FindByPos( aSelection.nStartPara, aSelection.nStartPos, 0 ); |
| DBG_ASSERT(pField,"getPresentation: Feld nicht gefunden"); |
| if (pField) |
| { |
| SvxURLField* pURL = (SvxURLField*)pField; |
| if (bShowCommand) |
| aRet = pURL->GetURL(); |
| else |
| aRet = pURL->GetRepresentation(); |
| } |
| } |
| |
| return aRet; |
| } |
| |
| // XTextContent |
| |
| void SAL_CALL ScCellFieldObj::attach( const uno::Reference<text::XTextRange>& xTextRange ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (xTextRange.is()) |
| { |
| uno::Reference<text::XText> xText(xTextRange->getText()); |
| if (xText.is()) |
| { |
| xText->insertTextContent( xTextRange, this, sal_True ); |
| } |
| } |
| } |
| |
| uno::Reference<text::XTextRange> SAL_CALL ScCellFieldObj::getAnchor() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pDocShell) |
| return new ScCellObj( pDocShell, aCellPos ); |
| return NULL; |
| } |
| |
| // XComponent |
| |
| void SAL_CALL ScCellFieldObj::dispose() throw(uno::RuntimeException) |
| { |
| OComponentHelper::dispose(); |
| } |
| |
| void SAL_CALL ScCellFieldObj::addEventListener( |
| const uno::Reference<lang::XEventListener>& xListener ) |
| throw(uno::RuntimeException) |
| { |
| OComponentHelper::addEventListener( xListener ); |
| } |
| |
| void SAL_CALL ScCellFieldObj::removeEventListener( |
| const uno::Reference<lang::XEventListener>& xListener ) |
| throw(uno::RuntimeException) |
| { |
| OComponentHelper::removeEventListener( xListener ); |
| } |
| |
| // XPropertySet |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellFieldObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef = pPropSet->getPropertySetInfo(); |
| return aRef; |
| } |
| |
| void SAL_CALL ScCellFieldObj::setPropertyValue( |
| const rtl::OUString& aPropertyName, const uno::Any& aValue ) |
| throw(beans::UnknownPropertyException, beans::PropertyVetoException, |
| lang::IllegalArgumentException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| String aNameString(aPropertyName); |
| rtl::OUString aStrVal; |
| if (pEditSource) |
| { |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| // Typ egal (in Zellen gibts nur URLs) |
| SvxFieldData* pField = aTempEngine.FindByPos( aSelection.nStartPara, aSelection.nStartPos, 0 ); |
| DBG_ASSERT(pField,"setPropertyValue: Feld nicht gefunden"); |
| if (pField) |
| { |
| SvxURLField* pURL = (SvxURLField*)pField; // ist eine Kopie in der ScUnoEditEngine |
| |
| sal_Bool bOk = sal_True; |
| if ( aNameString.EqualsAscii( SC_UNONAME_URL ) ) |
| { |
| if (aValue >>= aStrVal) |
| pURL->SetURL( aStrVal ); |
| } |
| else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) ) |
| { |
| if (aValue >>= aStrVal) |
| pURL->SetRepresentation( aStrVal ); |
| } |
| else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) ) |
| { |
| if (aValue >>= aStrVal) |
| pURL->SetTargetFrame( aStrVal ); |
| } |
| else |
| bOk = sal_False; |
| |
| if (bOk) |
| { |
| pEditEngine->QuickInsertField( SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection ); |
| pEditSource->UpdateData(); |
| } |
| } |
| } |
| else // noch nicht eingefuegt |
| { |
| if ( aNameString.EqualsAscii( SC_UNONAME_URL ) ) |
| { |
| if (aValue >>= aStrVal) |
| aUrl = String( aStrVal ); |
| } |
| else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) ) |
| { |
| if (aValue >>= aStrVal) |
| aRepresentation = String( aStrVal ); |
| } |
| else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) ) |
| { |
| if (aValue >>= aStrVal) |
| aTarget = String( aStrVal ); |
| } |
| } |
| } |
| |
| uno::Any SAL_CALL ScCellFieldObj::getPropertyValue( const rtl::OUString& aPropertyName ) |
| throw(beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| uno::Any aRet; |
| String aNameString(aPropertyName); |
| |
| // anchor type is always "as character", text wrap always "none" |
| |
| if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPE ) ) |
| aRet <<= text::TextContentAnchorType_AS_CHARACTER; |
| else if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPES ) ) |
| { |
| uno::Sequence<text::TextContentAnchorType> aSeq(1); |
| aSeq[0] = text::TextContentAnchorType_AS_CHARACTER; |
| aRet <<= aSeq; |
| } |
| else if ( aNameString.EqualsAscii( SC_UNONAME_TEXTWRAP ) ) |
| aRet <<= text::WrapTextMode_NONE; |
| else if (pEditSource) |
| { |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| // Typ egal (in Zellen gibts nur URLs) |
| SvxFieldData* pField = aTempEngine.FindByPos( aSelection.nStartPara, aSelection.nStartPos, 0 ); |
| DBG_ASSERT(pField,"getPropertyValue: Feld nicht gefunden"); |
| if (pField) |
| { |
| SvxURLField* pURL = (SvxURLField*)pField; |
| |
| if ( aNameString.EqualsAscii( SC_UNONAME_URL ) ) |
| aRet <<= rtl::OUString( pURL->GetURL() ); |
| else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) ) |
| aRet <<= rtl::OUString( pURL->GetRepresentation() ); |
| else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) ) |
| aRet <<= rtl::OUString( pURL->GetTargetFrame() ); |
| } |
| } |
| else // noch nicht eingefuegt |
| { |
| if ( aNameString.EqualsAscii( SC_UNONAME_URL ) ) |
| aRet <<= rtl::OUString( aUrl ); |
| else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) ) |
| aRet <<= rtl::OUString( aRepresentation ); |
| else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) ) |
| aRet <<= rtl::OUString( aTarget ); |
| } |
| return aRet; |
| } |
| |
| SC_IMPL_DUMMY_PROPERTY_LISTENER( ScCellFieldObj ) |
| |
| // XUnoTunnel |
| |
| sal_Int64 SAL_CALL ScCellFieldObj::getSomething( |
| const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException) |
| { |
| if ( rId.getLength() == 16 && |
| 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), |
| rId.getConstArray(), 16 ) ) |
| { |
| return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this)); |
| } |
| return 0; |
| } |
| |
| // static |
| const uno::Sequence<sal_Int8>& ScCellFieldObj::getUnoTunnelId() |
| { |
| static uno::Sequence<sal_Int8> * pSeq = 0; |
| if( !pSeq ) |
| { |
| osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); |
| if( !pSeq ) |
| { |
| static uno::Sequence< sal_Int8 > aSeq( 16 ); |
| rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); |
| pSeq = &aSeq; |
| } |
| } |
| return *pSeq; |
| } |
| |
| // static |
| ScCellFieldObj* ScCellFieldObj::getImplementation( |
| const uno::Reference<text::XTextContent> xObj ) |
| { |
| ScCellFieldObj* pRet = NULL; |
| uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY ); |
| if (xUT.is()) |
| pRet = reinterpret_cast<ScCellFieldObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId()))); |
| return pRet; |
| } |
| |
| // XServiceInfo |
| |
| rtl::OUString SAL_CALL ScCellFieldObj::getImplementationName() throw(uno::RuntimeException) |
| { |
| return rtl::OUString::createFromAscii( "ScCellFieldObj" ); |
| } |
| |
| sal_Bool SAL_CALL ScCellFieldObj::supportsService( const rtl::OUString& rServiceName ) |
| throw(uno::RuntimeException) |
| { |
| String aServiceStr( rServiceName ); |
| return aServiceStr.EqualsAscii( SCTEXTFIELD_SERVICE ) || |
| aServiceStr.EqualsAscii( SCTEXTCONTENT_SERVICE ); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellFieldObj::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| uno::Sequence<rtl::OUString> aRet(2); |
| rtl::OUString* pArray = aRet.getArray(); |
| pArray[0] = rtl::OUString::createFromAscii( SCTEXTFIELD_SERVICE ); |
| pArray[1] = rtl::OUString::createFromAscii( SCTEXTCONTENT_SERVICE ); |
| return aRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScHeaderFieldsObj::ScHeaderFieldsObj(ScHeaderFooterContentObj* pContent, sal_uInt16 nP, sal_uInt16 nT) : |
| pContentObj( pContent ), |
| nPart( nP ), |
| nType( nT ), |
| mpRefreshListeners( NULL ) |
| { |
| DBG_ASSERT( pContentObj, "ScHeaderFieldsObj ohne Objekt?" ); |
| |
| if (pContentObj) |
| { |
| pContentObj->acquire(); // darf nicht wegkommen |
| pEditSource = new ScHeaderFooterEditSource( pContentObj, nPart ); |
| } |
| else |
| pEditSource = NULL; |
| } |
| |
| ScHeaderFieldsObj::~ScHeaderFieldsObj() |
| { |
| delete pEditSource; |
| |
| if (pContentObj) |
| pContentObj->release(); |
| |
| // increment refcount to prevent double call off dtor |
| osl_incrementInterlockedCount( &m_refCount ); |
| |
| if (mpRefreshListeners) |
| { |
| lang::EventObject aEvent; |
| aEvent.Source = static_cast<cppu::OWeakObject*>(this); |
| if (mpRefreshListeners) |
| { |
| mpRefreshListeners->disposeAndClear(aEvent); |
| DELETEZ( mpRefreshListeners ); |
| } |
| } |
| } |
| |
| // XIndexAccess (via XTextFields) |
| |
| ScHeaderFieldObj* ScHeaderFieldsObj::GetObjectByIndex_Impl(sal_Int32 Index) const |
| { |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| TypeId aTypeId = NULL; |
| switch (nType) |
| { |
| case SC_SERVICE_PAGEFIELD: aTypeId = TYPE(SvxPageField); break; |
| case SC_SERVICE_PAGESFIELD: aTypeId = TYPE(SvxPagesField); break; |
| case SC_SERVICE_DATEFIELD: aTypeId = TYPE(SvxDateField); break; |
| case SC_SERVICE_TIMEFIELD: aTypeId = TYPE(SvxTimeField); break; |
| case SC_SERVICE_TITLEFIELD: aTypeId = TYPE(SvxFileField); break; |
| case SC_SERVICE_FILEFIELD: aTypeId = TYPE(SvxExtFileField); break; |
| case SC_SERVICE_SHEETFIELD: aTypeId = TYPE(SvxTableField); break; |
| // bei SC_SERVICE_INVALID bleibt TypeId Null |
| } |
| SvxFieldData* pData = aTempEngine.FindByIndex( (sal_uInt16)Index, aTypeId ); |
| if ( pData ) |
| { |
| sal_uInt16 nPar = aTempEngine.GetFieldPar(); |
| xub_StrLen nPos = aTempEngine.GetFieldPos(); |
| |
| sal_uInt16 nFieldType = nType; |
| if ( nFieldType == SC_SERVICE_INVALID ) |
| { |
| if ( pData->ISA( SvxPageField ) ) nFieldType = SC_SERVICE_PAGEFIELD; |
| else if ( pData->ISA( SvxPagesField ) ) nFieldType = SC_SERVICE_PAGESFIELD; |
| else if ( pData->ISA( SvxDateField ) ) nFieldType = SC_SERVICE_DATEFIELD; |
| else if ( pData->ISA( SvxTimeField ) ) nFieldType = SC_SERVICE_TIMEFIELD; |
| else if ( pData->ISA( SvxFileField ) ) nFieldType = SC_SERVICE_TITLEFIELD; |
| else if ( pData->ISA( SvxExtFileField ) ) nFieldType = SC_SERVICE_FILEFIELD; |
| else if ( pData->ISA( SvxTableField ) ) nFieldType = SC_SERVICE_SHEETFIELD; |
| } |
| |
| ESelection aSelection( nPar, nPos, nPar, nPos+1 ); // Field is 1 character |
| return new ScHeaderFieldObj( pContentObj, nPart, nFieldType, aSelection ); |
| } |
| return NULL; |
| } |
| |
| sal_Int32 SAL_CALL ScHeaderFieldsObj::getCount() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| //! Feld-Funktionen muessen an den Forwarder !!! |
| ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| |
| TypeId aTypeId = NULL; |
| switch (nType) |
| { |
| case SC_SERVICE_PAGEFIELD: aTypeId = TYPE(SvxPageField); break; |
| case SC_SERVICE_PAGESFIELD: aTypeId = TYPE(SvxPagesField); break; |
| case SC_SERVICE_DATEFIELD: aTypeId = TYPE(SvxDateField); break; |
| case SC_SERVICE_TIMEFIELD: aTypeId = TYPE(SvxTimeField); break; |
| case SC_SERVICE_TITLEFIELD: aTypeId = TYPE(SvxFileField); break; |
| case SC_SERVICE_FILEFIELD: aTypeId = TYPE(SvxExtFileField); break; |
| case SC_SERVICE_SHEETFIELD: aTypeId = TYPE(SvxTableField); break; |
| } |
| return aTempEngine.CountFields(aTypeId); // Felder zaehlen |
| } |
| |
| uno::Any SAL_CALL ScHeaderFieldsObj::getByIndex( sal_Int32 nIndex ) |
| throw(lang::IndexOutOfBoundsException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex)); |
| if (xField.is()) |
| return uno::makeAny(xField); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| // return uno::Any(); |
| } |
| |
| uno::Type SAL_CALL ScHeaderFieldsObj::getElementType() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return getCppuType((uno::Reference<text::XTextField>*)0); |
| } |
| |
| sal_Bool SAL_CALL ScHeaderFieldsObj::hasElements() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ( getCount() != 0 ); |
| } |
| |
| uno::Reference<container::XEnumeration> SAL_CALL ScHeaderFieldsObj::createEnumeration() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextFieldEnumeration"))); |
| } |
| |
| void SAL_CALL ScHeaderFieldsObj::addContainerListener( |
| const uno::Reference<container::XContainerListener>& /* xListener */ ) |
| throw(uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScHeaderFieldsObj::removeContainerListener( |
| const uno::Reference<container::XContainerListener>& /* xListener */ ) |
| throw(uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| // XRefreshable |
| void SAL_CALL ScHeaderFieldsObj::refresh( ) |
| throw (uno::RuntimeException) |
| { |
| if (mpRefreshListeners) |
| { |
| // Call all listeners. |
| uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements()); |
| sal_uInt32 nLength(aListeners.getLength()); |
| if (nLength) |
| { |
| const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray(); |
| if (pInterfaces) |
| { |
| lang::EventObject aEvent; |
| aEvent.Source.set(uno::Reference< util::XRefreshable >(const_cast<ScHeaderFieldsObj*>(this))); |
| sal_uInt32 i(0); |
| while (i < nLength) |
| { |
| try |
| { |
| while(i < nLength) |
| { |
| static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent); |
| ++pInterfaces; |
| ++i; |
| } |
| } |
| catch(uno::RuntimeException&) |
| { |
| // DBG_ERROR("a object is gone without to remove from Broadcaster"); |
| ++pInterfaces; |
| ++i; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void SAL_CALL ScHeaderFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener ) |
| throw (uno::RuntimeException) |
| { |
| if (xListener.is()) |
| { |
| ScUnoGuard aGuard; |
| if (!mpRefreshListeners) |
| mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex); |
| mpRefreshListeners->addInterface(xListener); |
| } |
| } |
| |
| void SAL_CALL ScHeaderFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener ) |
| throw (uno::RuntimeException) |
| { |
| if (xListener.is()) |
| { |
| ScUnoGuard aGuard; |
| if (mpRefreshListeners) |
| mpRefreshListeners->removeInterface(xListener); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| SvxFileFormat lcl_UnoToSvxFileFormat( sal_Int16 nUnoValue ) |
| { |
| switch( nUnoValue ) |
| { |
| case text::FilenameDisplayFormat::FULL: return SVXFILEFORMAT_FULLPATH; |
| case text::FilenameDisplayFormat::PATH: return SVXFILEFORMAT_PATH; |
| case text::FilenameDisplayFormat::NAME: return SVXFILEFORMAT_NAME; |
| // case text::FilenameDisplayFormat::NAME_AND_EXT: |
| default: |
| return SVXFILEFORMAT_NAME_EXT; |
| } |
| } |
| |
| sal_Int16 lcl_SvxToUnoFileFormat( SvxFileFormat nSvxValue ) |
| { |
| switch( nSvxValue ) |
| { |
| case SVXFILEFORMAT_NAME_EXT: return text::FilenameDisplayFormat::NAME_AND_EXT; |
| case SVXFILEFORMAT_FULLPATH: return text::FilenameDisplayFormat::FULL; |
| case SVXFILEFORMAT_PATH: return text::FilenameDisplayFormat::PATH; |
| // case SVXFILEFORMAT_NAME: |
| default: |
| return text::FilenameDisplayFormat::NAME; |
| } |
| } |
| |
| |
| // Default-ctor wird fuer SMART_REFLECTION_IMPLEMENTATION gebraucht |
| //UNUSED2008-05 ScHeaderFieldObj::ScHeaderFieldObj() : |
| //UNUSED2008-05 OComponentHelper( getMutex() ), |
| //UNUSED2008-05 aPropSet( lcl_GetHeaderFieldPropertyMap() ), |
| //UNUSED2008-05 pContentObj( NULL ), |
| //UNUSED2008-05 nPart( 0 ), |
| //UNUSED2008-05 nType( 0 ), |
| //UNUSED2008-05 nFileFormat( SVXFILEFORMAT_NAME_EXT ) |
| //UNUSED2008-05 { |
| //UNUSED2008-05 pEditSource = NULL; |
| //UNUSED2008-05 } |
| |
| ScHeaderFieldObj::ScHeaderFieldObj(ScHeaderFooterContentObj* pContent, sal_uInt16 nP, |
| sal_uInt16 nT, const ESelection& rSel) : |
| OComponentHelper( getMutex() ), |
| pPropSet( (nT == SC_SERVICE_FILEFIELD) ? lcl_GetFileFieldPropertySet() : lcl_GetHeaderFieldPropertySet() ), |
| pContentObj( pContent ), |
| nPart( nP ), |
| nType( nT ), |
| aSelection( rSel ), |
| nFileFormat( SVXFILEFORMAT_NAME_EXT ) |
| { |
| // pContent ist Null, wenn per ServiceProvider erzeugt |
| |
| if (pContentObj) |
| { |
| pContentObj->acquire(); // darf nicht wegkommen |
| pEditSource = new ScHeaderFooterEditSource( pContentObj, nPart ); |
| } |
| else |
| pEditSource = NULL; |
| } |
| |
| uno::Any SAL_CALL ScHeaderFieldObj::queryAggregation( const uno::Type& rType ) |
| throw(uno::RuntimeException) |
| { |
| SC_QUERYINTERFACE( text::XTextField ) |
| SC_QUERYINTERFACE( text::XTextContent ) // parent of XTextField |
| SC_QUERYINTERFACE( beans::XPropertySet ) |
| SC_QUERYINTERFACE( lang::XUnoTunnel ) |
| SC_QUERYINTERFACE( lang::XServiceInfo ) |
| |
| return OComponentHelper::queryAggregation( rType ); // XComponent |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScHeaderFieldObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> aParentTypes(OComponentHelper::getTypes()); |
| long nParentLen = aParentTypes.getLength(); |
| const uno::Type* pParentPtr = aParentTypes.getConstArray(); |
| |
| aTypes.realloc( nParentLen + 4 ); |
| uno::Type* pPtr = aTypes.getArray(); |
| pPtr[nParentLen + 0] = getCppuType((const uno::Reference<text::XTextField>*)0); |
| pPtr[nParentLen + 1] = getCppuType((const uno::Reference<beans::XPropertySet>*)0); |
| pPtr[nParentLen + 2] = getCppuType((const uno::Reference<lang::XUnoTunnel>*)0); |
| pPtr[nParentLen + 3] = getCppuType((const uno::Reference<lang::XServiceInfo>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> SAL_CALL ScHeaderFieldObj::getImplementationId() |
| throw(uno::RuntimeException) |
| { |
| static uno::Sequence< sal_Int8 > aId; |
| if( aId.getLength() == 0 ) |
| { |
| aId.realloc( 16 ); |
| rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); |
| } |
| return aId; |
| } |
| |
| uno::Any SAL_CALL ScHeaderFieldObj::queryInterface( const uno::Type& rType ) |
| throw(uno::RuntimeException) |
| { |
| return OComponentHelper::queryInterface( rType ); |
| } |
| |
| void SAL_CALL ScHeaderFieldObj::acquire() throw() |
| { |
| OComponentHelper::acquire(); |
| } |
| |
| void SAL_CALL ScHeaderFieldObj::release() throw() |
| { |
| OComponentHelper::release(); |
| } |
| |
| void ScHeaderFieldObj::InitDoc( ScHeaderFooterContentObj* pContent, sal_uInt16 nP, |
| const ESelection& rSel ) |
| { |
| if ( pContent && !pEditSource ) |
| { |
| DBG_ASSERT( !pContentObj, "ContentObj, aber kein EditSource?" ); |
| |
| aSelection = rSel; |
| nPart = nP; |
| pContentObj = pContent; |
| |
| pContentObj->acquire(); // darf nicht wegkommen |
| pEditSource = new ScHeaderFooterEditSource( pContentObj, nPart ); |
| } |
| } |
| |
| ScHeaderFieldObj::~ScHeaderFieldObj() |
| { |
| delete pEditSource; |
| |
| if (pContentObj) |
| pContentObj->release(); |
| } |
| |
| // per getImplementation gerufen: |
| |
| SvxFieldItem ScHeaderFieldObj::CreateFieldItem() |
| { |
| DBG_ASSERT( !pEditSource, "CreateFieldItem mit eingefuegtem Feld" ); |
| |
| switch (nType) |
| { |
| case SC_SERVICE_PAGEFIELD: |
| { |
| SvxPageField aField; |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| case SC_SERVICE_PAGESFIELD: |
| { |
| SvxPagesField aField; |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| case SC_SERVICE_DATEFIELD: |
| { |
| SvxDateField aField; |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| case SC_SERVICE_TIMEFIELD: |
| { |
| SvxTimeField aField; |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| case SC_SERVICE_TITLEFIELD: |
| { |
| SvxFileField aField; |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| case SC_SERVICE_FILEFIELD: |
| { |
| SvxExtFileField aField; |
| aField.SetFormat( (SvxFileFormat) nFileFormat ); |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| case SC_SERVICE_SHEETFIELD: |
| { |
| SvxTableField aField; |
| return SvxFieldItem( aField, EE_FEATURE_FIELD ); |
| } |
| } |
| |
| return SvxFieldItem( SvxFieldData(), EE_FEATURE_FIELD ); |
| } |
| |
| void ScHeaderFieldObj::DeleteField() |
| { |
| if (pEditSource) |
| { |
| SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder(); |
| // pEditEngine->QuickDelete( aSelection ); |
| pForwarder->QuickInsertText( String(), aSelection ); |
| pEditSource->UpdateData(); |
| |
| aSelection.nEndPara = aSelection.nStartPara; |
| aSelection.nEndPos = aSelection.nStartPos; |
| |
| //! Broadcast, um Selektion in anderen Objekten anzupassen |
| //! (auch bei anderen Aktionen) |
| } |
| } |
| |
| // XTextField |
| |
| rtl::OUString SAL_CALL ScHeaderFieldObj::getPresentation( sal_Bool /* bShowCommand */ ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| String aRet; |
| |
| if (pEditSource) |
| { |
| // Feld von der EditEngine formatieren lassen, bShowCommand gibt's nicht |
| |
| SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder(); |
| aRet = pForwarder->GetText( aSelection ); |
| } |
| |
| return aRet; |
| } |
| |
| // XTextContent |
| |
| void SAL_CALL ScHeaderFieldObj::attach( const uno::Reference<text::XTextRange>& xTextRange ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (xTextRange.is()) |
| { |
| uno::Reference<text::XText> xText(xTextRange->getText()); |
| if (xText.is()) |
| { |
| xText->insertTextContent( xTextRange, this, sal_True ); |
| } |
| } |
| } |
| |
| uno::Reference<text::XTextRange> SAL_CALL ScHeaderFieldObj::getAnchor() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pContentObj) |
| { |
| uno::Reference<text::XText> xText; |
| if ( nPart == SC_HDFT_LEFT ) |
| xText = pContentObj->getLeftText(); |
| else if (nPart == SC_HDFT_CENTER) |
| xText = pContentObj->getCenterText(); |
| else |
| xText = pContentObj->getRightText(); |
| return uno::Reference<text::XTextRange>( xText, uno::UNO_QUERY ); |
| } |
| return NULL; |
| } |
| |
| // XComponent |
| |
| void SAL_CALL ScHeaderFieldObj::dispose() throw(uno::RuntimeException) |
| { |
| OComponentHelper::dispose(); |
| } |
| |
| void SAL_CALL ScHeaderFieldObj::addEventListener( |
| const uno::Reference<lang::XEventListener>& xListener ) |
| throw(uno::RuntimeException) |
| { |
| OComponentHelper::addEventListener( xListener ); |
| } |
| |
| void SAL_CALL ScHeaderFieldObj::removeEventListener( |
| const uno::Reference<lang::XEventListener>& xListener ) |
| throw(uno::RuntimeException) |
| { |
| OComponentHelper::removeEventListener( xListener ); |
| } |
| |
| // XPropertySet |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScHeaderFieldObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (nType == SC_SERVICE_FILEFIELD) |
| { |
| // file field has different properties |
| static uno::Reference<beans::XPropertySetInfo> aFileFieldInfo = pPropSet->getPropertySetInfo(); |
| return aFileFieldInfo; |
| } |
| else |
| { |
| static uno::Reference<beans::XPropertySetInfo> aRef = pPropSet->getPropertySetInfo(); |
| return aRef; |
| } |
| } |
| |
| void SAL_CALL ScHeaderFieldObj::setPropertyValue( |
| const rtl::OUString& aPropertyName, const uno::Any& aValue ) |
| throw(beans::UnknownPropertyException, beans::PropertyVetoException, |
| lang::IllegalArgumentException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| String aNameString(aPropertyName); |
| if ( nType == SC_SERVICE_FILEFIELD && aNameString.EqualsAscii( SC_UNONAME_FILEFORM ) ) |
| { |
| sal_Int16 nIntVal = 0; |
| if ( aValue >>= nIntVal ) |
| { |
| SvxFileFormat eFormat = lcl_UnoToSvxFileFormat( nIntVal ); |
| if (pEditSource) |
| { |
| ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| SvxFieldData* pField = aTempEngine.FindByPos( |
| aSelection.nStartPara, aSelection.nStartPos, TYPE(SvxExtFileField) ); |
| DBG_ASSERT(pField,"setPropertyValue: Field not found"); |
| if (pField) |
| { |
| SvxExtFileField* pExtFile = (SvxExtFileField*)pField; // local to the ScUnoEditEngine |
| pExtFile->SetFormat( eFormat ); |
| pEditEngine->QuickInsertField( SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection ); |
| pEditSource->UpdateData(); |
| } |
| } |
| else |
| nFileFormat = sal::static_int_cast<sal_Int16>(eFormat); // not inserted yet - store value |
| } |
| } |
| } |
| |
| uno::Any SAL_CALL ScHeaderFieldObj::getPropertyValue( const rtl::OUString& aPropertyName ) |
| throw(beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| //! Properties? |
| uno::Any aRet; |
| String aNameString(aPropertyName); |
| |
| // anchor type is always "as character", text wrap always "none" |
| |
| if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPE ) ) |
| aRet <<= text::TextContentAnchorType_AS_CHARACTER; |
| else if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPES ) ) |
| { |
| uno::Sequence<text::TextContentAnchorType> aSeq(1); |
| aSeq[0] = text::TextContentAnchorType_AS_CHARACTER; |
| aRet <<= aSeq; |
| } |
| else if ( aNameString.EqualsAscii( SC_UNONAME_TEXTWRAP ) ) |
| aRet <<= text::WrapTextMode_NONE; |
| else if ( nType == SC_SERVICE_FILEFIELD && aNameString.EqualsAscii( SC_UNONAME_FILEFORM ) ) |
| { |
| SvxFileFormat eFormat = SVXFILEFORMAT_NAME_EXT; |
| if (pEditSource) |
| { |
| ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine(); |
| ScUnoEditEngine aTempEngine(pEditEngine); |
| SvxFieldData* pField = aTempEngine.FindByPos( |
| aSelection.nStartPara, aSelection.nStartPos, TYPE(SvxExtFileField) ); |
| DBG_ASSERT(pField,"setPropertyValue: Field not found"); |
| if (pField) |
| { |
| const SvxExtFileField* pExtFile = (const SvxExtFileField*)pField; |
| eFormat = pExtFile->GetFormat(); |
| } |
| } |
| else |
| eFormat = (SvxFileFormat) nFileFormat; // not inserted yet - use stored value |
| |
| sal_Int16 nIntVal = lcl_SvxToUnoFileFormat( eFormat ); |
| aRet <<= nIntVal; |
| } |
| |
| return aRet; |
| } |
| |
| SC_IMPL_DUMMY_PROPERTY_LISTENER( ScHeaderFieldObj ) |
| |
| // XUnoTunnel |
| |
| sal_Int64 SAL_CALL ScHeaderFieldObj::getSomething( |
| const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException) |
| { |
| if ( rId.getLength() == 16 && |
| 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), |
| rId.getConstArray(), 16 ) ) |
| { |
| return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this)); |
| } |
| return 0; |
| } |
| |
| // static |
| const uno::Sequence<sal_Int8>& ScHeaderFieldObj::getUnoTunnelId() |
| { |
| static uno::Sequence<sal_Int8> * pSeq = 0; |
| if( !pSeq ) |
| { |
| osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); |
| if( !pSeq ) |
| { |
| static uno::Sequence< sal_Int8 > aSeq( 16 ); |
| rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); |
| pSeq = &aSeq; |
| } |
| } |
| return *pSeq; |
| } |
| |
| // static |
| ScHeaderFieldObj* ScHeaderFieldObj::getImplementation( |
| const uno::Reference<text::XTextContent> xObj ) |
| { |
| ScHeaderFieldObj* pRet = NULL; |
| uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY ); |
| if (xUT.is()) |
| pRet = reinterpret_cast<ScHeaderFieldObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId()))); |
| return pRet; |
| } |
| |
| // XServiceInfo |
| |
| rtl::OUString SAL_CALL ScHeaderFieldObj::getImplementationName() throw(uno::RuntimeException) |
| { |
| return rtl::OUString::createFromAscii( "ScHeaderFieldObj" ); |
| } |
| |
| sal_Bool SAL_CALL ScHeaderFieldObj::supportsService( const rtl::OUString& rServiceName ) |
| throw(uno::RuntimeException) |
| { |
| String aServiceStr( rServiceName ); |
| return aServiceStr.EqualsAscii( SCTEXTFIELD_SERVICE ) || |
| aServiceStr.EqualsAscii( SCTEXTCONTENT_SERVICE ); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScHeaderFieldObj::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| uno::Sequence<rtl::OUString> aRet(2); |
| rtl::OUString* pArray = aRet.getArray(); |
| pArray[0] = rtl::OUString::createFromAscii( SCTEXTFIELD_SERVICE ); |
| pArray[1] = rtl::OUString::createFromAscii( SCTEXTCONTENT_SERVICE ); |
| return aRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| |
| |
| |