| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| #include <DomainMapper_Impl.hxx> |
| #include <ConversionHelper.hxx> |
| #include <DomainMapperTableHandler.hxx> |
| #include <com/sun/star/uno/XComponentContext.hpp> |
| #include <com/sun/star/graphic/XGraphic.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/beans/XPropertyState.hpp> |
| #include <com/sun/star/container/XIndexReplace.hpp> |
| #include <com/sun/star/container/XNamed.hpp> |
| #include <com/sun/star/drawing/XDrawPageSupplier.hpp> |
| #include <com/sun/star/drawing/XShapes.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> |
| #include <com/sun/star/style/LineNumberPosition.hpp> |
| #include <com/sun/star/style/NumberingType.hpp> |
| #include <com/sun/star/drawing/XShape.hpp> |
| #include <com/sun/star/table/BorderLine.hpp> |
| #include <com/sun/star/text/ChapterFormat.hpp> |
| #include <com/sun/star/text/FilenameDisplayFormat.hpp> |
| #include <com/sun/star/text/UserDataPart.hpp> |
| #include <com/sun/star/text/SetVariableType.hpp> |
| #include <com/sun/star/text/XFootnote.hpp> |
| #include <com/sun/star/text/XLineNumberingProperties.hpp> |
| #include <com/sun/star/text/PageNumberType.hpp> |
| #include <com/sun/star/text/RelOrientation.hpp> |
| #include <com/sun/star/text/HoriOrientation.hpp> |
| #include <com/sun/star/text/VertOrientation.hpp> |
| #include <com/sun/star/text/ReferenceFieldPart.hpp> |
| #include <com/sun/star/text/ReferenceFieldSource.hpp> |
| #include <com/sun/star/text/SizeType.hpp> |
| #include <com/sun/star/text/TextContentAnchorType.hpp> |
| #include <com/sun/star/text/WrapTextMode.hpp> |
| #include <com/sun/star/text/XDependentTextField.hpp> |
| #include <com/sun/star/text/XParagraphCursor.hpp> |
| #include <com/sun/star/text/XRedline.hpp> |
| #include <com/sun/star/text/XTextAppendAndConvert.hpp> |
| #include <com/sun/star/text/XTextCopy.hpp> |
| #include <com/sun/star/text/XTextField.hpp> |
| #include <com/sun/star/text/XTextFieldsSupplier.hpp> |
| #include <com/sun/star/style/DropCapFormat.hpp> |
| #include <com/sun/star/util/DateTime.hpp> |
| #include <com/sun/star/util/XNumberFormatsSupplier.hpp> |
| #include <com/sun/star/util/XNumberFormats.hpp> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/string.h> |
| #include "FieldTypes.hxx" |
| |
| #include <tools/string.hxx> |
| #ifdef DEBUG_DOMAINMAPPER |
| #include <resourcemodel/QNameToString.hxx> |
| #include <resourcemodel/util.hxx> |
| #include <dmapperLoggers.hxx> |
| #endif |
| #include <ooxml/OOXMLFastTokens.hxx> |
| |
| #if DEBUG |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/style/TabStop.hpp> |
| #endif |
| |
| #include <map> |
| |
| using namespace ::com::sun::star; |
| using namespace ::rtl; |
| namespace writerfilter { |
| namespace dmapper{ |
| struct FieldConversion |
| { |
| ::rtl::OUString sWordCommand; |
| const sal_Char* cFieldServiceName; |
| const sal_Char* cFieldMasterServiceName; |
| FieldId eFieldId; |
| }; |
| |
| typedef ::std::map< ::rtl::OUString, FieldConversion> |
| FieldConversionMap_t; |
| |
| /*-- 18.07.2006 08:56:55--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Int32 FIB::GetData( Id nName ) |
| { |
| if( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR) |
| return aFIBData[nName - NS_rtf::LN_WIDENT]; |
| OSL_ENSURE( false, "invalid index in FIB"); |
| return -1; |
| } |
| /*-- 18.07.2006 08:56:55--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void FIB::SetData( Id nName, sal_Int32 nValue ) |
| { |
| OSL_ENSURE( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR, "invalid index in FIB"); |
| if( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR) |
| aFIBData[nName - NS_rtf::LN_WIDENT] = nValue; |
| } |
| /*-- 01.09.2006 10:22:03--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| DomainMapper_Impl::DomainMapper_Impl( |
| DomainMapper& rDMapper, |
| uno::Reference < uno::XComponentContext > xContext, |
| uno::Reference< lang::XComponent > xModel, |
| SourceDocumentType eDocumentType) : |
| m_eDocumentType( eDocumentType ), |
| m_rDMapper( rDMapper ), |
| m_xTextDocument( xModel, uno::UNO_QUERY ), |
| m_xTextFactory( xModel, uno::UNO_QUERY ), |
| m_xComponentContext( xContext ), |
| m_bFieldMode( false ), |
| m_bSetUserFieldContent( false ), |
| m_bIsFirstSection( true ), |
| m_bIsColumnBreakDeferred( false ), |
| m_bIsPageBreakDeferred( false ), |
| m_bIsInShape( false ), |
| m_bShapeContextAdded( false ), |
| m_pLastSectionContext( ), |
| m_nCurrentTabStopIndex( 0 ), |
| m_sCurrentParaStyleId(), |
| m_bInStyleSheetImport( false ), |
| m_bInAnyTableImport( false ), |
| m_bLineNumberingSet( false ), |
| m_bIsInFootnoteProperties( true ), |
| m_bIsCustomFtnMark( false ), |
| m_bIsParaChange( false ), |
| m_bParaChanged( false ), |
| m_bIsLastParaInSection( false ), |
| m_bIsInComments( false ) |
| , m_xAnnotationField() |
| , m_nAnnotationId( -1 ) |
| , m_aAnnotationPositions() |
| { |
| appendTableManager( ); |
| GetBodyText(); |
| uno::Reference< text::XTextAppend > xBodyTextAppend = uno::Reference< text::XTextAppend >( m_xBodyText, uno::UNO_QUERY ); |
| m_aTextAppendStack.push(xBodyTextAppend); |
| |
| //todo: does it make sense to set the body text as static text interface? |
| uno::Reference< text::XTextAppendAndConvert > xBodyTextAppendAndConvert( m_xBodyText, uno::UNO_QUERY ); |
| TableDataHandler_t::Pointer_t pTableHandler |
| (new DomainMapperTableHandler(xBodyTextAppendAndConvert, *this)); |
| getTableManager().setHandler(pTableHandler); |
| } |
| /*-- 01.09.2006 10:22:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| DomainMapper_Impl::~DomainMapper_Impl() |
| { |
| RemoveLastParagraph(); |
| popTableManager(); |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< container::XNameContainer > DomainMapper_Impl::GetPageStyles() |
| { |
| if(!m_xPageStyles.is()) |
| { |
| uno::Reference< style::XStyleFamiliesSupplier > xSupplier( m_xTextDocument, uno::UNO_QUERY ); |
| xSupplier->getStyleFamilies()->getByName(::rtl::OUString::createFromAscii("PageStyles")) >>= m_xPageStyles; |
| } |
| return m_xPageStyles; |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XText > DomainMapper_Impl::GetBodyText() |
| { |
| if(!m_xBodyText.is() && m_xTextDocument.is()) |
| { |
| m_xBodyText = m_xTextDocument->getText(); |
| } |
| return m_xBodyText; |
| } |
| /*-- 21.12.2006 12:09:30--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< beans::XPropertySet > DomainMapper_Impl::GetDocumentSettings() |
| { |
| if( !m_xDocumentSettings.is() ) |
| { |
| m_xDocumentSettings = uno::Reference< beans::XPropertySet >( |
| m_xTextFactory->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.Settings"))), uno::UNO_QUERY ); |
| } |
| return m_xDocumentSettings; |
| } |
| /*-- 21.12.2006 12:16:23--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::SetDocumentSettingsProperty( const ::rtl::OUString& rPropName, const uno::Any& rValue ) |
| { |
| uno::Reference< beans::XPropertySet > xSettings = GetDocumentSettings(); |
| if( xSettings.is() ) |
| { |
| try |
| { |
| xSettings->setPropertyValue( rPropName, rValue ); |
| } |
| catch( const uno::Exception& ) |
| { |
| } |
| } |
| } |
| |
| void DomainMapper_Impl::RemoveLastParagraph( ) |
| { |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| try |
| { |
| uno::Reference< text::XTextCursor > xCursor = xTextAppend->createTextCursor(); |
| xCursor->gotoEnd(false); |
| xCursor->goLeft( 1, true ); |
| xCursor->setString(::rtl::OUString()); |
| } |
| catch( const uno::Exception& rEx) |
| { |
| (void)rEx; |
| } |
| } |
| |
| void DomainMapper_Impl::SetIsLastParagraphInSection( bool bIsLast ) |
| { |
| m_bIsLastParaInSection = bIsLast; |
| } |
| |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushProperties(ContextType eId) |
| { |
| SectionPropertyMap* pSectionContext = 0; |
| PropertyMapPtr pInsert(eId == CONTEXT_SECTION ? |
| (pSectionContext = new SectionPropertyMap( m_bIsFirstSection )) : |
| eId == CONTEXT_PARAGRAPH ? new ParagraphPropertyMap : new PropertyMap); |
| if(eId == CONTEXT_SECTION) |
| { |
| if( m_bIsFirstSection ) |
| m_bIsFirstSection = false; |
| // beginning with the second section group a section has to be inserted |
| // into the document |
| SectionPropertyMap* pSectionContext_ = dynamic_cast< SectionPropertyMap* >( pInsert.get() ); |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| if(xTextAppend.is()) |
| pSectionContext_->SetStart( xTextAppend->getEnd() ); |
| } |
| m_aPropertyStacks[eId].push( pInsert ); |
| m_aContextStack.push(eId); |
| |
| m_pTopContext = m_aPropertyStacks[eId].top(); |
| } |
| /*-- 13.06.2007 16:18:18--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushStyleProperties( PropertyMapPtr pStyleProperties ) |
| { |
| m_aPropertyStacks[CONTEXT_STYLESHEET].push( pStyleProperties ); |
| m_aContextStack.push(CONTEXT_STYLESHEET); |
| |
| m_pTopContext = m_aPropertyStacks[CONTEXT_STYLESHEET].top(); |
| } |
| /*-- 28.01.2008 14:47:46--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushListProperties(PropertyMapPtr pListProperties) |
| { |
| m_aPropertyStacks[CONTEXT_LIST].push( pListProperties ); |
| m_aContextStack.push(CONTEXT_LIST); |
| m_pTopContext = m_aPropertyStacks[CONTEXT_LIST].top(); |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PopProperties(ContextType eId) |
| { |
| OSL_ENSURE(!m_aPropertyStacks[eId].empty(), "section stack already empty"); |
| |
| if ( eId == CONTEXT_SECTION ) |
| { |
| m_pLastSectionContext = m_aPropertyStacks[eId].top( ); |
| } |
| |
| m_aPropertyStacks[eId].pop(); |
| m_aContextStack.pop(); |
| if(!m_aContextStack.empty() && !m_aPropertyStacks[m_aContextStack.top()].empty()) |
| |
| m_pTopContext = m_aPropertyStacks[m_aContextStack.top()].top(); |
| else |
| { |
| // OSL_ENSURE(eId == CONTEXT_SECTION, "this should happen at a section context end"); |
| m_pTopContext.reset(); |
| } |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| PropertyMapPtr DomainMapper_Impl::GetTopContextOfType(ContextType eId) |
| { |
| PropertyMapPtr pRet; |
| OSL_ENSURE( !m_aPropertyStacks[eId].empty(), |
| "no context of this type available"); |
| if(!m_aPropertyStacks[eId].empty()) |
| pRet = m_aPropertyStacks[eId].top(); |
| return pRet; |
| } |
| |
| /*-- 24.05.2007 15:54:51--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextAppend > DomainMapper_Impl::GetTopTextAppend() |
| { |
| OSL_ENSURE(!m_aTextAppendStack.empty(), "text append stack is empty" ); |
| return m_aTextAppendStack.top().xTextAppend; |
| } |
| |
| /*-- 17.07.2006 08:47:04--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::InitTabStopFromStyle( const uno::Sequence< style::TabStop >& rInitTabStops ) |
| { |
| OSL_ENSURE(!m_aCurrentTabStops.size(), "tab stops already initialized"); |
| for( sal_Int32 nTab = 0; nTab < rInitTabStops.getLength(); ++nTab) |
| { |
| m_aCurrentTabStops.push_back( DeletableTabStop(rInitTabStops[nTab]) ); |
| } |
| } |
| |
| /*-- 29.06.2006 13:35:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::ModifyCurrentTabStop( Id nId, sal_Int32 nValue) |
| { |
| OSL_ENSURE(nId == NS_rtf::LN_dxaAdd || m_nCurrentTabStopIndex < m_aCurrentTabStops.size(), |
| "tab stop creation error"); |
| |
| if( nId != NS_rtf::LN_dxaAdd && m_nCurrentTabStopIndex >= m_aCurrentTabStops.size()) |
| return; |
| static const style::TabAlign aTabAlignFromWord[] = |
| { |
| style::TabAlign_LEFT, |
| style::TabAlign_CENTER, |
| style::TabAlign_RIGHT, |
| style::TabAlign_DECIMAL, |
| style::TabAlign_LEFT |
| }; |
| static const sal_Unicode aTabFillCharWord[] = |
| { |
| ' ', |
| '.', |
| '-', |
| '_', |
| '_', |
| 0xb7 |
| }; |
| |
| switch(nId) |
| { |
| case NS_rtf::LN_dxaAdd: //set tab |
| m_aCurrentTabStops.push_back( |
| DeletableTabStop(style::TabStop(ConversionHelper::convertTwipToMM100(nValue), style::TabAlign_LEFT, ' ', ' '))); |
| break; |
| case NS_rtf::LN_dxaDel: //deleted tab |
| { |
| //mark the tab stop at the given position as deleted |
| ::std::vector<DeletableTabStop>::iterator aIt = m_aCurrentTabStops.begin(); |
| ::std::vector<DeletableTabStop>::iterator aEndIt = m_aCurrentTabStops.end(); |
| sal_Int32 nConverted = ConversionHelper::convertTwipToMM100(nValue); |
| for( ; aIt != aEndIt; ++aIt) |
| { |
| if( aIt->Position == nConverted ) |
| { |
| aIt->bDeleted = true; |
| break; |
| } |
| } |
| } |
| break; |
| case NS_rtf::LN_TLC: //tab leading characters - for decimal tabs |
| // 0 - no leader, 1- dotted, 2 - hyphenated, 3 - single line, 4 - heavy line, 5 - middle dot |
| if( nValue >= 0 && nValue < sal::static_int_cast<sal_Int32>(sizeof(aTabFillCharWord) / sizeof (sal_Unicode))) |
| m_aCurrentTabStops[m_nCurrentTabStopIndex].FillChar = aTabFillCharWord[nValue]; |
| break; |
| case NS_rtf::LN_JC: //tab justification |
| //0 - left, 1 - centered, 2 - right, 3 - decimal 4 - bar |
| if( nValue >= 0 && nValue < sal::static_int_cast<sal_Int32>(sizeof(aTabAlignFromWord) / sizeof (style::TabAlign))) |
| m_aCurrentTabStops[m_nCurrentTabStopIndex].Alignment = aTabAlignFromWord[nValue]; |
| break; |
| } |
| } |
| |
| void DomainMapper_Impl::IncorporateTabStop( const DeletableTabStop & rTabStop ) |
| { |
| ::std::vector<DeletableTabStop>::iterator aIt = m_aCurrentTabStops.begin(); |
| ::std::vector<DeletableTabStop>::iterator aEndIt = m_aCurrentTabStops.end(); |
| sal_Int32 nConverted = rTabStop.Position; |
| bool bFound = false; |
| for( ; aIt != aEndIt; ++aIt) |
| { |
| if( aIt->Position == nConverted ) |
| { |
| bFound = true; |
| if( rTabStop.bDeleted ) |
| m_aCurrentTabStops.erase( aIt ); |
| else |
| *aIt = rTabStop; |
| break; |
| } |
| } |
| if( !bFound ) |
| m_aCurrentTabStops.push_back( rTabStop ); |
| } |
| /*-- 29.06.2006 13:35:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Sequence< style::TabStop > DomainMapper_Impl::GetCurrentTabStopAndClear() |
| { |
| uno::Sequence< style::TabStop > aRet( sal_Int32( m_aCurrentTabStops.size() ) ); |
| style::TabStop* pArray = aRet.getArray(); |
| ::std::vector<DeletableTabStop>::const_iterator aIt = m_aCurrentTabStops.begin(); |
| ::std::vector<DeletableTabStop>::const_iterator aEndIt = m_aCurrentTabStops.end(); |
| sal_Int32 nDeleted = 0; |
| for(sal_Int32 nIndex = 0; aIt != aEndIt; ++aIt) |
| { |
| if(!aIt->bDeleted) |
| pArray[nIndex++] = *aIt; |
| else |
| ++nDeleted; |
| } |
| m_aCurrentTabStops.clear(); |
| m_nCurrentTabStopIndex = 0; |
| if(nDeleted) |
| { |
| aRet.realloc( aRet.getLength() - nDeleted); |
| } |
| return aRet; |
| } |
| |
| /*-- 17.07.2006 09:08:26--------------------------------------------------- |
| returns a the value from the current paragraph style - if available |
| TODO: What about parent styles? |
| -----------------------------------------------------------------------*/ |
| uno::Any DomainMapper_Impl::GetPropertyFromStyleSheet(PropertyIds eId) |
| { |
| StyleSheetEntryPtr pEntry; |
| if( m_bInStyleSheetImport ) |
| pEntry = GetStyleSheetTable()->FindParentStyleSheet(::rtl::OUString()); |
| else |
| pEntry = |
| GetStyleSheetTable()->FindStyleSheetByISTD(GetCurrentParaStyleId()); |
| while(pEntry.get( ) ) |
| { |
| //is there a tab stop set? |
| if(pEntry->pProperties) |
| { |
| PropertyMap::const_iterator aPropertyIter = |
| pEntry->pProperties->find(PropertyDefinition(eId, false )); |
| if( aPropertyIter != pEntry->pProperties->end()) |
| { |
| return aPropertyIter->second; |
| } |
| } |
| //search until the property is set or no parent is available |
| pEntry = GetStyleSheetTable()->FindParentStyleSheet(pEntry->sBaseStyleIdentifier); |
| } |
| return uno::Any(); |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| ListsManager::Pointer DomainMapper_Impl::GetListTable() |
| { |
| if(!m_pListTable) |
| m_pListTable.reset( |
| new ListsManager( m_rDMapper, m_xTextFactory )); |
| return m_pListTable; |
| } |
| |
| |
| void DomainMapper_Impl::deferBreak( BreakType deferredBreakType) |
| { |
| switch (deferredBreakType) |
| { |
| case COLUMN_BREAK: |
| m_bIsColumnBreakDeferred = true; |
| break; |
| case PAGE_BREAK: |
| m_bIsPageBreakDeferred = true; |
| break; |
| default: |
| return; |
| } |
| } |
| |
| bool DomainMapper_Impl::isBreakDeferred( BreakType deferredBreakType ) |
| { |
| switch (deferredBreakType) |
| { |
| case COLUMN_BREAK: |
| return m_bIsColumnBreakDeferred; |
| case PAGE_BREAK: |
| return m_bIsPageBreakDeferred; |
| default: |
| return false; |
| } |
| } |
| |
| void DomainMapper_Impl::clearDeferredBreaks() |
| { |
| m_bIsColumnBreakDeferred = false; |
| m_bIsPageBreakDeferred = false; |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void lcl_MoveBorderPropertiesToFrame(uno::Sequence<beans::PropertyValue>& rFrameProperties, |
| uno::Reference<text::XTextRange> xStartTextRange, |
| uno::Reference<text::XTextRange> xEndTextRange ) |
| { |
| try |
| { |
| uno::Reference<text::XTextCursor> xRangeCursor = xStartTextRange->getText()->createTextCursorByRange( xStartTextRange ); |
| xRangeCursor->gotoRange( xEndTextRange, true ); |
| |
| uno::Reference<beans::XPropertySet> xTextRangeProperties(xRangeCursor, uno::UNO_QUERY); |
| if(!xTextRangeProperties.is()) |
| return ; |
| |
| PropertyIds aBorderProperties[] = |
| { |
| PROP_LEFT_BORDER, |
| PROP_RIGHT_BORDER, |
| PROP_TOP_BORDER, |
| PROP_BOTTOM_BORDER, |
| PROP_LEFT_BORDER_DISTANCE, |
| PROP_RIGHT_BORDER_DISTANCE, |
| PROP_TOP_BORDER_DISTANCE, |
| PROP_BOTTOM_BORDER_DISTANCE |
| }; |
| |
| sal_uInt32 nStart = rFrameProperties.getLength(); |
| sal_uInt32 nBorderPropertyCount = sizeof( aBorderProperties ) / sizeof(PropertyIds); |
| rFrameProperties.realloc(nStart + nBorderPropertyCount); |
| |
| beans::PropertyValue* pFrameProperties = rFrameProperties.getArray(); |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| for( sal_uInt32 nProperty = 0; nProperty < nBorderPropertyCount; ++nProperty) |
| { |
| ::rtl::OUString sPropertyName = rPropNameSupplier.GetName(aBorderProperties[nProperty]); |
| pFrameProperties[nStart].Name = sPropertyName; |
| pFrameProperties[nStart].Value = xTextRangeProperties->getPropertyValue(sPropertyName); |
| if( nProperty < 4 ) |
| xTextRangeProperties->setPropertyValue( sPropertyName, uno::makeAny(table::BorderLine())); |
| ++nStart; |
| } |
| rFrameProperties.realloc(nStart); |
| } |
| catch( const uno::Exception& rEx ) |
| { |
| (void)rEx; |
| } |
| } |
| /*-- 04.01.2008 10:59:19--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void lcl_AddRangeAndStyle( |
| ParagraphPropertiesPtr& pToBeSavedProperties, |
| uno::Reference< text::XTextAppend > xTextAppend, |
| PropertyMapPtr pPropertyMap) |
| { |
| uno::Reference<text::XParagraphCursor> xParaCursor( |
| xTextAppend->createTextCursorByRange( xTextAppend->getEnd()), uno::UNO_QUERY_THROW ); |
| pToBeSavedProperties->SetEndingRange(xParaCursor->getStart()); |
| xParaCursor->gotoStartOfParagraph( false ); |
| |
| pToBeSavedProperties->SetStartingRange(xParaCursor->getStart()); |
| if(pPropertyMap) |
| { |
| PropertyMap::iterator aParaStyleIter = pPropertyMap->find(PropertyDefinition( PROP_PARA_STYLE_NAME, false ) ); |
| if( aParaStyleIter != pPropertyMap->end()) |
| { |
| ::rtl::OUString sName; |
| aParaStyleIter->second >>= sName; |
| pToBeSavedProperties->SetParaStyleName(sName); |
| } |
| } |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| //define some default frame width - 0cm ATM: this allow the frame to be wrapped around the text |
| #define DEFAULT_FRAME_MIN_WIDTH 0 |
| |
| void DomainMapper_Impl::finishParagraph( PropertyMapPtr pPropertyMap ) |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->startElement("finishParagraph"); |
| #endif |
| |
| ParagraphPropertyMap* pParaContext = dynamic_cast< ParagraphPropertyMap* >( pPropertyMap.get() ); |
| TextAppendContext& rAppendContext = m_aTextAppendStack.top(); |
| uno::Reference< text::XTextAppend > xTextAppend = rAppendContext.xTextAppend; |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->attribute("isTextAppend", xTextAppend.is()); |
| #endif |
| |
| if(xTextAppend.is() && ! getTableManager( ).isIgnore() && pParaContext != NULL) |
| { |
| try |
| { |
| /*the following combinations of previous and current frame settings can occur: |
| (1) - no old frame and no current frame -> no special action |
| (2) - no old frame and current DropCap -> save DropCap for later use, don't call finishParagraph |
| remove character properties of the DropCap? |
| (3) - no old frame and current Frame -> save Frame for later use |
| (4) - old DropCap and no current frame -> add DropCap to the properties of the finished paragraph, delete previous setting |
| (5) - old DropCap and current frame -> add DropCap to the properties of the finished paragraph, save current frame settings |
| (6) - old Frame and new DropCap -> add old Frame, save DropCap for later use |
| (7) - old Frame and new same Frame -> continue |
| (8) - old Frame and new different Frame -> add old Frame, save new Frame for later use |
| (9) - old Frame and no current frame -> add old Frame, delete previous settings |
| |
| old _and_ new DropCap must not occur |
| */ |
| |
| bool bIsDropCap = |
| pParaContext->IsFrameMode() && |
| sal::static_int_cast<Id>(pParaContext->GetDropCap()) != NS_ooxml::LN_Value_wordprocessingml_ST_DropCap_none; |
| |
| style::DropCapFormat aDrop; |
| ParagraphPropertiesPtr pToBeSavedProperties; |
| bool bKeepLastParagraphProperties = false; |
| if( bIsDropCap ) |
| { |
| uno::Reference<text::XParagraphCursor> xParaCursor( |
| xTextAppend->createTextCursorByRange(xTextAppend->getEnd()), uno::UNO_QUERY_THROW); |
| //select paragraph |
| xParaCursor->gotoStartOfParagraph( true ); |
| uno::Reference< beans::XPropertyState > xParaProperties( xParaCursor, uno::UNO_QUERY_THROW ); |
| xParaProperties->setPropertyToDefault(rPropNameSupplier.GetName(PROP_CHAR_ESCAPEMENT)); |
| xParaProperties->setPropertyToDefault(rPropNameSupplier.GetName(PROP_CHAR_HEIGHT)); |
| //handles (2) and part of (6) |
| pToBeSavedProperties.reset( new ParagraphProperties(*pParaContext) ); |
| sal_Int32 nCount = xParaCursor->getString().getLength(); |
| pToBeSavedProperties->SetDropCapLength(nCount > 0 && nCount < 255 ? (sal_Int8)nCount : 1); |
| } |
| if( rAppendContext.pLastParagraphProperties.get() ) |
| { |
| if( sal::static_int_cast<Id>(rAppendContext.pLastParagraphProperties->GetDropCap()) != NS_ooxml::LN_Value_wordprocessingml_ST_DropCap_none) |
| { |
| //handles (4) and part of (5) |
| //create a DropCap property, add it to the property sequence of finishParagraph |
| sal_Int32 nLines = rAppendContext.pLastParagraphProperties->GetLines(); |
| aDrop.Lines = nLines > 0 && nLines < 254 ? (sal_Int8)++nLines : 2; |
| aDrop.Count = rAppendContext.pLastParagraphProperties->GetDropCapLength(); |
| aDrop.Distance = 0; //TODO: find distance value |
| //completes (5) |
| if( pParaContext->IsFrameMode() ) |
| pToBeSavedProperties.reset( new ParagraphProperties(*pParaContext) ); |
| } |
| else if(*rAppendContext.pLastParagraphProperties == *pParaContext ) |
| { |
| //handles (7) |
| rAppendContext.pLastParagraphProperties->SetEndingRange(xTextAppend->getEnd()); |
| bKeepLastParagraphProperties = true; |
| } |
| else |
| { |
| //handles (8)(9) and completes (6) |
| try |
| { |
| // |
| StyleSheetEntryPtr pParaStyle = |
| m_pStyleSheetTable->FindStyleSheetByConvertedStyleName(rAppendContext.pLastParagraphProperties->GetParaStyleName()); |
| |
| uno::Sequence< beans::PropertyValue > aFrameProperties(pParaStyle ? 15: 0); |
| if ( pParaStyle.get( ) ) |
| { |
| const ParagraphProperties* pStyleProperties = dynamic_cast<const ParagraphProperties*>( pParaStyle->pProperties.get() ); |
| beans::PropertyValue* pFrameProperties = aFrameProperties.getArray(); |
| pFrameProperties[0].Name = rPropNameSupplier.GetName(PROP_WIDTH); |
| pFrameProperties[1].Name = rPropNameSupplier.GetName(PROP_HEIGHT); |
| pFrameProperties[2].Name = rPropNameSupplier.GetName(PROP_SIZE_TYPE); |
| pFrameProperties[3].Name = rPropNameSupplier.GetName(PROP_WIDTH_TYPE); |
| pFrameProperties[4].Name = rPropNameSupplier.GetName(PROP_HORI_ORIENT); |
| pFrameProperties[5].Name = rPropNameSupplier.GetName(PROP_HORI_ORIENT_POSITION); |
| pFrameProperties[6].Name = rPropNameSupplier.GetName(PROP_HORI_ORIENT_RELATION); |
| pFrameProperties[7].Name = rPropNameSupplier.GetName(PROP_VERT_ORIENT); |
| pFrameProperties[8].Name = rPropNameSupplier.GetName(PROP_VERT_ORIENT_POSITION); |
| pFrameProperties[9].Name = rPropNameSupplier.GetName(PROP_VERT_ORIENT_RELATION); |
| pFrameProperties[10].Name = rPropNameSupplier.GetName(PROP_SURROUND); |
| pFrameProperties[11].Name = rPropNameSupplier.GetName(PROP_LEFT_MARGIN); |
| pFrameProperties[12].Name = rPropNameSupplier.GetName(PROP_RIGHT_MARGIN); |
| pFrameProperties[13].Name = rPropNameSupplier.GetName(PROP_TOP_MARGIN); |
| pFrameProperties[14].Name = rPropNameSupplier.GetName(PROP_BOTTOM_MARGIN); |
| sal_Int32 nWidth = |
| rAppendContext.pLastParagraphProperties->Getw() > 0 ? |
| rAppendContext.pLastParagraphProperties->Getw() : |
| pStyleProperties->Getw(); |
| bool bAutoWidth = nWidth < 1; |
| if( bAutoWidth ) |
| nWidth = DEFAULT_FRAME_MIN_WIDTH; |
| pFrameProperties[0].Value <<= nWidth; |
| pFrameProperties[1].Value <<= |
| rAppendContext.pLastParagraphProperties->Geth() > 0 ? |
| rAppendContext.pLastParagraphProperties->Geth() : |
| pStyleProperties->Geth(); |
| pFrameProperties[2].Value <<= sal_Int16( |
| rAppendContext.pLastParagraphProperties->GethRule() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GethRule() : |
| pStyleProperties->GethRule() >=0 ? pStyleProperties->GethRule() : text::SizeType::VARIABLE); |
| |
| pFrameProperties[3].Value <<= bAutoWidth ? text::SizeType::MIN : text::SizeType::FIX; |
| |
| sal_Int16 nHoriOrient = sal_Int16( |
| rAppendContext.pLastParagraphProperties->GetxAlign() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GetxAlign() : |
| pStyleProperties->GetxAlign() >= 0 ? pStyleProperties->GetxAlign() : text::HoriOrientation::NONE ); |
| pFrameProperties[4].Value <<= nHoriOrient; |
| |
| pFrameProperties[5].Value <<= |
| rAppendContext.pLastParagraphProperties->IsxValid() ? |
| rAppendContext.pLastParagraphProperties->Getx() : pStyleProperties->Getx(); |
| pFrameProperties[6].Value <<= sal_Int16( |
| rAppendContext.pLastParagraphProperties->GethAnchor() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GethAnchor() : |
| pStyleProperties->GethAnchor() ); |
| |
| sal_Int16 nVertOrient = sal_Int16( |
| rAppendContext.pLastParagraphProperties->GetyAlign() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GetyAlign() : |
| pStyleProperties->GetyAlign() >= 0 ? pStyleProperties->GetyAlign() : text::VertOrientation::NONE ); |
| pFrameProperties[7].Value <<= nVertOrient; |
| |
| pFrameProperties[8].Value <<= |
| rAppendContext.pLastParagraphProperties->IsyValid() ? |
| rAppendContext.pLastParagraphProperties->Gety() : pStyleProperties->Gety(); |
| pFrameProperties[9].Value <<= sal_Int16( |
| rAppendContext.pLastParagraphProperties->GetvAnchor() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GetvAnchor() : |
| pStyleProperties->GetvAnchor() ); |
| |
| pFrameProperties[10].Value <<= text::WrapTextMode( |
| rAppendContext.pLastParagraphProperties->GetWrap() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GetWrap() : |
| pStyleProperties->GetWrap()); |
| |
| sal_Int32 nBottomDist; |
| sal_Int32 nTopDist = nBottomDist = |
| rAppendContext.pLastParagraphProperties->GethSpace() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GethSpace() : |
| pStyleProperties->GethSpace(); |
| |
| pFrameProperties[11].Value <<= nVertOrient == text::VertOrientation::TOP ? 0 : nTopDist; |
| pFrameProperties[12].Value <<= nVertOrient == text::VertOrientation::BOTTOM ? 0 : nBottomDist; |
| |
| sal_Int32 nRightDist; |
| sal_Int32 nLeftDist = nRightDist = |
| rAppendContext.pLastParagraphProperties->GetvSpace() >= 0 ? |
| rAppendContext.pLastParagraphProperties->GetvSpace() : |
| pStyleProperties->GetvSpace() >= 0 ? pStyleProperties->GetvSpace() : 0; |
| pFrameProperties[13].Value <<= nHoriOrient == text::HoriOrientation::LEFT ? 0 : nLeftDist; |
| pFrameProperties[14].Value <<= nHoriOrient == text::HoriOrientation::RIGHT ? 0 : nRightDist; |
| |
| lcl_MoveBorderPropertiesToFrame(aFrameProperties, |
| rAppendContext.pLastParagraphProperties->GetStartingRange(), |
| rAppendContext.pLastParagraphProperties->GetEndingRange()); |
| } |
| //frame conversion has to be executed after table conversion |
| RegisterFrameConversion( |
| rAppendContext.pLastParagraphProperties->GetStartingRange(), |
| rAppendContext.pLastParagraphProperties->GetEndingRange(), |
| aFrameProperties ); |
| // next frame follows directly |
| if( pParaContext->IsFrameMode() ) |
| { |
| pToBeSavedProperties.reset( new ParagraphProperties(*pParaContext) ); |
| lcl_AddRangeAndStyle(pToBeSavedProperties, xTextAppend, pPropertyMap); |
| } |
| } |
| catch( const uno::Exception& rEx ) |
| { |
| (void)rEx; |
| } |
| } |
| |
| } |
| else // |
| { |
| // (1) doesn't need handling |
| // |
| if( !bIsDropCap && pParaContext->IsFrameMode() ) |
| { |
| pToBeSavedProperties.reset( new ParagraphProperties(*pParaContext) ); |
| lcl_AddRangeAndStyle(pToBeSavedProperties, xTextAppend, pPropertyMap); |
| } |
| } |
| uno::Sequence< beans::PropertyValue > aProperties; |
| if( pPropertyMap.get() ) |
| { |
| aProperties = pPropertyMap->GetPropertyValues(); |
| } |
| if( !bIsDropCap ) |
| { |
| if( aDrop.Lines > 1 ) |
| { |
| sal_uInt32 nLength = aProperties.getLength(); |
| aProperties.realloc( nLength + 1 ); |
| aProperties[nLength].Value <<= aDrop; |
| aProperties[nLength].Name = rPropNameSupplier.GetName(PROP_DROP_CAP_FORMAT); |
| } |
| uno::Reference< text::XTextRange > xTextRange = |
| xTextAppend->finishParagraph( aProperties ); |
| getTableManager( ).handle(xTextRange); |
| |
| // Set the anchor of the objects to the created paragraph |
| while ( m_aAnchoredStack.size( ) > 0 && !m_bIsInShape ) |
| { |
| uno::Reference< text::XTextContent > xObj = m_aAnchoredStack.top( ); |
| try |
| { |
| #if DEBUG |
| rtl::OUString sText( xTextRange->getString( ) ); |
| #endif |
| xObj->attach( xTextRange ); |
| } |
| catch ( uno::RuntimeException& ) |
| { |
| // this is normal: the shape is already attached |
| } |
| m_aAnchoredStack.pop( ); |
| } |
| |
| // Get the end of paragraph character inserted |
| uno::Reference< text::XTextCursor > xCur = xTextRange->getText( )->createTextCursor( ); |
| xCur->gotoEnd( false ); |
| xCur->goLeft( 1 , true ); |
| uno::Reference< text::XTextRange > xParaEnd( xCur, uno::UNO_QUERY ); |
| CheckParaRedline( xParaEnd ); |
| |
| // Remove the last empty section paragraph if needed |
| if ( m_bIsLastParaInSection && !m_bParaChanged ) |
| { |
| RemoveLastParagraph( ); |
| m_bIsLastParaInSection = false; |
| } |
| |
| m_bParaChanged = false; |
| } |
| if( !bKeepLastParagraphProperties ) |
| rAppendContext.pLastParagraphProperties = pToBeSavedProperties; |
| } |
| catch(const lang::IllegalArgumentException& rIllegal) |
| { |
| (void)rIllegal; |
| OSL_ENSURE( false, "IllegalArgumentException in DomainMapper_Impl::finishParagraph" ); |
| } |
| catch(const uno::Exception& rEx) |
| { |
| (void)rEx; |
| //OSL_ENSURE( false, "ArgumentException in DomainMapper_Impl::finishParagraph" ); |
| } |
| } |
| |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->endElement("finishParagraph"); |
| #endif |
| } |
| /*------------------------------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| util::DateTime lcl_DateStringToDateTime( const ::rtl::OUString& rDateTime ) |
| { |
| util::DateTime aDateTime; |
| //xsd::DateTime in the format [-]CCYY-MM-DDThh:mm:ss[Z|(+|-)hh:mm] example: 2008-01-21T10:42:00Z |
| //OUString getToken( sal_Int32 token, sal_Unicode cTok, sal_Int32& index ) const SAL_THROW(()) |
| sal_Int32 nIndex = 0; |
| ::rtl::OUString sDate = rDateTime.getToken( 0, 'T', nIndex ); |
| ::rtl::OUString sTime = rDateTime.getToken( 0, 'Z', nIndex ); |
| nIndex = 0; |
| aDateTime.Year = sal_uInt16( sDate.getToken( 0, '-', nIndex ).toInt32() ); |
| aDateTime.Month = sal_uInt16( sDate.getToken( 0, '-', nIndex ).toInt32() ); |
| aDateTime.Day = sal_uInt16( sDate.copy( nIndex ).toInt32() ); |
| |
| nIndex = 0; |
| aDateTime.Hours = sal_uInt16( sTime.getToken( 0, ':', nIndex ).toInt32() ); |
| aDateTime.Minutes = sal_uInt16( sTime.getToken( 0, ':', nIndex ).toInt32() ); |
| aDateTime.Seconds = sal_uInt16( sTime.copy( nIndex ).toInt32() ); |
| |
| return aDateTime; |
| } |
| void DomainMapper_Impl::appendTextPortion( const ::rtl::OUString& rString, PropertyMapPtr pPropertyMap ) |
| { |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| if(xTextAppend.is() && ! getTableManager( ).isIgnore()) |
| { |
| try |
| { |
| uno::Reference< text::XTextRange > xTextRange = |
| xTextAppend->appendTextPortion |
| (rString, pPropertyMap->GetPropertyValues()); |
| CheckRedline( xTextRange ); |
| m_bParaChanged = true; |
| |
| //getTableManager( ).handle(xTextRange); |
| } |
| catch(const lang::IllegalArgumentException& rEx) |
| { |
| (void)rEx; |
| OSL_ENSURE( false, "IllegalArgumentException in DomainMapper_Impl::appendTextPortion" ); |
| } |
| catch(const uno::Exception& rEx) |
| { |
| (void)rEx; |
| OSL_ENSURE( false, "Exception in DomainMapper_Impl::appendTextPortion" ); |
| } |
| } |
| } |
| /*-- 02.11.2006 12:08:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::appendTextContent( |
| const uno::Reference< text::XTextContent > xContent, |
| const uno::Sequence< beans::PropertyValue > xPropertyValues |
| ) |
| { |
| uno::Reference< text::XTextAppendAndConvert > xTextAppendAndConvert( m_aTextAppendStack.top().xTextAppend, uno::UNO_QUERY ); |
| OSL_ENSURE( xTextAppendAndConvert.is(), "trying to append a text content without XTextAppendAndConvert" ); |
| if(xTextAppendAndConvert.is() && ! getTableManager( ).isIgnore()) |
| { |
| try |
| { |
| xTextAppendAndConvert->appendTextContent( xContent, xPropertyValues ); |
| } |
| catch(const lang::IllegalArgumentException& ) |
| { |
| } |
| catch(const uno::Exception& ) |
| { |
| } |
| } |
| } |
| |
| /*-- 24.04.2008 08:38:07--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::appendOLE( const ::rtl::OUString& rStreamName, OLEHandlerPtr pOLEHandler ) |
| { |
| static const rtl::OUString sEmbeddedService(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextEmbeddedObject")); |
| try |
| { |
| uno::Reference< text::XTextContent > xOLE( m_xTextFactory->createInstance(sEmbeddedService), uno::UNO_QUERY_THROW ); |
| uno::Reference< beans::XPropertySet > xOLEProperties(xOLE, uno::UNO_QUERY_THROW); |
| |
| xOLEProperties->setPropertyValue(PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_STREAM_NAME ), |
| uno::makeAny( rStreamName )); |
| awt::Size aSize = pOLEHandler->getSize(); |
| if( !aSize.Width ) |
| aSize.Width = 1000; |
| if( !aSize.Height ) |
| aSize.Height = 1000; |
| xOLEProperties->setPropertyValue(PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_WIDTH ), |
| uno::makeAny(aSize.Width)); |
| xOLEProperties->setPropertyValue(PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_HEIGHT ), |
| uno::makeAny(aSize.Height)); |
| |
| uno::Reference< graphic::XGraphic > xGraphic = pOLEHandler->getReplacement(); |
| xOLEProperties->setPropertyValue(PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_GRAPHIC ), |
| uno::makeAny(xGraphic)); |
| |
| // |
| appendTextContent( xOLE, uno::Sequence< beans::PropertyValue >() ); |
| |
| } |
| catch( const uno::Exception& rEx ) |
| { |
| (void)rEx; |
| OSL_ENSURE( false, "Exception in creation of OLE object" ); |
| } |
| |
| } |
| /*-- 14.12.2006 12:26:00--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< beans::XPropertySet > DomainMapper_Impl::appendTextSectionAfter( |
| uno::Reference< text::XTextRange >& xBefore ) |
| { |
| uno::Reference< beans::XPropertySet > xRet; |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| if(xTextAppend.is()) |
| { |
| try |
| { |
| uno::Reference< text::XParagraphCursor > xCursor( |
| xTextAppend->createTextCursorByRange( xBefore ), uno::UNO_QUERY_THROW); |
| //the cursor has been moved to the end of the paragraph because of the appendTextPortion() calls |
| xCursor->gotoStartOfParagraph( false ); |
| xCursor->gotoEnd( true ); |
| //the paragraph after this new section is already inserted |
| xCursor->goLeft(1, true); |
| static const rtl::OUString sSectionService(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextSection")); |
| uno::Reference< text::XTextContent > xSection( m_xTextFactory->createInstance(sSectionService), uno::UNO_QUERY_THROW ); |
| xSection->attach( uno::Reference< text::XTextRange >( xCursor, uno::UNO_QUERY_THROW) ); |
| xRet = uno::Reference< beans::XPropertySet > (xSection, uno::UNO_QUERY ); |
| } |
| catch(const uno::Exception& ) |
| { |
| } |
| |
| } |
| |
| return xRet; |
| } |
| /*-- 02.11.2006 12:08:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushPageHeader(SectionPropertyMap::PageType eType) |
| { |
| //get the section context |
| PropertyMapPtr pContext = DomainMapper_Impl::GetTopContextOfType(CONTEXT_SECTION); |
| //ask for the header name of the given type |
| SectionPropertyMap* pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() ); |
| if(pSectionContext) |
| { |
| uno::Reference< beans::XPropertySet > xPageStyle = |
| pSectionContext->GetPageStyle( |
| GetPageStyles(), |
| m_xTextFactory, |
| eType == SectionPropertyMap::PAGE_FIRST ); |
| try |
| { |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| //switch on header use |
| xPageStyle->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HEADER_IS_ON), |
| uno::makeAny(sal_True) ); |
| // if a left header is available then header are not shared |
| bool bLeft = eType == SectionPropertyMap::PAGE_LEFT; |
| if( bLeft ) |
| xPageStyle->setPropertyValue(rPropNameSupplier.GetName(PROP_HEADER_IS_SHARED), uno::makeAny( false )); |
| |
| //set the interface |
| uno::Reference< text::XText > xHeaderText; |
| xPageStyle->getPropertyValue(rPropNameSupplier.GetName( bLeft ? PROP_HEADER_TEXT_LEFT : PROP_HEADER_TEXT) ) >>= xHeaderText; |
| m_aTextAppendStack.push( uno::Reference< text::XTextAppend >( xHeaderText, uno::UNO_QUERY_THROW)); |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| } |
| } |
| /*-- 24.07.2006 09:41:20--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushPageFooter(SectionPropertyMap::PageType eType) |
| { |
| //get the section context |
| PropertyMapPtr pContext = DomainMapper_Impl::GetTopContextOfType(CONTEXT_SECTION); |
| //ask for the footer name of the given type |
| SectionPropertyMap* pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() ); |
| if(pSectionContext) |
| { |
| uno::Reference< beans::XPropertySet > xPageStyle = |
| pSectionContext->GetPageStyle( |
| GetPageStyles(), |
| m_xTextFactory, |
| eType == SectionPropertyMap::PAGE_FIRST ); |
| try |
| { |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| //switch on footer use |
| xPageStyle->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_FOOTER_IS_ON), |
| uno::makeAny(sal_True) ); |
| // if a left header is available then footer is not shared |
| bool bLeft = eType == SectionPropertyMap::PAGE_LEFT; |
| if( bLeft ) |
| xPageStyle->setPropertyValue(rPropNameSupplier.GetName(PROP_FOOTER_IS_SHARED), uno::makeAny( false )); |
| //set the interface |
| uno::Reference< text::XText > xFooterText; |
| xPageStyle->getPropertyValue(rPropNameSupplier.GetName( bLeft ? PROP_FOOTER_TEXT_LEFT : PROP_FOOTER_TEXT) ) >>= xFooterText; |
| m_aTextAppendStack.push(uno::Reference< text::XTextAppend >( xFooterText, uno::UNO_QUERY_THROW )); |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| } |
| } |
| /*-- 24.07.2006 09:41:20--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PopPageHeaderFooter() |
| { |
| //header and footer always have an empty paragraph at the end |
| //this has to be removed |
| RemoveLastParagraph( ); |
| m_aTextAppendStack.pop(); |
| } |
| /*-- 24.05.2007 14:22:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushFootOrEndnote( bool bIsFootnote ) |
| { |
| try |
| { |
| PropertyMapPtr pTopContext = GetTopContext(); |
| uno::Reference< text::XText > xFootnoteText( GetTextFactory()->createInstance( |
| bIsFootnote ? |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Footnote") ) : ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Endnote") )), |
| uno::UNO_QUERY_THROW ); |
| uno::Reference< text::XFootnote > xFootnote( xFootnoteText, uno::UNO_QUERY_THROW ); |
| pTopContext->SetFootnote( xFootnote ); |
| if( pTopContext->GetFootnoteSymbol() != 0) |
| { |
| xFootnote->setLabel( ::rtl::OUString( pTopContext->GetFootnoteSymbol() ) ); |
| } |
| FontTablePtr pFontTable = GetFontTable(); |
| uno::Sequence< beans::PropertyValue > aFontProperties; |
| if( pFontTable && pTopContext->GetFootnoteFontId() >= 0 && pFontTable->size() > (size_t)pTopContext->GetFootnoteFontId() ) |
| { |
| const FontEntry::Pointer_t pFontEntry(pFontTable->getFontEntry(sal_uInt32(pTopContext->GetFootnoteFontId()))); |
| PropertyMapPtr aFontProps( new PropertyMap ); |
| aFontProps->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( pFontEntry->sFontName )); |
| aFontProps->Insert(PROP_CHAR_FONT_CHAR_SET, true, uno::makeAny( (sal_Int16)pFontEntry->nTextEncoding )); |
| aFontProps->Insert(PROP_CHAR_FONT_PITCH, true, uno::makeAny( pFontEntry->nPitchRequest )); |
| aFontProperties = aFontProps->GetPropertyValues(); |
| } |
| else if(pTopContext->GetFootnoteFontName().getLength()) |
| { |
| PropertyMapPtr aFontProps( new PropertyMap ); |
| aFontProps->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( pTopContext->GetFootnoteFontName() )); |
| aFontProperties = aFontProps->GetPropertyValues(); |
| } |
| appendTextContent( uno::Reference< text::XTextContent >( xFootnoteText, uno::UNO_QUERY_THROW ), aFontProperties ); |
| m_aTextAppendStack.push(uno::Reference< text::XTextAppend >( xFootnoteText, uno::UNO_QUERY_THROW )); |
| |
| // Redlines for the footnote anchor |
| CheckRedline( xFootnote->getAnchor( ) ); |
| } |
| catch( uno::Exception& ) |
| { |
| OSL_ENSURE( false, "exception in PushFootOrEndnote" ); |
| } |
| } |
| |
| void DomainMapper_Impl::CreateRedline( uno::Reference< text::XTextRange > xRange, RedlineParamsPtr& pRedline ) |
| { |
| if ( pRedline.get( ) ) |
| { |
| try |
| { |
| ::rtl::OUString sType; |
| PropertyNameSupplier & rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier( ); |
| switch ( pRedline->m_nToken & 0xffff ) |
| { |
| case ooxml::OOXML_mod: |
| sType = rPropNameSupplier.GetName( PROP_FORMAT ); |
| break; |
| case ooxml::OOXML_ins: |
| sType = rPropNameSupplier.GetName( PROP_INSERT ); |
| break; |
| case ooxml::OOXML_del: |
| sType = rPropNameSupplier.GetName( PROP_DELETE ); |
| break; |
| } |
| uno::Reference < text::XRedline > xRedline( xRange, uno::UNO_QUERY_THROW ); |
| beans::PropertyValues aRedlineProperties( 2 ); |
| beans::PropertyValue * pRedlineProperties = aRedlineProperties.getArray( ); |
| pRedlineProperties[0].Name = rPropNameSupplier.GetName( PROP_REDLINE_AUTHOR ); |
| pRedlineProperties[0].Value <<= pRedline->m_sAuthor; |
| pRedlineProperties[1].Name = rPropNameSupplier.GetName( PROP_REDLINE_DATE_TIME ); |
| pRedlineProperties[1].Value <<= lcl_DateStringToDateTime( pRedline->m_sDate ); |
| |
| xRedline->makeRedline( sType, aRedlineProperties ); |
| } |
| catch( const uno::Exception & rEx ) |
| { |
| ( void ) rEx; |
| // disabled: current writer redline impl. rather primitive, so it gets annoying |
| // OSL_ENSURE( false, "Exception in makeRedline" ); |
| } |
| } |
| } |
| |
| void DomainMapper_Impl::CheckParaRedline( uno::Reference< text::XTextRange > xRange ) |
| { |
| if ( m_pParaRedline.get( ) ) |
| { |
| CreateRedline( xRange, m_pParaRedline ); |
| ResetParaRedline( ); |
| } |
| } |
| |
| void DomainMapper_Impl::CheckRedline( uno::Reference< text::XTextRange > xRange ) |
| { |
| vector<RedlineParamsPtr>::iterator pIt = m_aRedlines.begin( ); |
| vector< RedlineParamsPtr > aCleaned; |
| for (; pIt != m_aRedlines.end( ); pIt++ ) |
| { |
| CreateRedline( xRange, *pIt ); |
| |
| // Adding the non-mod redlines to the temporary vector |
| if ( pIt->get( ) && ( ( *pIt )->m_nToken & 0xffff ) != ooxml::OOXML_mod ) |
| { |
| aCleaned.push_back( *pIt ); |
| } |
| } |
| |
| m_aRedlines.swap( aCleaned ); |
| } |
| |
| void DomainMapper_Impl::StartParaChange( ) |
| { |
| m_bIsParaChange = true; |
| } |
| |
| void DomainMapper_Impl::EndParaChange( ) |
| { |
| m_bIsParaChange = false; |
| } |
| |
| /*-- 22.12.2008 13:45:15--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushAnnotation() |
| { |
| try |
| { |
| PropertyMapPtr pTopContext = GetTopContext(); |
| m_bIsInComments = true; |
| m_xAnnotationField = uno::Reference< beans::XPropertySet >( GetTextFactory()->createInstance( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextField.Annotation") ) ), |
| uno::UNO_QUERY_THROW ); |
| uno::Reference< text::XText > xAnnotationText; |
| m_xAnnotationField->getPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("TextRange"))) >>= xAnnotationText; |
| m_aTextAppendStack.push(uno::Reference< text::XTextAppend >( xAnnotationText, uno::UNO_QUERY_THROW )); |
| } |
| catch( uno::Exception& ) |
| { |
| OSL_ENSURE( false, "exception in PushAnnotation" ); |
| } |
| } |
| /*-- 24.05.2007 14:22:29--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PopFootOrEndnote() |
| { |
| RemoveLastParagraph(); |
| m_aTextAppendStack.pop(); |
| } |
| /*-- 22.12.2008 13:45:15--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PopAnnotation() |
| { |
| m_bIsInComments = false; |
| |
| RemoveLastParagraph(); |
| m_aTextAppendStack.pop(); |
| |
| if ( m_nAnnotationId != -1 ) |
| { |
| // See if the annotation will be a single position or a range. |
| AnnotationPosition& aAnnotationPosition = m_aAnnotationPositions[ m_nAnnotationId ]; |
| if ( !aAnnotationPosition.m_xStart.is() |
| || !aAnnotationPosition.m_xEnd.is() ) |
| { |
| uno::Sequence< beans::PropertyValue > aEmptyProperties; |
| appendTextContent( uno::Reference< text::XTextContent >( m_xAnnotationField, uno::UNO_QUERY_THROW ), aEmptyProperties ); |
| } |
| else |
| { |
| // Create a range that points to the annotation start/end. |
| uno::Reference<text::XText> xText = aAnnotationPosition.m_xStart->getText(); |
| uno::Reference<text::XTextCursor> xCursor = xText->createTextCursorByRange( aAnnotationPosition.m_xStart ); |
| xCursor->gotoRange( aAnnotationPosition.m_xEnd, true ); |
| uno::Reference<text::XTextRange> xTextRange(xCursor, uno::UNO_QUERY_THROW); |
| |
| // Attach the annotation to the range. |
| uno::Reference<text::XTextAppend> xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| xTextAppend->insertTextContent(xTextRange, uno::Reference<text::XTextContent>(m_xAnnotationField, uno::UNO_QUERY_THROW), !xCursor->isCollapsed()); |
| } |
| m_aAnnotationPositions.erase( m_nAnnotationId ); |
| } |
| |
| m_xAnnotationField.clear(); |
| m_nAnnotationId = -1; |
| } |
| |
| void DomainMapper_Impl::PushShapeContext( const uno::Reference< drawing::XShape > xShape ) |
| { |
| m_bIsInShape = true; |
| try |
| { |
| // Add the shape to the text append stack |
| m_aTextAppendStack.push( uno::Reference< text::XTextAppend >( xShape, uno::UNO_QUERY_THROW ) ); |
| m_bShapeContextAdded = true; |
| |
| // Add the shape to the anchored objects stack |
| uno::Reference< text::XTextContent > xTxtContent( xShape, uno::UNO_QUERY_THROW ); |
| m_aAnchoredStack.push( xTxtContent ); |
| |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| |
| uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW ); |
| xProps->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_ANCHOR_TYPE ), |
| uno::makeAny( text::TextContentAnchorType_AT_PARAGRAPH ) ); |
| xProps->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_OPAQUE ), |
| uno::makeAny( true ) ); |
| } |
| catch ( const uno::Exception& e ) |
| { |
| #if DEBUG |
| clog << "Exception when adding shape: "; |
| clog << rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_UTF8 ).getStr( ); |
| clog << endl; |
| #endif |
| } |
| } |
| |
| /*-- 20.03.2008 09:01:59--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PopShapeContext() |
| { |
| if ( m_bShapeContextAdded ) |
| { |
| m_aTextAppendStack.pop(); |
| m_bShapeContextAdded = false; |
| } |
| m_bIsInShape = false; |
| } |
| /*-- 12.09.2006 08:07:55--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| ::rtl::OUString lcl_FindQuotedText( const ::rtl::OUString& rCommand, |
| const sal_Char* cStartQuote, const sal_Unicode uEndQuote ) |
| { |
| ::rtl::OUString sRet; |
| ::rtl::OUString sStartQuote( ::rtl::OUString::createFromAscii(cStartQuote) ); |
| sal_Int32 nStartIndex = rCommand.indexOf( sStartQuote ); |
| if( nStartIndex >= 0 ) |
| { |
| sal_Int32 nStartLength = sStartQuote.getLength(); |
| sal_Int32 nEndIndex = rCommand.indexOf( uEndQuote, nStartIndex + nStartLength); |
| if( nEndIndex > nStartIndex ) |
| { |
| sRet = rCommand.copy( nStartIndex + nStartLength, nEndIndex - nStartIndex - nStartLength); |
| } |
| } |
| return sRet; |
| |
| } |
| /*-- 08.09.2006 14:05:17--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Int16 lcl_ParseNumberingType( const ::rtl::OUString& rCommand ) |
| { |
| sal_Int16 nRet = style::NumberingType::PAGE_DESCRIPTOR; |
| |
| // The command looks like: " PAGE \* Arabic " |
| ::rtl::OUString sNumber = lcl_FindQuotedText(rCommand, "\\* ", ' '); |
| |
| if( sNumber.getLength() ) |
| { |
| //todo: might make sense to hash this list, too |
| struct NumberingPairs |
| { |
| const sal_Char* cWordName; |
| sal_Int16 nType; |
| }; |
| static const NumberingPairs aNumberingPairs[] = |
| { |
| {"Arabic", style::NumberingType::ARABIC} |
| ,{"ROMAN", style::NumberingType::ROMAN_UPPER} |
| ,{"roman", style::NumberingType::ROMAN_LOWER} |
| ,{"ALPHABETIC", style::NumberingType::CHARS_UPPER_LETTER} |
| ,{"alphabetic", style::NumberingType::CHARS_LOWER_LETTER} |
| ,{"CircleNum", style::NumberingType::CIRCLE_NUMBER} |
| ,{"ThaiArabic", style::NumberingType::CHARS_THAI} |
| ,{"ThaiCardText", style::NumberingType::CHARS_THAI} |
| ,{"ThaiLetter", style::NumberingType::CHARS_THAI} |
| // ,{"SBCHAR", style::NumberingType::} |
| // ,{"DBCHAR", style::NumberingType::} |
| // ,{"DBNUM1", style::NumberingType::} |
| // ,{"DBNUM2", style::NumberingType::} |
| // ,{"DBNUM3", style::NumberingType::} |
| // ,{"DBNUM4", style::NumberingType::} |
| ,{"Aiueo", style::NumberingType::AIU_FULLWIDTH_JA} |
| ,{"Iroha", style::NumberingType::IROHA_FULLWIDTH_JA} |
| // ,{"ZODIAC1", style::NumberingType::} |
| // ,{"ZODIAC2", style::NumberingType::} |
| // ,{"ZODIAC3", style::NumberingType::} |
| // ,{"CHINESENUM1", style::NumberingType::} |
| // ,{"CHINESENUM2", style::NumberingType::} |
| // ,{"CHINESENUM3", style::NumberingType::} |
| ,{"ArabicAlpha", style::NumberingType::CHARS_ARABIC} |
| ,{"ArabicAbjad", style::NumberingType::FULLWIDTH_ARABIC} |
| /* possible values: |
| style::NumberingType:: |
| |
| CHARS_UPPER_LETTER_N |
| CHARS_LOWER_LETTER_N |
| TRANSLITERATION |
| NATIVE_NUMBERING |
| CIRCLE_NUMBER |
| NUMBER_LOWER_ZH |
| NUMBER_UPPER_ZH |
| NUMBER_UPPER_ZH_TW |
| TIAN_GAN_ZH |
| DI_ZI_ZH |
| NUMBER_TRADITIONAL_JA |
| AIU_HALFWIDTH_JA |
| IROHA_HALFWIDTH_JA |
| NUMBER_UPPER_KO |
| NUMBER_HANGUL_KO |
| HANGUL_JAMO_KO |
| HANGUL_SYLLABLE_KO |
| HANGUL_CIRCLED_JAMO_KO |
| HANGUL_CIRCLED_SYLLABLE_KO |
| CHARS_HEBREW |
| CHARS_NEPALI |
| CHARS_KHMER |
| CHARS_LAO |
| CHARS_TIBETAN |
| CHARS_CYRILLIC_UPPER_LETTER_BG |
| CHARS_CYRILLIC_LOWER_LETTER_BG |
| CHARS_CYRILLIC_UPPER_LETTER_N_BG |
| CHARS_CYRILLIC_LOWER_LETTER_N_BG |
| CHARS_CYRILLIC_UPPER_LETTER_RU |
| CHARS_CYRILLIC_LOWER_LETTER_RU |
| CHARS_CYRILLIC_UPPER_LETTER_N_RU |
| CHARS_CYRILLIC_LOWER_LETTER_N_RU |
| CHARS_CYRILLIC_UPPER_LETTER_SR |
| CHARS_CYRILLIC_LOWER_LETTER_SR |
| CHARS_CYRILLIC_UPPER_LETTER_N_SR |
| CHARS_CYRILLIC_LOWER_LETTER_N_SR*/ |
| |
| }; |
| for( sal_uInt32 nNum = 0; nNum < sizeof(aNumberingPairs)/sizeof( NumberingPairs ); ++nNum) |
| { |
| if( /*sCommand*/sNumber.equalsAscii(aNumberingPairs[nNum].cWordName )) |
| { |
| nRet = aNumberingPairs[nNum].nType; |
| break; |
| } |
| } |
| |
| } |
| return nRet; |
| } |
| /*-- 08.09.2006 13:52:09--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| OUString lcl_ParseFormat( const ::rtl::OUString& rCommand ) |
| { |
| // The command looks like: " DATE \@ "dd MMMM yyyy" |
| return lcl_FindQuotedText(rCommand, "\\@ \"", '\"'); |
| } |
| /*-- 19.09.2006 10:01:20--------------------------------------------------- |
| extract a parameter (with or without quotes) between the command and the following backslash |
| -----------------------------------------------------------------------*/ |
| ::rtl::OUString lcl_ExtractParameter(const ::rtl::OUString& rCommand, sal_Int32 nCommandLength ) |
| { |
| sal_Int32 nStartIndex = nCommandLength; |
| sal_Int32 nEndIndex = 0; |
| sal_Int32 nQuoteIndex = rCommand.indexOf( '\"', nStartIndex); |
| if( nQuoteIndex >= 0) |
| { |
| nStartIndex = nQuoteIndex + 1; |
| nEndIndex = rCommand.indexOf( '\"', nStartIndex + 1) - 1; |
| } |
| else |
| { |
| nEndIndex = rCommand.indexOf( ::rtl::OUString::createFromAscii(" \\"), nStartIndex); |
| } |
| ::rtl::OUString sRet; |
| if( nEndIndex > nStartIndex + 1 ) |
| { |
| //remove spaces at start and end of the result |
| if(nQuoteIndex <= 0) |
| { |
| const sal_Unicode* pCommandStr = rCommand.getStr(); |
| while( nStartIndex < nEndIndex && pCommandStr[nStartIndex] == ' ') |
| ++nStartIndex; |
| while( nEndIndex > nStartIndex && pCommandStr[nEndIndex] == ' ') |
| --nEndIndex; |
| } |
| sRet = rCommand.copy( nStartIndex, nEndIndex - nStartIndex + 1); |
| } |
| return sRet; |
| } |
| |
| /*-- 15.09.2006 10:57:57--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| ::rtl::OUString lcl_ExctractAskVariableAndHint( const ::rtl::OUString& rCommand, ::rtl::OUString& rHint ) |
| { |
| // the first word after "ASK " is the variable |
| // the text after the variable and before a '\' is the hint |
| // if no hint is set the variable is used as hint |
| // the quotes of the hint have to be removed |
| sal_Int32 nIndex = rCommand.indexOf( ' ', 2);//find last space after 'ASK' |
| while(rCommand.getStr()[nIndex] == ' ') |
| ++nIndex; |
| ::rtl::OUString sShortCommand( rCommand.copy( nIndex ) ); //cut off the " ASK " |
| |
| nIndex = 0; |
| sShortCommand = sShortCommand.getToken( 0, '\\', nIndex); |
| nIndex = 0; |
| ::rtl::OUString sRet = sShortCommand.getToken( 0, ' ', nIndex); |
| if( nIndex > 0) |
| rHint = sShortCommand.copy( nIndex ); |
| if( !rHint.getLength() ) |
| rHint = sRet; |
| return sRet; |
| } |
| /*-- 24.01.2007 16:04:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| bool lcl_FindInCommand( |
| const ::rtl::OUString& rCommand, |
| sal_Unicode cSwitch, |
| ::rtl::OUString& rValue ) |
| { |
| bool bRet = false; |
| ::rtl::OUString sSearch('\\'); |
| sSearch += ::rtl::OUString( cSwitch ); |
| sal_Int32 nIndex = rCommand.indexOf( sSearch ); |
| if( nIndex >= 0 ) |
| { |
| bRet = true; |
| //find next '\' or end of string |
| sal_Int32 nEndIndex = rCommand.indexOf( '\\', nIndex + 1); |
| if( nEndIndex < 0 ) |
| nEndIndex = rCommand.getLength() - 1; |
| if( nEndIndex - nIndex > 3 ) |
| rValue = rCommand.copy( nIndex + 3, nEndIndex - nIndex - 3); |
| } |
| return bRet; |
| } |
| /*-- 01.09.2006 11:48:08--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| /*void DomainMapper_Impl::CreateField( ::rtl::OUString& rCommand ) |
| { |
| static FieldConversionMap_t aFieldConversionMap; |
| static bool bFilled = false; |
| m_bSetUserFieldContent = false; |
| if(!bFilled) |
| { |
| static const FieldConversion aFields[] = |
| { |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ADDRESSBLOCK")), "", "", FIELD_ADDRESSBLOCK }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ADVANCE")), "", "", FIELD_ADVANCE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ASK")), "SetExpression", "SetExpression", FIELD_ASK }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTONUM")), "SetExpression", "SetExpression", FIELD_AUTONUM }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTONUMLGL")), "SetExpression", "SetExpression", FIELD_AUTONUMLGL }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTONUMOUT")), "SetExpression", "SetExpression", FIELD_AUTONUMOUT }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTHOR")), "Author", "", FIELD_AUTHOR }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATE")), "DateTime", "", FIELD_DATE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("COMMENTS")), "DocInfo.Description", "", FIELD_COMMENTS }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CREATEDATE")), "DocInfo.CreateDateTime", "", FIELD_CREATEDATE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOCPROPERTY")), "", "", FIELD_DOCPROPERTY }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOCVARIABLE")), "User", "", FIELD_DOCVARIABLE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EDITTIME")), "DocInfo.EditTime", "", FIELD_EDITTIME }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FILLIN")), "Input", "", FIELD_FILLIN }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FILENAME")), "FileName", "", FIELD_FILENAME }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FILESIZE")), "", "", FIELD_FILESIZE }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FORMULA")), "", "", FIELD_FORMULA |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GOTOBUTTON")), "", "", FIELD_GOTOBUTTON }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HYPERLINK")), "", "", FIELD_HYPERLINK }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IF")), "ConditionalText", "", FIELD_IF }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INFO")), "","", FIELD_INFO }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INCLUDEPICTURE")), "", "", FIELD_INCLUDEPICTURE}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("KEYWORDS")), "DocInfo.KeyWords", "", FIELD_KEYWORDS }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LASTSAVEDBY")), "DocInfo.ChangeAuthor", "", FIELD_LASTSAVEDBY }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MACROBUTTON")), "Macro", "", FIELD_MACROBUTTON }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MERGEFIELD")), "Database", "Database", FIELD_MERGEFIELD}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MERGEREC")), "DatabaseNumberOfSet", "", FIELD_MERGEREC }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MERGESEQ")), "", "", FIELD_MERGESEQ }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NEXT")), "DatabaseNextSet", "", FIELD_NEXT }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NEXTIF")), "DatabaseNextSet", "", FIELD_NEXTIF }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PAGE")), "PageNumber", "", FIELD_PAGE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("REF")), "", "", FIELD_REF }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("REVNUM")), "DocInfo.Revision", "", FIELD_REVNUM }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SAVEDATE")), "DocInfo.Change", "", FIELD_SAVEDATE }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SECTION")), "", "", FIELD_SECTION }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SECTIONPAGES")), "", "", FIELD_SECTIONPAGES }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SEQ")), "SetExpression", "SetExpression", FIELD_SEQ }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SET")), "","", FIELD_SET }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SKIPIF")),"", "", FIELD_SKIPIF }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("STYLEREF")),"", "", FIELD_STYLEREF }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SUBJECT")), "DocInfo.Subject", "", FIELD_SUBJECT }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SYMBOL")),"", "", FIELD_SYMBOL }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TEMPLATE")), "TemplateName", "", FIELD_TEMPLATE}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TIME")), "DateTime", "", FIELD_TIME }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TITLE")), "DocInfo.Title", "", FIELD_TITLE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("USERINITIALS")), "ExtendedUser", "", FIELD_USERINITIALS}, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("USERADDRESS")), "", "", FIELD_USERADDRESS }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("USERNAME")), "ExtendedUser", "", FIELD_USERNAME } |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TOC")), "com.sun.star.text.ContentIndex", "", FIELD_TOC}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TC")), "com.sun.star.text.ContentIndexMark", "", FIELD_TC}, |
| |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("")), "", "", FIELD_}, |
| |
| }; |
| size_t nConversions = sizeof(aFields)/sizeof(FieldConversion); |
| for( size_t nConversion = 0; nConversion < nConversions; ++nConversion) |
| { |
| aFieldConversionMap.insert( FieldConversionMap_t::value_type( |
| aFields[nConversion].sWordCommand, |
| aFields[nConversion] )); |
| } |
| |
| bFilled = true; |
| } |
| try |
| { |
| uno::Reference< uno::XInterface > xFieldInterface; |
| //at first determine the field type - skip first space |
| ::rtl::OUString sCommand( rCommand.copy(rCommand.getLength() ? 1 : 0) ); |
| sal_Int32 nSpaceIndex = sCommand.indexOf( ' ' ); |
| if( 0 <= nSpaceIndex ) |
| sCommand = sCommand.copy( 0, nSpaceIndex ); |
| |
| FieldConversionMap_t::iterator aIt = aFieldConversionMap.find(sCommand); |
| if(aIt != aFieldConversionMap.end()) |
| { |
| uno::Reference< beans::XPropertySet > xFieldProperties; |
| if( FIELD_HYPERLINK != aIt->second.eFieldId && |
| FIELD_DOCPROPERTY != aIt->second.eFieldId && |
| FIELD_TOC != aIt->second.eFieldId && |
| FIELD_TC != aIt->second.eFieldId) |
| { |
| //add the service prefix |
| OUString sServiceName(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextField.")); |
| sServiceName += ::rtl::OUString::createFromAscii(aIt->second.cFieldServiceName ); |
| xFieldInterface = m_xTextFactory->createInstance(sServiceName); |
| xFieldProperties = uno::Reference< beans::XPropertySet >( xFieldInterface, uno::UNO_QUERY_THROW); |
| } |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| switch( aIt->second.eFieldId ) |
| { |
| case FIELD_ADDRESSBLOCK: break; |
| case FIELD_ADVANCE : break; |
| case FIELD_ASK : |
| { |
| //doesn the command contain a variable name? |
| ::rtl::OUString sVariable, sHint; |
| |
| sVariable = lcl_ExctractAskVariableAndHint( rCommand, sHint ); |
| if(sVariable.getLength()) |
| { |
| // determine field master name |
| uno::Reference< beans::XPropertySet > xMaster = FindOrCreateFieldMaster( |
| "com.sun.star.text.FieldMaster.SetExpression", sVariable ); |
| |
| // attach the master to the field |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| |
| // set input flag at the field |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_IS_INPUT), uno::makeAny( true )); |
| // set the prompt |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HINT), |
| uno::makeAny( sHint )); |
| } |
| else |
| { |
| //don't insert the field |
| //todo: maybe import a 'normal' input field here? |
| xFieldInterface = 0; |
| } |
| } |
| break; |
| case FIELD_AUTONUM : |
| case FIELD_AUTONUMLGL : |
| case FIELD_AUTONUMOUT : |
| { |
| //create a sequence field master "AutoNr" |
| uno::Reference< beans::XPropertySet > xMaster = FindOrCreateFieldMaster( |
| "com.sun.star.text.FieldMaster.SetExpression", |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AutoNr") )); |
| |
| xMaster->setPropertyValue( rPropNameSupplier.GetName(PROP_SUB_TYPE), |
| uno::makeAny(text::SetVariableType::SEQUENCE)); |
| |
| //apply the numbering type |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( lcl_ParseNumberingType(rCommand) )); |
| // attach the master to the field |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| } |
| break; |
| case FIELD_AUTHOR : |
| { |
| xFieldProperties->setPropertyValue( rPropNameSupplier.GetName(PROP_FULL_NAME), uno::makeAny( true )); |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" AUTHOR") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_DATE: |
| { |
| //not fixed, |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_IS_FIXED), |
| uno::makeAny( false )); |
| SetNumberFormat( rCommand, xFieldProperties ); |
| } |
| break; |
| case FIELD_COMMENTS : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" COMMENTS") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_CREATEDATE : |
| { |
| SetNumberFormat( rCommand, xFieldProperties ); |
| } |
| break; |
| case FIELD_DOCPROPERTY : |
| { |
| //some docproperties should be imported as document statistic fields, some as DocInfo fields |
| //others should be user fields |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" DOCPROPERTY") ); |
| if(sParam.getLength()) |
| { |
| #define SET_ARABIC 0x01 |
| #define SET_FULL_NAME 0x02 |
| struct DocPropertyMap |
| { |
| const sal_Char* pDocPropertyName; |
| const sal_Char* pServiceName; |
| sal_uInt8 nFlags; |
| }; |
| static const DocPropertyMap aDocProperties[] = |
| { |
| {"Author", "Author", SET_FULL_NAME}, |
| {"CreateTime", "DocInfo.CreateDateTime", 0}, |
| {"Characters", "CharacterCount", SET_ARABIC}, |
| {"Comments", "DocInfo.Description", 0}, |
| {"Keywords", "DocInfo.KeyWords", 0}, |
| {"LastPrinted", "DocInfo.PrintDateTime", 0}, |
| {"LastSavedBy", "DocInfo.ChangeAuthor", 0}, |
| {"LastSavedTime", "DocInfo.ChangeDateTime", 0}, |
| {"Paragraphs", "ParagraphCount", SET_ARABIC}, |
| {"RevisionNumber", "DocInfo.Revision", 0}, |
| {"Subject", "DocInfo.Subject", 0}, |
| {"Template", "TemplateName", 0}, |
| {"Title", "DocInfo.Title", 0}, |
| {"TotalEditingTime", "DocInfo.EditTime", 9}, |
| {"Words", "WordCount", SET_ARABIC} |
| |
| //other available DocProperties: |
| //Bytes, Category, CharactersWithSpaces, Company |
| //HyperlinkBase, |
| //Lines, Manager, NameofApplication, ODMADocId, Pages, |
| //Security, |
| }; |
| //search for a field mapping |
| ::rtl::OUString sFieldServiceName; |
| sal_uInt16 nMap = 0; |
| for( ; nMap < sizeof(aDocProperties) / sizeof(DocPropertyMap); ++nMap ) |
| { |
| if(sParam.equalsAscii(aDocProperties[nMap].pDocPropertyName)) |
| { |
| sFieldServiceName = ::rtl::OUString::createFromAscii(aDocProperties[nMap].pServiceName); |
| break; |
| } |
| } |
| ::rtl::OUString sServiceName(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextField.")); |
| if(sFieldServiceName.getLength()) |
| { |
| sServiceName += sFieldServiceName; |
| xFieldInterface = m_xTextFactory->createInstance(sServiceName); |
| xFieldProperties = uno::Reference< beans::XPropertySet >( xFieldInterface, uno::UNO_QUERY_THROW); |
| if(0 != (aDocProperties[nMap].nFlags & SET_ARABIC)) |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( style::NumberingType::ARABIC )); |
| else if(0 != (aDocProperties[nMap].nFlags & SET_FULL_NAME)) |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_FULL_NAME), uno::makeAny( true )); |
| |
| } |
| else |
| { |
| //create a user field and type |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster( "com.sun.star.text.FieldMaster.User", sParam ); |
| sServiceName += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("User")); |
| xFieldInterface = m_xTextFactory->createInstance(sServiceName); |
| xFieldProperties = uno::Reference< beans::XPropertySet >( xFieldInterface, uno::UNO_QUERY_THROW); |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| m_bSetUserFieldContent = true; |
| } |
| } |
| } |
| #undef SET_ARABIC |
| #undef SET_FULL_NAME |
| break; |
| case FIELD_DOCVARIABLE : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" DOCVARIABLE") ); |
| //create a user field and type |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster( "com.sun.star.text.FieldMaster.User", sParam ); |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| m_bSetUserFieldContent = true; |
| } |
| break; |
| case FIELD_EDITTIME : |
| //it's a numbering type, no number format! SetNumberFormat( rCommand, xFieldProperties ); |
| break; |
| case FIELD_FILLIN : |
| { |
| sal_Int32 nIndex = 0; |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HINT), uno::makeAny( rCommand.getToken( 1, '\"', nIndex))); |
| } |
| break; |
| case FIELD_FILENAME: |
| { |
| sal_Int32 nNumberingTypeIndex = rCommand.indexOf( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\\p"))); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_FILE_FORMAT), |
| uno::makeAny( nNumberingTypeIndex > 0 ? text::FilenameDisplayFormat::FULL : text::FilenameDisplayFormat::NAME )); |
| } |
| break; |
| case FIELD_FILESIZE : break; |
| case FIELD_FORMULA : break; |
| case FIELD_GOTOBUTTON : break; |
| case FIELD_HYPERLINK: |
| { |
| sal_Int32 nStartQuote = rCommand.indexOf( '\"' ); |
| sal_Int32 nEndQuote = nStartQuote < rCommand.getLength() + 1 ? rCommand.indexOf( '\"', nStartQuote + 1) : -1; |
| if( nEndQuote > 0) |
| m_sHyperlinkURL = rCommand.copy(nStartQuote + 1, nEndQuote - nStartQuote - 1); |
| } |
| break; |
| case FIELD_IF : break; |
| case FIELD_INFO : break; |
| case FIELD_INCLUDEPICTURE: break; |
| case FIELD_KEYWORDS : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" KEYWORDS") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_LASTSAVEDBY : break; |
| case FIELD_MACROBUTTON: |
| { |
| //extract macro name |
| sal_Int32 nIndex = sizeof(" MACROBUTTON "); |
| ::rtl::OUString sMacro = rCommand.getToken( 0, ' ', nIndex); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_MACRO_NAME), uno::makeAny( sMacro )); |
| |
| //extract quick help text |
| if( rCommand.getLength() > nIndex + 1) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HINT), |
| uno::makeAny( rCommand.copy( nIndex ))); |
| } |
| } |
| break; |
| case FIELD_MERGEFIELD : |
| { |
| //todo: create a database field and fieldmaster pointing to a column, only |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" MERGEFIELD") ); |
| //create a user field and type |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster( "com.sun.star.text.FieldMaster.Database", sParam ); |
| |
| // xFieldProperties->setPropertyValue( |
| // ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FieldCode")), |
| // uno::makeAny( rCommand.copy( nIndex + 1 ))); |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| m_bSetUserFieldContent = true; |
| } |
| break; |
| case FIELD_MERGEREC : break; |
| case FIELD_MERGESEQ : break; |
| case FIELD_NEXT : break; |
| case FIELD_NEXTIF : break; |
| case FIELD_PAGE : |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( lcl_ParseNumberingType(rCommand) )); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_SUB_TYPE), |
| uno::makeAny( text::PageNumberType_CURRENT )); |
| |
| break; |
| case FIELD_REF : break; |
| case FIELD_REVNUM : break; |
| case FIELD_SAVEDATE : |
| SetNumberFormat( rCommand, xFieldProperties ); |
| break; |
| case FIELD_SECTION : break; |
| case FIELD_SECTIONPAGES : break; |
| case FIELD_SEQ : break; |
| case FIELD_SET : break; |
| case FIELD_SKIPIF : break; |
| case FIELD_STYLEREF : break; |
| case FIELD_SUBJECT : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" SUBJECT") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_SYMBOL : break; |
| case FIELD_TEMPLATE: break; |
| case FIELD_TIME : |
| SetNumberFormat( rCommand, xFieldProperties ); |
| break; |
| case FIELD_TITLE : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" TITLE") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_USERINITIALS: |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_USER_DATA_TYPE), uno::makeAny( text::UserDataPart::SHORTCUT )); |
| //todo: if initials are provided - set them as fixed content |
| ::rtl::OUString sParam = lcl_ExtractParameter(rCommand, sizeof(" USERINITIALS") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_USERADDRESS : //todo: user address collects street, city ... |
| break; |
| case FIELD_USERNAME : //todo: user name is firstname + lastname |
| break; |
| case FIELD_TOC: |
| { |
| ::rtl::OUString sValue; |
| bool bTableOfFigures = false; |
| bool bHyperlinks = false; |
| bool bFromOutline = false; |
| bool bFromEntries = false; |
| ::rtl::OUString sTemplate; |
| ::rtl::OUString sChapterNoSeparator; |
| // \a Builds a table of figures but does not include the captions's label and number |
| if( lcl_FindInCommand( rCommand, 'a', sValue )) |
| { //make it a table of figures |
| bTableOfFigures = true; |
| } |
| // \b Uses a bookmark to specify area of document from which to build table of contents |
| // if( lcl_FindInCommand( rCommand, 'b', sValue )) |
| // { //todo: sValue contains the bookmark name - unsupported feature |
| // } |
| if( lcl_FindInCommand( rCommand, 'c', sValue )) |
| // \c Builds a table of figures of the given label |
| { |
| //todo: sValue contains the label's name |
| bTableOfFigures = true; |
| } |
| // \d Defines the separator between sequence and page numbers |
| if( lcl_FindInCommand( rCommand, 'd', sValue )) |
| { |
| //todo: insert the chapter number into each level and insert the separator additionally |
| sChapterNoSeparator = sValue; |
| } |
| // \f Builds a table of contents using TC entries instead of outline levels |
| if( lcl_FindInCommand( rCommand, 'f', sValue )) |
| { |
| //todo: sValue can contain a TOC entry identifier - use unclear |
| bFromEntries = true; |
| } |
| // \h Hyperlinks the entries and page numbers within the table of contents |
| if( lcl_FindInCommand( rCommand, 'h', sValue )) |
| { |
| //todo: make all entries to hyperlinks |
| bHyperlinks = true; |
| } |
| // \l Defines the TC entries field level used to build a table of contents |
| // if( lcl_FindInCommand( rCommand, 'l', sValue )) |
| // { |
| //todo: entries can only be included completely |
| // } |
| // \n Builds a table of contents or a range of entries, sucah as ?-9? in a table of contents without page numbers |
| // if( lcl_FindInCommand( rCommand, 'n', sValue )) |
| // { |
| //todo: what does the description mean? |
| // } |
| // \o Builds a table of contents by using outline levels instead of TC entries |
| if( lcl_FindInCommand( rCommand, 'o', sValue )) |
| { |
| bFromOutline = true; |
| } |
| // \p Defines the separator between the table entry and its page number |
| if( lcl_FindInCommand( rCommand, 'p', sValue )) |
| { } |
| // \s Builds a table of contents by using a sequence type |
| if( lcl_FindInCommand( rCommand, 's', sValue )) |
| { } |
| // \t Builds a table of contents by using style names other than the standard outline styles |
| if( lcl_FindInCommand( rCommand, 't', sValue )) |
| { |
| sTemplate = sValue; |
| } |
| // \u Builds a table of contents by using the applied paragraph outline level |
| if( lcl_FindInCommand( rCommand, 'u', sValue )) |
| { |
| bFromOutline = true; |
| //todo: what doesn 'the applied paragraph outline level' refer to? |
| } |
| // \w Preserve tab characters within table entries |
| // if( lcl_FindInCommand( rCommand, 'w', sValue )) |
| // { |
| //todo: not supported |
| // } |
| // \x Preserve newline characters within table entries |
| // if( lcl_FindInCommand( rCommand, 'x', sValue )) |
| // { |
| //todo: unsupported |
| // } |
| // \z Hides page numbers within the table of contens when shown in Web Layout View |
| // if( lcl_FindInCommand( rCommand, 'z', sValue )) |
| // { //todo: unsupported feature } |
| |
| m_xTOC = uno::Reference< beans::XPropertySet >( |
| m_xTextFactory->createInstance( |
| bTableOfFigures ? |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.IllustrationsIndex")) : |
| ::rtl::OUString::createFromAscii(aIt->second.cFieldServiceName)), |
| uno::UNO_QUERY_THROW); |
| if( !bTableOfFigures ) |
| { |
| m_xTOC->setPropertyValue( rPropNameSupplier.GetName( PROP_CREATE_FROM_OUTLINE ), uno::makeAny( bFromOutline )); |
| m_xTOC->setPropertyValue( rPropNameSupplier.GetName( PROP_CREATE_FROM_MARKS ), uno::makeAny( bFromEntries )); |
| if( sTemplate.getLength() ) |
| { |
| uno::Reference< container::XIndexReplace> xParaStyles; |
| m_xTOC->getPropertyValue(rPropNameSupplier.GetName(PROP_LEVEL_PARAGRAPH_STYLES)) >>= xParaStyles; |
| uno::Sequence< rtl::OUString> aStyles(1); |
| aStyles[0] = sTemplate; |
| xParaStyles->replaceByIndex(0, uno::makeAny(aStyles)); |
| } |
| if(bHyperlinks || sChapterNoSeparator.getLength()) |
| { |
| uno::Reference< container::XIndexReplace> xLevelFormats; |
| m_xTOC->getPropertyValue(rPropNameSupplier.GetName(PROP_LEVEL_FORMAT)) >>= xLevelFormats; |
| sal_Int32 nLevelCount = xLevelFormats->getCount(); |
| //start with level 1, 0 is the header level |
| for( sal_Int32 nLevel = 1; nLevel < nLevelCount; ++nLevel) |
| { |
| uno::Sequence< beans::PropertyValues > aLevel; |
| xLevelFormats->getByIndex( nLevel ) >>= aLevel; |
| //create a copy of the level and add two new entries - hyperlink start and end |
| bool bChapterNoSeparator = sChapterNoSeparator.getLength() > 0; |
| sal_Int32 nAdd = (bHyperlinks && bChapterNoSeparator) ? 4 : 2; |
| uno::Sequence< beans::PropertyValues > aNewLevel( aLevel.getLength() + nAdd); |
| beans::PropertyValues* pNewLevel = aNewLevel.getArray(); |
| if( bHyperlinks ) |
| { |
| beans::PropertyValues aHyperlink(1); |
| aHyperlink[0].Name = rPropNameSupplier.GetName( PROP_TOKEN_TYPE ); |
| aHyperlink[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_HYPERLINK_START ); |
| pNewLevel[0] = aHyperlink; |
| aHyperlink[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_HYPERLINK_END ); |
| pNewLevel[aNewLevel.getLength() -1] = aHyperlink; |
| } |
| if( bChapterNoSeparator ) |
| { |
| beans::PropertyValues aChapterNo(2); |
| aChapterNo[0].Name = rPropNameSupplier.GetName( PROP_TOKEN_TYPE ); |
| aChapterNo[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_CHAPTER_INFO ); |
| aChapterNo[1].Name = rPropNameSupplier.GetName( PROP_CHAPTER_FORMAT ); |
| //todo: is ChapterFormat::Number correct? |
| aChapterNo[1].Value <<= (sal_Int16)text::ChapterFormat::NUMBER; |
| pNewLevel[aNewLevel.getLength() - (bHyperlinks ? 4 : 2) ] = aChapterNo; |
| |
| beans::PropertyValues aChapterSeparator(2); |
| aChapterSeparator[0].Name = rPropNameSupplier.GetName( PROP_TOKEN_TYPE ); |
| aChapterSeparator[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_TEXT ); |
| aChapterSeparator[1].Name = rPropNameSupplier.GetName( PROP_TEXT ); |
| aChapterSeparator[1].Value <<= sChapterNoSeparator; |
| pNewLevel[aNewLevel.getLength() - (bHyperlinks ? 3 : 1)] = aChapterSeparator; |
| } |
| //copy the 'old' entries except the last (page no) |
| for( sal_Int32 nToken = 0; nToken < aLevel.getLength() - 1; ++nToken) |
| { |
| pNewLevel[nToken + 1] = aLevel[nToken]; |
| } |
| //copy page no entry (last or last but one depending on bHyperlinks |
| sal_Int32 nPageNo = aNewLevel.getLength() - (bHyperlinks ? 2 : 3); |
| pNewLevel[nPageNo] = aLevel[aLevel.getLength() - 1]; |
| |
| xLevelFormats->replaceByIndex( nLevel, uno::makeAny( aNewLevel ) ); |
| } |
| } |
| } |
| } |
| break; |
| case FIELD_TC : |
| { |
| m_xTC = uno::Reference< beans::XPropertySet >( |
| m_xTextFactory->createInstance( |
| ::rtl::OUString::createFromAscii(aIt->second.cFieldServiceName)), |
| uno::UNO_QUERY_THROW); |
| ::rtl::OUString sTCText = lcl_ExtractParameter(rCommand, sizeof(" TC") ); |
| if( sTCText.getLength()) |
| m_xTC->setPropertyValue(rPropNameSupplier.GetName(PROP_ALTERNATIVE_TEXT), |
| uno::makeAny(sTCText)); |
| ::rtl::OUString sValue; |
| // \f TC entry in doc with multiple tables |
| // if( lcl_FindInCommand( rCommand, 'f', sValue )) |
| // { |
| // todo: unsupported |
| // } |
| if( lcl_FindInCommand( rCommand, 'l', sValue )) |
| // \l Outline Level |
| { |
| sal_Int32 nLevel = sValue.toInt32(); |
| if( sValue.getLength() && nLevel >= 0 && nLevel <= 10 ) |
| m_xTC->setPropertyValue(rPropNameSupplier.GetName(PROP_LEVEL), uno::makeAny( nLevel )); |
| } |
| // if( lcl_FindInCommand( rCommand, 'n', sValue )) |
| // \n Suppress page numbers |
| // { |
| //todo: unsupported feature |
| // } |
| } |
| break; |
| } |
| } |
| m_xTextField = uno::Reference< text::XTextField >( xFieldInterface, uno::UNO_QUERY ); |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| } |
| */ |
| |
| /*-- 11.09.2006 13:16:35--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| /*bool DomainMapper_Impl::IsFieldAvailable() const |
| { |
| return m_xTextField.is() || m_xTOC.is() || m_xTC.is() || m_sHyperlinkURL.getLength(); |
| } |
| */ |
| /*-- 14.09.2006 12:46:52--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::GetCurrentLocale(lang::Locale& rLocale) |
| { |
| PropertyMapPtr pTopContext = GetTopContext(); |
| PropertyDefinition aCharLocale( PROP_CHAR_LOCALE, true ); |
| PropertyMap::iterator aLocaleIter = pTopContext->find( aCharLocale ); |
| if( aLocaleIter != pTopContext->end()) |
| aLocaleIter->second >>= rLocale; |
| else |
| { |
| PropertyMapPtr pParaContext = GetTopContextOfType(CONTEXT_PARAGRAPH); |
| aLocaleIter = pParaContext->find(aCharLocale); |
| if( aLocaleIter != pParaContext->end()) |
| { |
| aLocaleIter->second >>= rLocale; |
| } |
| } |
| } |
| |
| /*-- 14.09.2006 12:52:58--------------------------------------------------- |
| extract the number format from the command and apply the resulting number |
| format to the XPropertySet |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::SetNumberFormat( const ::rtl::OUString& rCommand, |
| uno::Reference< beans::XPropertySet >& xPropertySet ) |
| { |
| OUString sFormatString = lcl_ParseFormat( rCommand ); |
| // find \h - hijri/luna calendar todo: what about saka/era calendar? |
| bool bHijri = 0 < rCommand.indexOf( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\\h "))); |
| lang::Locale aUSLocale; |
| aUSLocale.Language = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("en")); |
| aUSLocale.Country = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("US")); |
| |
| //determine current locale - todo: is it necessary to initialize this locale? |
| lang::Locale aCurrentLocale = aUSLocale; |
| GetCurrentLocale( aCurrentLocale ); |
| ::rtl::OUString sFormat = ConversionHelper::ConvertMSFormatStringToSO( sFormatString, aCurrentLocale, bHijri); |
| |
| //get the number formatter and convert the string to a format value |
| try |
| { |
| uno::Reference< util::XNumberFormatsSupplier > xNumberSupplier( m_xTextDocument, uno::UNO_QUERY_THROW ); |
| long nKey = xNumberSupplier->getNumberFormats()->addNewConverted( sFormat, aUSLocale, aCurrentLocale ); |
| xPropertySet->setPropertyValue( |
| PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_NUMBER_FORMAT), |
| uno::makeAny( nKey )); |
| } |
| catch(const uno::Exception&) |
| { |
| } |
| } |
| |
| /*-- 15.09.2006 15:10:20--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< beans::XPropertySet > DomainMapper_Impl::FindOrCreateFieldMaster( |
| const sal_Char* pFieldMasterService, const ::rtl::OUString& rFieldMasterName ) |
| throw(::com::sun::star::uno::Exception) |
| { |
| // query master, create if not available |
| uno::Reference< text::XTextFieldsSupplier > xFieldsSupplier( GetTextDocument(), uno::UNO_QUERY ); |
| uno::Reference< container::XNameAccess > xFieldMasterAccess = xFieldsSupplier->getTextFieldMasters(); |
| uno::Reference< beans::XPropertySet > xMaster; |
| ::rtl::OUString sFieldMasterService( ::rtl::OUString::createFromAscii(pFieldMasterService) ); |
| ::rtl::OUStringBuffer aFieldMasterName; |
| aFieldMasterName.appendAscii( pFieldMasterService ); |
| aFieldMasterName.append(sal_Unicode('.')); |
| aFieldMasterName.append(rFieldMasterName); |
| ::rtl::OUString sFieldMasterName = aFieldMasterName.makeStringAndClear(); |
| if(xFieldMasterAccess->hasByName(sFieldMasterName)) |
| { |
| //get the master |
| xMaster = uno::Reference< beans::XPropertySet >(xFieldMasterAccess->getByName(sFieldMasterName), |
| uno::UNO_QUERY_THROW); |
| } |
| else |
| { |
| //create the master |
| xMaster = uno::Reference< beans::XPropertySet >( |
| m_xTextFactory->createInstance(sFieldMasterService), uno::UNO_QUERY_THROW); |
| //set the master's name |
| // sal_Int32 nIndex = rtl_str_indexOfStr( pFieldMasterService, "Database" ); |
| // if( nIndex < 0 ) |
| xMaster->setPropertyValue( |
| PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_NAME), |
| uno::makeAny(rFieldMasterName)); |
| // else |
| // { |
| // xMaster->setPropertyValue( |
| // PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_DATA_COLUMN_NAME), |
| // uno::makeAny(rFieldMasterName)); |
| // } |
| } |
| return xMaster; |
| } |
| |
| /*-- 29.01.2007 11:33:10--------------------------------------------------- |
| //field context starts with a 0x13 |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PushFieldContext() |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->element("pushFieldContext"); |
| #endif |
| |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| //insert a dummy char to make sure the start range doesn't move together with the to-be-appended text |
| xTextAppend->appendTextPortion(::rtl::OUString( '-' ), uno::Sequence< beans::PropertyValue >() ); |
| uno::Reference< text::XTextCursor > xCrsr = xTextAppend->createTextCursorByRange( xTextAppend->getEnd() ); |
| xCrsr->goLeft( 1, false ); |
| m_aFieldStack.push( FieldContextPtr( new FieldContext( xCrsr->getStart() ) ) ); |
| } |
| /*-- 29.01.2007 11:33:13--------------------------------------------------- |
| //the current field context waits for the completion of the command |
| -----------------------------------------------------------------------*/ |
| bool DomainMapper_Impl::IsOpenFieldCommand() const |
| { |
| return !m_aFieldStack.empty() && !m_aFieldStack.top()->IsCommandCompleted(); |
| } |
| /*-- 29.01.2007 11:33:13--------------------------------------------------- |
| //the current field context waits for the completion of the command |
| -----------------------------------------------------------------------*/ |
| bool DomainMapper_Impl::IsOpenField() const |
| { |
| return !m_aFieldStack.empty(); |
| } |
| /*-- 29.01.2007 11:49:13--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| FieldContext::FieldContext(uno::Reference< text::XTextRange > xStart) : |
| m_bFieldCommandCompleted( false ) |
| ,m_xStartRange( xStart ) |
| { |
| } |
| /*-- 29.01.2007 11:48:44--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| FieldContext::~FieldContext() |
| { |
| } |
| /*-- 29.01.2007 11:48:45--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void FieldContext::AppendCommand(const ::rtl::OUString& rPart) |
| { |
| m_sCommand += rPart; |
| } |
| |
| ::std::vector<rtl::OUString> FieldContext::GetCommandParts() const |
| { |
| ::std::vector<rtl::OUString> aResult; |
| sal_Int32 nIndex = 0; |
| bool bInString = false; |
| OUString sPart; |
| while (nIndex != -1) |
| { |
| OUString sToken = GetCommand().getToken(0, ' ', nIndex); |
| bool bInStringNext = bInString; |
| |
| if (sToken.getLength() == 0) |
| continue; |
| |
| if (sToken.getStr()[0] == '"') |
| { |
| bInStringNext = true; |
| sToken = sToken.copy(1); |
| } |
| if (sToken.getStr()[sToken.getLength() - 1] == '"') |
| { |
| bInStringNext = false; |
| sToken = sToken.copy(0, sToken.getLength() - 1); |
| } |
| |
| if (bInString) |
| { |
| if (bInStringNext) |
| { |
| sPart += OUString(' '); |
| sPart += sToken; |
| } |
| else |
| { |
| sPart += sToken; |
| aResult.push_back(sPart); |
| } |
| } |
| else |
| { |
| if (bInStringNext) |
| { |
| sPart = sToken; |
| } |
| else |
| { |
| aResult.push_back(sToken); |
| } |
| } |
| |
| bInString = bInStringNext; |
| } |
| |
| return aResult; |
| } |
| |
| /*-- 29.01.2007 11:33:15--------------------------------------------------- |
| //collect the pieces of the command |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::AppendFieldCommand(::rtl::OUString& rPartOfCommand) |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->startElement("appendFieldCommand"); |
| dmapper_logger->chars(rPartOfCommand); |
| dmapper_logger->endElement("appendFieldCommand"); |
| #endif |
| |
| FieldContextPtr pContext = m_aFieldStack.top(); |
| OSL_ENSURE( pContext.get(), "no field context available"); |
| if( pContext.get() ) |
| { |
| pContext->AppendCommand( rPartOfCommand ); |
| } |
| } |
| /*-- 13.12.2007 11:45:43--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| typedef std::multimap < sal_Int32, ::rtl::OUString > TOCStyleMap; |
| |
| const FieldConversionMap_t & lcl_GetFieldConversion() |
| { |
| static FieldConversionMap_t aFieldConversionMap; |
| static bool bFilled = false; |
| if(!bFilled) |
| { |
| static const FieldConversion aFields[] = |
| { |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ADDRESSBLOCK")), "", "", FIELD_ADDRESSBLOCK }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ADVANCE")), "", "", FIELD_ADVANCE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ASK")), "SetExpression", "SetExpression", FIELD_ASK }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTONUM")), "SetExpression", "SetExpression", FIELD_AUTONUM }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTONUMLGL")), "SetExpression", "SetExpression", FIELD_AUTONUMLGL }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTONUMOUT")), "SetExpression", "SetExpression", FIELD_AUTONUMOUT }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AUTHOR")), "Author", "", FIELD_AUTHOR }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATE")), "DateTime", "", FIELD_DATE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("COMMENTS")), "DocInfo.Description", "", FIELD_COMMENTS }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CREATEDATE")), "DocInfo.CreateDateTime", "", FIELD_CREATEDATE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOCPROPERTY")), "", "", FIELD_DOCPROPERTY }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOCVARIABLE")), "User", "", FIELD_DOCVARIABLE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EDITTIME")), "DocInfo.EditTime", "", FIELD_EDITTIME }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FILLIN")), "Input", "", FIELD_FILLIN }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FILENAME")), "FileName", "", FIELD_FILENAME }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FILESIZE")), "", "", FIELD_FILESIZE }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FORMULA")), "", "", FIELD_FORMULA }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FORMCHECKBOX")), "", "", FIELD_FORMCHECKBOX}, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FORMDROPDOWN")), "", "", FIELD_FORMDROWDOWN}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FORMTEXT")), "Input", "", FIELD_FORMTEXT}, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GOTOBUTTON")), "", "", FIELD_GOTOBUTTON }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HYPERLINK")), "", "", FIELD_HYPERLINK }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IF")), "ConditionalText", "", FIELD_IF }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INFO")), "","", FIELD_INFO }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INCLUDEPICTURE")), "", "", FIELD_INCLUDEPICTURE}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("KEYWORDS")), "DocInfo.KeyWords", "", FIELD_KEYWORDS }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LASTSAVEDBY")), "DocInfo.ChangeAuthor", "", FIELD_LASTSAVEDBY }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MACROBUTTON")), "Macro", "", FIELD_MACROBUTTON }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MERGEFIELD")), "Database", "Database", FIELD_MERGEFIELD}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MERGEREC")), "DatabaseNumberOfSet", "", FIELD_MERGEREC }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MERGESEQ")), "", "", FIELD_MERGESEQ }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NEXT")), "DatabaseNextSet", "", FIELD_NEXT }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NEXTIF")), "DatabaseNextSet", "", FIELD_NEXTIF }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PAGE")), "PageNumber", "", FIELD_PAGE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("REF")), "GetReference", "", FIELD_REF }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("REVNUM")), "DocInfo.Revision", "", FIELD_REVNUM }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SAVEDATE")), "DocInfo.Change", "", FIELD_SAVEDATE }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SECTION")), "", "", FIELD_SECTION }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SECTIONPAGES")), "", "", FIELD_SECTIONPAGES }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SEQ")), "SetExpression", "SetExpression", FIELD_SEQ }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SET")), "","", FIELD_SET }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SKIPIF")),"", "", FIELD_SKIPIF }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("STYLEREF")),"", "", FIELD_STYLEREF }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SUBJECT")), "DocInfo.Subject", "", FIELD_SUBJECT }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SYMBOL")),"", "", FIELD_SYMBOL }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TEMPLATE")), "TemplateName", "", FIELD_TEMPLATE}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TIME")), "DateTime", "", FIELD_TIME }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TITLE")), "DocInfo.Title", "", FIELD_TITLE }, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("USERINITIALS")), "ExtendedUser", "", FIELD_USERINITIALS}, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("USERADDRESS")), "", "", FIELD_USERADDRESS }, |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("USERNAME")), "ExtendedUser", "", FIELD_USERNAME } |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TOC")), "com.sun.star.text.ContentIndex", "", FIELD_TOC}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TC")), "com.sun.star.text.ContentIndexMark", "", FIELD_TC}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NUMCHARS")), "CharacterCount", "", FIELD_NUMCHARS}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NUMWORDS")), "WordCount", "", FIELD_NUMWORDS}, |
| {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NUMPAGES")), "PageCount", "", FIELD_NUMPAGES}, |
| |
| // {::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("")), "", "", FIELD_}, |
| |
| }; |
| size_t nConversions = sizeof(aFields)/sizeof(FieldConversion); |
| for( size_t nConversion = 0; nConversion < nConversions; ++nConversion) |
| { |
| aFieldConversionMap.insert( FieldConversionMap_t::value_type( |
| aFields[nConversion].sWordCommand, |
| aFields[nConversion] )); |
| } |
| |
| bFilled = true; |
| } |
| |
| return aFieldConversionMap; |
| } |
| |
| void DomainMapper_Impl::handleFieldAsk |
| (FieldContextPtr pContext, |
| PropertyNameSupplier& rPropNameSupplier, |
| uno::Reference< uno::XInterface > & xFieldInterface, |
| uno::Reference< beans::XPropertySet > xFieldProperties) |
| { |
| //doesn the command contain a variable name? |
| ::rtl::OUString sVariable, sHint; |
| |
| sVariable = lcl_ExctractAskVariableAndHint( pContext->GetCommand(), |
| sHint ); |
| if(sVariable.getLength()) |
| { |
| // determine field master name |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster |
| ("com.sun.star.text.FieldMaster.SetExpression", sVariable ); |
| |
| // attach the master to the field |
| uno::Reference< text::XDependentTextField > xDependentField |
| ( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| |
| // set input flag at the field |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_IS_INPUT), uno::makeAny( true )); |
| // set the prompt |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HINT), |
| uno::makeAny( sHint )); |
| } |
| else |
| { |
| //don't insert the field |
| //todo: maybe import a 'normal' input field here? |
| xFieldInterface = 0; |
| } |
| } |
| |
| void DomainMapper_Impl::handleAutoNum |
| (FieldContextPtr pContext, |
| PropertyNameSupplier& rPropNameSupplier, |
| uno::Reference< uno::XInterface > & xFieldInterface, |
| uno::Reference< beans::XPropertySet > xFieldProperties) |
| { |
| //create a sequence field master "AutoNr" |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster |
| ("com.sun.star.text.FieldMaster.SetExpression", |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AutoNr") )); |
| |
| xMaster->setPropertyValue( rPropNameSupplier.GetName(PROP_SUB_TYPE), |
| uno::makeAny(text::SetVariableType::SEQUENCE)); |
| |
| //apply the numbering type |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( lcl_ParseNumberingType(pContext->GetCommand()) )); |
| // attach the master to the field |
| uno::Reference< text::XDependentTextField > xDependentField |
| ( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| } |
| |
| void DomainMapper_Impl::handleAuthor |
| (FieldContextPtr pContext, |
| PropertyNameSupplier& rPropNameSupplier, |
| uno::Reference< uno::XInterface > & /*xFieldInterface*/, |
| uno::Reference< beans::XPropertySet > xFieldProperties) |
| { |
| xFieldProperties->setPropertyValue |
| ( rPropNameSupplier.GetName(PROP_FULL_NAME), uno::makeAny( true )); |
| ::rtl::OUString sParam = |
| lcl_ExtractParameter(pContext->GetCommand(), sizeof(" AUTHOR") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), |
| uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| |
| void DomainMapper_Impl::handleDocProperty |
| (FieldContextPtr pContext, |
| PropertyNameSupplier& rPropNameSupplier, |
| uno::Reference< uno::XInterface > & xFieldInterface, |
| uno::Reference< beans::XPropertySet > xFieldProperties) |
| { |
| //some docproperties should be imported as document statistic fields, some as DocInfo fields |
| //others should be user fields |
| ::rtl::OUString sParam = |
| lcl_ExtractParameter(pContext->GetCommand(), sizeof(" DOCPROPERTY") ); |
| |
| if(sParam.getLength()) |
| { |
| #define SET_ARABIC 0x01 |
| #define SET_FULL_NAME 0x02 |
| struct DocPropertyMap |
| { |
| const sal_Char* pDocPropertyName; |
| const sal_Char* pServiceName; |
| sal_uInt8 nFlags; |
| }; |
| static const DocPropertyMap aDocProperties[] = |
| { |
| {"Author", "Author", SET_FULL_NAME}, |
| {"CreateTime", "DocInfo.CreateDateTime", 0}, |
| {"Characters", "CharacterCount", SET_ARABIC}, |
| {"Comments", "DocInfo.Description", 0}, |
| {"Keywords", "DocInfo.KeyWords", 0}, |
| {"LastPrinted", "DocInfo.PrintDateTime", 0}, |
| {"LastSavedBy", "DocInfo.ChangeAuthor", 0}, |
| {"LastSavedTime", "DocInfo.ChangeDateTime", 0}, |
| {"Paragraphs", "ParagraphCount", SET_ARABIC}, |
| {"RevisionNumber", "DocInfo.Revision", 0}, |
| {"Subject", "DocInfo.Subject", 0}, |
| {"Template", "TemplateName", 0}, |
| {"Title", "DocInfo.Title", 0}, |
| {"TotalEditingTime", "DocInfo.EditTime", 9}, |
| {"Words", "WordCount", SET_ARABIC} |
| |
| //other available DocProperties: |
| //Bytes, Category, CharactersWithSpaces, Company |
| //HyperlinkBase, |
| //Lines, Manager, NameofApplication, ODMADocId, Pages, |
| //Security, |
| }; |
| //search for a field mapping |
| ::rtl::OUString sFieldServiceName; |
| sal_uInt16 nMap = 0; |
| for( ; nMap < sizeof(aDocProperties) / sizeof(DocPropertyMap); |
| ++nMap ) |
| { |
| if(sParam.equalsAscii(aDocProperties[nMap].pDocPropertyName)) |
| { |
| sFieldServiceName = |
| ::rtl::OUString::createFromAscii |
| (aDocProperties[nMap].pServiceName); |
| break; |
| } |
| } |
| ::rtl::OUString sServiceName(RTL_CONSTASCII_USTRINGPARAM |
| ("com.sun.star.text.TextField.")); |
| bool bIsCustomField = false; |
| if(!sFieldServiceName.getLength()) |
| { |
| //create a custom property field |
| sServiceName += |
| ::rtl::OUString::createFromAscii("DocInfo.Custom"); |
| bIsCustomField = true; |
| } |
| else |
| { |
| sServiceName += sFieldServiceName; |
| } |
| xFieldInterface = m_xTextFactory->createInstance(sServiceName); |
| xFieldProperties = |
| uno::Reference< beans::XPropertySet >( xFieldInterface, |
| uno::UNO_QUERY_THROW); |
| if( bIsCustomField ) |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NAME), uno::makeAny( sParam )); |
| else |
| { |
| if(0 != (aDocProperties[nMap].nFlags & SET_ARABIC)) |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( style::NumberingType::ARABIC )); |
| else if(0 != (aDocProperties[nMap].nFlags & SET_FULL_NAME)) |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_FULL_NAME), |
| uno::makeAny( true )); |
| } |
| } |
| |
| #undef SET_ARABIC |
| #undef SET_FULL_NAME |
| } |
| |
| void DomainMapper_Impl::handleToc |
| (FieldContextPtr pContext, |
| PropertyNameSupplier& rPropNameSupplier, |
| uno::Reference< uno::XInterface > & /*xFieldInterface*/, |
| uno::Reference< beans::XPropertySet > /*xFieldProperties*/, |
| const ::rtl::OUString & sTOCServiceName) |
| { |
| ::rtl::OUString sValue; |
| bool bTableOfFigures = false; |
| bool bHyperlinks = false; |
| bool bFromOutline = false; |
| bool bFromEntries = false; |
| sal_Int16 nMaxLevel = 10; |
| ::rtl::OUString sTemplate; |
| ::rtl::OUString sChapterNoSeparator; |
| // \a Builds a table of figures but does not include the captions's label and number |
| if( lcl_FindInCommand( pContext->GetCommand(), 'a', sValue )) |
| { //make it a table of figures |
| bTableOfFigures = true; |
| } |
| // \b Uses a bookmark to specify area of document from which to build table of contents |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'b', sValue )) |
| // { //todo: sValue contains the bookmark name - unsupported feature |
| // } |
| if( lcl_FindInCommand( pContext->GetCommand(), 'c', sValue )) |
| // \c Builds a table of figures of the given label |
| { |
| //todo: sValue contains the label's name |
| bTableOfFigures = true; |
| } |
| // \d Defines the separator between sequence and page numbers |
| if( lcl_FindInCommand( pContext->GetCommand(), 'd', sValue )) |
| { |
| //todo: insert the chapter number into each level and insert the separator additionally |
| sChapterNoSeparator = sValue; |
| } |
| // \f Builds a table of contents using TC entries instead of outline levels |
| if( lcl_FindInCommand( pContext->GetCommand(), 'f', sValue )) |
| { |
| //todo: sValue can contain a TOC entry identifier - use unclear |
| bFromEntries = true; |
| } |
| // \h Hyperlinks the entries and page numbers within the table of contents |
| if( lcl_FindInCommand( pContext->GetCommand(), 'h', sValue )) |
| { |
| //todo: make all entries to hyperlinks |
| bHyperlinks = true; |
| } |
| // \l Defines the TC entries field level used to build a table of contents |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'l', sValue )) |
| // { |
| //todo: entries can only be included completely |
| // } |
| // \n Builds a table of contents or a range of entries, sucah as ?-9? in a table of contents without page numbers |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'n', sValue )) |
| // { |
| //todo: what does the description mean? |
| // } |
| // \o Builds a table of contents by using outline levels instead of TC entries |
| if( lcl_FindInCommand( pContext->GetCommand(), 'o', sValue )) |
| { |
| bFromOutline = true; |
| UniString sParam( sValue ); |
| if (!sParam.Len()) |
| nMaxLevel = WW_OUTLINE_MAX; |
| else |
| { |
| xub_StrLen nIndex = 0; |
| sParam.GetToken( 0, '-', nIndex ); |
| nMaxLevel = sal_Int16( sParam.Copy( nIndex ).ToInt32( ) ); |
| } |
| } |
| // \p Defines the separator between the table entry and its page number |
| if( lcl_FindInCommand( pContext->GetCommand(), 'p', sValue )) |
| { } |
| // \s Builds a table of contents by using a sequence type |
| if( lcl_FindInCommand( pContext->GetCommand(), 's', sValue )) |
| { } |
| // \t Builds a table of contents by using style names other than the standard outline styles |
| if( lcl_FindInCommand( pContext->GetCommand(), 't', sValue )) |
| { |
| sal_Int32 nPos = 0; |
| ::rtl::OUString sToken = sValue.getToken( 1, '"', nPos); |
| sTemplate = sToken.getLength() ? sToken : sValue; |
| } |
| // \u Builds a table of contents by using the applied paragraph outline level |
| if( lcl_FindInCommand( pContext->GetCommand(), 'u', sValue )) |
| { |
| bFromOutline = true; |
| //todo: what doesn 'the applied paragraph outline level' refer to? |
| } |
| // \w Preserve tab characters within table entries |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'w', sValue )) |
| // { |
| //todo: not supported |
| // } |
| // \x Preserve newline characters within table entries |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'x', sValue )) |
| // { |
| //todo: unsupported |
| // } |
| // \z Hides page numbers within the table of contens when shown in Web Layout View |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'z', sValue )) |
| // { //todo: unsupported feature } |
| |
| //if there's no option then it should be created from outline |
| if( !bFromOutline && !bFromEntries && !sTemplate.getLength() ) |
| bFromOutline = true; |
| |
| uno::Reference< beans::XPropertySet > xTOC( |
| m_xTextFactory->createInstance |
| ( bTableOfFigures ? |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM |
| ("com.sun.star.text.IllustrationsIndex")) |
| : sTOCServiceName), |
| uno::UNO_QUERY_THROW); |
| xTOC->setPropertyValue(rPropNameSupplier.GetName( PROP_TITLE ), uno::makeAny(::rtl::OUString())); |
| if( !bTableOfFigures ) |
| { |
| xTOC->setPropertyValue( rPropNameSupplier.GetName( PROP_LEVEL ), uno::makeAny( nMaxLevel ) ); |
| xTOC->setPropertyValue( rPropNameSupplier.GetName( PROP_CREATE_FROM_OUTLINE ), uno::makeAny( bFromOutline )); |
| xTOC->setPropertyValue( rPropNameSupplier.GetName( PROP_CREATE_FROM_MARKS ), uno::makeAny( bFromEntries )); |
| if( sTemplate.getLength() ) |
| { |
| //the string contains comma separated the names and related levels |
| //like: "Heading 1,1,Heading 2,2" |
| TOCStyleMap aMap; |
| sal_Int32 nLevel; |
| sal_Int32 nPosition = 0; |
| while( nPosition >= 0) |
| { |
| ::rtl::OUString sStyleName = sTemplate.getToken( 0, ',', nPosition ); |
| //empty tokens should be skipped |
| while( !sStyleName.getLength() && nPosition > 0 ) |
| sStyleName = sTemplate.getToken( 0, ',', nPosition ); |
| nLevel = sTemplate.getToken( 0, ',', nPosition ).toInt32(); |
| if( !nLevel ) |
| nLevel = 1; |
| if( sStyleName.getLength() ) |
| aMap.insert( TOCStyleMap::value_type(nLevel, sStyleName) ); |
| } |
| uno::Reference< container::XIndexReplace> xParaStyles; |
| xTOC->getPropertyValue(rPropNameSupplier.GetName(PROP_LEVEL_PARAGRAPH_STYLES)) >>= xParaStyles; |
| for( nLevel = 1; nLevel < 10; ++nLevel) |
| { |
| sal_Int32 nLevelCount = aMap.count( nLevel ); |
| if( nLevelCount ) |
| { |
| TOCStyleMap::iterator aTOCStyleIter = aMap.find( nLevel ); |
| |
| uno::Sequence< rtl::OUString> aStyles( nLevelCount ); |
| for ( sal_Int32 nStyle = 0; nStyle < nLevelCount; ++nStyle, ++aTOCStyleIter ) |
| { |
| aStyles[nStyle] = aTOCStyleIter->second; |
| } |
| xParaStyles->replaceByIndex(nLevel - 1, uno::makeAny(aStyles)); |
| } |
| } |
| xTOC->setPropertyValue(rPropNameSupplier.GetName(PROP_CREATE_FROM_LEVEL_PARAGRAPH_STYLES), uno::makeAny( true )); |
| |
| } |
| if(bHyperlinks || sChapterNoSeparator.getLength()) |
| { |
| uno::Reference< container::XIndexReplace> xLevelFormats; |
| xTOC->getPropertyValue(rPropNameSupplier.GetName(PROP_LEVEL_FORMAT)) >>= xLevelFormats; |
| sal_Int32 nLevelCount = xLevelFormats->getCount(); |
| //start with level 1, 0 is the header level |
| for( sal_Int32 nLevel = 1; nLevel < nLevelCount; ++nLevel) |
| { |
| uno::Sequence< beans::PropertyValues > aLevel; |
| xLevelFormats->getByIndex( nLevel ) >>= aLevel; |
| //create a copy of the level and add two new entries - hyperlink start and end |
| bool bChapterNoSeparator = sChapterNoSeparator.getLength() > 0; |
| sal_Int32 nAdd = (bHyperlinks && bChapterNoSeparator) ? 4 : 2; |
| uno::Sequence< beans::PropertyValues > aNewLevel( aLevel.getLength() + nAdd); |
| beans::PropertyValues* pNewLevel = aNewLevel.getArray(); |
| if( bHyperlinks ) |
| { |
| beans::PropertyValues aHyperlink(1); |
| aHyperlink[0].Name = rPropNameSupplier.GetName( PROP_TOKEN_TYPE ); |
| aHyperlink[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_HYPERLINK_START ); |
| pNewLevel[0] = aHyperlink; |
| aHyperlink[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_HYPERLINK_END ); |
| pNewLevel[aNewLevel.getLength() -1] = aHyperlink; |
| } |
| if( bChapterNoSeparator ) |
| { |
| beans::PropertyValues aChapterNo(2); |
| aChapterNo[0].Name = rPropNameSupplier.GetName( PROP_TOKEN_TYPE ); |
| aChapterNo[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_CHAPTER_INFO ); |
| aChapterNo[1].Name = rPropNameSupplier.GetName( PROP_CHAPTER_FORMAT ); |
| //todo: is ChapterFormat::Number correct? |
| aChapterNo[1].Value <<= (sal_Int16)text::ChapterFormat::NUMBER; |
| pNewLevel[aNewLevel.getLength() - (bHyperlinks ? 4 : 2) ] = aChapterNo; |
| |
| beans::PropertyValues aChapterSeparator(2); |
| aChapterSeparator[0].Name = rPropNameSupplier.GetName( PROP_TOKEN_TYPE ); |
| aChapterSeparator[0].Value <<= rPropNameSupplier.GetName( PROP_TOKEN_TEXT ); |
| aChapterSeparator[1].Name = rPropNameSupplier.GetName( PROP_TEXT ); |
| aChapterSeparator[1].Value <<= sChapterNoSeparator; |
| pNewLevel[aNewLevel.getLength() - (bHyperlinks ? 3 : 1)] = aChapterSeparator; |
| } |
| //copy the 'old' entries except the last (page no) |
| for( sal_Int32 nToken = 0; nToken < aLevel.getLength() - 1; ++nToken) |
| { |
| pNewLevel[nToken + 1] = aLevel[nToken]; |
| } |
| //copy page no entry (last or last but one depending on bHyperlinks |
| sal_Int32 nPageNo = aNewLevel.getLength() - (bHyperlinks ? 2 : 3); |
| pNewLevel[nPageNo] = aLevel[aLevel.getLength() - 1]; |
| |
| xLevelFormats->replaceByIndex( nLevel, uno::makeAny( aNewLevel ) ); |
| } |
| } |
| } |
| pContext->SetTOC( xTOC ); |
| } |
| |
| void DomainMapper_Impl::AddAnnotationPosition( |
| const bool bStart, |
| const sal_Int32 nAnnotationId ) |
| { |
| if (m_aTextAppendStack.empty()) |
| return; |
| |
| // Create a cursor, pointing to the current position. |
| uno::Reference<text::XTextAppend> xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| uno::Reference<text::XTextRange> xCurrent; |
| if (xTextAppend.is()) |
| { |
| uno::Reference<text::XTextCursor> xCursor = xTextAppend->createTextCursorByRange(xTextAppend->getEnd()); |
| xCurrent = xCursor->getStart(); |
| } |
| |
| // And save it, to be used by PopAnnotation() later. |
| AnnotationPosition& aAnnotationPosition = m_aAnnotationPositions[ nAnnotationId ]; |
| if ( bStart ) |
| { |
| aAnnotationPosition.m_xStart = xCurrent; |
| } |
| else |
| { |
| aAnnotationPosition.m_xEnd = xCurrent; |
| } |
| m_aAnnotationPositions[ nAnnotationId ] = aAnnotationPosition; |
| } |
| |
| /*-- 29.01.2007 11:33:16--------------------------------------------------- |
| //the field command has to be closed (0x14 appeared) |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::CloseFieldCommand() |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->element("closeFieldCommand"); |
| #endif |
| |
| FieldContextPtr pContext = m_aFieldStack.top(); |
| OSL_ENSURE( pContext.get(), "no field context available"); |
| if( pContext.get() ) |
| { |
| m_bSetUserFieldContent = false; |
| FieldConversionMap_t aFieldConversionMap = lcl_GetFieldConversion(); |
| |
| try |
| { |
| uno::Reference< uno::XInterface > xFieldInterface; |
| //at first determine the field type - erase leading and trailing whitespaces |
| ::rtl::OUString sCommand( pContext->GetCommand().trim() ); |
| sal_Int32 nSpaceIndex = sCommand.indexOf( ' ' ); |
| if( 0 <= nSpaceIndex ) |
| sCommand = sCommand.copy( 0, nSpaceIndex ); |
| |
| FieldConversionMap_t::iterator aIt = aFieldConversionMap.find(sCommand); |
| if(aIt != aFieldConversionMap.end()) |
| { |
| uno::Reference< beans::XPropertySet > xFieldProperties; |
| bool bCreateField = true; |
| switch (aIt->second.eFieldId) |
| { |
| case FIELD_HYPERLINK: |
| case FIELD_DOCPROPERTY: |
| case FIELD_TOC: |
| case FIELD_TC: |
| case FIELD_FORMCHECKBOX: |
| bCreateField = false; |
| break; |
| default: |
| break; |
| } |
| if( bCreateField) |
| { |
| //add the service prefix |
| OUString sServiceName(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextField.")); |
| sServiceName += ::rtl::OUString::createFromAscii(aIt->second.cFieldServiceName ); |
| |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->startElement("fieldService"); |
| dmapper_logger->chars(sServiceName); |
| dmapper_logger->endElement("fieldService"); |
| #endif |
| |
| xFieldInterface = m_xTextFactory->createInstance(sServiceName); |
| xFieldProperties = uno::Reference< beans::XPropertySet >( xFieldInterface, uno::UNO_QUERY_THROW); |
| } |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| switch( aIt->second.eFieldId ) |
| { |
| case FIELD_ADDRESSBLOCK: break; |
| case FIELD_ADVANCE : break; |
| case FIELD_ASK : |
| handleFieldAsk(pContext, rPropNameSupplier, xFieldInterface, xFieldProperties); |
| break; |
| case FIELD_AUTONUM : |
| case FIELD_AUTONUMLGL : |
| case FIELD_AUTONUMOUT : |
| handleAutoNum(pContext, rPropNameSupplier, xFieldInterface, xFieldProperties); |
| break; |
| case FIELD_AUTHOR : |
| handleAuthor(pContext, rPropNameSupplier, xFieldInterface, xFieldProperties); |
| break; |
| case FIELD_DATE: |
| { |
| //not fixed, |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_IS_FIXED), |
| uno::makeAny( false )); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_IS_DATE), |
| uno::makeAny( true )); |
| SetNumberFormat( pContext->GetCommand(), xFieldProperties ); |
| } |
| break; |
| case FIELD_COMMENTS : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" COMMENTS") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_CREATEDATE : |
| { |
| SetNumberFormat( pContext->GetCommand(), xFieldProperties ); |
| } |
| break; |
| case FIELD_DOCPROPERTY : |
| handleDocProperty(pContext, rPropNameSupplier, xFieldInterface, xFieldProperties); |
| break; |
| case FIELD_DOCVARIABLE : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" DOCVARIABLE") ); |
| //create a user field and type |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster( "com.sun.star.text.FieldMaster.User", sParam ); |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| m_bSetUserFieldContent = true; |
| } |
| break; |
| case FIELD_EDITTIME : |
| //it's a numbering type, no number format! SetNumberFormat( pContext->GetCommand(), xFieldProperties ); |
| break; |
| case FIELD_FILLIN : |
| { |
| sal_Int32 nIndex = 0; |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HINT), uno::makeAny( pContext->GetCommand().getToken( 1, '\"', nIndex))); |
| } |
| break; |
| case FIELD_FILENAME: |
| { |
| sal_Int32 nNumberingTypeIndex = pContext->GetCommand().indexOf( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\\p"))); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_FILE_FORMAT), |
| uno::makeAny( nNumberingTypeIndex > 0 ? text::FilenameDisplayFormat::FULL : text::FilenameDisplayFormat::NAME_AND_EXT )); |
| } |
| break; |
| case FIELD_FILESIZE : break; |
| case FIELD_FORMULA : break; |
| case FIELD_FORMCHECKBOX : |
| { |
| FFDataHandler::Pointer_t |
| pFFDataHandler(pContext->getFFDataHandler()); |
| FormControlHelper::Pointer_t |
| pFormControlHelper(new FormControlHelper |
| (FIELD_FORMCHECKBOX, |
| m_xTextDocument, pFFDataHandler)); |
| pContext->setFormControlHelper(pFormControlHelper); |
| } |
| break; |
| case FIELD_FORMDROPDOWN : break; |
| case FIELD_FORMTEXT : |
| { |
| FFDataHandler::Pointer_t pFFDataHandler |
| (pContext->getFFDataHandler()); |
| |
| xFieldProperties->setPropertyValue |
| (rPropNameSupplier.GetName(PROP_HINT), |
| uno::makeAny(pFFDataHandler->getStatusText())); |
| xFieldProperties->setPropertyValue |
| (rPropNameSupplier.GetName(PROP_HELP), |
| uno::makeAny(pFFDataHandler->getHelpText())); |
| xFieldProperties->setPropertyValue |
| (rPropNameSupplier.GetName(PROP_CONTENT), |
| uno::makeAny(pFFDataHandler->getTextDefault())); |
| } |
| break; |
| case FIELD_GOTOBUTTON : break; |
| case FIELD_HYPERLINK: |
| { |
| ::std::vector<rtl::OUString> aParts = pContext->GetCommandParts(); |
| ::std::vector<rtl::OUString>::const_iterator aItEnd = aParts.end(); |
| ::std::vector<rtl::OUString>::const_iterator aPartIt = aParts.begin(); |
| |
| OUString sURL; |
| |
| while (aPartIt != aItEnd) |
| { |
| if (aPartIt->equalsAscii("\\l")) |
| { |
| aPartIt++; |
| |
| if (aPartIt == aItEnd) |
| break; |
| |
| sURL = OUString('#'); |
| sURL += *aPartIt; |
| } |
| else if (aPartIt->equalsAscii("\\m") || |
| aPartIt->equalsAscii("\\n")) |
| { |
| } |
| else if (aPartIt->equalsAscii("\\o") || |
| aPartIt->equalsAscii("\\t")) |
| { |
| aPartIt++; |
| |
| if (aPartIt == aItEnd) |
| break; |
| } |
| else |
| { |
| sURL = *aPartIt; |
| } |
| |
| aPartIt++; |
| } |
| |
| if (sURL.getLength() > 0) |
| { |
| pContext->SetHyperlinkURL(sURL); |
| } |
| } |
| break; |
| case FIELD_IF : break; |
| case FIELD_INFO : break; |
| case FIELD_INCLUDEPICTURE: break; |
| case FIELD_KEYWORDS : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" KEYWORDS") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_LASTSAVEDBY : break; |
| case FIELD_MACROBUTTON: |
| { |
| //extract macro name |
| sal_Int32 nIndex = sizeof(" MACROBUTTON "); |
| ::rtl::OUString sMacro = pContext->GetCommand().getToken( 0, ' ', nIndex); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_MACRO_NAME), uno::makeAny( sMacro )); |
| |
| //extract quick help text |
| if( pContext->GetCommand().getLength() > nIndex + 1) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_HINT), |
| uno::makeAny( pContext->GetCommand().copy( nIndex ))); |
| } |
| } |
| break; |
| case FIELD_MERGEFIELD : |
| { |
| //todo: create a database field and fieldmaster pointing to a column, only |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" MERGEFIELD") ); |
| //create a user field and type |
| uno::Reference< beans::XPropertySet > xMaster = |
| FindOrCreateFieldMaster( "com.sun.star.text.FieldMaster.Database", sParam ); |
| |
| // xFieldProperties->setPropertyValue( |
| // ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FieldCode")), |
| // uno::makeAny( pContext->GetCommand().copy( nIndex + 1 ))); |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| m_bSetUserFieldContent = true; |
| } |
| break; |
| case FIELD_MERGEREC : break; |
| case FIELD_MERGESEQ : break; |
| case FIELD_NEXT : break; |
| case FIELD_NEXTIF : break; |
| case FIELD_PAGE : |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( lcl_ParseNumberingType(pContext->GetCommand()) )); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_SUB_TYPE), |
| uno::makeAny( text::PageNumberType_CURRENT )); |
| |
| break; |
| case FIELD_REF: |
| { |
| ::rtl::OUString sBookmark = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" REF") ); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_REFERENCE_FIELD_SOURCE), |
| uno::makeAny( sal_Int16(text::ReferenceFieldSource::BOOKMARK)) ); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_SOURCE_NAME), |
| uno::makeAny( sBookmark) ); |
| sal_Int16 nFieldPart = text::ReferenceFieldPart::TEXT; |
| ::rtl::OUString sValue; |
| if( lcl_FindInCommand( pContext->GetCommand(), 'p', sValue )) |
| { |
| //above-below |
| nFieldPart = text::ReferenceFieldPart::UP_DOWN; |
| } |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_REFERENCE_FIELD_PART ), uno::makeAny( nFieldPart )); |
| } |
| break; |
| case FIELD_REVNUM : break; |
| case FIELD_SAVEDATE : |
| SetNumberFormat( pContext->GetCommand(), xFieldProperties ); |
| break; |
| case FIELD_SECTION : break; |
| case FIELD_SECTIONPAGES : break; |
| case FIELD_SEQ : |
| { |
| // command looks like: " SEQ Table \* ARABIC " |
| ::rtl::OUString sCmd(pContext->GetCommand()); |
| // find the sequence name, e.g. "SEQ" |
| ::rtl::OUString sSeqName = lcl_FindQuotedText(sCmd, "SEQ ", '\\'); |
| sSeqName = sSeqName.trim(); |
| |
| // create a sequence field master using the sequence name |
| uno::Reference< beans::XPropertySet > xMaster = FindOrCreateFieldMaster( |
| "com.sun.star.text.FieldMaster.SetExpression", |
| sSeqName); |
| |
| xMaster->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_SUB_TYPE), |
| uno::makeAny(text::SetVariableType::SEQUENCE)); |
| |
| // apply the numbering type |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( lcl_ParseNumberingType(pContext->GetCommand()) )); |
| |
| // attach the master to the field |
| uno::Reference< text::XDependentTextField > xDependentField( xFieldInterface, uno::UNO_QUERY_THROW ); |
| xDependentField->attachTextFieldMaster( xMaster ); |
| } |
| break; |
| case FIELD_SET : break; |
| case FIELD_SKIPIF : break; |
| case FIELD_STYLEREF : break; |
| case FIELD_SUBJECT : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" SUBJECT") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_SYMBOL : break; |
| case FIELD_TEMPLATE: break; |
| case FIELD_TIME : |
| SetNumberFormat( pContext->GetCommand(), xFieldProperties ); |
| break; |
| case FIELD_TITLE : |
| { |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" TITLE") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_USERINITIALS: |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_USER_DATA_TYPE), uno::makeAny( text::UserDataPart::SHORTCUT )); |
| //todo: if initials are provided - set them as fixed content |
| ::rtl::OUString sParam = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" USERINITIALS") ); |
| if(sParam.getLength()) |
| { |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName( PROP_IS_FIXED ), uno::makeAny( true )); |
| //PROP_CURRENT_PRESENTATION is set later anyway |
| } |
| } |
| break; |
| case FIELD_USERADDRESS : //todo: user address collects street, city ... |
| break; |
| case FIELD_USERNAME : //todo: user name is firstname + lastname |
| break; |
| case FIELD_TOC: |
| handleToc(pContext, rPropNameSupplier, xFieldInterface, xFieldProperties, |
| ::rtl::OUString::createFromAscii(aIt->second.cFieldServiceName)); |
| break; |
| case FIELD_TC : |
| { |
| uno::Reference< beans::XPropertySet > xTC( |
| m_xTextFactory->createInstance( |
| ::rtl::OUString::createFromAscii(aIt->second.cFieldServiceName)), |
| uno::UNO_QUERY_THROW); |
| ::rtl::OUString sTCText = lcl_ExtractParameter(pContext->GetCommand(), sizeof(" TC") ); |
| if( sTCText.getLength()) |
| xTC->setPropertyValue(rPropNameSupplier.GetName(PROP_ALTERNATIVE_TEXT), |
| uno::makeAny(sTCText)); |
| ::rtl::OUString sValue; |
| // \f TC entry in doc with multiple tables |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'f', sValue )) |
| // { |
| // todo: unsupported |
| // } |
| if( lcl_FindInCommand( pContext->GetCommand(), 'l', sValue )) |
| // \l Outline Level |
| { |
| sal_Int32 nLevel = sValue.toInt32(); |
| if( sValue.getLength() && nLevel >= 0 && nLevel <= 10 ) |
| xTC->setPropertyValue(rPropNameSupplier.GetName(PROP_LEVEL), uno::makeAny( (sal_Int16)nLevel )); |
| } |
| // if( lcl_FindInCommand( pContext->GetCommand(), 'n', sValue )) |
| // \n Suppress page numbers |
| // { |
| //todo: unsupported feature |
| // } |
| pContext->SetTC( xTC ); |
| } |
| break; |
| case FIELD_NUMCHARS: |
| case FIELD_NUMWORDS: |
| case FIELD_NUMPAGES: |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_NUMBERING_TYPE), |
| uno::makeAny( lcl_ParseNumberingType(pContext->GetCommand()) )); |
| break; |
| |
| } |
| } |
| //set the text field if there is any |
| pContext->SetTextField( uno::Reference< text::XTextField >( xFieldInterface, uno::UNO_QUERY ) ); |
| } |
| catch( uno::Exception& rEx) |
| { |
| (void)rEx; |
| OSL_ENSURE( false, "Exception in CloseFieldCommand()" ); |
| } |
| pContext->SetCommandCompleted(); |
| } |
| } |
| /*-- 29.01.2007 11:33:16--------------------------------------------------- |
| //the _current_ fields require a string type result while TOCs accept richt results |
| -----------------------------------------------------------------------*/ |
| bool DomainMapper_Impl::IsFieldResultAsString() |
| { |
| bool bRet = false; |
| OSL_ENSURE( !m_aFieldStack.empty(), "field stack empty?"); |
| FieldContextPtr pContext = m_aFieldStack.top(); |
| OSL_ENSURE( pContext.get(), "no field context available"); |
| if( pContext.get() ) |
| { |
| bRet = pContext->GetTextField().is(); |
| } |
| return bRet; |
| } |
| /*-- 01.09.2006 11:48:09--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::SetFieldResult( ::rtl::OUString& rResult ) |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->startElement("setFieldResult"); |
| dmapper_logger->chars(rResult); |
| #endif |
| |
| FieldContextPtr pContext = m_aFieldStack.top(); |
| OSL_ENSURE( pContext.get(), "no field context available"); |
| if( pContext.get() ) |
| { |
| uno::Reference<text::XTextField> xTextField = pContext->GetTextField(); |
| try |
| { |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| OSL_ENSURE( xTextField.is() |
| //||m_xTOC.is() ||m_xTC.is() |
| //||m_sHyperlinkURL.getLength() |
| , "DomainMapper_Impl::SetFieldResult: field not created" ); |
| if(xTextField.is()) |
| { |
| try |
| { |
| if( m_bSetUserFieldContent ) |
| { |
| // user field content has to be set at the field master |
| uno::Reference< text::XDependentTextField > xDependentField( xTextField, uno::UNO_QUERY_THROW ); |
| xDependentField->getTextFieldMaster()->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_CONTENT), |
| uno::makeAny( rResult )); |
| } |
| else |
| { |
| uno::Reference< beans::XPropertySet > xFieldProperties( xTextField, uno::UNO_QUERY_THROW); |
| xFieldProperties->setPropertyValue( |
| rPropNameSupplier.GetName(PROP_CURRENT_PRESENTATION), |
| uno::makeAny( rResult )); |
| } |
| } |
| catch( const beans::UnknownPropertyException& ) |
| { |
| //some fields don't have a CurrentPresentation (DateTime) |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| { |
| |
| } |
| } |
| } |
| |
| void DomainMapper_Impl::SetFieldFFData(FFDataHandler::Pointer_t pFFDataHandler) |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->startElement("setFieldFFData"); |
| #endif |
| |
| FieldContextPtr pContext = m_aFieldStack.top(); |
| if (pContext.get()) |
| { |
| pContext->setFFDataHandler(pFFDataHandler); |
| } |
| |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->endElement("setFieldFFData"); |
| #endif |
| } |
| |
| /*-- 29.01.2007 11:33:17--------------------------------------------------- |
| //the end of field is reached (0x15 appeared) - the command might still be open |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::PopFieldContext() |
| { |
| #ifdef DEBUG_DOMAINMAPPER |
| dmapper_logger->element("popFieldContext"); |
| #endif |
| |
| FieldContextPtr pContext = m_aFieldStack.top(); |
| OSL_ENSURE( pContext.get(), "no field context available"); |
| if( pContext.get() ) |
| { |
| if( !pContext->IsCommandCompleted() ) |
| CloseFieldCommand(); |
| |
| //insert the field, TC or TOC |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| if(xTextAppend.is()) |
| { |
| try |
| { |
| uno::Reference< text::XTextCursor > xCrsr = xTextAppend->createTextCursorByRange(pContext->GetStartRange()); |
| //remove the dummy character |
| xCrsr->goRight( 1, true ); |
| xCrsr->setString( ::rtl::OUString() ); |
| uno::Reference< text::XTextContent > xToInsert( pContext->GetTOC(), uno::UNO_QUERY ); |
| if( xToInsert.is() ) |
| { |
| xCrsr->gotoEnd( true ); |
| xToInsert->attach( uno::Reference< text::XTextRange >( xCrsr, uno::UNO_QUERY_THROW )); |
| } |
| else |
| { |
| xToInsert = uno::Reference< text::XTextContent >(pContext->GetTC(), uno::UNO_QUERY); |
| if( !xToInsert.is() ) |
| xToInsert = uno::Reference< text::XTextContent >(pContext->GetTextField(), uno::UNO_QUERY); |
| if( xToInsert.is() ) |
| { |
| uno::Reference< text::XTextAppendAndConvert > xTextAppendAndConvert( xTextAppend, uno::UNO_QUERY_THROW ); |
| xTextAppendAndConvert->appendTextContent( xToInsert, uno::Sequence< beans::PropertyValue >() ); |
| } |
| else |
| { |
| FormControlHelper::Pointer_t pFormControlHelper(pContext->getFormControlHelper()); |
| if (pFormControlHelper.get() != NULL) |
| { |
| uno::Reference<text::XTextRange> xTxtRange(xCrsr, uno::UNO_QUERY); |
| pFormControlHelper->insertControl(xTxtRange); |
| } |
| else if(pContext->GetHyperlinkURL().getLength()) |
| { |
| PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| xCrsr->gotoEnd( true ); |
| |
| uno::Reference< beans::XPropertySet > xCrsrProperties( xCrsr, uno::UNO_QUERY_THROW ); |
| xCrsrProperties->setPropertyValue(rPropNameSupplier.GetName(PROP_HYPER_LINK_U_R_L), uno:: |
| makeAny(pContext->GetHyperlinkURL())); |
| } |
| } |
| } |
| } |
| catch(const lang::IllegalArgumentException& ) |
| { |
| OSL_ENSURE( false, "IllegalArgumentException in PopFieldContext()" ); |
| } |
| catch(const uno::Exception& ) |
| { |
| OSL_ENSURE( false, "exception in PopFieldContext()" ); |
| } |
| } |
| // |
| //TOCs have to include all the imported content |
| //... |
| } |
| //remove the field context |
| m_aFieldStack.pop(); |
| } |
| /*-- 11.06.2007 16:19:00--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::AddBookmark( |
| const ::rtl::OUString& rBookmarkName, |
| const sal_Int32 nId ) |
| { |
| uno::Reference< text::XTextAppend > xTextAppend = m_aTextAppendStack.top().xTextAppend; |
| BookmarkMap_t::iterator aBookmarkIter = m_aBookmarkMap.find( nId ); |
| //is the bookmark name already registered? |
| try |
| { |
| if( aBookmarkIter != m_aBookmarkMap.end() ) |
| { |
| static const rtl::OUString sBookmarkService(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Bookmark")); |
| uno::Reference< text::XTextContent > xBookmark( m_xTextFactory->createInstance( sBookmarkService ), uno::UNO_QUERY_THROW ); |
| uno::Reference< text::XTextCursor > xCursor; |
| uno::Reference< text::XText > xText = aBookmarkIter->second.m_xTextRange->getText(); |
| if( aBookmarkIter->second.m_bIsStartOfText ) |
| xCursor = xText->createTextCursorByRange( xText->getStart() ); |
| else |
| { |
| xCursor = xText->createTextCursorByRange( aBookmarkIter->second.m_xTextRange ); |
| xCursor->goRight( 1, false ); |
| } |
| |
| xCursor->gotoRange( xTextAppend->getEnd(), true ); |
| uno::Reference< container::XNamed > xBkmNamed( xBookmark, uno::UNO_QUERY_THROW ); |
| //todo: make sure the name is not used already! |
| xBkmNamed->setName( aBookmarkIter->second.m_sBookmarkName ); |
| xTextAppend->insertTextContent( uno::Reference< text::XTextRange >( xCursor, uno::UNO_QUERY_THROW), xBookmark, !xCursor->isCollapsed() ); |
| m_aBookmarkMap.erase( aBookmarkIter ); |
| } |
| else |
| { |
| //otherwise insert a text range as marker |
| uno::Reference< text::XTextCursor > xCursor = xTextAppend->createTextCursorByRange( xTextAppend->getEnd() ); |
| bool bIsStart = !xCursor->goLeft(1, false); |
| uno::Reference< text::XTextRange > xCurrent = xCursor->getStart(); |
| m_aBookmarkMap.insert(BookmarkMap_t::value_type( nId, BookmarkInsertPosition( bIsStart, rBookmarkName, xCurrent ) )); |
| } |
| } |
| catch( const uno::Exception& ) |
| { |
| //TODO: What happens to bookmarks where start and end are at different XText objects? |
| } |
| } |
| /*-- 01.11.2006 14:57:44--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| GraphicImportPtr DomainMapper_Impl::GetGraphicImport(GraphicImportType eGraphicImportType) |
| { |
| if(!m_pGraphicImport) |
| m_pGraphicImport.reset( new GraphicImport( m_xComponentContext, m_xTextFactory, m_rDMapper, eGraphicImportType ) ); |
| return m_pGraphicImport; |
| } |
| /*-- 09.08.2007 10:19:45--------------------------------------------------- |
| reset graphic import if the last import resulted in a shape, not a graphic |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::ResetGraphicImport() |
| { |
| m_pGraphicImport.reset(); |
| } |
| /*-- 01.11.2006 09:25:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::ImportGraphic(writerfilter::Reference< Properties >::Pointer_t ref, GraphicImportType eGraphicImportType) |
| { |
| GetGraphicImport(eGraphicImportType); |
| if( eGraphicImportType != IMPORT_AS_DETECTED_INLINE && eGraphicImportType != IMPORT_AS_DETECTED_ANCHOR ) |
| { |
| //create the graphic |
| ref->resolve( *m_pGraphicImport ); |
| } |
| |
| //insert it into the document at the current cursor position |
| |
| uno::Reference<text::XTextContent> xTextContent |
| (m_pGraphicImport->GetGraphicObject()); |
| |
| //insert it into the document at the current cursor position |
| OSL_ENSURE( xTextContent.is(), "DomainMapper_Impl::ImportGraphic"); |
| if( xTextContent.is()) |
| appendTextContent( xTextContent, uno::Sequence< beans::PropertyValue >() ); |
| |
| m_pGraphicImport.reset(); |
| } |
| |
| /*-- 28.12.2006 14:00:47--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::SetLineNumbering( sal_Int32 nLnnMod, sal_Int32 nLnc, sal_Int32 ndxaLnn ) |
| { |
| if( !m_bLineNumberingSet ) |
| { |
| const PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier(); |
| |
| try |
| { |
| uno::Reference< text::XLineNumberingProperties > xLineProperties( m_xTextDocument, uno::UNO_QUERY_THROW ); |
| uno::Reference< beans::XPropertySet > xProperties = xLineProperties->getLineNumberingProperties(); |
| uno::Any aTrue( uno::makeAny( true )); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_IS_ON ), aTrue); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_COUNT_EMPTY_LINES ), aTrue ); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_COUNT_LINES_IN_FRAMES ), uno::makeAny( false ) ); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_INTERVAL ), uno::makeAny( static_cast< sal_Int16 >( nLnnMod ))); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_DISTANCE ), uno::makeAny( ConversionHelper::convertTwipToMM100(ndxaLnn) )); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_NUMBER_POSITION ), uno::makeAny( style::LineNumberPosition::LEFT)); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_NUMBERING_TYPE ), uno::makeAny( style::NumberingType::ARABIC)); |
| xProperties->setPropertyValue( rPropNameSupplier.GetName( PROP_RESTART_AT_EACH_PAGE ), uno::makeAny( nLnc == 0 )); |
| } |
| catch( const uno::Exception& ) |
| {} |
| |
| |
| |
| /* |
| { SW_PROP_NAME(UNO_NAME_CHAR_STYLE_NAME |
| { SW_PROP_NAME(UNO_NAME_COUNT_EMPTY_LINES |
| { SW_PROP_NAME(UNO_NAME_COUNT_LINES_IN_FRAMES |
| { SW_PROP_NAME(UNO_NAME_DISTANCE |
| { SW_PROP_NAME(UNO_NAME_IS_ON |
| { SW_PROP_NAME(UNO_NAME_INTERVAL |
| { SW_PROP_NAME(UNO_NAME_SEPARATOR_TEXT |
| { SW_PROP_NAME(UNO_NAME_NUMBER_POSITION |
| { SW_PROP_NAME(UNO_NAME_NUMBERING_TYPE |
| { SW_PROP_NAME(UNO_NAME_RESTART_AT_EACH_PAGE |
| { SW_PROP_NAME(UNO_NAME_SEPARATOR_INTERVAL |
| */ |
| } |
| m_bLineNumberingSet = true; |
| } |
| /*-- 31.08.2007 13:50:49--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::SetPageMarginTwip( PageMarElement eElement, sal_Int32 nValue ) |
| { |
| nValue = ConversionHelper::convertTwipToMM100(nValue); |
| switch(eElement) |
| { |
| case PAGE_MAR_TOP : m_aPageMargins.top = nValue; break; |
| case PAGE_MAR_RIGHT : m_aPageMargins.right = nValue; break; |
| case PAGE_MAR_BOTTOM : m_aPageMargins.bottom = nValue; break; |
| case PAGE_MAR_LEFT : m_aPageMargins.left = nValue; break; |
| case PAGE_MAR_HEADER : m_aPageMargins.header = nValue; break; |
| case PAGE_MAR_FOOTER : m_aPageMargins.footer = nValue; break; |
| case PAGE_MAR_GUTTER : m_aPageMargins.gutter = nValue; break; |
| } |
| } |
| |
| /*-- 31.08.2007 13:47:50--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| _PageMar::_PageMar() |
| { |
| header = footer = top = bottom = ConversionHelper::convertTwipToMM100( sal_Int32(1440)); |
| right = left = ConversionHelper::convertTwipToMM100( sal_Int32(1800)); |
| gutter = 0; |
| } |
| |
| /*-- 07.03.2008 12:07:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::RegisterFrameConversion( |
| uno::Reference< text::XTextRange > xFrameStartRange, |
| uno::Reference< text::XTextRange > xFrameEndRange, |
| uno::Sequence< beans::PropertyValue > aFrameProperties |
| ) |
| { |
| OSL_ENSURE( |
| !m_aFrameProperties.getLength() && !m_xFrameStartRange.is() && !m_xFrameEndRange.is(), |
| "frame properties not removed"); |
| m_aFrameProperties = aFrameProperties; |
| m_xFrameStartRange = xFrameStartRange; |
| m_xFrameEndRange = xFrameEndRange; |
| } |
| /*-- 07.03.2008 12:07:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| bool DomainMapper_Impl::ExecuteFrameConversion() |
| { |
| bool bRet = false; |
| if( m_xFrameStartRange.is() && m_xFrameEndRange.is() ) |
| { |
| bRet = true; |
| try |
| { |
| uno::Reference< text::XTextAppendAndConvert > xTextAppendAndConvert( GetTopTextAppend(), uno::UNO_QUERY_THROW ); |
| xTextAppendAndConvert->convertToTextFrame( |
| m_xFrameStartRange, |
| m_xFrameEndRange, |
| m_aFrameProperties ); |
| } |
| catch( const uno::Exception& rEx) |
| { |
| (void)rEx; |
| bRet = false; |
| } |
| m_xFrameStartRange = 0; |
| m_xFrameEndRange = 0; |
| m_aFrameProperties.realloc( 0 ); |
| } |
| return bRet; |
| } |
| |
| void DomainMapper_Impl::AddNewRedline( ) |
| { |
| RedlineParamsPtr pNew( new RedlineParams ); |
| pNew->m_nToken = ooxml::OOXML_mod; |
| if ( !m_bIsParaChange ) |
| { |
| m_aRedlines.push_back( pNew ); |
| } |
| else |
| { |
| m_pParaRedline.swap( pNew ); |
| } |
| } |
| |
| RedlineParamsPtr DomainMapper_Impl::GetTopRedline( ) |
| { |
| RedlineParamsPtr pResult; |
| if ( !m_bIsParaChange && m_aRedlines.size( ) > 0 ) |
| pResult = m_aRedlines.back( ); |
| else if ( m_bIsParaChange ) |
| pResult = m_pParaRedline; |
| return pResult; |
| } |
| |
| sal_Int32 DomainMapper_Impl::GetCurrentRedlineToken( ) |
| { |
| sal_Int32 nToken = 0; |
| RedlineParamsPtr pCurrent( GetTopRedline( ) ); |
| if ( pCurrent.get( ) ) |
| nToken = pCurrent->m_nToken; |
| return nToken; |
| } |
| |
| void DomainMapper_Impl::SetCurrentRedlineAuthor( rtl::OUString sAuthor ) |
| { |
| if (m_xAnnotationField.is()) |
| { |
| m_xAnnotationField->setPropertyValue( |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Author")), |
| uno::makeAny(sAuthor) ); |
| } |
| else |
| { |
| RedlineParamsPtr pCurrent( GetTopRedline( ) ); |
| if ( pCurrent.get( ) ) |
| pCurrent->m_sAuthor = sAuthor; |
| } |
| } |
| |
| void DomainMapper_Impl::SetCurrentRedlineInitials( rtl::OUString sInitials ) |
| { |
| if (m_xAnnotationField.is()) |
| { |
| m_xAnnotationField->setPropertyValue( |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Initials")), |
| uno::makeAny(sInitials) ); |
| } |
| } |
| |
| void DomainMapper_Impl::SetCurrentRedlineDate( rtl::OUString sDate ) |
| { |
| if (m_xAnnotationField.is()) |
| { |
| m_xAnnotationField->setPropertyValue( |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DateTimeValue")), |
| uno::makeAny( ConversionHelper::convertDateTime( sDate ) ) ); |
| } |
| else |
| { |
| RedlineParamsPtr pCurrent( GetTopRedline( ) ); |
| if ( pCurrent.get( ) ) |
| pCurrent->m_sDate = sDate; |
| } |
| } |
| |
| void DomainMapper_Impl::SetCurrentRedlineId( sal_Int32 sId ) |
| { |
| if (m_xAnnotationField.is()) |
| { |
| m_nAnnotationId = sId; |
| } |
| else |
| { |
| RedlineParamsPtr pCurrent( GetTopRedline( ) ); |
| if ( pCurrent.get( ) ) |
| pCurrent->m_nId = sId; |
| } |
| } |
| |
| void DomainMapper_Impl::SetCurrentRedlineToken( sal_Int32 nToken ) |
| { |
| RedlineParamsPtr pCurrent( GetTopRedline( ) ); |
| if ( pCurrent.get( ) ) |
| pCurrent->m_nToken = nToken; |
| } |
| |
| /*-- 19.03.2008 11:35:38--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::RemoveCurrentRedline( ) |
| { |
| if ( m_aRedlines.size( ) > 0 ) |
| { |
| m_aRedlines.pop_back( ); |
| } |
| } |
| |
| void DomainMapper_Impl::ResetParaRedline( ) |
| { |
| if ( m_pParaRedline.get( ) ) |
| { |
| RedlineParamsPtr pEmpty; |
| m_pParaRedline.swap( pEmpty ); |
| } |
| } |
| |
| /*-- 22.09.2009 10:26:19--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void DomainMapper_Impl::ApplySettingsTable() |
| { |
| if( m_pSettingsTable ) |
| { |
| try |
| { |
| uno::Reference< beans::XPropertySet > xTextDefaults( |
| m_xTextFactory->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Defaults"))), uno::UNO_QUERY_THROW ); |
| sal_Int32 nDefTab = m_pSettingsTable->GetDefaultTabStop(); |
| xTextDefaults->setPropertyValue( PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_TAB_STOP_DISTANCE ), uno::makeAny(nDefTab) ); |
| } |
| catch(const uno::Exception& ) |
| { |
| } |
| } |
| } |
| |
| SectionPropertyMap * DomainMapper_Impl::GetSectionContext() |
| { |
| SectionPropertyMap* pSectionContext = 0; |
| //the section context is not available before the first call of startSectionGroup() |
| if( !IsAnyTableImport() ) |
| { |
| PropertyMapPtr pContext = GetTopContextOfType(CONTEXT_SECTION); |
| OSL_ENSURE(pContext.get(), "Section context is not in the stack!"); |
| pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() ); |
| } |
| |
| return pSectionContext; |
| } |
| |
| }} |