| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| |
| #define _SVSTDARR_USHORTSSORT |
| #define _SVSTDARR_USHORTS |
| #include <svl/svstdarr.hxx> |
| #include <com/sun/star/text/ReferenceFieldPart.hpp> |
| #include <com/sun/star/text/ReferenceFieldSource.hpp> |
| #include <unotools/localedatawrapper.hxx> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <editeng/unolingu.hxx> |
| #include <doc.hxx> |
| #include <pam.hxx> |
| #include <cntfrm.hxx> |
| #include <pagefrm.hxx> |
| #include <docary.hxx> |
| #include <fmtfld.hxx> |
| #include <txtfld.hxx> |
| #include <txtftn.hxx> |
| #include <fmtrfmrk.hxx> |
| #include <txtrfmrk.hxx> |
| #include <fmtftn.hxx> |
| #include <ndtxt.hxx> |
| #include <chpfld.hxx> |
| #include <reffld.hxx> |
| #include <expfld.hxx> |
| #include <txtfrm.hxx> |
| #include <flyfrm.hxx> |
| #include <pagedesc.hxx> |
| #include <IMark.hxx> |
| #include <crossrefbookmark.hxx> |
| #include <ftnidx.hxx> |
| #include <viewsh.hxx> |
| #include <unofldmid.h> |
| #include <SwStyleNameMapper.hxx> |
| #include <shellres.hxx> |
| #include <poolfmt.hxx> |
| #include <poolfmt.hrc> |
| #include <comcore.hrc> |
| #include <numrule.hxx> |
| #include <SwNodeNum.hxx> |
| #include <switerator.hxx> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::text; |
| using namespace ::com::sun::star::lang; |
| using ::rtl::OUString; |
| |
| extern void InsertSort( SvUShorts& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos = 0 ); |
| |
| void lcl_GetLayTree( const SwFrm* pFrm, SvPtrarr& rArr ) |
| { |
| while( pFrm ) |
| { |
| if( pFrm->IsBodyFrm() ) // soll uns nicht weiter interessieren |
| pFrm = pFrm->GetUpper(); |
| else |
| { |
| void* p = (void*)pFrm; |
| rArr.Insert( p, rArr.Count() ); |
| |
| // bei der Seite ist schluss |
| if( pFrm->IsPageFrm() ) |
| break; |
| |
| if( pFrm->IsFlyFrm() ) |
| pFrm = ((SwFlyFrm*)pFrm)->GetAnchorFrm(); |
| else |
| pFrm = pFrm->GetUpper(); |
| } |
| } |
| } |
| |
| |
| sal_Bool IsFrameBehind( const SwTxtNode& rMyNd, sal_uInt16 nMySttPos, |
| const SwTxtNode& rBehindNd, sal_uInt16 nSttPos ) |
| { |
| const SwTxtFrm *pMyFrm = (SwTxtFrm*)rMyNd.getLayoutFrm( rMyNd.GetDoc()->GetCurrentLayout(), 0,0,sal_False), |
| *pFrm = (SwTxtFrm*)rBehindNd.getLayoutFrm( rBehindNd.GetDoc()->GetCurrentLayout(), 0,0,sal_False); |
| |
| while( pFrm && !pFrm->IsInside( nSttPos ) ) |
| pFrm = (SwTxtFrm*)pFrm->GetFollow(); |
| while( pMyFrm && !pMyFrm->IsInside( nMySttPos ) ) |
| pMyFrm = (SwTxtFrm*)pMyFrm->GetFollow(); |
| |
| if( !pFrm || !pMyFrm || pFrm == pMyFrm ) |
| return sal_False; |
| |
| SvPtrarr aRefArr( 10, 10 ), aArr( 10, 10 ); |
| ::lcl_GetLayTree( pFrm, aRefArr ); |
| ::lcl_GetLayTree( pMyFrm, aArr ); |
| |
| sal_uInt16 nRefCnt = aRefArr.Count() - 1, nCnt = aArr.Count() - 1; |
| sal_Bool bVert = sal_False; |
| sal_Bool bR2L = sal_False; |
| |
| // solange bis ein Frame ungleich ist ? |
| while( nRefCnt && nCnt && aRefArr[ nRefCnt ] == aArr[ nCnt ] ) |
| { |
| const SwFrm* pTmpFrm = (const SwFrm*)aArr[ nCnt ]; |
| bVert = pTmpFrm->IsVertical(); |
| bR2L = pTmpFrm->IsRightToLeft(); |
| --nCnt, --nRefCnt; |
| } |
| |
| // sollte einer der Counter ueberlaeufen? |
| if( aRefArr[ nRefCnt ] == aArr[ nCnt ] ) |
| { |
| if( nCnt ) |
| --nCnt; |
| else |
| --nRefCnt; |
| } |
| |
| const SwFrm* pRefFrm = (const SwFrm*)aRefArr[ nRefCnt ]; |
| const SwFrm* pFldFrm = (const SwFrm*)aArr[ nCnt ]; |
| |
| // unterschiedliche Frames, dann ueberpruefe deren Y-/X-Position |
| sal_Bool bRefIsLower = sal_False; |
| if( ( FRM_COLUMN | FRM_CELL ) & pFldFrm->GetType() || |
| ( FRM_COLUMN | FRM_CELL ) & pRefFrm->GetType() ) |
| { |
| if( pFldFrm->GetType() == pRefFrm->GetType() ) |
| { |
| // hier ist die X-Pos wichtiger! |
| if( bVert ) |
| { |
| if( bR2L ) |
| bRefIsLower = pRefFrm->Frm().Top() < pFldFrm->Frm().Top() || |
| ( pRefFrm->Frm().Top() == pFldFrm->Frm().Top() && |
| pRefFrm->Frm().Left() < pFldFrm->Frm().Left() ); |
| else |
| bRefIsLower = pRefFrm->Frm().Top() < pFldFrm->Frm().Top() || |
| ( pRefFrm->Frm().Top() == pFldFrm->Frm().Top() && |
| pRefFrm->Frm().Left() > pFldFrm->Frm().Left() ); |
| } |
| else if( bR2L ) |
| bRefIsLower = pRefFrm->Frm().Left() > pFldFrm->Frm().Left() || |
| ( pRefFrm->Frm().Left() == pFldFrm->Frm().Left() && |
| pRefFrm->Frm().Top() < pFldFrm->Frm().Top() ); |
| else |
| bRefIsLower = pRefFrm->Frm().Left() < pFldFrm->Frm().Left() || |
| ( pRefFrm->Frm().Left() == pFldFrm->Frm().Left() && |
| pRefFrm->Frm().Top() < pFldFrm->Frm().Top() ); |
| pRefFrm = 0; |
| } |
| else if( ( FRM_COLUMN | FRM_CELL ) & pFldFrm->GetType() ) |
| pFldFrm = (const SwFrm*)aArr[ nCnt - 1 ]; |
| else |
| pRefFrm = (const SwFrm*)aRefArr[ nRefCnt - 1 ]; |
| } |
| |
| if( pRefFrm ) // als Flag missbrauchen |
| { |
| if( bVert ) |
| { |
| if( bR2L ) |
| bRefIsLower = pRefFrm->Frm().Left() < pFldFrm->Frm().Left() || |
| ( pRefFrm->Frm().Left() == pFldFrm->Frm().Left() && |
| pRefFrm->Frm().Top() < pFldFrm->Frm().Top() ); |
| else |
| bRefIsLower = pRefFrm->Frm().Left() > pFldFrm->Frm().Left() || |
| ( pRefFrm->Frm().Left() == pFldFrm->Frm().Left() && |
| pRefFrm->Frm().Top() < pFldFrm->Frm().Top() ); |
| } |
| else if( bR2L ) |
| bRefIsLower = pRefFrm->Frm().Top() < pFldFrm->Frm().Top() || |
| ( pRefFrm->Frm().Top() == pFldFrm->Frm().Top() && |
| pRefFrm->Frm().Left() > pFldFrm->Frm().Left() ); |
| else |
| bRefIsLower = pRefFrm->Frm().Top() < pFldFrm->Frm().Top() || |
| ( pRefFrm->Frm().Top() == pFldFrm->Frm().Top() && |
| pRefFrm->Frm().Left() < pFldFrm->Frm().Left() ); |
| } |
| return bRefIsLower; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Referenzen holen |
| --------------------------------------------------------------------*/ |
| |
| |
| SwGetRefField::SwGetRefField( SwGetRefFieldType* pFldType, |
| const String& rSetRef, sal_uInt16 nSubTyp, |
| sal_uInt16 nSeqenceNo, sal_uLong nFmt ) |
| : SwField( pFldType, nFmt ), |
| sSetRefName( rSetRef ), |
| nSubType( nSubTyp ), |
| nSeqNo( nSeqenceNo ) |
| { |
| } |
| |
| SwGetRefField::~SwGetRefField() |
| { |
| } |
| |
| String SwGetRefField::GetDescription() const |
| { |
| return SW_RES(STR_REFERENCE); |
| } |
| |
| sal_uInt16 SwGetRefField::GetSubType() const |
| { |
| return nSubType; |
| } |
| |
| void SwGetRefField::SetSubType( sal_uInt16 n ) |
| { |
| nSubType = n; |
| } |
| |
| // --> OD 2007-11-09 #i81002# |
| bool SwGetRefField::IsRefToHeadingCrossRefBookmark() const |
| { |
| return GetSubType() == REF_BOOKMARK && |
| ::sw::mark::CrossRefHeadingBookmark::IsLegalName(sSetRefName); |
| } |
| |
| bool SwGetRefField::IsRefToNumItemCrossRefBookmark() const |
| { |
| return GetSubType() == REF_BOOKMARK && |
| ::sw::mark::CrossRefNumItemBookmark::IsLegalName(sSetRefName); |
| } |
| |
| const SwTxtNode* SwGetRefField::GetReferencedTxtNode() const |
| { |
| SwDoc* pDoc = dynamic_cast<SwGetRefFieldType*>(GetTyp())->GetDoc(); |
| sal_uInt16 nDummy = USHRT_MAX; |
| return SwGetRefFieldType::FindAnchor( pDoc, sSetRefName, nSubType, nSeqNo, &nDummy ); |
| } |
| // <-- |
| // --> OD 2008-01-09 #i85090# |
| String SwGetRefField::GetExpandedTxtOfReferencedTxtNode() const |
| { |
| const SwTxtNode* pReferencedTxtNode( GetReferencedTxtNode() ); |
| return pReferencedTxtNode |
| ? pReferencedTxtNode->GetExpandTxt( 0, STRING_LEN, true, true ) |
| : aEmptyStr; |
| } |
| |
| String SwGetRefField::Expand() const |
| { |
| return sTxt; |
| } |
| |
| |
| String SwGetRefField::GetFieldName() const |
| { |
| String aStr(GetTyp()->GetName()); |
| aStr += ' '; |
| aStr += sSetRefName; |
| return aStr; |
| } |
| |
| void SwGetRefField::UpdateField( const SwTxtFld* pFldTxtAttr ) |
| { |
| sTxt.Erase(); |
| |
| SwDoc* pDoc = ((SwGetRefFieldType*)GetTyp())->GetDoc(); |
| sal_uInt16 nStt = USHRT_MAX; |
| sal_uInt16 nEnd = USHRT_MAX; |
| SwTxtNode* pTxtNd = SwGetRefFieldType::FindAnchor( pDoc, sSetRefName, nSubType, nSeqNo, &nStt, &nEnd ); |
| if ( !pTxtNd ) |
| { |
| sTxt = ViewShell::GetShellRes()->aGetRefFld_RefItemNotFound; |
| return ; |
| } |
| |
| switch( GetFormat() ) |
| { |
| case REF_CONTENT: |
| case REF_ONLYNUMBER: |
| case REF_ONLYCAPTION: |
| case REF_ONLYSEQNO: |
| { |
| switch( nSubType ) |
| { |
| case REF_SEQUENCEFLD: |
| nEnd = pTxtNd->GetTxt().Len(); |
| switch( GetFormat() ) |
| { |
| case REF_ONLYNUMBER: |
| if( nStt + 1 < nEnd ) |
| nEnd = nStt + 1; |
| nStt = 0; |
| break; |
| |
| case REF_ONLYCAPTION: |
| { |
| const SwTxtAttr* const pTxtAttr = pTxtNd->GetTxtAttrForCharAt(nStt, RES_TXTATR_FIELD); |
| if( pTxtAttr != NULL ) |
| nStt = SwGetExpField::GetReferenceTextPos( pTxtAttr->GetFmtFld(), *pDoc ); |
| else if( nStt + 1 < nEnd ) |
| ++nStt; |
| } |
| break; |
| |
| case REF_ONLYSEQNO: |
| if( nStt + 1 < nEnd ) |
| nEnd = nStt + 1; |
| break; |
| |
| default: |
| nStt = 0; |
| break; |
| } |
| break; |
| |
| case REF_BOOKMARK: |
| if( USHRT_MAX == nEnd ) |
| { |
| // Text steht ueber verschiedene Nodes verteilt. |
| // Gesamten Text oder nur bis zum Ende vom Node? |
| nEnd = pTxtNd->GetTxt().Len(); |
| } |
| break; |
| |
| case REF_OUTLINE: |
| break; |
| |
| case REF_FOOTNOTE: |
| case REF_ENDNOTE: |
| { |
| // die Nummer oder den NumString besorgen |
| sal_uInt16 n, nFtnCnt = pDoc->GetFtnIdxs().Count(); |
| SwTxtFtn* pFtnIdx; |
| for( n = 0; n < nFtnCnt; ++n ) |
| if( nSeqNo == (pFtnIdx = pDoc->GetFtnIdxs()[ n ])->GetSeqRefNo() ) |
| { |
| sTxt = pFtnIdx->GetFtn().GetViewNumStr( *pDoc ); |
| break; |
| } |
| nStt = nEnd; // kein Bereich, der String ist fertig |
| } |
| break; |
| } |
| |
| if( nStt != nEnd ) // ein Bereich? |
| { |
| sTxt = pTxtNd->GetExpandTxt( nStt, nEnd - nStt ); |
| |
| // alle Sonderzeichen entfernen (durch Blanks ersetzen): |
| if( sTxt.Len() ) |
| { |
| sTxt.EraseAllChars( 0xad ); |
| for( sal_Unicode* p = sTxt.GetBufferAccess(); *p; ++p ) |
| { |
| if( *p < 0x20 ) |
| *p = 0x20; |
| else if(*p == 0x2011) |
| *p = '-'; |
| } |
| } |
| } |
| } |
| break; |
| |
| case REF_PAGE: |
| case REF_PAGE_PGDESC: |
| { |
| const SwTxtFrm* pFrm = (SwTxtFrm*)pTxtNd->getLayoutFrm( pDoc->GetCurrentLayout(), 0,0,sal_False), |
| *pSave = pFrm; |
| while( pFrm && !pFrm->IsInside( nStt ) ) |
| pFrm = (SwTxtFrm*)pFrm->GetFollow(); |
| |
| if( pFrm || 0 != ( pFrm = pSave )) |
| { |
| sal_uInt16 nPageNo = pFrm->GetVirtPageNum(); |
| const SwPageFrm *pPage; |
| if( REF_PAGE_PGDESC == GetFormat() && |
| 0 != ( pPage = pFrm->FindPageFrm() ) && |
| pPage->GetPageDesc() ) |
| sTxt = pPage->GetPageDesc()->GetNumType().GetNumStr( nPageNo ); |
| else |
| sTxt = String::CreateFromInt32(nPageNo); |
| } |
| } |
| break; |
| |
| case REF_CHAPTER: |
| { |
| // ein bischen trickreich: suche irgend einen Frame |
| const SwFrm* pFrm = pTxtNd->getLayoutFrm( pDoc->GetCurrentLayout() ); |
| if( pFrm ) |
| { |
| SwChapterFieldType aFldTyp; |
| SwChapterField aFld( &aFldTyp, 0 ); |
| aFld.SetLevel( MAXLEVEL - 1 ); |
| aFld.ChangeExpansion( pFrm, pTxtNd, sal_True ); |
| sTxt = aFld.GetNumber(); |
| } |
| } |
| break; |
| |
| case REF_UPDOWN: |
| { |
| // simplified: use parameter <pFldTxtAttr> |
| if( !pFldTxtAttr || !pFldTxtAttr->GetpTxtNode() ) |
| break; |
| |
| LocaleDataWrapper aLocaleData( ::comphelper::getProcessServiceFactory(), SvxCreateLocale( GetLanguage() ) ); |
| |
| // erstmal ein "Kurz" - Test - falls beide im selben |
| // Node stehen! |
| if( pFldTxtAttr->GetpTxtNode() == pTxtNd ) |
| { |
| sTxt = nStt < *pFldTxtAttr->GetStart() |
| ? aLocaleData.getAboveWord() |
| : aLocaleData.getBelowWord(); |
| break; |
| } |
| |
| sTxt = |
| ::IsFrameBehind( *pFldTxtAttr->GetpTxtNode(), *pFldTxtAttr->GetStart(), *pTxtNd, nStt ) |
| ? aLocaleData.getAboveWord() |
| : aLocaleData.getBelowWord(); |
| } |
| break; |
| |
| case REF_NUMBER: |
| case REF_NUMBER_NO_CONTEXT: |
| case REF_NUMBER_FULL_CONTEXT: |
| { |
| if ( pFldTxtAttr && pFldTxtAttr->GetpTxtNode() ) |
| { |
| sTxt = MakeRefNumStr( pFldTxtAttr->GetTxtNode(), *pTxtNd, GetFormat() ); |
| } |
| } |
| break; |
| |
| default: |
| DBG_ERROR("<SwGetRefField::UpdateField(..)> - unknown format type"); |
| } |
| } |
| |
| // --> OD 2007-09-06 #i81002# |
| String SwGetRefField::MakeRefNumStr( const SwTxtNode& rTxtNodeOfField, |
| const SwTxtNode& rTxtNodeOfReferencedItem, |
| const sal_uInt32 nRefNumFormat ) const |
| { |
| if ( rTxtNodeOfReferencedItem.HasNumber() && |
| rTxtNodeOfReferencedItem.IsCountedInList() ) |
| { |
| ASSERT( rTxtNodeOfReferencedItem.GetNum(), |
| "<SwGetRefField::MakeRefNumStr(..)> - referenced paragraph has number, but no <SwNodeNum> instance --> please inform OD!" ); |
| |
| // Determine, up to which level the superior list labels have to be |
| // included - default is to include all superior list labels. |
| sal_uInt8 nRestrictInclToThisLevel( 0 ); |
| // Determine for format REF_NUMBER the level, up to which the superior |
| // list labels have to be restricted, if the text node of the reference |
| // field and the text node of the referenced item are in the same |
| // document context. |
| if ( nRefNumFormat == REF_NUMBER && |
| rTxtNodeOfField.FindFlyStartNode() |
| == rTxtNodeOfReferencedItem.FindFlyStartNode() && |
| rTxtNodeOfField.FindFootnoteStartNode() |
| == rTxtNodeOfReferencedItem.FindFootnoteStartNode() && |
| rTxtNodeOfField.FindHeaderStartNode() |
| == rTxtNodeOfReferencedItem.FindHeaderStartNode() && |
| rTxtNodeOfField.FindFooterStartNode() |
| == rTxtNodeOfReferencedItem.FindFooterStartNode() ) |
| { |
| const SwNodeNum* pNodeNumForTxtNodeOfField( 0 ); |
| if ( rTxtNodeOfField.HasNumber() && |
| rTxtNodeOfField.GetNumRule() == rTxtNodeOfReferencedItem.GetNumRule() ) |
| { |
| pNodeNumForTxtNodeOfField = rTxtNodeOfField.GetNum(); |
| } |
| else |
| { |
| pNodeNumForTxtNodeOfField = |
| rTxtNodeOfReferencedItem.GetNum()->GetPrecedingNodeNumOf( rTxtNodeOfField ); |
| } |
| if ( pNodeNumForTxtNodeOfField ) |
| { |
| const SwNumberTree::tNumberVector rFieldNumVec = pNodeNumForTxtNodeOfField->GetNumberVector(); |
| const SwNumberTree::tNumberVector rRefItemNumVec = rTxtNodeOfReferencedItem.GetNum()->GetNumberVector(); |
| sal_uInt8 nLevel( 0 ); |
| while ( nLevel < rFieldNumVec.size() && nLevel < rRefItemNumVec.size() ) |
| { |
| if ( rRefItemNumVec[nLevel] == rFieldNumVec[nLevel] ) |
| { |
| nRestrictInclToThisLevel = nLevel + 1; |
| } |
| else |
| { |
| break; |
| } |
| ++nLevel; |
| } |
| } |
| } |
| |
| // Determine, if superior list labels have to be included |
| const bool bInclSuperiorNumLabels( |
| ( nRestrictInclToThisLevel < rTxtNodeOfReferencedItem.GetActualListLevel() && |
| ( nRefNumFormat == REF_NUMBER || nRefNumFormat == REF_NUMBER_FULL_CONTEXT ) ) ); |
| |
| ASSERT( rTxtNodeOfReferencedItem.GetNumRule(), |
| "<SwGetRefField::MakeRefNumStr(..)> - referenced numbered paragraph has no numbering rule set --> please inform OD!" ); |
| return rTxtNodeOfReferencedItem.GetNumRule()->MakeRefNumString( |
| *(rTxtNodeOfReferencedItem.GetNum()), |
| bInclSuperiorNumLabels, |
| nRestrictInclToThisLevel ); |
| } |
| |
| return String(); |
| } |
| // <-- |
| |
| SwField* SwGetRefField::Copy() const |
| { |
| SwGetRefField* pFld = new SwGetRefField( (SwGetRefFieldType*)GetTyp(), |
| sSetRefName, nSubType, |
| nSeqNo, GetFormat() ); |
| pFld->sTxt = sTxt; |
| return pFld; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: ReferenzName holen |
| --------------------------------------------------------------------*/ |
| |
| |
| const String& SwGetRefField::GetPar1() const |
| { |
| return sSetRefName; |
| } |
| |
| |
| void SwGetRefField::SetPar1( const String& rName ) |
| { |
| sSetRefName = rName; |
| } |
| |
| |
| String SwGetRefField::GetPar2() const |
| { |
| return Expand(); |
| } |
| |
| sal_Bool SwGetRefField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const |
| { |
| switch( nWhichId ) |
| { |
| case FIELD_PROP_USHORT1: |
| { |
| sal_Int16 nPart = 0; |
| switch(GetFormat()) |
| { |
| case REF_PAGE : nPart = ReferenceFieldPart::PAGE ; break; |
| case REF_CHAPTER : nPart = ReferenceFieldPart::CHAPTER ; break; |
| case REF_CONTENT : nPart = ReferenceFieldPart::TEXT ; break; |
| case REF_UPDOWN : nPart = ReferenceFieldPart::UP_DOWN ; break; |
| case REF_PAGE_PGDESC: nPart = ReferenceFieldPart::PAGE_DESC ; break; |
| case REF_ONLYNUMBER : nPart = ReferenceFieldPart::CATEGORY_AND_NUMBER ; break; |
| case REF_ONLYCAPTION: nPart = ReferenceFieldPart::ONLY_CAPTION ; break; |
| case REF_ONLYSEQNO : nPart = ReferenceFieldPart::ONLY_SEQUENCE_NUMBER; break; |
| // --> OD 2007-09-06 #i81002# |
| case REF_NUMBER: nPart = ReferenceFieldPart::NUMBER; break; |
| case REF_NUMBER_NO_CONTEXT: nPart = ReferenceFieldPart::NUMBER_NO_CONTEXT; break; |
| case REF_NUMBER_FULL_CONTEXT: nPart = ReferenceFieldPart::NUMBER_FULL_CONTEXT; break; |
| // <-- |
| } |
| rAny <<= nPart; |
| } |
| break; |
| case FIELD_PROP_USHORT2: |
| { |
| sal_Int16 nSource = 0; |
| switch(nSubType) |
| { |
| case REF_SETREFATTR : nSource = ReferenceFieldSource::REFERENCE_MARK; break; |
| case REF_SEQUENCEFLD: nSource = ReferenceFieldSource::SEQUENCE_FIELD; break; |
| case REF_BOOKMARK : nSource = ReferenceFieldSource::BOOKMARK; break; |
| case REF_OUTLINE : DBG_ERROR("not implemented"); break; |
| case REF_FOOTNOTE : nSource = ReferenceFieldSource::FOOTNOTE; break; |
| case REF_ENDNOTE : nSource = ReferenceFieldSource::ENDNOTE; break; |
| } |
| rAny <<= nSource; |
| } |
| break; |
| case FIELD_PROP_PAR1: |
| { |
| String sTmp(GetPar1()); |
| if(REF_SEQUENCEFLD == nSubType) |
| { |
| sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( sTmp, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ); |
| switch( nPoolId ) |
| { |
| case RES_POOLCOLL_LABEL_ABB: |
| case RES_POOLCOLL_LABEL_TABLE: |
| case RES_POOLCOLL_LABEL_FRAME: |
| case RES_POOLCOLL_LABEL_DRAWING: |
| SwStyleNameMapper::FillProgName(nPoolId, sTmp) ; |
| break; |
| } |
| } |
| rAny <<= rtl::OUString(sTmp); |
| } |
| break; |
| case FIELD_PROP_PAR3: |
| rAny <<= rtl::OUString(Expand()); |
| break; |
| case FIELD_PROP_SHORT1: |
| rAny <<= (sal_Int16)nSeqNo; |
| break; |
| default: |
| DBG_ERROR("illegal property"); |
| } |
| return sal_True; |
| } |
| |
| sal_Bool SwGetRefField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId ) |
| { |
| String sTmp; |
| switch( nWhichId ) |
| { |
| case FIELD_PROP_USHORT1: |
| { |
| sal_Int16 nPart = 0; |
| rAny >>= nPart; |
| switch(nPart) |
| { |
| case ReferenceFieldPart::PAGE: nPart = REF_PAGE; break; |
| case ReferenceFieldPart::CHAPTER: nPart = REF_CHAPTER; break; |
| case ReferenceFieldPart::TEXT: nPart = REF_CONTENT; break; |
| case ReferenceFieldPart::UP_DOWN: nPart = REF_UPDOWN; break; |
| case ReferenceFieldPart::PAGE_DESC: nPart = REF_PAGE_PGDESC; break; |
| case ReferenceFieldPart::CATEGORY_AND_NUMBER: nPart = REF_ONLYNUMBER; break; |
| case ReferenceFieldPart::ONLY_CAPTION: nPart = REF_ONLYCAPTION; break; |
| case ReferenceFieldPart::ONLY_SEQUENCE_NUMBER : nPart = REF_ONLYSEQNO; break; |
| // --> OD 2007-09-06 #i81002# |
| case ReferenceFieldPart::NUMBER: nPart = REF_NUMBER; break; |
| case ReferenceFieldPart::NUMBER_NO_CONTEXT: nPart = REF_NUMBER_NO_CONTEXT; break; |
| case ReferenceFieldPart::NUMBER_FULL_CONTEXT: nPart = REF_NUMBER_FULL_CONTEXT; break; |
| // <-- |
| default: return sal_False; |
| } |
| SetFormat(nPart); |
| } |
| break; |
| case FIELD_PROP_USHORT2: |
| { |
| sal_Int16 nSource = 0; |
| rAny >>= nSource; |
| switch(nSource) |
| { |
| case ReferenceFieldSource::REFERENCE_MARK : nSubType = REF_SETREFATTR ; break; |
| case ReferenceFieldSource::SEQUENCE_FIELD : |
| { |
| if(REF_SEQUENCEFLD == nSubType) |
| break; |
| nSubType = REF_SEQUENCEFLD; |
| ConvertProgrammaticToUIName(); |
| } |
| break; |
| case ReferenceFieldSource::BOOKMARK : nSubType = REF_BOOKMARK ; break; |
| case ReferenceFieldSource::FOOTNOTE : nSubType = REF_FOOTNOTE ; break; |
| case ReferenceFieldSource::ENDNOTE : nSubType = REF_ENDNOTE ; break; |
| } |
| } |
| break; |
| case FIELD_PROP_PAR1: |
| { |
| OUString sTmpStr; |
| rAny >>= sTmpStr; |
| SetPar1(sTmpStr); |
| ConvertProgrammaticToUIName(); |
| } |
| break; |
| case FIELD_PROP_PAR3: |
| SetExpand( ::GetString( rAny, sTmp )); |
| break; |
| case FIELD_PROP_SHORT1: |
| { |
| sal_Int16 nSetSeq = 0; |
| rAny >>= nSetSeq; |
| if(nSetSeq >= 0) |
| nSeqNo = nSetSeq; |
| } |
| break; |
| default: |
| DBG_ERROR("illegal property"); |
| } |
| return sal_True; |
| } |
| |
| void SwGetRefField::ConvertProgrammaticToUIName() |
| { |
| if(GetTyp() && REF_SEQUENCEFLD == nSubType) |
| { |
| SwDoc* pDoc = ((SwGetRefFieldType*)GetTyp())->GetDoc(); |
| const String& rPar1 = GetPar1(); |
| //don't convert when the name points to an existing field type |
| if(!pDoc->GetFldType(RES_SETEXPFLD, rPar1, false)) |
| { |
| sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromProgName( rPar1, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ); |
| sal_uInt16 nResId = USHRT_MAX; |
| switch( nPoolId ) |
| { |
| case RES_POOLCOLL_LABEL_ABB: |
| nResId = STR_POOLCOLL_LABEL_ABB; |
| break; |
| case RES_POOLCOLL_LABEL_TABLE: |
| nResId = STR_POOLCOLL_LABEL_TABLE; |
| break; |
| case RES_POOLCOLL_LABEL_FRAME: |
| nResId = STR_POOLCOLL_LABEL_FRAME; |
| break; |
| case RES_POOLCOLL_LABEL_DRAWING: |
| nResId = STR_POOLCOLL_LABEL_DRAWING; |
| break; |
| } |
| if( nResId != USHRT_MAX ) |
| SetPar1(SW_RESSTR( nResId )); |
| } |
| } |
| } |
| |
| SwGetRefFieldType::SwGetRefFieldType( SwDoc* pDc ) |
| : SwFieldType( RES_GETREFFLD ), pDoc( pDc ) |
| {} |
| |
| |
| SwFieldType* SwGetRefFieldType::Copy() const |
| { |
| return new SwGetRefFieldType( pDoc ); |
| } |
| |
| |
| void SwGetRefFieldType::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew ) |
| { |
| // Update auf alle GetReferenz-Felder |
| if( !pNew && !pOld ) |
| { |
| SwIterator<SwFmtFld,SwFieldType> aIter( *this ); |
| for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) |
| { |
| // nur die GetRef-Felder Updaten |
| //JP 3.4.2001: Task 71231 - we need the correct language |
| SwGetRefField* pGRef = (SwGetRefField*)pFmtFld->GetField(); |
| const SwTxtFld* pTFld; |
| if( !pGRef->GetLanguage() && |
| 0 != ( pTFld = pFmtFld->GetTxtFld()) && |
| pTFld->GetpTxtNode() ) |
| { |
| pGRef->SetLanguage( pTFld->GetpTxtNode()->GetLang( |
| *pTFld->GetStart() ) ); |
| } |
| |
| pGRef->UpdateField( pFmtFld->GetTxtFld() ); |
| } |
| } |
| // weiter an die Text-Felder, diese "Expandieren" den Text |
| NotifyClients( pOld, pNew ); |
| } |
| |
| SwTxtNode* SwGetRefFieldType::FindAnchor( SwDoc* pDoc, const String& rRefMark, |
| sal_uInt16 nSubType, sal_uInt16 nSeqNo, |
| sal_uInt16* pStt, sal_uInt16* pEnd ) |
| { |
| ASSERT( pStt, "warum wird keine StartPos abgefragt?" ); |
| |
| SwTxtNode* pTxtNd = 0; |
| switch( nSubType ) |
| { |
| case REF_SETREFATTR: |
| { |
| const SwFmtRefMark *pRef = pDoc->GetRefMark( rRefMark ); |
| if( pRef && pRef->GetTxtRefMark() ) |
| { |
| pTxtNd = (SwTxtNode*)&pRef->GetTxtRefMark()->GetTxtNode(); |
| *pStt = *pRef->GetTxtRefMark()->GetStart(); |
| if( pEnd ) |
| *pEnd = *pRef->GetTxtRefMark()->GetAnyEnd(); |
| } |
| } |
| break; |
| |
| case REF_SEQUENCEFLD: |
| { |
| SwFieldType* pFldType = pDoc->GetFldType( RES_SETEXPFLD, rRefMark, false ); |
| if( pFldType && pFldType->GetDepends() && |
| nsSwGetSetExpType::GSE_SEQ & ((SwSetExpFieldType*)pFldType)->GetType() ) |
| { |
| SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); |
| for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) |
| { |
| if( pFmtFld->GetTxtFld() && nSeqNo == |
| ((SwSetExpField*)pFmtFld->GetField())->GetSeqNumber() ) |
| { |
| SwTxtFld* pTxtFld = pFmtFld->GetTxtFld(); |
| pTxtNd = (SwTxtNode*)pTxtFld->GetpTxtNode(); |
| *pStt = *pTxtFld->GetStart(); |
| if( pEnd ) |
| *pEnd = (*pStt) + 1; |
| break; |
| } |
| } |
| } |
| } |
| break; |
| |
| case REF_BOOKMARK: |
| { |
| IDocumentMarkAccess::const_iterator_t ppMark = pDoc->getIDocumentMarkAccess()->findMark(rRefMark); |
| if(ppMark != pDoc->getIDocumentMarkAccess()->getAllMarksEnd()) |
| { |
| const ::sw::mark::IMark* pBkmk = ppMark->get(); |
| const SwPosition* pPos = &pBkmk->GetMarkStart(); |
| |
| pTxtNd = pPos->nNode.GetNode().GetTxtNode(); |
| *pStt = pPos->nContent.GetIndex(); |
| if(pEnd) |
| { |
| if(!pBkmk->IsExpanded()) |
| { |
| *pEnd = *pStt; |
| // --> OD 2007-10-18 #i81002# |
| if(dynamic_cast< ::sw::mark::CrossRefBookmark const *>(pBkmk)) |
| { |
| ASSERT( pTxtNd, |
| "<SwGetRefFieldType::FindAnchor(..)> - node marked by cross-reference bookmark isn't a text node --> crash" ); |
| *pEnd = pTxtNd->Len(); |
| } |
| // <-- |
| } |
| else if(pBkmk->GetOtherMarkPos().nNode == pBkmk->GetMarkPos().nNode) |
| *pEnd = pBkmk->GetMarkEnd().nContent.GetIndex(); |
| else |
| *pEnd = USHRT_MAX; |
| } |
| } |
| } |
| break; |
| |
| case REF_OUTLINE: |
| break; |
| |
| case REF_FOOTNOTE: |
| case REF_ENDNOTE: |
| { |
| sal_uInt16 n, nFtnCnt = pDoc->GetFtnIdxs().Count(); |
| SwTxtFtn* pFtnIdx; |
| for( n = 0; n < nFtnCnt; ++n ) |
| if( nSeqNo == (pFtnIdx = pDoc->GetFtnIdxs()[ n ])->GetSeqRefNo() ) |
| { |
| SwNodeIndex* pIdx = pFtnIdx->GetStartNode(); |
| if( pIdx ) |
| { |
| SwNodeIndex aIdx( *pIdx, 1 ); |
| if( 0 == ( pTxtNd = aIdx.GetNode().GetTxtNode())) |
| pTxtNd = (SwTxtNode*)pDoc->GetNodes().GoNext( &aIdx ); |
| } |
| *pStt = 0; |
| if( pEnd ) |
| *pEnd = 0; |
| break; |
| } |
| } |
| break; |
| } |
| |
| return pTxtNd; |
| } |
| |
| |
| struct _RefIdsMap |
| { |
| String aName; |
| SvUShortsSort aIds, aDstIds, aIdsMap; |
| SvUShorts aMap; |
| sal_Bool bInit; |
| |
| _RefIdsMap( const String& rName ) |
| : aName( rName ), aIds( 16, 16 ), aIdsMap( 16, 16 ), aMap( 16, 16 ), |
| bInit( sal_False ) |
| {} |
| |
| void Check( SwDoc& rDoc, SwDoc& rDestDoc, SwGetRefField& rFld, |
| sal_Bool bField = sal_True ); |
| |
| sal_Bool IsInit() const { return bInit; } |
| }; |
| |
| SV_DECL_PTRARR_DEL( _RefIdsMaps, _RefIdsMap*, 5, 5 ) |
| SV_IMPL_PTRARR( _RefIdsMaps, _RefIdsMap* ) |
| |
| void _RefIdsMap::Check( SwDoc& rDoc, SwDoc& rDestDoc, SwGetRefField& rFld, |
| sal_Bool bField ) |
| { |
| |
| if( !bInit ) |
| { |
| if( bField ) |
| { |
| const SwTxtNode* pNd; |
| SwFieldType* pType; |
| if( 0 != ( pType = rDestDoc.GetFldType( RES_SETEXPFLD, aName, false ) )) |
| { |
| SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); |
| for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() ) |
| if( pF->GetTxtFld() && |
| 0 != ( pNd = pF->GetTxtFld()->GetpTxtNode() ) && |
| pNd->GetNodes().IsDocNodes() ) |
| aIds.Insert( ((SwSetExpField*)pF->GetField())->GetSeqNumber() ); |
| } |
| if( 0 != ( pType = rDoc.GetFldType( RES_SETEXPFLD, aName, false ) )) |
| { |
| SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); |
| for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() ) |
| if( pF->GetTxtFld() && |
| 0 != ( pNd = pF->GetTxtFld()->GetpTxtNode() ) && |
| pNd->GetNodes().IsDocNodes() ) |
| aDstIds.Insert( ((SwSetExpField*)pF->GetField())->GetSeqNumber() ); |
| } |
| } |
| else |
| { |
| sal_uInt16 n; |
| |
| for( n = rDestDoc.GetFtnIdxs().Count(); n; ) |
| aIds.Insert( rDestDoc.GetFtnIdxs()[ --n ]->GetSeqRefNo() ); |
| for( n = rDoc.GetFtnIdxs().Count(); n; ) |
| aDstIds.Insert( rDoc.GetFtnIdxs()[ --n ]->GetSeqRefNo() ); |
| } |
| bInit = sal_True; |
| } |
| |
| // dann teste mal, ob die Nummer schon vergeben ist |
| // oder ob eine neue bestimmt werden muss. |
| sal_uInt16 nPos, nSeqNo = rFld.GetSeqNo(); |
| if( aIds.Seek_Entry( nSeqNo ) && aDstIds.Seek_Entry( nSeqNo )) |
| { |
| // ist schon vergeben, also muss eine neue |
| // erzeugt werden. |
| if( aIdsMap.Seek_Entry( nSeqNo, &nPos )) |
| rFld.SetSeqNo( aMap[ nPos ] ); |
| else |
| { |
| sal_uInt16 n; |
| |
| for( n = 0; n < aIds.Count(); ++n ) |
| if( n != aIds[ n ] ) |
| break; |
| |
| // die neue SeqNo eintragen, damit die "belegt" ist |
| aIds.Insert( n ); |
| aIdsMap.Insert( nSeqNo, nPos ); |
| aMap.Insert( n, nPos ); |
| rFld.SetSeqNo( n ); |
| |
| // und noch die Felder oder Fuss-/EndNote auf die neue |
| // Id umsetzen |
| if( bField ) |
| { |
| SwFieldType* pType = rDoc.GetFldType( RES_SETEXPFLD, aName, false ); |
| if( pType ) |
| { |
| SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); |
| for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() ) |
| if( pF->GetTxtFld() && nSeqNo == |
| ((SwSetExpField*)pF->GetField())->GetSeqNumber() ) |
| ((SwSetExpField*)pF->GetField())->SetSeqNumber( n ); |
| } |
| } |
| else |
| { |
| SwTxtFtn* pFtnIdx; |
| for( sal_uInt16 i = 0, nCnt = rDoc.GetFtnIdxs().Count(); i < nCnt; ++i ) |
| if( nSeqNo == (pFtnIdx = rDoc.GetFtnIdxs()[ i ])->GetSeqRefNo() ) |
| { |
| pFtnIdx->SetSeqNo( n ); |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| aIds.Insert( nSeqNo ); |
| aIdsMap.Insert( nSeqNo, nPos ); |
| aMap.Insert( nSeqNo, nPos ); |
| } |
| } |
| |
| |
| void SwGetRefFieldType::MergeWithOtherDoc( SwDoc& rDestDoc ) |
| { |
| if( &rDestDoc != pDoc && |
| rDestDoc.GetSysFldType( RES_GETREFFLD )->GetDepends() ) |
| { |
| // dann gibt es im DestDoc RefFelder, also muessen im SourceDoc |
| // alle RefFelder auf einduetige Ids in beiden Docs umgestellt |
| // werden. |
| _RefIdsMap aFntMap( aEmptyStr ); |
| _RefIdsMaps aFldMap; |
| |
| SwIterator<SwFmtFld,SwFieldType> aIter( *this ); |
| for( SwFmtFld* pFld = aIter.First(); pFld; pFld = aIter.Next() ) |
| { |
| SwGetRefField& rRefFld = *(SwGetRefField*)pFld->GetField(); |
| switch( rRefFld.GetSubType() ) |
| { |
| case REF_SEQUENCEFLD: |
| { |
| _RefIdsMap* pMap = 0; |
| for( sal_uInt16 n = aFldMap.Count(); n; ) |
| if( aFldMap[ --n ]->aName == rRefFld.GetSetRefName() ) |
| { |
| pMap = aFldMap[ n ]; |
| break; |
| } |
| if( !pMap ) |
| { |
| pMap = new _RefIdsMap( rRefFld.GetSetRefName() ); |
| aFldMap.C40_INSERT( _RefIdsMap, pMap, aFldMap.Count() ); |
| } |
| |
| pMap->Check( *pDoc, rDestDoc, rRefFld, sal_True ); |
| } |
| break; |
| |
| case REF_FOOTNOTE: |
| case REF_ENDNOTE: |
| aFntMap.Check( *pDoc, rDestDoc, rRefFld, sal_False ); |
| break; |
| } |
| } |
| } |
| } |
| |
