| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| #include <editeng/brkitem.hxx> |
| |
| #define _ZFORLIST_DECLARE_TABLE |
| #include <hintids.hxx> |
| #include <fmtpdsc.hxx> |
| #include <fmtanchr.hxx> |
| #include <fmtcntnt.hxx> |
| #include <doc.hxx> |
| #include <IDocumentUndoRedo.hxx> |
| #include <pam.hxx> |
| #include <ndtxt.hxx> |
| #include <fldbas.hxx> |
| #include <swtable.hxx> |
| #include <ddefld.hxx> |
| #include <undobj.hxx> |
| #include <IMark.hxx> |
| #include <mvsave.hxx> |
| #include <cellatr.hxx> |
| #include <swtblfmt.hxx> |
| #include <swddetbl.hxx> |
| #include <docary.hxx> |
| #include <fmtcnct.hxx> |
| #include <redline.hxx> |
| #include <paratr.hxx> |
| #include <pagedesc.hxx> |
| #include <poolfmt.hxx> |
| #include <SwNodeNum.hxx> |
| #ifndef DBG_UTIL |
| #define CHECK_TABLE(t) |
| #else |
| #ifdef DEBUG |
| #define CHECK_TABLE(t) (t).CheckConsistency(); |
| #else |
| #define CHECK_TABLE(t) |
| #endif |
| #endif |
| |
| namespace |
| { |
| /* |
| The lcl_CopyBookmarks function has to copy bookmarks from the source to the destination nodes |
| array. It is called after a call of the _CopyNodes(..) function. But this function does not copy |
| every node (at least at the moment: 2/08/2006 ), section start and end nodes will not be copied if the corresponding end/start node is outside the copied pam. |
| The lcl_NonCopyCount function counts the number of these nodes, given the copied pam and a node |
| index inside the pam. |
| rPam is the original source pam, rLastIdx is the last calculated position, rDelCount the number |
| of "non-copy" nodes between rPam.Start() and rLastIdx. |
| nNewIdx is the new position of interest. |
| */ |
| |
| static void lcl_NonCopyCount( const SwPaM& rPam, SwNodeIndex& rLastIdx, const sal_uLong nNewIdx, sal_uLong& rDelCount ) |
| { |
| sal_uLong nStart = rPam.Start()->nNode.GetIndex(); |
| sal_uLong nEnd = rPam.End()->nNode.GetIndex(); |
| if( rLastIdx.GetIndex() < nNewIdx ) // Moving forward? |
| { |
| do // count "non-copy" nodes |
| { |
| SwNode& rNode = rLastIdx.GetNode(); |
| if( ( rNode.IsSectionNode() && rNode.EndOfSectionIndex() >= nEnd ) |
| || ( rNode.IsEndNode() && rNode.StartOfSectionNode()->GetIndex() < nStart ) ) |
| ++rDelCount; |
| rLastIdx++; |
| } |
| while( rLastIdx.GetIndex() < nNewIdx ); |
| } |
| else if( rDelCount ) // optimization: if there are no "non-copy" nodes until now, |
| // no move backward needed |
| { |
| while( rLastIdx.GetIndex() > nNewIdx ) |
| { |
| SwNode& rNode = rLastIdx.GetNode(); |
| if( ( rNode.IsSectionNode() && rNode.EndOfSectionIndex() >= nEnd ) |
| || ( rNode.IsEndNode() && rNode.StartOfSectionNode()->GetIndex() < nStart ) ) |
| --rDelCount; |
| rLastIdx--; |
| } |
| } |
| } |
| |
| static void lcl_SetCpyPos( const SwPosition& rOrigPos, |
| const SwPosition& rOrigStt, |
| const SwPosition& rCpyStt, |
| SwPosition& rChgPos, |
| sal_uLong nDelCount ) |
| { |
| sal_uLong nNdOff = rOrigPos.nNode.GetIndex(); |
| nNdOff -= rOrigStt.nNode.GetIndex(); |
| nNdOff -= nDelCount; |
| xub_StrLen nCntntPos = rOrigPos.nContent.GetIndex(); |
| |
| // --> OD, AMA 2008-07-07 #b6713815# |
| // Always adjust <nNode> at to be changed <SwPosition> instance <rChgPos> |
| rChgPos.nNode = nNdOff + rCpyStt.nNode.GetIndex(); |
| if( !nNdOff ) |
| // <-- |
| { |
| // dann nur den Content anpassen |
| if( nCntntPos > rOrigStt.nContent.GetIndex() ) |
| nCntntPos = nCntntPos - rOrigStt.nContent.GetIndex(); |
| else |
| nCntntPos = 0; |
| nCntntPos = nCntntPos + rCpyStt.nContent.GetIndex(); |
| } |
| rChgPos.nContent.Assign( rChgPos.nNode.GetNode().GetCntntNode(), nCntntPos ); |
| } |
| |
| // TODO: use SaveBookmark (from _DelBookmarks) |
| static void lcl_CopyBookmarks( |
| const SwPaM& rPam, |
| SwPaM& rCpyPam ) |
| { |
| const SwDoc* pSrcDoc = rPam.GetDoc(); |
| SwDoc* pDestDoc = rCpyPam.GetDoc(); |
| const IDocumentMarkAccess* const pSrcMarkAccess = pSrcDoc->getIDocumentMarkAccess(); |
| ::sw::UndoGuard const undoGuard(pDestDoc->GetIDocumentUndoRedo()); |
| |
| const SwPosition &rStt = *rPam.Start(), &rEnd = *rPam.End(); |
| SwPosition* pCpyStt = rCpyPam.Start(); |
| |
| typedef ::std::vector< const ::sw::mark::IMark* > mark_vector_t; |
| mark_vector_t vMarksToCopy; |
| for ( IDocumentMarkAccess::const_iterator_t ppMark = pSrcMarkAccess->getAllMarksBegin(); |
| ppMark != pSrcMarkAccess->getAllMarksEnd(); |
| ppMark++ ) |
| { |
| const ::sw::mark::IMark* const pMark = ppMark->get(); |
| |
| const SwPosition& rMarkStart = pMark->GetMarkStart(); |
| const SwPosition& rMarkEnd = pMark->GetMarkEnd(); |
| // only include marks that are in the range and not touching both start and end |
| // - not for annotation marks. |
| const bool bIsNotOnBoundary = |
| pMark->IsExpanded() |
| ? (rMarkStart != rStt || rMarkEnd != rEnd) // rMarkStart != rMarkEnd |
| : (rMarkStart != rStt && rMarkEnd != rEnd); // rMarkStart == rMarkEnd |
| if ( rMarkStart >= rStt && rMarkEnd <= rEnd |
| && ( bIsNotOnBoundary |
| || IDocumentMarkAccess::GetType( *pMark ) == IDocumentMarkAccess::ANNOTATIONMARK ) ) |
| { |
| vMarksToCopy.push_back(pMark); |
| } |
| } |
| // We have to count the "non-copied" nodes.. |
| SwNodeIndex aCorrIdx(rStt.nNode); |
| sal_uLong nDelCount = 0; |
| for(mark_vector_t::const_iterator ppMark = vMarksToCopy.begin(); |
| ppMark != vMarksToCopy.end(); |
| ++ppMark) |
| { |
| const ::sw::mark::IMark* const pMark = *ppMark; |
| SwPaM aTmpPam(*pCpyStt); |
| lcl_NonCopyCount(rPam, aCorrIdx, pMark->GetMarkPos().nNode.GetIndex(), nDelCount); |
| lcl_SetCpyPos( pMark->GetMarkPos(), rStt, *pCpyStt, *aTmpPam.GetPoint(), nDelCount); |
| if(pMark->IsExpanded()) |
| { |
| aTmpPam.SetMark(); |
| lcl_NonCopyCount(rPam, aCorrIdx, pMark->GetOtherMarkPos().nNode.GetIndex(), nDelCount); |
| lcl_SetCpyPos(pMark->GetOtherMarkPos(), rStt, *pCpyStt, *aTmpPam.GetMark(), nDelCount); |
| } |
| |
| ::sw::mark::IMark* const pNewMark = pDestDoc->getIDocumentMarkAccess()->makeMark( |
| aTmpPam, |
| pMark->GetName(), |
| IDocumentMarkAccess::GetType(*pMark)); |
| // Explicitly try to get exactly the same name as in the source |
| // because NavigatorReminders, DdeBookmarks etc. ignore the proposed name |
| pDestDoc->getIDocumentMarkAccess()->renameMark(pNewMark, pMark->GetName()); |
| ::sw::mark::IBookmark* const pNewBookmark = |
| dynamic_cast< ::sw::mark::IBookmark* const >(pNewMark); |
| if(pNewBookmark) /* copying additional attributes for bookmarks */ |
| { |
| const ::sw::mark::IBookmark* const pOldBookmark = dynamic_cast< const ::sw::mark::IBookmark* >(pMark); |
| pNewBookmark->SetKeyCode(pOldBookmark->GetKeyCode()); |
| pNewBookmark->SetShortName(pOldBookmark->GetShortName()); |
| } |
| ::sfx2::Metadatable const*const pMetadatable( |
| dynamic_cast< ::sfx2::Metadatable const* >(pMark)); |
| ::sfx2::Metadatable *const pNewMetadatable( |
| dynamic_cast< ::sfx2::Metadatable * >(pNewMark)); |
| if (pMetadatable && pNewMetadatable) |
| { |
| pNewMetadatable->RegisterAsCopyOf(*pMetadatable); |
| } |
| } |
| } |
| } |
| |
| // Struktur fuer das Mappen von alten und neuen Frame-Formaten an den |
| // Boxen und Lines einer Tabelle |
| |
| struct _MapTblFrmFmt |
| { |
| const SwFrmFmt *pOld, *pNew; |
| _MapTblFrmFmt( const SwFrmFmt *pOldFmt, const SwFrmFmt*pNewFmt ) |
| : pOld( pOldFmt ), pNew( pNewFmt ) |
| {} |
| }; |
| |
| SV_DECL_VARARR( _MapTblFrmFmts, _MapTblFrmFmt, 0, 10 ) |
| SV_IMPL_VARARR( _MapTblFrmFmts, _MapTblFrmFmt ); |
| |
| SwCntntNode* SwTxtNode::MakeCopy( SwDoc* pDoc, const SwNodeIndex& rIdx ) const |
| { |
| // the Copy-Textnode is the Node with the Text, the Copy-Attrnode is the |
| // node with the collection and hard attributes. Normally ist the same |
| // node, but if insert a glossary without formatting, then the Attrnode |
| // is the prev node of the destionation position in dest. document. |
| SwTxtNode* pCpyTxtNd = (SwTxtNode*)this; |
| SwTxtNode* pCpyAttrNd = pCpyTxtNd; |
| |
| // kopiere die Formate in das andere Dokument: |
| SwTxtFmtColl* pColl = 0; |
| if( pDoc->IsInsOnlyTextGlossary() ) |
| { |
| SwNodeIndex aIdx( rIdx, -1 ); |
| if( aIdx.GetNode().IsTxtNode() ) |
| { |
| pCpyAttrNd = aIdx.GetNode().GetTxtNode(); |
| pColl = &pCpyAttrNd->GetTxtColl()->GetNextTxtFmtColl(); |
| } |
| } |
| if( !pColl ) |
| pColl = pDoc->CopyTxtColl( *GetTxtColl() ); |
| |
| SwTxtNode* pTxtNd = pDoc->GetNodes().MakeTxtNode( rIdx, pColl ); |
| |
| // METADATA: register copy |
| pTxtNd->RegisterAsCopyOf(*pCpyTxtNd); |
| |
| // kopiere Attribute/Text |
| if( !pCpyAttrNd->HasSwAttrSet() ) |
| // wurde ein AttrSet fuer die Numerierung angelegt, so loesche diesen! |
| pTxtNd->ResetAllAttr(); |
| |
| // if Copy-Textnode unequal to Copy-Attrnode, then copy first |
| // the attributes into the new Node. |
| if( pCpyAttrNd != pCpyTxtNd ) |
| { |
| pCpyAttrNd->CopyAttr( pTxtNd, 0, 0 ); |
| if( pCpyAttrNd->HasSwAttrSet() ) |
| { |
| SwAttrSet aSet( *pCpyAttrNd->GetpSwAttrSet() ); |
| aSet.ClearItem( RES_PAGEDESC ); |
| aSet.ClearItem( RES_BREAK ); |
| aSet.CopyToModify( *pTxtNd ); |
| } |
| } |
| |
| // ??? reicht das ??? was ist mit PostIts/Feldern/FeldTypen ??? |
| // --> OD 2008-11-18 #i96213# - force copy of all attributes |
| pCpyTxtNd->CopyText( pTxtNd, SwIndex( pCpyTxtNd ), |
| pCpyTxtNd->GetTxt().Len(), true ); |
| // <-- |
| |
| //FEATURE::CONDCOLL |
| if( RES_CONDTXTFMTCOLL == pColl->Which() ) |
| pTxtNd->ChkCondColl(); |
| //FEATURE::CONDCOLL |
| |
| return pTxtNd; |
| } |
| |
| |
| sal_Bool lcl_SrchNew( const _MapTblFrmFmt& rMap, void * pPara ) |
| { |
| if( rMap.pOld != *(const SwFrmFmt**)pPara ) |
| return sal_True; |
| *((const SwFrmFmt**)pPara) = rMap.pNew; |
| return sal_False; // abbrechen, Pointer gefunden |
| } |
| |
| |
| struct _CopyTable |
| { |
| SwDoc* pDoc; |
| sal_uLong nOldTblSttIdx; |
| _MapTblFrmFmts& rMapArr; |
| SwTableLine* pInsLine; |
| SwTableBox* pInsBox; |
| SwTableNode *pTblNd; |
| const SwTable *pOldTable; |
| |
| _CopyTable( SwDoc* pDc, _MapTblFrmFmts& rArr, sal_uLong nOldStt, |
| SwTableNode& rTblNd, const SwTable* pOldTbl ) |
| : pDoc(pDc), nOldTblSttIdx(nOldStt), rMapArr(rArr), |
| pInsLine(0), pInsBox(0), pTblNd(&rTblNd), pOldTable( pOldTbl ) |
| {} |
| }; |
| |
| sal_Bool lcl_CopyTblBox( const SwTableBox*& rpBox, void* pPara ); |
| |
| sal_Bool lcl_CopyTblLine( const SwTableLine*& rpLine, void* pPara ); |
| |
| sal_Bool lcl_CopyTblBox( const SwTableBox*& rpBox, void* pPara ) |
| { |
| _CopyTable* pCT = (_CopyTable*)pPara; |
| |
| SwTableBoxFmt* pBoxFmt = (SwTableBoxFmt*)rpBox->GetFrmFmt(); |
| pCT->rMapArr.ForEach( lcl_SrchNew, &pBoxFmt ); |
| if( pBoxFmt == rpBox->GetFrmFmt() ) // ein neues anlegen ?? |
| { |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == pBoxFmt->GetItemState( RES_BOXATR_FORMULA, sal_False, |
| &pItem ) && ((SwTblBoxFormula*)pItem)->IsIntrnlName() ) |
| { |
| ((SwTblBoxFormula*)pItem)->PtrToBoxNm( pCT->pOldTable ); |
| } |
| |
| pBoxFmt = pCT->pDoc->MakeTableBoxFmt(); |
| pBoxFmt->CopyAttrs( *rpBox->GetFrmFmt() ); |
| |
| if( rpBox->GetSttIdx() ) |
| { |
| SvNumberFormatter* pN = pCT->pDoc->GetNumberFormatter( sal_False ); |
| if( pN && pN->HasMergeFmtTbl() && SFX_ITEM_SET == pBoxFmt-> |
| GetItemState( RES_BOXATR_FORMAT, sal_False, &pItem ) ) |
| { |
| sal_uLong nOldIdx = ((SwTblBoxNumFormat*)pItem)->GetValue(); |
| sal_uLong nNewIdx = pN->GetMergeFmtIndex( nOldIdx ); |
| if( nNewIdx != nOldIdx ) |
| pBoxFmt->SetFmtAttr( SwTblBoxNumFormat( nNewIdx )); |
| |
| } |
| } |
| |
| pCT->rMapArr.Insert( _MapTblFrmFmt( rpBox->GetFrmFmt(), pBoxFmt ), |
| pCT->rMapArr.Count() ); |
| } |
| |
| sal_uInt16 nLines = rpBox->GetTabLines().Count(); |
| SwTableBox* pNewBox; |
| if( nLines ) |
| pNewBox = new SwTableBox( pBoxFmt, nLines, pCT->pInsLine ); |
| else |
| { |
| //Modified for i119955,2012.6.13 |
| //Avoid overflow problem... |
| int nIn = rpBox->GetSttIdx() - pCT->nOldTblSttIdx; |
| if ( nIn > 0 ) |
| { |
| //End |
| SwNodeIndex aNewIdx( *pCT->pTblNd, |
| rpBox->GetSttIdx() - pCT->nOldTblSttIdx ); |
| ASSERT( aNewIdx.GetNode().IsStartNode(), "Index nicht auf einem StartNode" ); |
| pNewBox = new SwTableBox( pBoxFmt, aNewIdx, pCT->pInsLine ); |
| pNewBox->setRowSpan( rpBox->getRowSpan() ); |
| //Modified for i119955,2012.6.13 |
| }else |
| { |
| return sal_False; |
| } |
| //End |
| } |
| |
| pCT->pInsLine->GetTabBoxes().C40_INSERT( SwTableBox, pNewBox, |
| pCT->pInsLine->GetTabBoxes().Count() ); |
| |
| if( nLines ) |
| { |
| _CopyTable aPara( *pCT ); |
| aPara.pInsBox = pNewBox; |
| ((SwTableBox*)rpBox)->GetTabLines().ForEach( &lcl_CopyTblLine, &aPara ); |
| } |
| else if( pNewBox->IsInHeadline( &pCT->pTblNd->GetTable() )) |
| // in der HeadLine sind die Absaetze mit BedingtenVorlage anzupassen |
| pNewBox->GetSttNd()->CheckSectionCondColl(); |
| return sal_True; |
| } |
| |
| sal_Bool lcl_CopyTblLine( const SwTableLine*& rpLine, void* pPara ) |
| { |
| _CopyTable* pCT = (_CopyTable*)pPara; |
| SwTableLineFmt* pLineFmt = (SwTableLineFmt*)rpLine->GetFrmFmt(); |
| pCT->rMapArr.ForEach( lcl_SrchNew, &pLineFmt ); |
| if( pLineFmt == rpLine->GetFrmFmt() ) // ein neues anlegen ?? |
| { |
| pLineFmt = pCT->pDoc->MakeTableLineFmt(); |
| pLineFmt->CopyAttrs( *rpLine->GetFrmFmt() ); |
| pCT->rMapArr.Insert( _MapTblFrmFmt( rpLine->GetFrmFmt(), pLineFmt ), |
| pCT->rMapArr.Count()); |
| } |
| SwTableLine* pNewLine = new SwTableLine( pLineFmt, |
| rpLine->GetTabBoxes().Count(), pCT->pInsBox ); |
| // die neue Zeile in die Tabelle eintragen |
| if( pCT->pInsBox ) |
| { |
| pCT->pInsBox->GetTabLines().C40_INSERT( SwTableLine, pNewLine, |
| pCT->pInsBox->GetTabLines().Count() ); |
| } |
| else |
| { |
| pCT->pTblNd->GetTable().GetTabLines().C40_INSERT( SwTableLine, pNewLine, |
| pCT->pTblNd->GetTable().GetTabLines().Count() ); |
| } |
| pCT->pInsLine = pNewLine; |
| ((SwTableLine*)rpLine)->GetTabBoxes().ForEach( &lcl_CopyTblBox, pCT ); |
| return sal_True; |
| } |
| |
| SwTableNode* SwTableNode::MakeCopy( SwDoc* pDoc, const SwNodeIndex& rIdx ) const |
| { |
| // in welchen Array steht ich denn Nodes, UndoNodes ?? |
| SwNodes& rNds = (SwNodes&)GetNodes(); |
| |
| { |
| // nicht in Fussnoten kopieren !! |
| /* |
| !! Mal ohne Frames |
| SwCntntNode* pCNd = pDoc->GetNodes()[ rIdx ]->GetCntntNode(); |
| SwFrm* pFrm; |
| if( (pCNd && 0 != ( pFrm = pCNd->GetFrm())) |
| ? pFrm->FindFtnFrm() |
| : rIdx < pDoc->GetNodes().EndOfInserts && |
| pDoc->GetNodes()[pDoc->GetNodes().EndOfInserts]->StartOfSection() |
| < rIdx ) |
| */ |
| if( rIdx < pDoc->GetNodes().GetEndOfInserts().GetIndex() && |
| rIdx >= pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex() ) |
| return 0; |
| } |
| |
| // das TableFrmFmt kopieren |
| String sTblName( GetTable().GetFrmFmt()->GetName() ); |
| if( !pDoc->IsCopyIsMove() ) |
| { |
| const SwFrmFmts& rTblFmts = *pDoc->GetTblFrmFmts(); |
| for( sal_uInt16 n = rTblFmts.Count(); n; ) |
| if( rTblFmts[ --n ]->GetName() == sTblName ) |
| { |
| sTblName = pDoc->GetUniqueTblName(); |
| break; |
| } |
| } |
| |
| SwFrmFmt* pTblFmt = pDoc->MakeTblFrmFmt( sTblName, pDoc->GetDfltFrmFmt() ); |
| pTblFmt->CopyAttrs( *GetTable().GetFrmFmt() ); |
| SwTableNode* pTblNd = new SwTableNode( rIdx ); |
| SwEndNode* pEndNd = new SwEndNode( rIdx, *pTblNd ); |
| SwNodeIndex aInsPos( *pEndNd ); |
| |
| SwTable& rTbl = (SwTable&)pTblNd->GetTable(); |
| rTbl.RegisterToFormat( *pTblFmt ); |
| |
| rTbl.SetRowsToRepeat( GetTable().GetRowsToRepeat() ); |
| rTbl.SetTblChgMode( GetTable().GetTblChgMode() ); |
| rTbl.SetTableModel( GetTable().IsNewModel() ); |
| |
| SwDDEFieldType* pDDEType = 0; |
| if( IS_TYPE( SwDDETable, &GetTable() )) |
| { |
| // es wird eine DDE-Tabelle kopiert |
| // ist im neuen Dokument ueberhaupt der FeldTyp vorhanden ? |
| pDDEType = ((SwDDETable&)GetTable()).GetDDEFldType(); |
| if( pDDEType->IsDeleted() ) |
| pDoc->InsDeletedFldType( *pDDEType ); |
| else |
| pDDEType = (SwDDEFieldType*)pDoc->InsertFldType( *pDDEType ); |
| ASSERT( pDDEType, "unbekannter FieldType" ); |
| |
| // tauschen am Node den Tabellen-Pointer aus |
| SwDDETable* pNewTable = new SwDDETable( pTblNd->GetTable(), pDDEType ); |
| pTblNd->SetNewTable( pNewTable, sal_False ); |
| } |
| // dann kopiere erstmal den Inhalt der Tabelle, die Zuordnung der |
| // Boxen/Lines und das anlegen der Frames erfolgt spaeter |
| SwNodeRange aRg( *this, +1, *EndOfSectionNode() ); // (wo stehe in denn nun ??) |
| |
| // If there is a table in this table, the table format for the outer table |
| // does not seem to be used, because the table does not have any contents yet |
| // (see IsUsed). Therefore the inner table gets the same name as the outer table. |
| // We have to make sure that the table node of the SwTable is accessible, even |
| // without any content in aSortCntBoxes. #i26629# |
| pTblNd->GetTable().SetTableNode( pTblNd ); |
| rNds._Copy( aRg, aInsPos, sal_False ); |
| pTblNd->GetTable().SetTableNode( 0 ); |
| |
| // Sonderbehandlung fuer eine einzelne Box |
| if( 1 == GetTable().GetTabSortBoxes().Count() ) |
| { |
| aRg.aStart.Assign( *pTblNd, 1 ); |
| aRg.aEnd.Assign( *pTblNd->EndOfSectionNode() ); |
| pDoc->GetNodes().SectionDown( &aRg, SwTableBoxStartNode ); |
| } |
| |
| // loesche alle Frames vom kopierten Bereich, diese werden beim |
| // erzeugen des TableFrames angelegt ! |
| pTblNd->DelFrms(); |
| |
| _MapTblFrmFmts aMapArr; |
| _CopyTable aPara( pDoc, aMapArr, GetIndex(), *pTblNd, &GetTable() ); |
| |
| ((SwTable&)GetTable()).GetTabLines().ForEach( &lcl_CopyTblLine, &aPara ); |
| |
| if( pDDEType ) |
| pDDEType->IncRefCnt(); |
| |
| CHECK_TABLE( GetTable() ); |
| return pTblNd; |
| } |
| |
| void SwTxtNode::CopyCollFmt( SwTxtNode& rDestNd ) |
| { |
| // kopiere die Formate in das andere Dokument: |
| |
| // Sonderbehandlung fuer PageBreak/PageDesc/ColBrk |
| SwDoc* pDestDoc = rDestNd.GetDoc(); |
| SwAttrSet aPgBrkSet( pDestDoc->GetAttrPool(), aBreakSetRange ); |
| const SwAttrSet* pSet; |
| |
| if( 0 != ( pSet = rDestNd.GetpSwAttrSet() ) ) |
| { |
| // Sonderbehandlung fuer unsere Break-Attribute |
| const SfxPoolItem* pAttr; |
| if( SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False, &pAttr ) ) |
| aPgBrkSet.Put( *pAttr ); |
| |
| if( SFX_ITEM_SET == pSet->GetItemState( RES_PAGEDESC, sal_False, &pAttr ) ) |
| aPgBrkSet.Put( *pAttr ); |
| } |
| |
| rDestNd.ChgFmtColl( pDestDoc->CopyTxtColl( *GetTxtColl() )); |
| if( 0 != ( pSet = GetpSwAttrSet() ) ) |
| pSet->CopyToModify( rDestNd ); |
| |
| if( aPgBrkSet.Count() ) |
| rDestNd.SetAttr( aPgBrkSet ); |
| } |
| |
| |
| // ----- Copy-Methode vom SwDoc ------ |
| |
| // verhinder das Kopieren in Fly's, die im Bereich verankert sind. |
| sal_Bool lcl_ChkFlyFly( SwDoc* pDoc, sal_uLong nSttNd, sal_uLong nEndNd, |
| sal_uLong nInsNd ) |
| { |
| const SwSpzFrmFmts& rFrmFmtTbl = *pDoc->GetSpzFrmFmts(); |
| |
| for( sal_uInt16 n = 0; n < rFrmFmtTbl.Count(); ++n ) |
| { |
| SwFrmFmt const*const pFmt = rFrmFmtTbl[n]; |
| SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor(); |
| SwPosition const*const pAPos = pAnchor->GetCntntAnchor(); |
| if (pAPos && |
| ((FLY_AS_CHAR == pAnchor->GetAnchorId()) || |
| (FLY_AT_CHAR == pAnchor->GetAnchorId()) || |
| (FLY_AT_FLY == pAnchor->GetAnchorId()) || |
| (FLY_AT_PARA == pAnchor->GetAnchorId())) && |
| nSttNd <= pAPos->nNode.GetIndex() && |
| pAPos->nNode.GetIndex() < nEndNd ) |
| { |
| const SwFmtCntnt& rCntnt = pFmt->GetCntnt(); |
| SwStartNode* pSNd; |
| if( !rCntnt.GetCntntIdx() || |
| 0 == ( pSNd = rCntnt.GetCntntIdx()->GetNode().GetStartNode() )) |
| continue; |
| |
| if( pSNd->GetIndex() < nInsNd && |
| nInsNd < pSNd->EndOfSectionIndex() ) |
| return sal_True; // nicht kopieren !! |
| |
| if( lcl_ChkFlyFly( pDoc, pSNd->GetIndex(), |
| pSNd->EndOfSectionIndex(), nInsNd ) ) |
| return sal_True; // nicht kopieren !! |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| void lcl_DeleteRedlines( const SwPaM& rPam, SwPaM& rCpyPam ) |
| { |
| const SwDoc* pSrcDoc = rPam.GetDoc(); |
| const SwRedlineTbl& rTbl = pSrcDoc->GetRedlineTbl(); |
| if( rTbl.Count() ) |
| { |
| SwDoc* pDestDoc = rCpyPam.GetDoc(); |
| SwPosition* pCpyStt = rCpyPam.Start(), *pCpyEnd = rCpyPam.End(); |
| SwPaM* pDelPam = 0; |
| const SwPosition *pStt = rPam.Start(), *pEnd = rPam.End(); |
| // We have to count the "non-copied" nodes |
| sal_uLong nDelCount = 0; |
| SwNodeIndex aCorrIdx( pStt->nNode ); |
| |
| sal_uInt16 n = 0; |
| pSrcDoc->GetRedline( *pStt, &n ); |
| for( ; n < rTbl.Count(); ++n ) |
| { |
| const SwRedline* pRedl = rTbl[ n ]; |
| if( nsRedlineType_t::REDLINE_DELETE == pRedl->GetType() && pRedl->IsVisible() ) |
| { |
| const SwPosition *pRStt = pRedl->Start(), *pREnd = pRedl->End(); |
| |
| SwComparePosition eCmpPos = ComparePosition( *pStt, *pEnd, *pRStt, *pREnd ); |
| switch( eCmpPos ) |
| { |
| case POS_COLLIDE_END: |
| case POS_BEFORE: // Pos1 liegt vor Pos2 |
| break; |
| |
| case POS_COLLIDE_START: |
| case POS_BEHIND: // Pos1 liegt hinter Pos2 |
| n = rTbl.Count(); |
| break; |
| |
| default: |
| { |
| pDelPam = new SwPaM( *pCpyStt, pDelPam ); |
| if( *pStt < *pRStt ) |
| { |
| lcl_NonCopyCount( rPam, aCorrIdx, pRStt->nNode.GetIndex(), nDelCount ); |
| lcl_SetCpyPos( *pRStt, *pStt, *pCpyStt, |
| *pDelPam->GetPoint(), nDelCount ); |
| } |
| pDelPam->SetMark(); |
| |
| if( *pEnd < *pREnd ) |
| *pDelPam->GetPoint() = *pCpyEnd; |
| else |
| { |
| lcl_NonCopyCount( rPam, aCorrIdx, pREnd->nNode.GetIndex(), nDelCount ); |
| lcl_SetCpyPos( *pREnd, *pStt, *pCpyStt, |
| *pDelPam->GetPoint(), nDelCount ); |
| } |
| } |
| } |
| } |
| } |
| |
| if( pDelPam ) |
| { |
| RedlineMode_t eOld = pDestDoc->GetRedlineMode(); |
| pDestDoc->SetRedlineMode_intern( (RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE)); |
| |
| ::sw::UndoGuard const undoGuard(pDestDoc->GetIDocumentUndoRedo()); |
| |
| do { |
| pDestDoc->DeleteAndJoin( *(SwPaM*)pDelPam->GetNext() ); |
| if( pDelPam->GetNext() == pDelPam ) |
| break; |
| delete pDelPam->GetNext(); |
| } while( sal_True ); |
| delete pDelPam; |
| |
| pDestDoc->SetRedlineMode_intern( eOld ); |
| } |
| } |
| } |
| |
| void lcl_DeleteRedlines( const SwNodeRange& rRg, SwNodeRange& rCpyRg ) |
| { |
| SwDoc* pSrcDoc = rRg.aStart.GetNode().GetDoc(); |
| if( pSrcDoc->GetRedlineTbl().Count() ) |
| { |
| SwPaM aRgTmp( rRg.aStart, rRg.aEnd ); |
| SwPaM aCpyTmp( rCpyRg.aStart, rCpyRg.aEnd ); |
| lcl_DeleteRedlines( aRgTmp, aCpyTmp ); |
| } |
| } |
| |
| // Kopieren eines Bereiches im oder in ein anderes Dokument ! |
| |
| bool |
| SwDoc::CopyRange( SwPaM& rPam, SwPosition& rPos, const bool bCopyAll ) const |
| { |
| const SwPosition *pStt = rPam.Start(), *pEnd = rPam.End(); |
| |
| SwDoc* pDoc = rPos.nNode.GetNode().GetDoc(); |
| bool bColumnSel = pDoc->IsClipBoard() && pDoc->IsColumnSelection(); |
| |
| // kein Copy abfangen. |
| if( !rPam.HasMark() || ( *pStt >= *pEnd && !bColumnSel ) ) |
| return false; |
| |
| // verhinder das Kopieren in Fly's, die im Bereich verankert sind. |
| if( pDoc == this ) |
| { |
| // Start-/EndNode noch korrigieren |
| sal_uLong nStt = pStt->nNode.GetIndex(), |
| nEnd = pEnd->nNode.GetIndex(), |
| nDiff = nEnd - nStt +1; |
| SwNode* pNd = GetNodes()[ nStt ]; |
| if( pNd->IsCntntNode() && pStt->nContent.GetIndex() ) |
| ++nStt, --nDiff; |
| if( (pNd = GetNodes()[ nEnd ])->IsCntntNode() && |
| ((SwCntntNode*)pNd)->Len() != pEnd->nContent.GetIndex() ) |
| --nEnd, --nDiff; |
| if( nDiff && |
| lcl_ChkFlyFly( pDoc, nStt, nEnd, rPos.nNode.GetIndex() ) ) |
| { |
| return false; |
| } |
| } |
| |
| SwPaM* pRedlineRange = 0; |
| if( pDoc->IsRedlineOn() || |
| (!pDoc->IsIgnoreRedline() && pDoc->GetRedlineTbl().Count() ) ) |
| pRedlineRange = new SwPaM( rPos ); |
| |
| RedlineMode_t eOld = pDoc->GetRedlineMode(); |
| |
| bool bRet = false; |
| |
| if( pDoc != this ) |
| { // ordinary copy |
| bRet = CopyImpl( rPam, rPos, true, bCopyAll, pRedlineRange ); |
| } |
| // Copy in sich selbst (ueber mehrere Nodes wird hier gesondert |
| // behandelt; in einem TextNode wird normal behandelt) |
| else if( ! ( *pStt <= rPos && rPos < *pEnd && |
| ( pStt->nNode != pEnd->nNode || |
| !pStt->nNode.GetNode().IsTxtNode() )) ) |
| { // ordinary copy |
| bRet = CopyImpl( rPam, rPos, true, bCopyAll, pRedlineRange ); |
| } |
| else |
| { |
| ASSERT( this == pDoc, " falscher Copy-Zweig!" ); |
| ASSERT(false, "mst: i thought this could be dead code;" |
| "please tell me what you did to get here!"); |
| pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE)); |
| |
| // dann kopiere den Bereich im unteren DokumentBereich, |
| // (mit Start/End-Nodes geklammert) und verschiebe diese |
| // dann an die gewuenschte Stelle. |
| |
| SwUndoCpyDoc* pUndo = 0; |
| SwPaM aPam( rPos ); // UndoBereich sichern |
| if (pDoc->GetIDocumentUndoRedo().DoesUndo()) |
| { |
| pDoc->GetIDocumentUndoRedo().ClearRedo(); |
| pUndo = new SwUndoCpyDoc( aPam ); |
| } |
| |
| { |
| ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo()); |
| SwStartNode* pSttNd = pDoc->GetNodes().MakeEmptySection( |
| SwNodeIndex( GetNodes().GetEndOfAutotext() )); |
| aPam.GetPoint()->nNode = *pSttNd->EndOfSectionNode(); |
| // copy without Frames |
| pDoc->CopyImpl( rPam, *aPam.GetPoint(), false, bCopyAll, 0 ); |
| |
| aPam.GetPoint()->nNode = pDoc->GetNodes().GetEndOfAutotext(); |
| aPam.SetMark(); |
| SwCntntNode* pNode = |
| pDoc->GetNodes().GoPrevious( &aPam.GetMark()->nNode ); |
| pNode->MakeEndIndex( &aPam.GetMark()->nContent ); |
| |
| aPam.GetPoint()->nNode = *aPam.GetNode()->StartOfSectionNode(); |
| pNode = pDoc->GetNodes().GoNext( &aPam.GetPoint()->nNode ); |
| pNode->MakeStartIndex( &aPam.GetPoint()->nContent ); |
| // move to desired position |
| pDoc->MoveRange( aPam, rPos, DOC_MOVEDEFAULT ); |
| |
| pNode = aPam.GetCntntNode(); |
| *aPam.GetPoint() = rPos; // Cursor umsetzen fuers Undo ! |
| aPam.SetMark(); // auch den Mark umsetzen !! |
| aPam.DeleteMark(); // aber keinen Bereich makieren !! |
| pDoc->DeleteSection( pNode ); // Bereich wieder loeschen |
| } |
| |
| // if Undo is enabled, store the insertion range |
| if (pDoc->GetIDocumentUndoRedo().DoesUndo()) |
| { |
| pUndo->SetInsertRange( aPam ); |
| pDoc->GetIDocumentUndoRedo().AppendUndo(pUndo); |
| } |
| |
| if( pRedlineRange ) |
| { |
| pRedlineRange->SetMark(); |
| *pRedlineRange->GetPoint() = *aPam.GetPoint(); |
| *pRedlineRange->GetMark() = *aPam.GetMark(); |
| } |
| |
| pDoc->SetModified(); |
| bRet = true; |
| } |
| |
| pDoc->SetRedlineMode_intern( eOld ); |
| if( pRedlineRange ) |
| { |
| if( pDoc->IsRedlineOn() ) |
| pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, *pRedlineRange ), true); |
| else |
| pDoc->SplitRedline( *pRedlineRange ); |
| delete pRedlineRange; |
| } |
| |
| return bRet; |
| } |
| |
| // Kopieren eines Bereiches im oder in ein anderes Dokument ! |
| // Die Position darf nicht im Bereich liegen !! |
| |
| bool lcl_MarksWholeNode(const SwPaM & rPam) |
| { |
| bool bResult = false; |
| const SwPosition* pStt = rPam.Start(); |
| const SwPosition* pEnd = rPam.End(); |
| |
| if (NULL != pStt && NULL != pEnd) |
| { |
| const SwTxtNode* pSttNd = pStt->nNode.GetNode().GetTxtNode(); |
| const SwTxtNode* pEndNd = pEnd->nNode.GetNode().GetTxtNode(); |
| |
| if (NULL != pSttNd && NULL != pEndNd && |
| pStt->nContent.GetIndex() == 0 && |
| pEnd->nContent.GetIndex() == pEndNd->Len()) |
| { |
| bResult = true; |
| } |
| } |
| |
| return bResult; |
| } |
| |
| // --> OD 2009-08-25 #i86492# |
| bool lcl_ContainsOnlyParagraphsInList( const SwPaM& rPam ) |
| { |
| bool bRet = false; |
| |
| const SwTxtNode* pTxtNd = rPam.Start()->nNode.GetNode().GetTxtNode(); |
| const SwTxtNode* pEndTxtNd = rPam.End()->nNode.GetNode().GetTxtNode(); |
| if ( pTxtNd && pTxtNd->IsInList() && |
| pEndTxtNd && pEndTxtNd->IsInList() ) |
| { |
| bRet = true; |
| SwNodeIndex aIdx(rPam.Start()->nNode); |
| |
| do |
| { |
| aIdx++; |
| pTxtNd = aIdx.GetNode().GetTxtNode(); |
| |
| if ( !pTxtNd || !pTxtNd->IsInList() ) |
| { |
| bRet = false; |
| break; |
| } |
| } while ( pTxtNd && pTxtNd != pEndTxtNd ); |
| } |
| |
| |
| return bRet; |
| } |
| // <-- |
| |
| bool SwDoc::CopyImpl( SwPaM& rPam, SwPosition& rPos, |
| const bool bMakeNewFrms, const bool bCopyAll, |
| SwPaM *const pCpyRange ) const |
| { |
| SwDoc* pDoc = rPos.nNode.GetNode().GetDoc(); |
| const bool bColumnSel = pDoc->IsClipBoard() && pDoc->IsColumnSelection(); |
| |
| SwPosition* pStt = rPam.Start(); |
| SwPosition* pEnd = rPam.End(); |
| |
| // kein Copy abfangen. |
| if( !rPam.HasMark() || ( *pStt >= *pEnd && !bColumnSel ) || |
| //JP 29.6.2001: 88963 - dont copy if inspos is in region of start to end |
| //JP 15.11.2001: don't test inclusive the end, ever exclusive |
| ( pDoc == this && *pStt <= rPos && rPos < *pEnd )) |
| { |
| return false; |
| } |
| |
| const bool bEndEqualIns = pDoc == this && rPos == *pEnd; |
| |
| // falls Undo eingeschaltet, erzeuge das UndoCopy-Objekt |
| SwUndoCpyDoc* pUndo = 0; |
| SwPaM aCpyPam( rPos ); |
| |
| SwTblNumFmtMerge aTNFM( *this, *pDoc ); |
| |
| if (pDoc->GetIDocumentUndoRedo().DoesUndo()) |
| { |
| pUndo = new SwUndoCpyDoc( aCpyPam ); |
| pDoc->GetIDocumentUndoRedo().AppendUndo( pUndo ); |
| } |
| |
| RedlineMode_t eOld = pDoc->GetRedlineMode(); |
| pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE)); |
| |
| |
| // bewege den Pam von der Insert-Position ein zurueck, dadurch wird |
| // die Position nicht "verschoben" |
| aCpyPam.SetMark(); |
| sal_Bool bCanMoveBack = aCpyPam.Move( fnMoveBackward, fnGoCntnt ); |
| if( !bCanMoveBack ) |
| aCpyPam.GetPoint()->nNode--; |
| |
| SwNodeRange aRg( pStt->nNode, pEnd->nNode ); |
| SwNodeIndex aInsPos( rPos.nNode ); |
| const bool bOneNode = pStt->nNode == pEnd->nNode; |
| SwTxtNode* pSttTxtNd = pStt->nNode.GetNode().GetTxtNode(); |
| SwTxtNode* pEndTxtNd = pEnd->nNode.GetNode().GetTxtNode(); |
| SwTxtNode* pDestTxtNd = aInsPos.GetNode().GetTxtNode(); |
| bool bCopyCollFmt = !pDoc->IsInsOnlyTextGlossary() && |
| ( ( pDestTxtNd && !pDestTxtNd->GetTxt().Len() ) || |
| ( !bOneNode && !rPos.nContent.GetIndex() ) ); |
| bool bCopyBookmarks = true; |
| sal_Bool bStartIsTxtNode = 0 != pSttTxtNd; |
| |
| // #i104585# copy outline num rule to clipboard (for ASCII filter) |
| if (pDoc->IsClipBoard() && GetOutlineNumRule()) |
| { |
| pDoc->SetOutlineNumRule(*GetOutlineNumRule()); |
| } |
| |
| // --> OD 2009-08-25 #i86492# |
| // Correct the search for a previous list: |
| // First search for non-outline numbering list. Then search for non-outline |
| // bullet list. |
| // Keep also the <ListId> value for possible propagation. |
| String aListIdToPropagate; |
| const SwNumRule* pNumRuleToPropagate = |
| pDoc->SearchNumRule( rPos, false, true, false, 0, aListIdToPropagate, true ); |
| if ( !pNumRuleToPropagate ) |
| { |
| pNumRuleToPropagate = |
| pDoc->SearchNumRule( rPos, false, false, false, 0, aListIdToPropagate, true ); |
| } |
| // <-- |
| // --> OD 2009-08-25 #i86492# |
| // Do not propagate previous found list, if |
| // - destination is an empty paragraph which is not in a list and |
| // - source contains at least one paragraph which is not in a list |
| if ( pNumRuleToPropagate && |
| pDestTxtNd && !pDestTxtNd->GetTxt().Len() && !pDestTxtNd->IsInList() && |
| !lcl_ContainsOnlyParagraphsInList( rPam ) ) |
| { |
| pNumRuleToPropagate = 0; |
| } |
| // <-- |
| |
| // Block, damit aus diesem gesprungen werden kann !! |
| do { |
| if( pSttTxtNd ) |
| { |
| // den Anfang nicht komplett kopieren ? |
| if( !bCopyCollFmt || bColumnSel || pStt->nContent.GetIndex() ) |
| { |
| SwIndex aDestIdx( rPos.nContent ); |
| sal_Bool bCopyOk = sal_False; |
| if( !pDestTxtNd ) |
| { |
| if( pStt->nContent.GetIndex() || bOneNode ) |
| pDestTxtNd = pDoc->GetNodes().MakeTxtNode( aInsPos, |
| pDoc->GetTxtCollFromPool(RES_POOLCOLL_STANDARD)); |
| else |
| { |
| pDestTxtNd = static_cast<SwTxtNode*>(pSttTxtNd->MakeCopy( pDoc, aInsPos )); |
| bCopyOk = sal_True; |
| } |
| aDestIdx.Assign( pDestTxtNd, 0 ); |
| bCopyCollFmt = true; |
| } |
| else if( !bOneNode || bColumnSel ) |
| { |
| xub_StrLen nCntntEnd = pEnd->nContent.GetIndex(); |
| { |
| ::sw::UndoGuard const ug(pDoc->GetIDocumentUndoRedo()); |
| pDoc->SplitNode( rPos, false ); |
| } |
| |
| if( bCanMoveBack && rPos == *aCpyPam.GetPoint() ) |
| { |
| // nach dem SplitNode, den CpyPam wieder richtig aufspannen |
| aCpyPam.Move( fnMoveBackward, fnGoCntnt ); |
| aCpyPam.Move( fnMoveBackward, fnGoCntnt ); |
| } |
| |
| pDestTxtNd = pDoc->GetNodes()[ aInsPos.GetIndex()-1 ]->GetTxtNode(); |
| aDestIdx.Assign( pDestTxtNd, pDestTxtNd->GetTxt().Len() ); |
| |
| // korrigiere den Bereich wieder !! |
| if( bEndEqualIns ) |
| { |
| sal_Bool bChg = pEnd != rPam.GetPoint(); |
| if( bChg ) |
| rPam.Exchange(); |
| rPam.Move( fnMoveBackward, fnGoCntnt ); |
| if( bChg ) |
| rPam.Exchange(); |
| |
| aRg.aEnd = pEnd->nNode; |
| pEndTxtNd = pEnd->nNode.GetNode().GetTxtNode(); |
| } |
| else if( rPos == *pEnd ) // Wurde das Ende auch verschoben |
| { |
| pEnd->nNode--; |
| pEnd->nContent.Assign( pDestTxtNd, nCntntEnd ); |
| aRg.aEnd = pEnd->nNode; |
| pEndTxtNd = pEnd->nNode.GetNode().GetTxtNode(); |
| } |
| } |
| |
| /* #107213#: Safe numrule item at destination. */ |
| // --> OD 2009-08-25 #i86492# |
| // Safe also <ListId> item of destination. |
| int aNumRuleState = SFX_ITEM_UNKNOWN; |
| SwNumRuleItem aNumRuleItem; |
| int aListIdState = SFX_ITEM_UNKNOWN; |
| SfxStringItem aListIdItem( RES_PARATR_LIST_ID, String() ); |
| { |
| const SfxItemSet * pAttrSet = pDestTxtNd->GetpSwAttrSet(); |
| if (pAttrSet != NULL) |
| { |
| const SfxPoolItem * pItem = NULL; |
| aNumRuleState = pAttrSet->GetItemState(RES_PARATR_NUMRULE, sal_False, &pItem); |
| if (SFX_ITEM_SET == aNumRuleState) |
| aNumRuleItem = *((SwNumRuleItem *) pItem); |
| |
| aListIdState = |
| pAttrSet->GetItemState(RES_PARATR_LIST_ID, sal_False, &pItem); |
| if (SFX_ITEM_SET == aListIdState) |
| { |
| aListIdItem.SetValue( static_cast<const SfxStringItem*>(pItem)->GetValue() ); |
| } |
| } |
| } |
| // <-- |
| /* #107213# */ |
| |
| if( !bCopyOk ) |
| { |
| const xub_StrLen nCpyLen = ( (bOneNode) |
| ? pEnd->nContent.GetIndex() |
| : pSttTxtNd->GetTxt().Len() ) |
| - pStt->nContent.GetIndex(); |
| pSttTxtNd->CopyText( pDestTxtNd, aDestIdx, |
| pStt->nContent, nCpyLen ); |
| if( bEndEqualIns ) |
| pEnd->nContent -= nCpyLen; |
| } |
| |
| if( bOneNode ) |
| { |
| if( bCopyCollFmt ) |
| { |
| pSttTxtNd->CopyCollFmt( *pDestTxtNd ); |
| |
| /* #107213# If only a part of one paragraph is copied |
| restore the numrule at the destination. */ |
| // --> OD 2009-08-25 #i86492# |
| // restore also <ListId> item |
| if ( !lcl_MarksWholeNode(rPam) ) |
| { |
| if (SFX_ITEM_SET == aNumRuleState) |
| { |
| pDestTxtNd->SetAttr(aNumRuleItem); |
| } |
| else |
| { |
| pDestTxtNd->ResetAttr(RES_PARATR_NUMRULE); |
| } |
| if (SFX_ITEM_SET == aListIdState) |
| { |
| pDestTxtNd->SetAttr(aListIdItem); |
| } |
| else |
| { |
| pDestTxtNd->ResetAttr(RES_PARATR_LIST_ID); |
| } |
| } |
| } |
| |
| break; |
| } |
| |
| aRg.aStart++; |
| } |
| } |
| else if( pDestTxtNd ) |
| { |
| // Problems with insertion of table selections into "normal" text solved. |
| // We have to set the correct PaM for Undo, if this PaM starts in a textnode, |
| // the undo operation will try to merge this node after removing the table. |
| // If we didn't split a textnode, the PaM should start at the inserted table node |
| if( rPos.nContent.GetIndex() == pDestTxtNd->Len() ) |
| { // Insertion at the last position of a textnode (empty or not) |
| aInsPos++; // The table will be inserted behind the text node |
| } |
| else if( rPos.nContent.GetIndex() ) |
| { // Insertion in the middle of a text node, it has to be split |
| // (and joined from undo) |
| bStartIsTxtNode = sal_True; |
| // splitte den TextNode, bei dem Eingefuegt wird. |
| |
| xub_StrLen nCntntEnd = pEnd->nContent.GetIndex(); |
| { |
| ::sw::UndoGuard const ug(pDoc->GetIDocumentUndoRedo()); |
| pDoc->SplitNode( rPos, false ); |
| } |
| |
| if( bCanMoveBack && rPos == *aCpyPam.GetPoint() ) |
| { |
| // nach dem SplitNode, den CpyPam wieder richtig aufspannen |
| aCpyPam.Move( fnMoveBackward, fnGoCntnt ); |
| aCpyPam.Move( fnMoveBackward, fnGoCntnt ); |
| } |
| |
| // korrigiere den Bereich wieder !! |
| if( bEndEqualIns ) |
| aRg.aEnd--; |
| else if( rPos == *pEnd ) // Wurde das Ende auch verschoben |
| { |
| rPos.nNode-=2; |
| rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), |
| nCntntEnd ); |
| rPos.nNode++; |
| aRg.aEnd--; |
| } |
| } |
| else if( bCanMoveBack ) |
| { //Insertion at the first position of a text node. It will not be splitted, the table |
| // will be inserted before the text node. |
| // See below, before the SetInsertRange funciton of the undo object will be called, |
| // the CpyPam would be moved to the next content position. This has to be avoided |
| // We want to be moved to the table node itself thus we have to set bCanMoveBack |
| // and to manipulate aCpyPam. |
| bCanMoveBack = false; |
| aCpyPam.GetPoint()->nNode--; |
| } |
| } |
| |
| pDestTxtNd = aInsPos.GetNode().GetTxtNode(); |
| if( pEndTxtNd ) |
| { |
| SwIndex aDestIdx( rPos.nContent ); |
| if( !pDestTxtNd ) |
| { |
| pDestTxtNd = pDoc->GetNodes().MakeTxtNode( aInsPos, |
| pDoc->GetTxtCollFromPool(RES_POOLCOLL_STANDARD)); |
| aDestIdx.Assign( pDestTxtNd, 0 ); |
| aInsPos--; |
| |
| // #112756# #98130# if we have to insert an extra text node |
| // at the destination, this node will be our new destination |
| // (text) node, and thus we set bStartisTxtNode to true. This |
| // will ensure that this node will be deleted during Undo |
| // using JoinNext. |
| DBG_ASSERT( !bStartIsTxtNode, "Oops, undo may be instable now." ); |
| bStartIsTxtNode = sal_True; |
| } |
| |
| /* #107213# Save numrule at destination */ |
| // --> OD 2009-08-25 #i86492# |
| // Safe also <ListId> item of destination. |
| int aNumRuleState = SFX_ITEM_UNKNOWN; |
| SwNumRuleItem aNumRuleItem; |
| int aListIdState = SFX_ITEM_UNKNOWN; |
| SfxStringItem aListIdItem( RES_PARATR_LIST_ID, String() ); |
| { |
| const SfxItemSet* pAttrSet = pDestTxtNd->GetpSwAttrSet(); |
| if (pAttrSet != NULL) |
| { |
| const SfxPoolItem * pItem = NULL; |
| |
| aNumRuleState = |
| pAttrSet->GetItemState(RES_PARATR_NUMRULE, sal_False, &pItem); |
| if (SFX_ITEM_SET == aNumRuleState) |
| aNumRuleItem = *((SwNumRuleItem *) pItem); |
| |
| aListIdState = |
| pAttrSet->GetItemState(RES_PARATR_LIST_ID, sal_False, &pItem); |
| if (SFX_ITEM_SET == aListIdState) |
| aListIdItem.SetValue( static_cast<const SfxStringItem*>(pItem)->GetValue() ); |
| } |
| } |
| // <-- |
| /* #107213# */ |
| |
| const bool bEmptyDestNd = 0 == pDestTxtNd->GetTxt().Len(); |
| pEndTxtNd->CopyText( pDestTxtNd, aDestIdx, SwIndex( pEndTxtNd ), |
| pEnd->nContent.GetIndex() ); |
| |
| // auch alle FormatVorlagen kopieren |
| if( bCopyCollFmt && ( bOneNode || bEmptyDestNd )) |
| { |
| pEndTxtNd->CopyCollFmt( *pDestTxtNd ); |
| |
| if ( bOneNode ) |
| { |
| /* #107213# If only a part of one paragraph is copied |
| restore the numrule at the destination. */ |
| // --> OD 2009-08-25 #i86492# |
| // restore also <ListId> item |
| if ( !lcl_MarksWholeNode(rPam) ) |
| { |
| if (SFX_ITEM_SET == aNumRuleState) |
| { |
| pDestTxtNd->SetAttr(aNumRuleItem); |
| } |
| else |
| { |
| pDestTxtNd->ResetAttr(RES_PARATR_NUMRULE); |
| } |
| if (SFX_ITEM_SET == aListIdState) |
| { |
| pDestTxtNd->SetAttr(aListIdItem); |
| } |
| else |
| { |
| pDestTxtNd->ResetAttr(RES_PARATR_LIST_ID); |
| } |
| } |
| } |
| } |
| } |
| |
| if( bCopyAll || aRg.aStart != aRg.aEnd ) |
| { |
| SfxItemSet aBrkSet( pDoc->GetAttrPool(), aBreakSetRange ); |
| if( pSttTxtNd && bCopyCollFmt && pDestTxtNd->HasSwAttrSet() ) |
| { |
| aBrkSet.Put( *pDestTxtNd->GetpSwAttrSet() ); |
| if( SFX_ITEM_SET == aBrkSet.GetItemState( RES_BREAK, sal_False ) ) |
| pDestTxtNd->ResetAttr( RES_BREAK ); |
| if( SFX_ITEM_SET == aBrkSet.GetItemState( RES_PAGEDESC, sal_False ) ) |
| pDestTxtNd->ResetAttr( RES_PAGEDESC ); |
| } |
| |
| if( aInsPos == pEnd->nNode ) |
| { |
| SwNodeIndex aSaveIdx( aInsPos, -1 ); |
| CopyWithFlyInFly( aRg, 0, aInsPos, &rPam, bMakeNewFrms, sal_False ); |
| aSaveIdx++; |
| pEnd->nNode = aSaveIdx; |
| pEnd->nContent.Assign( aSaveIdx.GetNode().GetTxtNode(), 0 ); |
| } |
| else |
| CopyWithFlyInFly( aRg, pEnd->nContent.GetIndex(), aInsPos, &rPam, bMakeNewFrms, sal_False ); |
| |
| bCopyBookmarks = false; |
| |
| // harte Umbrueche wieder in den ersten Node setzen |
| if( aBrkSet.Count() && 0 != ( pDestTxtNd = pDoc->GetNodes()[ |
| aCpyPam.GetPoint()->nNode.GetIndex()+1 ]->GetTxtNode() ) ) |
| { |
| pDestTxtNd->SetAttr( aBrkSet ); |
| } |
| } |
| } while( sal_False ); |
| |
| // Position ummelden ( falls verschoben / im anderen Node ) |
| rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), |
| rPos.nContent.GetIndex() ); |
| |
| if( rPos.nNode != aInsPos ) |
| { |
| aCpyPam.GetMark()->nNode = aInsPos; |
| aCpyPam.GetMark()->nContent.Assign( aCpyPam.GetCntntNode(sal_False), 0 ); |
| rPos = *aCpyPam.GetMark(); |
| } |
| else |
| *aCpyPam.GetMark() = rPos; |
| |
| aCpyPam.Move( fnMoveForward, bCanMoveBack ? fnGoCntnt : fnGoNode ); |
| aCpyPam.Exchange(); |
| |
| // dann kopiere noch alle Bookmarks |
| if( bCopyBookmarks && getIDocumentMarkAccess()->getAllMarksCount() ) |
| lcl_CopyBookmarks( rPam, aCpyPam ); |
| |
| if( nsRedlineMode_t::REDLINE_DELETE_REDLINES & eOld ) |
| lcl_DeleteRedlines( rPam, aCpyPam ); |
| |
| // falls Undo eingeschaltet ist, so speicher den eingefuegten Bereich |
| if (pDoc->GetIDocumentUndoRedo().DoesUndo()) |
| { |
| pUndo->SetInsertRange( aCpyPam, sal_True, bStartIsTxtNode ); |
| } |
| |
| if( pCpyRange ) |
| { |
| pCpyRange->SetMark(); |
| *pCpyRange->GetPoint() = *aCpyPam.GetPoint(); |
| *pCpyRange->GetMark() = *aCpyPam.GetMark(); |
| } |
| |
| if ( pNumRuleToPropagate ) |
| { |
| // --> OD 2009-08-25 #i86492# |
| // use <SwDoc::SetNumRule(..)>, because it also handles the <ListId> |
| // pDoc->ReplaceNumRule(aCpyPam, *pNumRuleToPropagate); |
| pDoc->SetNumRule( aCpyPam, *pNumRuleToPropagate, false, |
| aListIdToPropagate, sal_True, true ); |
| } |
| |
| pDoc->SetRedlineMode_intern( eOld ); |
| pDoc->SetModified(); |
| |
| return true; |
| } |
| |
| |
| // ----- Copy-Methode vom SwDoc - "kopiere Fly's in Fly's" ------ |
| |
| void SwDoc::CopyWithFlyInFly( |
| const SwNodeRange& rRg, |
| const xub_StrLen nEndContentIndex, |
| const SwNodeIndex& rInsPos, |
| const SwPaM* pCopiedPaM, |
| const sal_Bool bMakeNewFrms, |
| const sal_Bool bDelRedlines, |
| const sal_Bool bCopyFlyAtFly ) const |
| { |
| SwDoc* pDest = rInsPos.GetNode().GetDoc(); |
| |
| _SaveRedlEndPosForRestore aRedlRest( rInsPos, 0 ); |
| |
| SwNodeIndex aSavePos( rInsPos, -1 ); |
| sal_Bool bEndIsEqualEndPos = rInsPos == rRg.aEnd; |
| GetNodes()._CopyNodes( rRg, rInsPos, bMakeNewFrms, sal_True ); |
| aSavePos++; |
| if( bEndIsEqualEndPos ) |
| ((SwNodeIndex&)rRg.aEnd) = aSavePos; |
| |
| aRedlRest.Restore(); |
| |
| #ifdef DBG_UTIL |
| { |
| //JP 17.06.99: Bug 66973 - check count only if the selection is in |
| // the same (or no) section. Becaus not full selected |
| // section are not copied. |
| const SwSectionNode* pSSectNd = rRg.aStart.GetNode().FindSectionNode(); |
| SwNodeIndex aTmpI( rRg.aEnd, -1 ); |
| const SwSectionNode* pESectNd = aTmpI.GetNode().FindSectionNode(); |
| if( pSSectNd == pESectNd && |
| !rRg.aStart.GetNode().IsSectionNode() && |
| !aTmpI.GetNode().IsEndNode() ) |
| { |
| ASSERT( rInsPos.GetIndex() - aSavePos.GetIndex() == |
| rRg.aEnd.GetIndex() - rRg.aStart.GetIndex(), |
| "Es wurden zu wenig Nodes kopiert!" ) |
| } |
| } |
| #endif |
| |
| { |
| ::sw::UndoGuard const undoGuard(pDest->GetIDocumentUndoRedo()); |
| CopyFlyInFlyImpl( rRg, nEndContentIndex, aSavePos, bCopyFlyAtFly ); |
| } |
| |
| SwNodeRange aCpyRange( aSavePos, rInsPos ); |
| |
| // dann kopiere noch alle Bookmarks |
| if( getIDocumentMarkAccess()->getAllMarksCount() ) |
| { |
| SwPaM aRgTmp( rRg.aStart, rRg.aEnd ); |
| SwPaM aCpyTmp( aCpyRange.aStart, aCpyRange.aEnd ); |
| |
| lcl_CopyBookmarks( |
| pCopiedPaM != NULL ? *pCopiedPaM : aRgTmp, |
| aCpyTmp ); |
| } |
| |
| if( bDelRedlines && ( nsRedlineMode_t::REDLINE_DELETE_REDLINES & pDest->GetRedlineMode() )) |
| lcl_DeleteRedlines( rRg, aCpyRange ); |
| |
| pDest->GetNodes()._DelDummyNodes( aCpyRange ); |
| } |
| |
| void lcl_ChainFmts( SwFlyFrmFmt *pSrc, SwFlyFrmFmt *pDest ) |
| { |
| SwFmtChain aSrc( pSrc->GetChain() ); |
| if ( !aSrc.GetNext() ) |
| { |
| aSrc.SetNext( pDest ); |
| pSrc->SetFmtAttr( aSrc ); |
| } |
| SwFmtChain aDest( pDest->GetChain() ); |
| if ( !aDest.GetPrev() ) |
| { |
| aDest.SetPrev( pSrc ); |
| pDest->SetFmtAttr( aDest ); |
| } |
| } |
| |
| void SwDoc::CopyFlyInFlyImpl( |
| const SwNodeRange& rRg, |
| const xub_StrLen nEndContentIndex, |
| const SwNodeIndex& rStartIdx, |
| const bool bCopyFlyAtFly ) const |
| { |
| // Bug 22727: suche erst mal alle Flys zusammen, sortiere sie entsprechend |
| // ihrer Ordnungsnummer und kopiere sie erst dann. Damit wird |
| // die Ordnungsnummer (wird nur im DrawModel verwaltet) |
| // beibehalten. |
| SwDoc *const pDest = rStartIdx.GetNode().GetDoc(); |
| _ZSortFlys aArr; |
| sal_uInt16 nArrLen = GetSpzFrmFmts()->Count(); |
| |
| for ( sal_uInt16 n = 0; n < nArrLen; ++n ) |
| { |
| SwFrmFmt const*const pFmt = (*GetSpzFrmFmts())[n]; |
| SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor(); |
| SwPosition const*const pAPos = pAnchor->GetCntntAnchor(); |
| bool bAtCntnt = (pAnchor->GetAnchorId() == FLY_AT_PARA); |
| if ( pAPos && |
| ( bAtCntnt || |
| (pAnchor->GetAnchorId() == FLY_AT_FLY) || |
| (pAnchor->GetAnchorId() == FLY_AT_CHAR)) && |
| (( bCopyFlyAtFly && FLY_AT_FLY == pAnchor->GetAnchorId() ) |
| ? rRg.aStart <= pAPos->nNode.GetIndex() + 1 |
| : ( IsRedlineMove() |
| ? rRg.aStart < pAPos->nNode |
| : rRg.aStart <= pAPos->nNode )) && |
| pAPos->nNode <= rRg.aEnd ) |
| { |
| //frames at the last source node are not always copied: |
| //- if the node is empty and is the last node of the document or a table cell |
| // or a text frame then tey have to be copied |
| //- if the content index in this node is > 0 then paragph and frame bound objects are copied |
| //- to-character bound objects are copied if their index is <= nEndContentIndex |
| bool bAdd = false; |
| if( pAPos->nNode < rRg.aEnd ) |
| bAdd = true; |
| if( !bAdd ) |
| { |
| bool bEmptyNode = false; |
| bool bLastNode = false; |
| // is the node empty? |
| const SwNodes& rNodes = pAPos->nNode.GetNodes(); |
| SwTxtNode* pTxtNode; |
| if( 0 != ( pTxtNode = pAPos->nNode.GetNode().GetTxtNode() )) |
| { |
| bEmptyNode = !pTxtNode->GetTxt().Len(); |
| if( bEmptyNode ) |
| { |
| //last node information is only necessary to know for the last TextNode |
| SwNodeIndex aTmp( pAPos->nNode ); |
| ++aTmp;//goto next node |
| while (aTmp.GetNode().IsEndNode()) |
| { |
| if( aTmp == rNodes.GetEndOfContent().GetIndex() ) |
| { |
| bLastNode = true; |
| break; |
| } |
| ++aTmp; |
| } |
| } |
| } |
| bAdd = bLastNode && bEmptyNode; |
| if( !bAdd ) |
| { |
| if( bAtCntnt ) |
| bAdd = nEndContentIndex > 0; |
| else |
| bAdd = pAPos->nContent <= nEndContentIndex; |
| } |
| } |
| if( bAdd ) |
| aArr.Insert( _ZSortFly( pFmt, pAnchor, nArrLen + aArr.Count() )); |
| } |
| } |
| |
| //Alle kopierten (also die neu erzeugten) Rahmen in ein weiteres Array |
| //stopfen. Dort sizten sie passend zu den Originalen, damit hinterher |
| //die Chains entsprechend aufgebaut werden koennen. |
| SvPtrarr aNewArr( 10, 10 ); |
| |
| for ( sal_uInt16 n = 0; n < aArr.Count(); ++n ) |
| { |
| const _ZSortFly& rZSortFly = aArr[ n ]; |
| |
| // --> OD 2006-01-04 #i59964# |
| // correct determination of new anchor position |
| SwFmtAnchor aAnchor( *rZSortFly.GetAnchor() ); |
| SwPosition* pNewPos = (SwPosition*)aAnchor.GetCntntAnchor(); |
| // for at-paragraph and at-character anchored objects the new anchor |
| // position can *not* be determined by the difference of the current |
| // anchor position to the start of the copied range, because not |
| // complete selected sections in the copied range aren't copied - see |
| // method <SwNodes::_CopyNodes(..)>. |
| // Thus, the new anchor position in the destination document is found |
| // by counting the text nodes. |
| if ((aAnchor.GetAnchorId() == FLY_AT_PARA) || |
| (aAnchor.GetAnchorId() == FLY_AT_CHAR) ) |
| { |
| // First, determine number of anchor text node in the copied range. |
| // Note: The anchor text node *have* to be inside the copied range. |
| sal_uLong nAnchorTxtNdNumInRange( 0L ); |
| bool bAnchorTxtNdFound( false ); |
| SwNodeIndex aIdx( rRg.aStart ); |
| while ( !bAnchorTxtNdFound && aIdx <= rRg.aEnd ) |
| { |
| if ( aIdx.GetNode().IsTxtNode() ) |
| { |
| ++nAnchorTxtNdNumInRange; |
| bAnchorTxtNdFound = aAnchor.GetCntntAnchor()->nNode == aIdx; |
| } |
| |
| ++aIdx; |
| } |
| if ( !bAnchorTxtNdFound ) |
| { |
| // This case can *not* happen, but to be robust take the first |
| // text node in the destination document. |
| ASSERT( false, |
| "<SwDoc::_CopyFlyInFly(..)> - anchor text node in copied range not found" ); |
| nAnchorTxtNdNumInRange = 1; |
| } |
| // Second, search corresponding text node in destination document |
| // by counting forward from start insert position <rStartIdx> the |
| // determined number of text nodes. |
| aIdx = rStartIdx; |
| SwNodeIndex aAnchorNdIdx( rStartIdx ); |
| const SwNode& aEndOfContentNd = |
| aIdx.GetNode().GetNodes().GetEndOfContent(); |
| while ( nAnchorTxtNdNumInRange > 0 && |
| &(aIdx.GetNode()) != &aEndOfContentNd ) |
| { |
| if ( aIdx.GetNode().IsTxtNode() ) |
| { |
| --nAnchorTxtNdNumInRange; |
| aAnchorNdIdx = aIdx; |
| } |
| |
| ++aIdx; |
| } |
| if ( !aAnchorNdIdx.GetNode().IsTxtNode() ) |
| { |
| // This case can *not* happen, but to be robust take the first |
| // text node in the destination document. |
| ASSERT( false, |
| "<SwDoc::_CopyFlyInFly(..)> - found anchor node index isn't a text node" ); |
| aAnchorNdIdx = rStartIdx; |
| while ( !aAnchorNdIdx.GetNode().IsTxtNode() ) |
| { |
| ++aAnchorNdIdx; |
| } |
| } |
| // apply found anchor text node as new anchor position |
| pNewPos->nNode = aAnchorNdIdx; |
| } |
| else |
| { |
| long nOffset = pNewPos->nNode.GetIndex() - rRg.aStart.GetIndex(); |
| SwNodeIndex aIdx( rStartIdx, nOffset ); |
| pNewPos->nNode = aIdx; |
| } |
| // <-- |
| // die am Zeichen Flys wieder ans das vorgegebene Zeichen setzen |
| if ((FLY_AT_CHAR == aAnchor.GetAnchorId()) && |
| pNewPos->nNode.GetNode().IsTxtNode() ) |
| { |
| pNewPos->nContent.Assign( (SwTxtNode*)&pNewPos->nNode.GetNode(), |
| pNewPos->nContent.GetIndex() ); |
| } |
| else |
| { |
| pNewPos->nContent.Assign( 0, 0 ); |
| } |
| |
| // ueberpruefe Rekursion: Inhalt in "seinen eigenen" Frame |
| // kopieren. Dann nicht kopieren |
| sal_Bool bMakeCpy = sal_True; |
| if( pDest == this ) |
| { |
| const SwFmtCntnt& rCntnt = rZSortFly.GetFmt()->GetCntnt(); |
| const SwStartNode* pSNd; |
| if( rCntnt.GetCntntIdx() && |
| 0 != ( pSNd = rCntnt.GetCntntIdx()->GetNode().GetStartNode() ) && |
| pSNd->GetIndex() < rStartIdx.GetIndex() && |
| rStartIdx.GetIndex() < pSNd->EndOfSectionIndex() ) |
| { |
| bMakeCpy = sal_False; |
| aArr.Remove( n, 1 ); |
| --n; |
| } |
| } |
| |
| // Format kopieren und den neuen Anker setzen |
| if( bMakeCpy ) |
| aNewArr.Insert( pDest->CopyLayoutFmt( *rZSortFly.GetFmt(), |
| aAnchor, false, true ), aNewArr.Count() ); |
| } |
| |
| //Alle chains, die im Original vorhanden sind, soweit wie moeglich wieder |
| //aufbauen. |
| ASSERT( aArr.Count() == aNewArr.Count(), "Missing new Flys" ); |
| if ( aArr.Count() == aNewArr.Count() ) |
| { |
| for ( sal_uInt16 n = 0; n < aArr.Count(); ++n ) |
| { |
| const SwFrmFmt *pFmt = aArr[n].GetFmt(); |
| const SwFmtChain &rChain = pFmt->GetChain(); |
| int nCnt = 0 != rChain.GetPrev(); |
| nCnt += rChain.GetNext() ? 1: 0; |
| for ( sal_uInt16 k = 0; nCnt && k < aArr.Count(); ++k ) |
| { |
| const _ZSortFly &rTmp = aArr[k]; |
| const SwFrmFmt *pTmp = rTmp.GetFmt(); |
| if ( rChain.GetPrev() == pTmp ) |
| { |
| ::lcl_ChainFmts( (SwFlyFrmFmt*)aNewArr[k], |
| (SwFlyFrmFmt*)aNewArr[n] ); |
| --nCnt; |
| } |
| else if ( rChain.GetNext() == pTmp ) |
| { |
| ::lcl_ChainFmts( (SwFlyFrmFmt*)aNewArr[n], |
| (SwFlyFrmFmt*)aNewArr[k] ); |
| --nCnt; |
| } |
| } |
| } |
| } |
| } |
| |
| |
| |
| |
