| /************************************************************** |
| * |
| * 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_sw.hxx" |
| |
| #include <unobookmark.hxx> |
| #include <vos/mutex.hxx> |
| #include <vcl/svapp.hxx> |
| |
| #include <TextCursorHelper.hxx> |
| #include <unotextrange.hxx> |
| #include <unomap.hxx> |
| #include <unoprnms.hxx> |
| #include <unoevtlstnr.hxx> |
| #include <IMark.hxx> |
| #include <crossrefbookmark.hxx> |
| #include <doc.hxx> |
| #include <IDocumentUndoRedo.hxx> |
| #include <docary.hxx> |
| #include <swundo.hxx> |
| #include <comcore.hrc> |
| #include <SwRewriter.hxx> |
| #include <docsh.hxx> |
| |
| |
| using namespace ::sw::mark; |
| using namespace ::com::sun::star; |
| using ::rtl::OUString; |
| |
| |
| namespace |
| { |
| static OUString lcl_QuoteName(const OUString& rName) |
| { |
| static const OUString sStart = OUString(String(SW_RES(STR_START_QUOTE))); |
| static const OUString sEnd = OUString(String(SW_RES(STR_END_QUOTE))); |
| ::rtl::OUStringBuffer sBuf(64); |
| return sBuf.append(sStart).append(rName).append(sEnd).makeStringAndClear(); |
| } |
| } |
| |
| /****************************************************************** |
| * SwXBookmark |
| ******************************************************************/ |
| |
| class SwXBookmark::Impl |
| : public SwClient |
| { |
| |
| public: |
| SwEventListenerContainer m_ListenerContainer; |
| SwDoc * m_pDoc; |
| ::sw::mark::IMark * m_pRegisteredBookmark; |
| ::rtl::OUString m_sMarkName; |
| |
| |
| Impl( SwXBookmark & rThis, |
| SwDoc *const pDoc, ::sw::mark::IMark *const /*pBookmark*/) |
| : SwClient() |
| , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis)) |
| , m_pDoc(pDoc) |
| , m_pRegisteredBookmark(0) |
| { |
| // DO NOT regiserInMark here! (because SetXBookmark would delete rThis) |
| } |
| |
| void registerInMark(SwXBookmark & rThis, ::sw::mark::IMark *const pBkmk); |
| protected: |
| // SwClient |
| virtual void Modify( const SfxPoolItem *pOld, const SfxPoolItem *pNew); |
| |
| }; |
| |
| void SwXBookmark::Impl::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) |
| { |
| ClientModify(this, pOld, pNew); |
| if (!GetRegisteredIn()) |
| { |
| m_pRegisteredBookmark = NULL; |
| m_pDoc = NULL; |
| m_ListenerContainer.Disposing(); |
| } |
| } |
| |
| void SwXBookmark::Impl::registerInMark( |
| SwXBookmark & rThis, |
| ::sw::mark::IMark *const pBkmk) |
| { |
| if (pBkmk) |
| { |
| pBkmk->Add(this); |
| ::sw::mark::MarkBase *const pMarkBase(dynamic_cast< ::sw::mark::MarkBase * >(pBkmk)); |
| OSL_ENSURE(pMarkBase, "registerInMark: no MarkBase?"); |
| if (pMarkBase) |
| { |
| const uno::Reference<text::XTextContent> xBookmark(& rThis); |
| pMarkBase->SetXBookmark(xBookmark); |
| } |
| } |
| else if (m_pRegisteredBookmark) |
| { |
| m_sMarkName = m_pRegisteredBookmark->GetName(); |
| m_pRegisteredBookmark->Remove(this); |
| } |
| m_pRegisteredBookmark = pBkmk; |
| } |
| |
| |
| const ::sw::mark::IMark* SwXBookmark::GetBookmark() const |
| { |
| return m_pImpl->m_pRegisteredBookmark; |
| } |
| |
| SwXBookmark::SwXBookmark( |
| ::sw::mark::IMark *const pBkmk, |
| SwDoc *const pDoc) |
| : m_pImpl( new SwXBookmark::Impl(*this, pDoc, pBkmk) ) |
| { |
| } |
| |
| SwXBookmark::SwXBookmark() |
| : m_pImpl( new SwXBookmark::Impl(*this, 0, 0) ) |
| { |
| } |
| |
| SwXBookmark::~SwXBookmark() |
| { |
| } |
| |
| uno::Reference<text::XTextContent> SwXBookmark::CreateXBookmark( |
| SwDoc & rDoc, |
| ::sw::mark::IMark & rBookmark) |
| { |
| // #i105557#: do not iterate over the registered clients: race condition |
| ::sw::mark::MarkBase *const pMarkBase(dynamic_cast< ::sw::mark::MarkBase * >(&rBookmark)); |
| OSL_ENSURE(pMarkBase, "CreateXBookmark: no MarkBase?"); |
| if (!pMarkBase) { return 0; } |
| uno::Reference<text::XTextContent> xBookmark(pMarkBase->GetXBookmark()); |
| if (!xBookmark.is()) |
| { |
| OSL_ENSURE( |
| dynamic_cast< ::sw::mark::IBookmark* >(&rBookmark) || IDocumentMarkAccess::GetType(rBookmark) == IDocumentMarkAccess::ANNOTATIONMARK, |
| "<SwXBookmark::GetObject(..)>" |
| "SwXBookmark requested for non-bookmark mark and non-annotation mark."); |
| SwXBookmark *const pXBookmark = new SwXBookmark(&rBookmark, &rDoc); |
| xBookmark.set(pXBookmark); |
| pXBookmark->registerInMark( pMarkBase); |
| } |
| return xBookmark; |
| } |
| |
| |
| void SwXBookmark::registerInMark( ::sw::mark::IMark *const pBkmk ) |
| { |
| m_pImpl->registerInMark( *this, pBkmk ); |
| } |
| |
| ::sw::mark::IMark const* SwXBookmark::GetBookmarkInDoc(SwDoc const*const pDoc, |
| const uno::Reference< lang::XUnoTunnel> & xUT) |
| { |
| SwXBookmark *const pXBkm( |
| ::sw::UnoTunnelGetImplementation<SwXBookmark>(xUT)); |
| if (pXBkm && (pDoc == pXBkm->m_pImpl->m_pDoc)) |
| { |
| return pXBkm->m_pImpl->m_pRegisteredBookmark; |
| } |
| return 0; |
| } |
| |
| const uno::Sequence< sal_Int8 > & SwXBookmark::getUnoTunnelId() |
| { |
| static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); |
| return aSeq; |
| } |
| |
| sal_Int64 SAL_CALL SwXBookmark::getSomething( const uno::Sequence< sal_Int8 >& rId ) |
| throw (uno::RuntimeException) |
| { |
| return ::sw::UnoTunnelImpl<SwXBookmark>(rId, this); |
| } |
| |
| void SwXBookmark::attachToRangeEx( |
| const uno::Reference< text::XTextRange > & xTextRange, |
| IDocumentMarkAccess::MarkType eType) |
| throw (lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| if (m_pImpl->m_pRegisteredBookmark) |
| { |
| throw uno::RuntimeException(); |
| } |
| |
| const uno::Reference<lang::XUnoTunnel> xRangeTunnel( |
| xTextRange, uno::UNO_QUERY); |
| SwXTextRange* pRange = 0; |
| OTextCursorHelper* pCursor = 0; |
| if(xRangeTunnel.is()) |
| { |
| pRange = ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel); |
| pCursor = |
| ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel); |
| } |
| |
| SwDoc *const pDoc = |
| (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0); |
| if (!pDoc) |
| { |
| throw lang::IllegalArgumentException(); |
| } |
| |
| m_pImpl->m_pDoc = pDoc; |
| SwUnoInternalPaM aPam(*m_pImpl->m_pDoc); |
| ::sw::XTextRangeToSwPaM(aPam, xTextRange); |
| UnoActionContext aCont(m_pImpl->m_pDoc); |
| if (!m_pImpl->m_sMarkName.getLength()) |
| { |
| m_pImpl->m_sMarkName = OUString::createFromAscii("Bookmark"); |
| } |
| if ((eType == IDocumentMarkAccess::BOOKMARK) && |
| ::sw::mark::CrossRefNumItemBookmark::IsLegalName(m_pImpl->m_sMarkName)) |
| { |
| eType = IDocumentMarkAccess::CROSSREF_NUMITEM_BOOKMARK; |
| } |
| else if ((eType == IDocumentMarkAccess::BOOKMARK) && |
| ::sw::mark::CrossRefHeadingBookmark::IsLegalName(m_pImpl->m_sMarkName) && |
| IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( aPam ) ) |
| { |
| eType = IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK; |
| } |
| registerInMark( m_pImpl->m_pDoc->getIDocumentMarkAccess()->makeMark( aPam, m_pImpl->m_sMarkName, eType ) ); |
| // Check, if bookmark has been created. |
| // E.g., the creation of a cross-reference bookmark is suppress, |
| // if the PaM isn't a valid one for cross-reference bookmarks. |
| if (!m_pImpl->m_pRegisteredBookmark) |
| { |
| OSL_ENSURE(false, |
| "<SwXBookmark::attachToRange(..)>" |
| " - could not create Mark."); |
| throw lang::IllegalArgumentException(); |
| } |
| } |
| |
| void SwXBookmark::attachToRange( const uno::Reference< text::XTextRange > & xTextRange ) |
| throw (lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| attachToRangeEx(xTextRange, IDocumentMarkAccess::BOOKMARK); |
| } |
| |
| void SAL_CALL SwXBookmark::attach( const uno::Reference< text::XTextRange > & xTextRange ) |
| throw (lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| attachToRange( xTextRange ); |
| } |
| |
| uno::Reference< text::XTextRange > SAL_CALL SwXBookmark::getAnchor() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| if (!m_pImpl->m_pRegisteredBookmark) |
| { |
| throw uno::RuntimeException(); |
| } |
| return SwXTextRange::CreateXTextRange( |
| *m_pImpl->m_pDoc, |
| m_pImpl->m_pRegisteredBookmark->GetMarkPos(), |
| (m_pImpl->m_pRegisteredBookmark->IsExpanded()) |
| ? &m_pImpl->m_pRegisteredBookmark->GetOtherMarkPos() : NULL); |
| } |
| |
| void SAL_CALL SwXBookmark::dispose() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| if (m_pImpl->m_pRegisteredBookmark) |
| { |
| m_pImpl->m_pDoc->getIDocumentMarkAccess()->deleteMark( m_pImpl->m_pRegisteredBookmark ); |
| } |
| } |
| |
| void SAL_CALL SwXBookmark::addEventListener( |
| const uno::Reference< lang::XEventListener > & xListener) |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard g(Application::GetSolarMutex()); |
| |
| if (!m_pImpl->m_pRegisteredBookmark) |
| { |
| throw uno::RuntimeException(); |
| } |
| m_pImpl->m_ListenerContainer.AddListener(xListener); |
| } |
| |
| void SAL_CALL SwXBookmark::removeEventListener( |
| const uno::Reference< lang::XEventListener > & xListener) |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard g(Application::GetSolarMutex()); |
| |
| if (!m_pImpl->m_pRegisteredBookmark || |
| !m_pImpl->m_ListenerContainer.RemoveListener(xListener)) |
| { |
| throw uno::RuntimeException(); |
| } |
| } |
| |
| OUString SAL_CALL SwXBookmark::getName() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| return (m_pImpl->m_pRegisteredBookmark) |
| ? m_pImpl->m_pRegisteredBookmark->GetName() |
| : m_pImpl->m_sMarkName; |
| } |
| |
| void SAL_CALL SwXBookmark::setName(const OUString& rName) |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| if (!m_pImpl->m_pRegisteredBookmark) |
| { |
| m_pImpl->m_sMarkName = rName; |
| } |
| if (!m_pImpl->m_pRegisteredBookmark || (getName() == rName)) |
| { |
| return; |
| } |
| IDocumentMarkAccess *const pMarkAccess = |
| m_pImpl->m_pDoc->getIDocumentMarkAccess(); |
| if(pMarkAccess->findMark(rName) != pMarkAccess->getAllMarksEnd()) |
| { |
| throw uno::RuntimeException(); |
| } |
| |
| SwPaM aPam(m_pImpl->m_pRegisteredBookmark->GetMarkPos()); |
| if (m_pImpl->m_pRegisteredBookmark->IsExpanded()) |
| { |
| aPam.SetMark(); |
| *aPam.GetMark() = m_pImpl->m_pRegisteredBookmark->GetOtherMarkPos(); |
| } |
| |
| SwRewriter aRewriter; |
| aRewriter.AddRule(UNDO_ARG1, lcl_QuoteName(getName())); |
| aRewriter.AddRule(UNDO_ARG2, SW_RES(STR_YIELDS)); |
| aRewriter.AddRule(UNDO_ARG3, lcl_QuoteName(rName)); |
| |
| m_pImpl->m_pDoc->GetIDocumentUndoRedo().StartUndo( |
| UNDO_BOOKMARK_RENAME, &aRewriter); |
| pMarkAccess->renameMark(m_pImpl->m_pRegisteredBookmark, rName); |
| m_pImpl->m_pDoc->GetIDocumentUndoRedo().EndUndo( |
| UNDO_BOOKMARK_RENAME, &aRewriter); |
| } |
| |
| OUString SAL_CALL |
| SwXBookmark::getImplementationName() throw (uno::RuntimeException) |
| { |
| return OUString::createFromAscii("SwXBookmark"); |
| } |
| |
| static char const*const g_ServicesBookmark[] = |
| { |
| "com.sun.star.text.TextContent", |
| "com.sun.star.text.Bookmark", |
| "com.sun.star.document.LinkTarget", |
| }; |
| static const size_t g_nServicesBookmark( |
| sizeof(g_ServicesBookmark)/sizeof(g_ServicesBookmark[0])); |
| |
| sal_Bool SAL_CALL SwXBookmark::supportsService(const OUString& rServiceName) |
| throw (uno::RuntimeException) |
| { |
| return ::sw::SupportsServiceImpl( |
| g_nServicesBookmark, g_ServicesBookmark, rServiceName); |
| } |
| |
| uno::Sequence< OUString > SAL_CALL |
| SwXBookmark::getSupportedServiceNames() throw (uno::RuntimeException) |
| { |
| return ::sw::GetSupportedServiceNamesImpl( |
| g_nServicesBookmark, g_ServicesBookmark); |
| } |
| |
| // MetadatableMixin |
| ::sfx2::Metadatable* SwXBookmark::GetCoreObject() |
| { |
| return dynamic_cast< ::sfx2::Metadatable* >(m_pImpl->m_pRegisteredBookmark); |
| } |
| |
| uno::Reference<frame::XModel> SwXBookmark::GetModel() |
| { |
| if (m_pImpl->m_pDoc) |
| { |
| SwDocShell const * const pShell( m_pImpl->m_pDoc->GetDocShell() ); |
| return (pShell) ? pShell->GetModel() : 0; |
| } |
| return 0; |
| } |
| |
| |
| uno::Reference< beans::XPropertySetInfo > SAL_CALL |
| SwXBookmark::getPropertySetInfo() throw (uno::RuntimeException) |
| { |
| vos::OGuard g(Application::GetSolarMutex()); |
| |
| static uno::Reference< beans::XPropertySetInfo > xRef( |
| aSwMapProvider.GetPropertySet(PROPERTY_MAP_BOOKMARK) |
| ->getPropertySetInfo() ); |
| return xRef; |
| } |
| |
| void SAL_CALL |
| SwXBookmark::setPropertyValue(const OUString& PropertyName, |
| const uno::Any& /*rValue*/) |
| throw (beans::UnknownPropertyException, beans::PropertyVetoException, |
| lang::IllegalArgumentException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| // nothing to set here |
| throw lang::IllegalArgumentException( ::rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM("Property is read-only: ")) |
| + PropertyName, static_cast< cppu::OWeakObject * >(this), 0 ); |
| } |
| |
| uno::Any SAL_CALL SwXBookmark::getPropertyValue(const OUString& rPropertyName) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| vos::OGuard g(Application::GetSolarMutex()); |
| |
| uno::Any aRet; |
| if (! ::sw::GetDefaultTextContentValue(aRet, rPropertyName)) |
| { |
| if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME))) |
| { |
| aRet <<= getName(); |
| } |
| } |
| return aRet; |
| } |
| |
| void SAL_CALL |
| SwXBookmark::addPropertyChangeListener( |
| const ::rtl::OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| OSL_ENSURE(false, |
| "SwXBookmark::addPropertyChangeListener(): not implemented"); |
| } |
| |
| void SAL_CALL |
| SwXBookmark::removePropertyChangeListener( |
| const ::rtl::OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| OSL_ENSURE(false, |
| "SwXBookmark::removePropertyChangeListener(): not implemented"); |
| } |
| |
| void SAL_CALL |
| SwXBookmark::addVetoableChangeListener( |
| const ::rtl::OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| OSL_ENSURE(false, |
| "SwXBookmark::addVetoableChangeListener(): not implemented"); |
| } |
| |
| void SAL_CALL |
| SwXBookmark::removeVetoableChangeListener( |
| const ::rtl::OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| OSL_ENSURE(false, |
| "SwXBookmark::removeVetoableChangeListener(): not implemented"); |
| } |
| |
| /****************************************************************** |
| * SwXFieldmark |
| ******************************************************************/ |
| |
| SwXFieldmark::SwXFieldmark( bool _isReplacementObject ) |
| : SwXFieldmark_Base() |
| , isReplacementObject(_isReplacementObject) |
| { |
| } |
| |
| |
| SwXFieldmark::SwXFieldmark( |
| bool _isReplacementObject, |
| ::sw::mark::IMark *const pMark, |
| SwDoc *const pDoc ) |
| : SwXFieldmark_Base( pMark, pDoc ) |
| , isReplacementObject( _isReplacementObject ) |
| { |
| } |
| |
| |
| uno::Reference<text::XTextContent> SwXFieldmark::CreateXFieldmark( |
| SwDoc & rDoc, |
| ::sw::mark::IMark & rBookmark ) |
| { |
| // do not iterate over the registered clients: race condition |
| ::sw::mark::MarkBase *const pMarkBase( dynamic_cast< ::sw::mark::MarkBase * >(&rBookmark)); |
| OSL_ENSURE(pMarkBase, "CreateXFieldmark: no MarkBase?"); |
| if (!pMarkBase) { return 0; } |
| |
| uno::Reference<text::XTextContent> xBookmark(pMarkBase->GetXBookmark()); |
| if (!xBookmark.is()) |
| { |
| SwXFieldmark* pXFieldmark = NULL; |
| if ( dynamic_cast< ::sw::mark::TextFieldmark* >(&rBookmark) ) |
| { |
| pXFieldmark = new SwXFieldmark( false, &rBookmark, &rDoc ); |
| } |
| else if ( dynamic_cast< ::sw::mark::CheckboxFieldmark* >(&rBookmark) ) |
| { |
| pXFieldmark = new SwXFieldmark( true, &rBookmark, &rDoc ); |
| } |
| if ( pXFieldmark != NULL ) |
| { |
| xBookmark.set( pXFieldmark ); |
| pXFieldmark->registerInMark( pMarkBase ); |
| } |
| } |
| return xBookmark; |
| } |
| |
| |
| void SwXFieldmarkParameters::insertByName(const OUString& aName, const uno::Any& aElement) |
| throw (lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark::parameter_map_t* pParameters = getCoreParameters(); |
| if(pParameters->find(aName) != pParameters->end()) |
| throw container::ElementExistException(); |
| (*pParameters)[aName] = aElement; |
| } |
| |
| void SwXFieldmarkParameters::removeByName(const OUString& aName) |
| throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(!getCoreParameters()->erase(aName)) |
| throw container::NoSuchElementException(); |
| } |
| |
| void SwXFieldmarkParameters::replaceByName(const OUString& aName, const uno::Any& aElement) |
| throw (lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark::parameter_map_t* pParameters = getCoreParameters(); |
| IFieldmark::parameter_map_t::iterator pEntry = pParameters->find(aName); |
| if(pEntry == pParameters->end()) |
| throw container::NoSuchElementException(); |
| pEntry->second = aElement; |
| } |
| |
| uno::Any SwXFieldmarkParameters::getByName(const OUString& aName) |
| throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark::parameter_map_t* pParameters = getCoreParameters(); |
| IFieldmark::parameter_map_t::iterator pEntry = pParameters->find(aName); |
| if(pEntry == pParameters->end()) |
| throw container::NoSuchElementException(); |
| return pEntry->second; |
| } |
| |
| uno::Sequence<OUString> SwXFieldmarkParameters::getElementNames() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark::parameter_map_t* pParameters = getCoreParameters(); |
| uno::Sequence<OUString> vResult(pParameters->size()); |
| OUString* pOutEntry = vResult.getArray(); |
| for(IFieldmark::parameter_map_t::iterator pEntry = pParameters->begin(); pEntry!=pParameters->end(); ++pEntry, ++pOutEntry) |
| *pOutEntry = pEntry->first; |
| return vResult; |
| } |
| |
| ::sal_Bool SwXFieldmarkParameters::hasByName(const OUString& aName) |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark::parameter_map_t* pParameters = getCoreParameters(); |
| return (pParameters->find(aName) != pParameters->end()); |
| } |
| |
| uno::Type SwXFieldmarkParameters::getElementType() |
| throw (uno::RuntimeException) |
| { |
| return ::cppu::UnoType< ::cppu::UnoVoidType>::get(); |
| } |
| |
| ::sal_Bool SwXFieldmarkParameters::hasElements() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| return !getCoreParameters()->empty(); |
| } |
| |
| void SwXFieldmarkParameters::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) |
| { |
| ClientModify(this, pOld, pNew); |
| } |
| |
| |
| IFieldmark::parameter_map_t* SwXFieldmarkParameters::getCoreParameters() |
| throw (uno::RuntimeException) |
| { |
| const IFieldmark* pFieldmark = dynamic_cast< const IFieldmark* >(GetRegisteredIn()); |
| if(!pFieldmark) |
| throw uno::RuntimeException(); |
| return const_cast< IFieldmark* >(pFieldmark)->GetParameters(); |
| } |
| |
| |
| void SwXFieldmark::attachToRange( const uno::Reference < text::XTextRange >& xTextRange ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| attachToRangeEx( xTextRange, |
| ( isReplacementObject ? IDocumentMarkAccess::CHECKBOX_FIELDMARK : IDocumentMarkAccess::TEXT_FIELDMARK ) ); |
| } |
| |
| ::rtl::OUString SwXFieldmark::getFieldType(void) |
| throw(uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| const IFieldmark *pBkm = dynamic_cast<const IFieldmark*>(GetBookmark()); |
| if(!pBkm) |
| throw uno::RuntimeException(); |
| return pBkm->GetFieldname(); |
| } |
| |
| void SwXFieldmark::setFieldType(const::rtl::OUString & fieldType) |
| throw(uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark *pBkm = const_cast<IFieldmark*>( |
| dynamic_cast<const IFieldmark*>(GetBookmark())); |
| if(!pBkm) |
| throw uno::RuntimeException(); |
| pBkm->SetFieldname(fieldType); |
| } |
| |
| uno::Reference<container::XNameContainer> SwXFieldmark::getParameters() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| IFieldmark *pBkm = const_cast<IFieldmark*>( |
| dynamic_cast<const IFieldmark*>(GetBookmark())); |
| if(!pBkm) |
| throw uno::RuntimeException(); |
| return uno::Reference<container::XNameContainer>(new SwXFieldmarkParameters(pBkm)); |
| } |
| |