1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sw.hxx" 26 27 #include <svl/smplhint.hxx> 28 #include <hintids.hxx> 29 #include <sfx2/linkmgr.hxx> 30 #include <svl/itemiter.hxx> 31 #include <tools/resid.hxx> 32 #include <fmtcntnt.hxx> 33 #include <fmtanchr.hxx> 34 #include <txtftn.hxx> 35 #include <fmtclds.hxx> 36 #include <doc.hxx> 37 #include <IDocumentUndoRedo.hxx> 38 #include <rootfrm.hxx> 39 #include <pam.hxx> 40 #include <ndtxt.hxx> 41 #include <section.hxx> 42 #include <UndoSection.hxx> 43 #include <UndoDelete.hxx> 44 #include <swundo.hxx> 45 #include <calc.hxx> 46 #include <swtable.hxx> 47 #include <swserv.hxx> 48 #include <frmfmt.hxx> 49 #include <frmtool.hxx> 50 #include <ftnidx.hxx> 51 #include <docary.hxx> 52 #include <redline.hxx> 53 #include <sectfrm.hxx> 54 #include <pagefrm.hxx> 55 #include <cntfrm.hxx> 56 #include <node2lay.hxx> 57 #include <doctxm.hxx> 58 #include <fmtftntx.hxx> 59 #include <comcore.hrc> 60 // --> OD 2005-12-01 #i27138# 61 #include <viewsh.hxx> 62 #include <txtfrm.hxx> 63 // <-- 64 65 66 // OD 04.11.2003 #i21457# - new implementation of local method <lcl_IsInSameTblBox(..)>. 67 // Method now determines the previous/next on its own. Thus, it can be controlled, 68 // for which previous/next is checked, if it's visible. 69 bool lcl_IsInSameTblBox( SwNodes& _rNds, 70 const SwNode& _rNd, 71 const bool _bPrev ) 72 { 73 const SwTableNode* pTblNd = _rNd.FindTableNode(); 74 if ( !pTblNd ) 75 { 76 return true; 77 } 78 79 // determine index to be checked. Its assumed that a previous/next exist. 80 SwNodeIndex aChkIdx( _rNd ); 81 { 82 // determine index of previous/next - skip hidden ones, which are 83 // inside the table. 84 // If found one is before/after table, this one isn't in the same 85 // table box as <_rNd>. 86 bool bFound = false; 87 do 88 { 89 if ( _bPrev 90 ? !_rNds.GoPrevSection( &aChkIdx, sal_False, sal_False ) 91 : !_rNds.GoNextSection( &aChkIdx, sal_False, sal_False ) ) 92 { 93 ASSERT( false, "<lcl_IsInSameTblBox(..)> - no previous/next!" ); 94 return false; 95 } 96 else 97 { 98 if ( aChkIdx < pTblNd->GetIndex() || 99 aChkIdx > pTblNd->EndOfSectionNode()->GetIndex() ) 100 { 101 return false; 102 } 103 else 104 { 105 // check, if found one isn't inside a hidden section, which 106 // is also inside the table. 107 SwSectionNode* pSectNd = aChkIdx.GetNode().FindSectionNode(); 108 if ( !pSectNd || 109 pSectNd->GetIndex() < pTblNd->GetIndex() || 110 !pSectNd->GetSection().IsHiddenFlag() ) 111 { 112 bFound = true; 113 } 114 } 115 } 116 } while ( !bFound ); 117 } 118 119 // dann suche den StartNode der Box 120 const SwTableSortBoxes& rSortBoxes = pTblNd->GetTable().GetTabSortBoxes(); 121 sal_uLong nIdx = _rNd.GetIndex(); 122 for( sal_uInt16 n = 0; n < rSortBoxes.Count(); ++n ) 123 { 124 const SwStartNode* pNd = rSortBoxes[ n ]->GetSttNd(); 125 if ( pNd->GetIndex() < nIdx && nIdx < pNd->EndOfSectionIndex() ) 126 { 127 // dann muss der andere Index in derselben Section liegen 128 nIdx = aChkIdx.GetIndex(); 129 return pNd->GetIndex() < nIdx && nIdx < pNd->EndOfSectionIndex(); 130 } 131 } 132 133 return true; 134 } 135 136 void lcl_CheckEmptyLayFrm( SwNodes& rNds, SwSectionData& rSectionData, 137 const SwNode& rStt, const SwNode& rEnd ) 138 { 139 SwNodeIndex aIdx( rStt ); 140 if( !rNds.GoPrevSection( &aIdx, sal_True, sal_False ) || 141 !CheckNodesRange( rStt, aIdx, sal_True ) || 142 // OD 04.11.2003 #i21457# 143 !lcl_IsInSameTblBox( rNds, rStt, true )) 144 { 145 aIdx = rEnd; 146 if( !rNds.GoNextSection( &aIdx, sal_True, sal_False ) || 147 !CheckNodesRange( rEnd, aIdx, sal_True ) || 148 // OD 04.11.2003 #i21457# 149 !lcl_IsInSameTblBox( rNds, rEnd, false )) 150 { 151 rSectionData.SetHidden( false ); 152 } 153 } 154 } 155 156 SwSection * 157 SwDoc::InsertSwSection(SwPaM const& rRange, SwSectionData & rNewData, 158 SwTOXBase const*const pTOXBase, 159 SfxItemSet const*const pAttr, bool const bUpdate) 160 { 161 const SwNode* pPrvNd = 0; 162 sal_uInt16 nRegionRet = 0; 163 if( rRange.HasMark() && 164 0 == ( nRegionRet = IsInsRegionAvailable( rRange, &pPrvNd ) )) 165 { 166 ASSERT( !this, "Selection ueber verschiedene Sections" ); 167 return 0; 168 } 169 170 // Teste ob das gesamte Dokument versteckt werden soll, 171 // koennen wir zur Zeit nicht !!!! 172 if (rNewData.IsHidden() && rRange.HasMark()) 173 { 174 const SwPosition *pStt = rRange.Start(), *pEnd = rRange.End(); 175 if( !pStt->nContent.GetIndex() && 176 pEnd->nNode.GetNode().GetCntntNode()->Len() == 177 pEnd->nContent.GetIndex() ) 178 { 179 ::lcl_CheckEmptyLayFrm( GetNodes(), 180 rNewData, 181 pStt->nNode.GetNode(), 182 pEnd->nNode.GetNode() ); 183 } 184 } 185 186 SwUndoInsSection* pUndoInsSect = 0; 187 bool const bUndo(GetIDocumentUndoRedo().DoesUndo()); 188 if (bUndo) 189 { 190 pUndoInsSect = new SwUndoInsSection(rRange, rNewData, pAttr, pTOXBase); 191 GetIDocumentUndoRedo().AppendUndo( pUndoInsSect ); 192 GetIDocumentUndoRedo().DoUndo(false); 193 } 194 195 SwSectionFmt* const pFmt = MakeSectionFmt( 0 ); 196 if ( pAttr ) 197 { 198 pFmt->SetFmtAttr( *pAttr ); 199 } 200 201 SwSectionNode* pNewSectNode = 0; 202 203 RedlineMode_t eOld = GetRedlineMode(); 204 SetRedlineMode_intern( (RedlineMode_t)((eOld & ~nsRedlineMode_t::REDLINE_SHOW_MASK) | nsRedlineMode_t::REDLINE_IGNORE)); 205 206 if( rRange.HasMark() ) 207 { 208 SwPosition *pSttPos = (SwPosition*)rRange.Start(), 209 *pEndPos = (SwPosition*)rRange.End(); 210 if( pPrvNd && 3 == nRegionRet ) 211 { 212 ASSERT( pPrvNd, "der SectionNode fehlt" ); 213 SwNodeIndex aStt( pSttPos->nNode ), aEnd( pEndPos->nNode, +1 ); 214 while( pPrvNd != aStt.GetNode().StartOfSectionNode() ) 215 aStt--; 216 while( pPrvNd != aEnd.GetNode().StartOfSectionNode() ) 217 aEnd++; 218 219 --aEnd; // im InsertSection ist Ende inclusive 220 pNewSectNode = GetNodes().InsertTextSection( 221 aStt, *pFmt, rNewData, pTOXBase, & aEnd); 222 } 223 else 224 { 225 if( pUndoInsSect ) 226 { 227 if( !( pPrvNd && 1 == nRegionRet ) && 228 pSttPos->nContent.GetIndex() ) 229 { 230 SwTxtNode* const pTNd = 231 pSttPos->nNode.GetNode().GetTxtNode(); 232 if (pTNd) 233 { 234 pUndoInsSect->SaveSplitNode( pTNd, sal_True ); 235 } 236 } 237 238 if ( !( pPrvNd && 2 == nRegionRet ) ) 239 { 240 SwTxtNode *const pTNd = 241 pEndPos->nNode.GetNode().GetTxtNode(); 242 if (pTNd && 243 (pTNd->GetTxt().Len() != pEndPos->nContent.GetIndex())) 244 { 245 pUndoInsSect->SaveSplitNode( pTNd, sal_False ); 246 } 247 } 248 } 249 250 const SwCntntNode* pCNd; 251 if( pPrvNd && 1 == nRegionRet ) 252 { 253 pSttPos->nNode.Assign( *pPrvNd ); 254 pSttPos->nContent.Assign( pSttPos->nNode.GetNode().GetCntntNode(), 0 ); 255 } 256 else if( pSttPos->nContent.GetIndex() ) 257 { 258 SplitNode( *pSttPos, false ); 259 } 260 261 if( pPrvNd && 2 == nRegionRet ) 262 { 263 pEndPos->nNode.Assign( *pPrvNd ); 264 pEndPos->nContent.Assign( pEndPos->nNode.GetNode().GetCntntNode(), 0 ); 265 } 266 else 267 { 268 pCNd = pEndPos->nNode.GetNode().GetCntntNode(); 269 if( pCNd && pCNd->Len() != pEndPos->nContent.GetIndex() ) 270 { 271 xub_StrLen nCntnt = pSttPos->nContent.GetIndex(); 272 SplitNode( *pEndPos, false ); 273 274 SwTxtNode* pTNd; 275 if( pEndPos->nNode.GetIndex() == pSttPos->nNode.GetIndex() ) 276 { 277 pSttPos->nNode--; 278 pEndPos->nNode--; 279 pTNd = pSttPos->nNode.GetNode().GetTxtNode(); 280 pSttPos->nContent.Assign( pTNd, nCntnt ); 281 } 282 else 283 { 284 // wieder ans Ende vom vorherigen setzen 285 pEndPos->nNode--; 286 pTNd = pEndPos->nNode.GetNode().GetTxtNode(); 287 } 288 if( pTNd ) nCntnt = pTNd->GetTxt().Len(); else nCntnt = 0; 289 pEndPos->nContent.Assign( pTNd, nCntnt ); 290 } 291 } 292 pNewSectNode = GetNodes().InsertTextSection( 293 pSttPos->nNode, *pFmt, rNewData, pTOXBase, &pEndPos->nNode); 294 } 295 } 296 else 297 { 298 const SwPosition* pPos = rRange.GetPoint(); 299 const SwCntntNode* pCNd = pPos->nNode.GetNode().GetCntntNode(); 300 if( !pPos->nContent.GetIndex() ) 301 { 302 pNewSectNode = GetNodes().InsertTextSection( 303 pPos->nNode, *pFmt, rNewData, pTOXBase, 0, true); 304 } 305 else if( pPos->nContent.GetIndex() == pCNd->Len() ) 306 { 307 pNewSectNode = GetNodes().InsertTextSection( 308 pPos->nNode, *pFmt, rNewData, pTOXBase, 0, false); 309 } 310 else 311 { 312 if( pUndoInsSect && pCNd->IsTxtNode() ) 313 { 314 pUndoInsSect->SaveSplitNode( (SwTxtNode*)pCNd, sal_True ); 315 } 316 SplitNode( *pPos, false ); 317 pNewSectNode = GetNodes().InsertTextSection( 318 pPos->nNode, *pFmt, rNewData, pTOXBase, 0, true); 319 } 320 } 321 322 //FEATURE::CONDCOLL 323 pNewSectNode->CheckSectionCondColl(); 324 //FEATURE::CONDCOLL 325 326 SetRedlineMode_intern( eOld ); 327 328 if( IsRedlineOn() || (!IsIgnoreRedline() && pRedlineTbl->Count() )) 329 { 330 SwPaM aPam( *pNewSectNode->EndOfSectionNode(), *pNewSectNode, 1 ); 331 if( IsRedlineOn() ) 332 { 333 AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true); 334 } 335 else 336 { 337 SplitRedline( aPam ); 338 } 339 } 340 341 // ist eine Condition gesetzt 342 if (rNewData.IsHidden() && rNewData.GetCondition().Len()) 343 { 344 // dann berechne bis zu dieser Position 345 SwCalc aCalc( *this ); 346 if( ! IsInReading() ) 347 { 348 FldsToCalc( aCalc, pNewSectNode->GetIndex(), USHRT_MAX ); 349 } 350 SwSection& rNewSect = pNewSectNode->GetSection(); 351 rNewSect.SetCondHidden( aCalc.Calculate( rNewSect.GetCondition() ).GetBool() ); 352 } 353 354 sal_Bool bUpdateFtn = sal_False; 355 if( GetFtnIdxs().Count() && pAttr ) 356 { 357 sal_uInt16 nVal = ((SwFmtFtnAtTxtEnd&)pAttr->Get( 358 RES_FTN_AT_TXTEND )).GetValue(); 359 if( ( FTNEND_ATTXTEND_OWNNUMSEQ == nVal || 360 FTNEND_ATTXTEND_OWNNUMANDFMT == nVal ) || 361 ( FTNEND_ATTXTEND_OWNNUMSEQ == ( nVal = ((SwFmtEndAtTxtEnd&) 362 pAttr->Get( RES_END_AT_TXTEND )).GetValue() ) || 363 FTNEND_ATTXTEND_OWNNUMANDFMT == nVal )) 364 { 365 bUpdateFtn = sal_True; 366 } 367 } 368 369 if( pUndoInsSect ) 370 { 371 pUndoInsSect->SetSectNdPos( pNewSectNode->GetIndex() ); 372 pUndoInsSect->SetUpdtFtnFlag( bUpdateFtn ); 373 GetIDocumentUndoRedo().DoUndo(bUndo); 374 } 375 376 if (rNewData.IsLinkType()) 377 { 378 pNewSectNode->GetSection().CreateLink( bUpdate ? CREATE_UPDATE : CREATE_CONNECT ); 379 } 380 381 if( bUpdateFtn ) 382 { 383 GetFtnIdxs().UpdateFtn( SwNodeIndex( *pNewSectNode )); 384 } 385 386 SetModified(); 387 return &pNewSectNode->GetSection(); 388 } 389 390 sal_uInt16 SwDoc::IsInsRegionAvailable( const SwPaM& rRange, 391 const SwNode** ppSttNd ) const 392 { 393 sal_uInt16 nRet = 1; 394 if( rRange.HasMark() ) 395 { 396 // teste ob es sich um eine gueltige Selektion handelt 397 const SwPosition* pStt = rRange.Start(), 398 * pEnd = rRange.End(); 399 400 const SwCntntNode* pCNd = pEnd->nNode.GetNode().GetCntntNode(); 401 const SwNode* pNd = &pStt->nNode.GetNode(); 402 const SwSectionNode* pSectNd = pNd->FindSectionNode(); 403 const SwSectionNode* pEndSectNd = pCNd ? pCNd->FindSectionNode() : 0; 404 if( pSectNd && pEndSectNd && pSectNd != pEndSectNd ) 405 { 406 // versuche eine umschliessende Section zu erzeugen 407 // Aber, nur wenn der Start am Sectionanfang und das Ende am 408 // Section Ende liegt! 409 nRet = 0; 410 if( !pStt->nContent.GetIndex() && pSectNd->GetIndex() 411 == pStt->nNode.GetIndex() - 1 && pEnd->nContent.GetIndex() == 412 pCNd->Len() ) 413 { 414 SwNodeIndex aIdx( pStt->nNode, -1 ); 415 sal_uLong nCmp = pEnd->nNode.GetIndex(); 416 const SwStartNode* pPrvNd; 417 const SwEndNode* pNxtNd; 418 while( 0 != ( pPrvNd = (pNd = &aIdx.GetNode())->GetSectionNode() ) && 419 !( aIdx.GetIndex() < nCmp && 420 nCmp < pPrvNd->EndOfSectionIndex() ) ) 421 { 422 aIdx--; 423 } 424 if( !pPrvNd ) 425 pPrvNd = pNd->IsStartNode() ? (SwStartNode*)pNd 426 : pNd->StartOfSectionNode(); 427 428 aIdx = pEnd->nNode.GetIndex() + 1; 429 nCmp = pStt->nNode.GetIndex(); 430 while( 0 != ( pNxtNd = (pNd = &aIdx.GetNode())->GetEndNode() ) && 431 pNxtNd->StartOfSectionNode()->IsSectionNode() && 432 !( pNxtNd->StartOfSectionIndex() < nCmp && 433 nCmp < aIdx.GetIndex() ) ) 434 { 435 aIdx++; 436 } 437 if( !pNxtNd ) 438 pNxtNd = pNd->EndOfSectionNode(); 439 440 if( pPrvNd && pNxtNd && pPrvNd == pNxtNd->StartOfSectionNode() ) 441 { 442 nRet = 3; 443 444 if( ppSttNd ) 445 *ppSttNd = pPrvNd; 446 } 447 } 448 } 449 else if( !pSectNd && pEndSectNd ) 450 { 451 // try to create a section enclosing it if the end is at the section end 452 nRet = 0; 453 if( pEnd->nContent.GetIndex() == pCNd->Len() ) 454 { 455 SwNodeIndex aIdx( pEnd->nNode, 1 ); 456 if( aIdx.GetNode().IsEndNode() && 457 0 != aIdx.GetNode().FindSectionNode() ) 458 { 459 do { 460 aIdx++; 461 } while( aIdx.GetNode().IsEndNode() && 462 0 != aIdx.GetNode().FindSectionNode() ); 463 // if( !aIdx.GetNode().IsEndNode() ) 464 { 465 nRet = 2; 466 if( ppSttNd ) 467 { 468 aIdx--; 469 *ppSttNd = &aIdx.GetNode(); 470 } 471 } 472 } 473 } 474 } 475 else if( pSectNd && !pEndSectNd ) 476 { 477 // try to create a section enclosing it if the start is at the section start 478 nRet = 0; 479 if( !pStt->nContent.GetIndex() ) 480 { 481 SwNodeIndex aIdx( pStt->nNode, -1 ); 482 if( aIdx.GetNode().IsSectionNode() ) 483 { 484 do { 485 aIdx--; 486 } while( aIdx.GetNode().IsSectionNode() ); 487 if( !aIdx.GetNode().IsSectionNode() ) 488 { 489 nRet = 1; 490 if( ppSttNd ) 491 { 492 aIdx++; 493 *ppSttNd = &aIdx.GetNode(); 494 } 495 } 496 } 497 } 498 } 499 } 500 return nRet; 501 } 502 503 SwSection* SwDoc::GetCurrSection( const SwPosition& rPos ) const 504 { 505 const SwSectionNode* pSectNd = rPos.nNode.GetNode().FindSectionNode(); 506 if( pSectNd ) 507 return (SwSection*)&pSectNd->GetSection(); 508 return 0; 509 } 510 511 SwSectionFmt* SwDoc::MakeSectionFmt( SwSectionFmt *pDerivedFrom ) 512 { 513 if( !pDerivedFrom ) 514 pDerivedFrom = (SwSectionFmt*)pDfltFrmFmt; 515 SwSectionFmt* pNew = new SwSectionFmt( pDerivedFrom, this ); 516 pSectionFmtTbl->Insert( pNew, pSectionFmtTbl->Count() ); 517 return pNew; 518 } 519 520 void SwDoc::DelSectionFmt( SwSectionFmt *pFmt, sal_Bool bDelNodes ) 521 { 522 sal_uInt16 nPos = pSectionFmtTbl->GetPos( pFmt ); 523 524 GetIDocumentUndoRedo().StartUndo(UNDO_DELSECTION, NULL); 525 526 if( USHRT_MAX != nPos ) 527 { 528 const SwNodeIndex* pIdx = pFmt->GetCntnt( sal_False ).GetCntntIdx(); 529 const SfxPoolItem* pFtnEndAtTxtEnd; 530 if( SFX_ITEM_SET != pFmt->GetItemState( 531 RES_FTN_AT_TXTEND, sal_True, &pFtnEndAtTxtEnd ) || 532 SFX_ITEM_SET != pFmt->GetItemState( 533 RES_END_AT_TXTEND, sal_True, &pFtnEndAtTxtEnd )) 534 pFtnEndAtTxtEnd = 0; 535 536 const SwSectionNode* pSectNd; 537 538 if( GetIDocumentUndoRedo().DoesUndo() ) 539 { 540 if( bDelNodes && pIdx && &GetNodes() == &pIdx->GetNodes() && 541 0 != (pSectNd = pIdx->GetNode().GetSectionNode() )) 542 { 543 SwNodeIndex aUpdIdx( *pIdx ); 544 SwPaM aPaM( *pSectNd->EndOfSectionNode(), *pSectNd ); 545 GetIDocumentUndoRedo().AppendUndo( new SwUndoDelete( aPaM )); 546 if( pFtnEndAtTxtEnd ) 547 GetFtnIdxs().UpdateFtn( aUpdIdx ); 548 SetModified(); 549 //#126178# start/end undo have to be pairs! 550 GetIDocumentUndoRedo().EndUndo(UNDO_DELSECTION, NULL); 551 return ; 552 } 553 GetIDocumentUndoRedo().AppendUndo( MakeUndoDelSection( *pFmt ) ); 554 } 555 else if( bDelNodes && pIdx && &GetNodes() == &pIdx->GetNodes() && 556 0 != (pSectNd = pIdx->GetNode().GetSectionNode() )) 557 { 558 SwNodeIndex aUpdIdx( *pIdx ); 559 DeleteSection( (SwNode*)pSectNd ); 560 if( pFtnEndAtTxtEnd ) 561 GetFtnIdxs().UpdateFtn( aUpdIdx ); 562 SetModified(); 563 //#126178# start/end undo have to be pairs! 564 GetIDocumentUndoRedo().EndUndo(UNDO_DELSECTION, NULL); 565 return ; 566 } 567 568 { 569 SwPtrMsgPoolItem aMsgHint( RES_REMOVE_UNO_OBJECT, pFmt ); 570 pFmt->ModifyNotification( &aMsgHint, &aMsgHint ); 571 } 572 573 // A ClearRedo could result in a rekursive call of this function and delete some section 574 // formats => the position iside the SectionFmtTbl could have changed 575 nPos = pSectionFmtTbl->GetPos( pFmt ); 576 577 // ACHTUNG: erst aus dem Array entfernen und dann loeschen. 578 // Der Section-DTOR versucht selbst noch sein Format 579 // zu loeschen! 580 pSectionFmtTbl->Remove( nPos ); 581 //FEATURE::CONDCOLL 582 sal_uLong nCnt = 0, nSttNd = 0; 583 if( pIdx && &GetNodes() == &pIdx->GetNodes() && 584 0 != (pSectNd = pIdx->GetNode().GetSectionNode() )) 585 { 586 nSttNd = pSectNd->GetIndex(); 587 nCnt = pSectNd->EndOfSectionIndex() - nSttNd - 1; 588 } 589 //FEATURE::CONDCOLL 590 591 delete pFmt; 592 593 if( nSttNd && pFtnEndAtTxtEnd ) 594 { 595 SwNodeIndex aUpdIdx( GetNodes(), nSttNd ); 596 GetFtnIdxs().UpdateFtn( aUpdIdx ); 597 } 598 599 //FEATURE::CONDCOLL 600 SwCntntNode* pCNd; 601 for( ; nCnt--; ++nSttNd ) 602 if( 0 != (pCNd = GetNodes()[ nSttNd ]->GetCntntNode() ) && 603 RES_CONDTXTFMTCOLL == pCNd->GetFmtColl()->Which() ) 604 pCNd->ChkCondColl(); 605 //FEATURE::CONDCOLL 606 } 607 608 GetIDocumentUndoRedo().EndUndo(UNDO_DELSECTION, NULL); 609 610 SetModified(); 611 } 612 613 void SwDoc::UpdateSection(sal_uInt16 const nPos, SwSectionData & rNewData, 614 SfxItemSet const*const pAttr, bool const bPreventLinkUpdate) 615 { 616 SwSectionFmt* pFmt = (*pSectionFmtTbl)[ nPos ]; 617 SwSection* pSection = pFmt->GetSection(); 618 /// OD 04.10.2002 #102894# 619 /// remember hidden condition flag of SwSection before changes 620 bool bOldCondHidden = pSection->IsCondHidden() ? true : false; 621 622 if (pSection->DataEquals(rNewData)) 623 { 624 // die Attribute ueberpruefen 625 sal_Bool bOnlyAttrChg = sal_False; 626 if( pAttr && pAttr->Count() ) 627 { 628 SfxItemIter aIter( *pAttr ); 629 sal_uInt16 nWhich = aIter.GetCurItem()->Which(); 630 while( sal_True ) 631 { 632 if( pFmt->GetFmtAttr( nWhich ) != *aIter.GetCurItem() ) 633 { 634 bOnlyAttrChg = sal_True; 635 break; 636 } 637 638 if( aIter.IsAtEnd() ) 639 break; 640 nWhich = aIter.NextItem()->Which(); 641 } 642 } 643 644 if( bOnlyAttrChg ) 645 { 646 if (GetIDocumentUndoRedo().DoesUndo()) 647 { 648 GetIDocumentUndoRedo().AppendUndo( 649 MakeUndoUpdateSection( *pFmt, true ) ); 650 } 651 // #i32968# Inserting columns in the section causes MakeFrmFmt 652 // to put two objects of type SwUndoFrmFmt on the undo stack. 653 // We don't want them. 654 ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo()); 655 pFmt->SetFmtAttr( *pAttr ); 656 SetModified(); 657 } 658 return; 659 } 660 661 // Teste ob eine gesamte Content-Section (Dokument/TabellenBox/Fly) 662 // versteckt werden soll, koennen wir zur Zeit nicht !!!! 663 const SwNodeIndex* pIdx = 0; 664 { 665 if (rNewData.IsHidden()) 666 { 667 pIdx = pFmt->GetCntnt().GetCntntIdx(); 668 if (pIdx) 669 { 670 const SwSectionNode* pSectNd = 671 pIdx->GetNode().GetSectionNode(); 672 if (pSectNd) 673 { 674 ::lcl_CheckEmptyLayFrm( GetNodes(), rNewData, 675 *pSectNd, *pSectNd->EndOfSectionNode() ); 676 } 677 } 678 } 679 } 680 681 if (GetIDocumentUndoRedo().DoesUndo()) 682 { 683 GetIDocumentUndoRedo().AppendUndo(MakeUndoUpdateSection(*pFmt, false)); 684 } 685 // #i32968# Inserting columns in the section causes MakeFrmFmt to put two 686 // objects of type SwUndoFrmFmt on the undo stack. We don't want them. 687 ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo()); 688 689 // #56167# Der LinkFileName koennte auch nur aus Separatoren bestehen 690 String sCompareString = sfx2::cTokenSeperator; 691 sCompareString += sfx2::cTokenSeperator; 692 const bool bUpdate = 693 (!pSection->IsLinkType() && rNewData.IsLinkType()) 694 || ( rNewData.GetLinkFileName().Len() 695 && (rNewData.GetLinkFileName() != sCompareString) 696 && (rNewData.GetLinkFileName() != pSection->GetLinkFileName())); 697 698 String sSectName( rNewData.GetSectionName() ); 699 if (sSectName != pSection->GetSectionName()) 700 GetUniqueSectionName( &sSectName ); 701 else 702 sSectName.Erase(); 703 704 /// OD 04.10.2002 #102894# - NOTE 705 /// In SwSection::operator=(..) class member bCondHiddenFlag is always set to sal_True. 706 /// IMHO this have to be changed, but I can't estimate the consequences: 707 /// Either it is set to sal_True using corresponding method <SwSection.SetCondHidden(..)>, 708 /// or it is set to the value of SwSection which is assigned to it. 709 /// Discussion with AMA results that the adjustment to the assignment operator 710 /// could be very risky -> see notes in bug #102894#. 711 pSection->SetSectionData(rNewData); 712 713 if( pAttr ) 714 pSection->GetFmt()->SetFmtAttr( *pAttr ); 715 716 if( sSectName.Len() ) 717 { 718 pSection->SetSectionName( sSectName ); 719 } 720 721 // ist eine Condition gesetzt 722 if( pSection->IsHidden() && pSection->GetCondition().Len() ) 723 { 724 // dann berechne bis zu dieser Position 725 SwCalc aCalc( *this ); 726 if( !pIdx ) 727 pIdx = pFmt->GetCntnt().GetCntntIdx(); 728 FldsToCalc( aCalc, pIdx->GetIndex(), USHRT_MAX ); 729 /// OD 04.10.2002 #102894# 730 /// Because on using SwSection::operator=() to set up <pSection> 731 /// with <rNewData> and the above given note, the hidden condition flag 732 /// has to be set to sal_False, if hidden condition flag of <pFmt->GetSection()> 733 /// (SwSection before the changes) is sal_False (already saved in <bOldCondHidden>) 734 /// and new calculated condition is sal_True. 735 /// This is necessary, because otherwise the <SetCondHidden> would have 736 /// no effect. 737 bool bCalculatedCondHidden = 738 aCalc.Calculate( pSection->GetCondition() ).GetBool() ? true : false; 739 if ( bCalculatedCondHidden && !bOldCondHidden ) 740 { 741 pSection->SetCondHidden( false ); 742 } 743 pSection->SetCondHidden( bCalculatedCondHidden ); 744 } 745 746 if( bUpdate ) 747 pSection->CreateLink( bPreventLinkUpdate ? CREATE_CONNECT : CREATE_UPDATE ); 748 else if( !pSection->IsLinkType() && pSection->IsConnected() ) 749 { 750 pSection->Disconnect(); 751 GetLinkManager().Remove( &pSection->GetBaseLink() ); 752 } 753 754 SetModified(); 755 } 756 757 /* -----------------19.02.99 09:31------------------- 758 * LockFrms wurde im InsertSection genutzt, um zu verhindern, dass 759 * SectionFrms durch das DelFrms zerstoert werden. Dies ist durch 760 * den Destroy-Listen-Mechanismus ueberfluessig geworden. 761 * Falls diese Methode doch noch einmal reanimiert wird, bietet es 762 * sich vielleicht an, beim Entlocken die SectionFrms auf Inhalt zu 763 * pruefen und dann ggf. zur Zerstoerung anzumelden. 764 * --------------------------------------------------*/ 765 766 // und dann waren da noch die Fussnoten: 767 void lcl_DeleteFtn( SwSectionNode *pNd, sal_uLong nStt, sal_uLong nEnd ) 768 { 769 SwFtnIdxs& rFtnArr = pNd->GetDoc()->GetFtnIdxs(); 770 if( rFtnArr.Count() ) 771 { 772 sal_uInt16 nPos; 773 rFtnArr.SeekEntry( SwNodeIndex( *pNd ), &nPos ); 774 SwTxtFtn* pSrch; 775 776 // loesche erstmal alle, die dahinter stehen 777 while( nPos < rFtnArr.Count() && 778 _SwTxtFtn_GetIndex( (pSrch = rFtnArr[ nPos ]) ) <= nEnd ) 779 { 780 // Werden die Nodes nicht geloescht mussen sie bei den Seiten 781 // abmeldet (Frms loeschen) werden, denn sonst bleiben sie 782 // stehen (Undo loescht sie nicht!) 783 pSrch->DelFrms(0); 784 ++nPos; 785 } 786 787 while( nPos-- && 788 _SwTxtFtn_GetIndex( (pSrch = rFtnArr[ nPos ]) ) >= nStt ) 789 { 790 // Werden die Nodes nicht geloescht mussen sie bei den Seiten 791 // abmeldet (Frms loeschen) werden, denn sonst bleiben sie 792 // stehen (Undo loescht sie nicht!) 793 pSrch->DelFrms(0); 794 } 795 } 796 } 797 798 static inline bool lcl_IsTOXSection(SwSectionData const& rSectionData) 799 { 800 return (TOX_CONTENT_SECTION == rSectionData.GetType()) 801 || (TOX_HEADER_SECTION == rSectionData.GetType()); 802 } 803 804 SwSectionNode* SwNodes::InsertTextSection(SwNodeIndex const& rNdIdx, 805 SwSectionFmt& rSectionFmt, 806 SwSectionData const& rSectionData, 807 SwTOXBase const*const pTOXBase, 808 SwNodeIndex const*const pEnde, 809 bool const bInsAtStart, bool const bCreateFrms) 810 { 811 SwNodeIndex aInsPos( rNdIdx ); 812 if( !pEnde ) // kein Bereich also neue Section davor/hinter anlegen 813 { 814 // #i26762# 815 ASSERT(!pEnde || rNdIdx <= *pEnde, 816 "Section start and end in wrong order!"); 817 818 if( bInsAtStart ) 819 { 820 if (!lcl_IsTOXSection(rSectionData)) 821 { 822 do { 823 aInsPos--; 824 } while( aInsPos.GetNode().IsSectionNode() ); 825 aInsPos++; 826 } 827 } 828 else 829 { 830 SwNode* pNd; 831 aInsPos++; 832 if (!lcl_IsTOXSection(rSectionData)) 833 { 834 while( aInsPos.GetIndex() < Count() - 1 && 835 ( pNd = &aInsPos.GetNode())->IsEndNode() && 836 pNd->StartOfSectionNode()->IsSectionNode()) 837 { 838 aInsPos++; 839 } 840 } 841 } 842 } 843 844 SwSectionNode *const pSectNd = 845 new SwSectionNode(aInsPos, rSectionFmt, pTOXBase); 846 if( pEnde ) 847 { 848 // Sonderfall fuer die Reader/Writer 849 if( &pEnde->GetNode() != &GetEndOfContent() ) 850 aInsPos = pEnde->GetIndex()+1; 851 // #i58710: We created a RTF document with a section break inside a table cell 852 // We are not able to handle a section start inside a table and the section end outside. 853 const SwNode* pLastNode = pSectNd->StartOfSectionNode()->EndOfSectionNode(); 854 if( aInsPos > pLastNode->GetIndex() ) 855 aInsPos = pLastNode->GetIndex(); 856 // Another way round: if the section starts outside a table but the end is inside... 857 // aInsPos is at the moment the Position where my EndNode will be inserted 858 const SwStartNode* pStartNode = aInsPos.GetNode().StartOfSectionNode(); 859 // This StartNode should be in front of me, but if not, I wanna survive 860 sal_uLong nMyIndex = pSectNd->GetIndex(); 861 if( pStartNode->GetIndex() > nMyIndex ) // Suspicious! 862 { 863 const SwNode* pTemp; 864 do 865 { 866 pTemp = pStartNode; // pTemp is a suspicious one 867 pStartNode = pStartNode->StartOfSectionNode(); 868 } 869 while( pStartNode->GetIndex() > nMyIndex ); 870 pTemp = pTemp->EndOfSectionNode(); 871 // If it starts behind me but ends behind my end... 872 if( pTemp->GetIndex() >= aInsPos.GetIndex() ) 873 aInsPos = pTemp->GetIndex()+1; // ...I have to correct my end position 874 } 875 876 } 877 else 878 { 879 SwTxtNode* pCpyTNd = rNdIdx.GetNode().GetTxtNode(); 880 if( pCpyTNd ) 881 { 882 SwTxtNode* pTNd = new SwTxtNode( aInsPos, pCpyTNd->GetTxtColl() ); 883 if( pCpyTNd->HasSwAttrSet() ) 884 { 885 // Task 70955 - move PageDesc/Break to the first Node of the 886 // section 887 const SfxItemSet& rSet = *pCpyTNd->GetpSwAttrSet(); 888 if( SFX_ITEM_SET == rSet.GetItemState( RES_BREAK ) || 889 SFX_ITEM_SET == rSet.GetItemState( RES_PAGEDESC )) 890 { 891 SfxItemSet aSet( rSet ); 892 if( bInsAtStart ) 893 pCpyTNd->ResetAttr( RES_PAGEDESC, RES_BREAK ); 894 else 895 { 896 aSet.ClearItem( RES_PAGEDESC ); 897 aSet.ClearItem( RES_BREAK ); 898 } 899 pTNd->SetAttr( aSet ); 900 } 901 else 902 pTNd->SetAttr( rSet ); 903 } 904 // den Frame anlegen nicht vergessen !! 905 pCpyTNd->MakeFrms( *pTNd ); 906 } 907 else 908 new SwTxtNode( aInsPos, (SwTxtFmtColl*)GetDoc()->GetDfltTxtFmtColl() ); 909 } 910 new SwEndNode( aInsPos, *pSectNd ); 911 912 pSectNd->GetSection().SetSectionData(rSectionData); 913 SwSectionFmt* pSectFmt = pSectNd->GetSection().GetFmt(); 914 915 // Hier bietet sich als Optimierung an, vorhandene Frames nicht zu 916 // zerstoeren und wieder neu anzulegen, sondern nur umzuhaengen. 917 sal_Bool bInsFrm = bCreateFrms && !pSectNd->GetSection().IsHidden() && 918 GetDoc()->GetCurrentViewShell(); //swmod 071108//swmod 071225 919 SwNode2Layout *pNode2Layout = NULL; 920 if( bInsFrm ) 921 { 922 SwNodeIndex aTmp( *pSectNd ); 923 if( !pSectNd->GetNodes().FindPrvNxtFrmNode( aTmp, pSectNd->EndOfSectionNode() ) ) 924 // dann sammel mal alle Uppers ein 925 pNode2Layout = new SwNode2Layout( *pSectNd ); 926 } 927 928 // jetzt noch bei allen im Bereich den richtigen StartNode setzen 929 sal_uLong nEnde = pSectNd->EndOfSectionIndex(); 930 sal_uLong nStart = pSectNd->GetIndex()+1; 931 sal_uLong nSkipIdx = ULONG_MAX; 932 for( sal_uLong n = nStart; n < nEnde; ++n ) 933 { 934 SwNode* pNd = (*this)[n]; 935 936 //JP 30.04.99: Bug 65644 - alle in der NodeSection liegenden 937 // Sections unter die neue haengen 938 if( ULONG_MAX == nSkipIdx ) 939 pNd->pStartOfSection = pSectNd; 940 else if( n >= nSkipIdx ) 941 nSkipIdx = ULONG_MAX; 942 943 if( pNd->IsStartNode() ) 944 { 945 // die Verschachtelung der Formate herstellen! 946 if( pNd->IsSectionNode() ) 947 { 948 ((SwSectionNode*)pNd)->GetSection().GetFmt()-> 949 SetDerivedFrom( pSectFmt ); 950 ((SwSectionNode*)pNd)->DelFrms(); 951 n = pNd->EndOfSectionIndex(); 952 } 953 else 954 { 955 if( pNd->IsTableNode() ) 956 ((SwTableNode*)pNd)->DelFrms(); 957 958 if( ULONG_MAX == nSkipIdx ) 959 nSkipIdx = pNd->EndOfSectionIndex(); 960 } 961 } 962 else if( pNd->IsCntntNode() ) 963 ((SwCntntNode*)pNd)->DelFrms(); 964 } 965 966 lcl_DeleteFtn( pSectNd, nStart, nEnde ); 967 968 if( bInsFrm ) 969 { 970 if( pNode2Layout ) 971 { 972 sal_uLong nIdx = pSectNd->GetIndex(); 973 pNode2Layout->RestoreUpperFrms( pSectNd->GetNodes(), nIdx, nIdx + 1 ); 974 delete pNode2Layout; 975 } 976 else 977 pSectNd->MakeFrms( &aInsPos ); 978 } 979 980 return pSectNd; 981 } 982 983 SwSectionNode* SwNode::FindSectionNode() 984 { 985 if( IsSectionNode() ) 986 return GetSectionNode(); 987 SwStartNode* pTmp = pStartOfSection; 988 while( !pTmp->IsSectionNode() && pTmp->GetIndex() ) 989 #if defined( ALPHA ) && defined( UNX ) 990 pTmp = ((SwNode*)pTmp)->pStartOfSection; 991 #else 992 pTmp = pTmp->pStartOfSection; 993 #endif 994 return pTmp->GetSectionNode(); 995 } 996 997 998 //--------- 999 // SwSectionNode 1000 //--------- 1001 1002 // ugly hack to make m_pSection const 1003 static SwSectionFmt & 1004 lcl_initParent(SwSectionNode & rThis, SwSectionFmt & rFmt) 1005 { 1006 SwSectionNode *const pParent = 1007 rThis.StartOfSectionNode()->FindSectionNode(); 1008 if( pParent ) 1009 { 1010 // das Format beim richtigen Parent anmelden. 1011 rFmt.SetDerivedFrom( pParent->GetSection().GetFmt() ); 1012 } 1013 return rFmt; 1014 } 1015 1016 SwSectionNode::SwSectionNode(SwNodeIndex const& rIdx, 1017 SwSectionFmt & rFmt, SwTOXBase const*const pTOXBase) 1018 : SwStartNode( rIdx, ND_SECTIONNODE ) 1019 , m_pSection( (pTOXBase) 1020 ? new SwTOXBaseSection(*pTOXBase, lcl_initParent(*this, rFmt)) 1021 : new SwSection( CONTENT_SECTION, rFmt.GetName(), 1022 lcl_initParent(*this, rFmt) ) ) 1023 { 1024 // jetzt noch die Verbindung von Format zum Node setzen 1025 // Modify unterdruecken, interresiert keinen 1026 rFmt.LockModify(); 1027 rFmt.SetFmtAttr( SwFmtCntnt( this ) ); 1028 rFmt.UnlockModify(); 1029 } 1030 1031 #if OSL_DEBUG_LEVEL > 1 1032 //Hier werden ueberfluessige SectionFrms entfernt 1033 SwFrm* SwClearDummies( SwFrm* pFrm ) 1034 { 1035 SwFrm* pTmp = pFrm; 1036 while( pTmp ) 1037 { 1038 ASSERT( !pTmp->GetUpper(), "SwClearDummies: No Upper allowed!" ); 1039 if( pTmp->IsSctFrm() ) 1040 { 1041 SwSectionFrm* pSectFrm = (SwSectionFrm*)pFrm; 1042 pTmp = pTmp->GetNext(); 1043 if( !pSectFrm->GetLower() ) 1044 { 1045 if( pSectFrm->GetPrev() ) 1046 pSectFrm->GetPrev()->pNext = pTmp; 1047 else 1048 pFrm = pTmp; 1049 if( pTmp ) 1050 pTmp->pPrev = pSectFrm->GetPrev(); 1051 delete pSectFrm; 1052 } 1053 } 1054 else 1055 pTmp = pTmp->GetNext(); 1056 } 1057 return pFrm; 1058 } 1059 #endif 1060 1061 SwSectionNode::~SwSectionNode() 1062 { 1063 // mba: test if iteration works as clients will be removed in callback 1064 // --> OD #i117863# 1065 // use hint which allows to specify, if the content shall be saved or not 1066 m_pSection->GetFmt()->CallSwClientNotify( SwSectionFrmMoveAndDeleteHint( sal_True ) ); 1067 // <-- 1068 SwSectionFmt* pFmt = m_pSection->GetFmt(); 1069 if( pFmt ) 1070 { 1071 // das Attribut entfernen, weil die Section ihr Format loescht 1072 // und falls das Cntnt-Attribut vorhanden ist, die Section aufhebt. 1073 pFmt->LockModify(); 1074 pFmt->ResetFmtAttr( RES_CNTNT ); 1075 pFmt->UnlockModify(); 1076 } 1077 } 1078 1079 1080 SwFrm *SwSectionNode::MakeFrm( SwFrm *pSib ) 1081 { 1082 m_pSection->m_Data.SetHiddenFlag(false); 1083 return new SwSectionFrm( *m_pSection, pSib ); 1084 } 1085 1086 //Methode erzeugt fuer den vorhergehenden Node alle Ansichten vom 1087 //Dokument. Die erzeugten Contentframes werden in das entsprechende 1088 //Layout gehaengt. 1089 void SwSectionNode::MakeFrms(const SwNodeIndex & rIdx ) 1090 { 1091 // also nehme meinen nachfolgenden oder vorhergehenden ContentFrame: 1092 SwNodes& rNds = GetNodes(); 1093 if( rNds.IsDocNodes() && rNds.GetDoc()->GetCurrentViewShell() ) //swmod 071108//swmod 071225 1094 { 1095 if( GetSection().IsHidden() || IsCntntHidden() ) 1096 { 1097 SwNodeIndex aIdx( *EndOfSectionNode() ); 1098 SwCntntNode* pCNd = rNds.GoNextSection( &aIdx, sal_True, sal_False ); 1099 if( !pCNd ) 1100 { 1101 aIdx = *this; 1102 if( 0 == ( pCNd = rNds.GoPrevSection( &aIdx, sal_True, sal_False )) ) 1103 return ; 1104 } 1105 pCNd = aIdx.GetNode().GetCntntNode(); 1106 pCNd->MakeFrms( (SwCntntNode&)rIdx.GetNode() ); 1107 } 1108 else 1109 { 1110 SwNode2Layout aNode2Layout( *this, rIdx.GetIndex() ); 1111 SwFrm *pFrm, *pNew; 1112 while( 0 != (pFrm = aNode2Layout.NextFrm()) ) 1113 { 1114 ASSERT( pFrm->IsSctFrm(), "Depend von Section keine Section." ); 1115 pNew = rIdx.GetNode().GetCntntNode()->MakeFrm( pFrm ); 1116 1117 SwSectionNode* pS = rIdx.GetNode().FindSectionNode(); 1118 // --> OD 2008-06-23 #156927# 1119 // Assure that node is not inside a table, which is inside the 1120 // found section. 1121 if ( pS ) 1122 { 1123 SwTableNode* pTableNode = rIdx.GetNode().FindTableNode(); 1124 if ( pTableNode && 1125 pTableNode->GetIndex() > pS->GetIndex() ) 1126 { 1127 pS = 0; 1128 } 1129 } 1130 // <-- 1131 // if the node is in a section, the sectionframe now 1132 // has to be created.. 1133 // OD 14.11.2002 #104684# - boolean to control <Init()> of a new 1134 // section frame. 1135 bool bInitNewSect = false; 1136 if( pS ) 1137 { 1138 SwSectionFrm *pSct = new SwSectionFrm( pS->GetSection(), pFrm ); 1139 // OD 14.11.2002 #104684# - prepare <Init()> of new section frame. 1140 bInitNewSect = true; 1141 SwLayoutFrm* pUp = pSct; 1142 while( pUp->Lower() ) // for columned sections 1143 { 1144 ASSERT( pUp->Lower()->IsLayoutFrm(),"Who's in there?" ); 1145 pUp = (SwLayoutFrm*)pUp->Lower(); 1146 } 1147 pNew->Paste( pUp, NULL ); 1148 // --> OD 2005-12-01 #i27138# 1149 // notify accessibility paragraphs objects about changed 1150 // CONTENT_FLOWS_FROM/_TO relation. 1151 // Relation CONTENT_FLOWS_FROM for next paragraph will change 1152 // and relation CONTENT_FLOWS_TO for previous paragraph will change. 1153 if ( pNew->IsTxtFrm() ) 1154 { 1155 ViewShell* pViewShell( pNew->getRootFrm()->GetCurrShell() ); 1156 if ( pViewShell && pViewShell->GetLayout() && 1157 pViewShell->GetLayout()->IsAnyShellAccessible() ) 1158 { 1159 pViewShell->InvalidateAccessibleParaFlowRelation( 1160 dynamic_cast<SwTxtFrm*>(pNew->FindNextCnt( true )), 1161 dynamic_cast<SwTxtFrm*>(pNew->FindPrevCnt( true )) ); 1162 } 1163 } 1164 // <-- 1165 pNew = pSct; 1166 } 1167 1168 // wird ein Node vorher oder nachher mit Frames versehen 1169 if ( rIdx < GetIndex() ) 1170 // der neue liegt vor mir 1171 pNew->Paste( pFrm->GetUpper(), pFrm ); 1172 else 1173 // der neue liegt hinter mir 1174 pNew->Paste( pFrm->GetUpper(), pFrm->GetNext() ); 1175 // --> OD 2005-12-01 #i27138# 1176 // notify accessibility paragraphs objects about changed 1177 // CONTENT_FLOWS_FROM/_TO relation. 1178 // Relation CONTENT_FLOWS_FROM for next paragraph will change 1179 // and relation CONTENT_FLOWS_TO for previous paragraph will change. 1180 if ( pNew->IsTxtFrm() ) 1181 { 1182 ViewShell* pViewShell( pNew->getRootFrm()->GetCurrShell() ); 1183 if ( pViewShell && pViewShell->GetLayout() && 1184 pViewShell->GetLayout()->IsAnyShellAccessible() ) 1185 { 1186 pViewShell->InvalidateAccessibleParaFlowRelation( 1187 dynamic_cast<SwTxtFrm*>(pNew->FindNextCnt( true )), 1188 dynamic_cast<SwTxtFrm*>(pNew->FindPrevCnt( true )) ); 1189 } 1190 } 1191 // <-- 1192 if ( bInitNewSect ) 1193 static_cast<SwSectionFrm*>(pNew)->Init(); 1194 } 1195 } 1196 } 1197 } 1198 1199 //Fuer jedes vorkommen im Layout einen SectionFrm anlegen und vor den 1200 //entsprechenden CntntFrm pasten. 1201 1202 void SwSectionNode::MakeFrms( SwNodeIndex* pIdxBehind, SwNodeIndex* pEndIdx ) 1203 { 1204 ASSERT( pIdxBehind, "kein Index" ); 1205 SwNodes& rNds = GetNodes(); 1206 SwDoc* pDoc = rNds.GetDoc(); 1207 1208 *pIdxBehind = *this; 1209 1210 m_pSection->m_Data.SetHiddenFlag(true); 1211 1212 if( rNds.IsDocNodes() ) 1213 { 1214 SwNodeIndex *pEnd = pEndIdx ? pEndIdx : 1215 new SwNodeIndex( *EndOfSectionNode(), 1 ); 1216 ::MakeFrms( pDoc, *pIdxBehind, *pEnd ); 1217 if( !pEndIdx ) 1218 delete pEnd; 1219 } 1220 1221 } 1222 1223 void SwSectionNode::DelFrms() 1224 { 1225 sal_uLong nStt = GetIndex()+1, nEnd = EndOfSectionIndex(); 1226 if( nStt >= nEnd ) 1227 { 1228 // unser Flag muessen wir noch aktualisieren 1229 // pSection->bHiddenFlag = sal_True; 1230 return ; 1231 } 1232 1233 SwNodes& rNds = GetNodes(); 1234 m_pSection->GetFmt()->DelFrms(); 1235 1236 // unser Flag muessen wir noch aktualisieren 1237 m_pSection->m_Data.SetHiddenFlag(true); 1238 1239 // Bug 30582: falls der Bereich in Fly oder TabellenBox ist, dann 1240 // kann er nur "gehiddet" werden, wenn weiterer Content 1241 // vorhanden ist, der "Frames" haelt. Sonst hat der 1242 // Fly/TblBox-Frame keinen Lower !!! 1243 { 1244 SwNodeIndex aIdx( *this ); 1245 if( !rNds.GoPrevSection( &aIdx, sal_True, sal_False ) || 1246 !CheckNodesRange( *this, aIdx, sal_True ) || 1247 // OD 04.11.2003 #i21457# 1248 !lcl_IsInSameTblBox( rNds, *this, true )) 1249 { 1250 aIdx = *EndOfSectionNode(); 1251 if( !rNds.GoNextSection( &aIdx, sal_True, sal_False ) || 1252 !CheckNodesRange( *EndOfSectionNode(), aIdx, sal_True ) || 1253 // OD 04.11.2003 #i21457# 1254 !lcl_IsInSameTblBox( rNds, *EndOfSectionNode(), false )) 1255 { 1256 m_pSection->m_Data.SetHiddenFlag(false); 1257 } 1258 } 1259 } 1260 } 1261 1262 SwSectionNode* SwSectionNode::MakeCopy( SwDoc* pDoc, const SwNodeIndex& rIdx ) const 1263 { 1264 // in welchen Array steht ich denn: Nodes, UndoNodes ?? 1265 const SwNodes& rNds = GetNodes(); 1266 1267 // das SectionFrmFmt kopieren 1268 SwSectionFmt* pSectFmt = pDoc->MakeSectionFmt( 0 ); 1269 pSectFmt->CopyAttrs( *GetSection().GetFmt() ); 1270 1271 ::std::auto_ptr<SwTOXBase> pTOXBase; 1272 if (TOX_CONTENT_SECTION == GetSection().GetType()) 1273 { 1274 ASSERT( GetSection().ISA( SwTOXBaseSection ), "no TOXBaseSection!" ); 1275 SwTOXBaseSection const& rTBS( 1276 dynamic_cast<SwTOXBaseSection const&>(GetSection())); 1277 pTOXBase.reset( new SwTOXBase(rTBS, pDoc) ); 1278 } 1279 1280 SwSectionNode *const pSectNd = 1281 new SwSectionNode(rIdx, *pSectFmt, pTOXBase.get()); 1282 SwEndNode* pEndNd = new SwEndNode( rIdx, *pSectNd ); 1283 SwNodeIndex aInsPos( *pEndNd ); 1284 1285 // Werte uebertragen 1286 SwSection *const pNewSect = pSectNd->m_pSection.get(); 1287 1288 if (TOX_CONTENT_SECTION != GetSection().GetType()) 1289 { 1290 // beim Move den Namen beibehalten 1291 if( rNds.GetDoc() == pDoc && pDoc->IsCopyIsMove() ) 1292 { 1293 pNewSect->SetSectionName( GetSection().GetSectionName() ); 1294 } 1295 else 1296 { 1297 pNewSect->SetSectionName( 1298 pDoc->GetUniqueSectionName( &GetSection().GetSectionName() )); 1299 } 1300 } 1301 1302 1303 pNewSect->SetType( GetSection().GetType() ); 1304 pNewSect->SetCondition( GetSection().GetCondition() ); 1305 pNewSect->SetLinkFileName( GetSection().GetLinkFileName() ); 1306 if( !pNewSect->IsHiddenFlag() && GetSection().IsHidden() ) 1307 pNewSect->SetHidden( sal_True ); 1308 if( !pNewSect->IsProtectFlag() && GetSection().IsProtect() ) 1309 pNewSect->SetProtect( sal_True ); 1310 // --> FME 2004-06-22 #114856# edit in readonly sections 1311 if( !pNewSect->IsEditInReadonlyFlag() && GetSection().IsEditInReadonly() ) 1312 pNewSect->SetEditInReadonly( sal_True ); 1313 // <-- 1314 1315 SwNodeRange aRg( *this, +1, *EndOfSectionNode() ); // (wo stehe in denn nun ??) 1316 rNds._Copy( aRg, aInsPos, sal_False ); 1317 1318 // loesche alle Frames vom kopierten Bereich, diese werden beim 1319 // erzeugen des SectionFrames angelegt ! 1320 pSectNd->DelFrms(); 1321 1322 // dann kopiere auch noch die Links/Server 1323 if( pNewSect->IsLinkType() ) // den Link eintragen 1324 pNewSect->CreateLink( pDoc->GetCurrentViewShell() ? CREATE_CONNECT //swmod 071108//swmod 071225 1325 : CREATE_NONE ); 1326 1327 // falls als Server aus dem Undo kopiert wird, wieder eintragen 1328 if (m_pSection->IsServer() 1329 && pDoc->GetIDocumentUndoRedo().IsUndoNodes(rNds)) 1330 { 1331 pNewSect->SetRefObject( m_pSection->GetObject() ); 1332 pDoc->GetLinkManager().InsertServer( pNewSect->GetObject() ); 1333 } 1334 1335 // METADATA: copy xml:id; must be done after insertion of node 1336 pSectFmt->RegisterAsCopyOf(*GetSection().GetFmt()); 1337 1338 return pSectNd; 1339 } 1340 1341 sal_Bool SwSectionNode::IsCntntHidden() const 1342 { 1343 ASSERT( !m_pSection->IsHidden(), 1344 "That's simple: Hidden Section => Hidden Content" ); 1345 SwNodeIndex aTmp( *this, 1 ); 1346 sal_uLong nEnd = EndOfSectionIndex(); 1347 while( aTmp < nEnd ) 1348 { 1349 if( aTmp.GetNode().IsSectionNode() ) 1350 { 1351 const SwSection& rSect = ((SwSectionNode&)aTmp.GetNode()).GetSection(); 1352 if( rSect.IsHiddenFlag() ) 1353 // dann diese Section ueberspringen 1354 aTmp = *aTmp.GetNode().EndOfSectionNode(); 1355 } 1356 else 1357 { 1358 if( aTmp.GetNode().IsCntntNode() || aTmp.GetNode().IsTableNode() ) 1359 return sal_False; // Nicht versteckter Inhalt wurde gefunden 1360 ASSERT( aTmp.GetNode().IsEndNode(), "EndNode expected" ); 1361 } 1362 aTmp++; 1363 } 1364 return sal_True; // Alles versteckt 1365 } 1366 1367 1368 void SwSectionNode::NodesArrChgd() 1369 { 1370 SwSectionFmt *const pFmt = m_pSection->GetFmt(); 1371 if( pFmt ) 1372 { 1373 SwNodes& rNds = GetNodes(); 1374 SwDoc* pDoc = pFmt->GetDoc(); 1375 1376 if( !rNds.IsDocNodes() ) 1377 { 1378 SwPtrMsgPoolItem aMsgHint( RES_REMOVE_UNO_OBJECT, pFmt ); 1379 pFmt->ModifyNotification( &aMsgHint, &aMsgHint ); 1380 } 1381 1382 pFmt->LockModify(); 1383 pFmt->SetFmtAttr( SwFmtCntnt( this )); 1384 pFmt->UnlockModify(); 1385 1386 SwSectionNode* pSectNd = StartOfSectionNode()->FindSectionNode(); 1387 // set the correct parent from the new section 1388 pFmt->SetDerivedFrom( pSectNd ? pSectNd->GetSection().GetFmt() 1389 : pDoc->GetDfltFrmFmt() ); 1390 1391 // jetzt noch bei allen im Bereich den richtigen StartNode setzen 1392 sal_uLong nStart = GetIndex()+1, nEnde = EndOfSectionIndex(); 1393 for( sal_uLong n = nStart; n < nEnde; ++n ) 1394 // die Verschachtelung der Formate herstellen! 1395 if( 0 != ( pSectNd = rNds[ n ]->GetSectionNode() ) ) 1396 { 1397 pSectNd->GetSection().GetFmt()->SetDerivedFrom( pFmt ); 1398 n = pSectNd->EndOfSectionIndex(); 1399 } 1400 1401 // verschieben vom Nodes- ins UndoNodes-Array? 1402 if( rNds.IsDocNodes() ) 1403 { 1404 ASSERT( pDoc == GetDoc(), 1405 "verschieben in unterschiedliche Documente?" ); 1406 if( m_pSection->IsLinkType() ) // den Link austragen 1407 m_pSection->CreateLink( pDoc->GetCurrentViewShell() ? CREATE_CONNECT //swmod 071108 1408 : CREATE_NONE );//swmod 071225 1409 if (m_pSection->IsServer()) 1410 { 1411 pDoc->GetLinkManager().InsertServer( m_pSection->GetObject() ); 1412 } 1413 } 1414 else 1415 { 1416 if (CONTENT_SECTION != m_pSection->GetType()) 1417 { 1418 pDoc->GetLinkManager().Remove( &m_pSection->GetBaseLink() ); 1419 } 1420 1421 if (m_pSection->IsServer()) 1422 { 1423 pDoc->GetLinkManager().RemoveServer( m_pSection->GetObject() ); 1424 } 1425 } 1426 } 1427 } 1428 1429 1430 String SwDoc::GetUniqueSectionName( const String* pChkStr ) const 1431 { 1432 ResId aId( STR_REGION_DEFNAME, *pSwResMgr ); 1433 String aName( aId ); 1434 xub_StrLen nNmLen = aName.Len(); 1435 1436 sal_uInt16 nNum = 0; 1437 sal_uInt16 nTmp, nFlagSize = ( pSectionFmtTbl->Count() / 8 ) +2; 1438 sal_uInt8* pSetFlags = new sal_uInt8[ nFlagSize ]; 1439 memset( pSetFlags, 0, nFlagSize ); 1440 1441 const SwSectionNode* pSectNd; 1442 sal_uInt16 n; 1443 1444 for( n = 0; n < pSectionFmtTbl->Count(); ++n ) 1445 if( 0 != ( pSectNd = (*pSectionFmtTbl)[ n ]->GetSectionNode( sal_False ) )) 1446 { 1447 const String& rNm = pSectNd->GetSection().GetSectionName(); 1448 if( rNm.Match( aName ) == nNmLen ) 1449 { 1450 // Nummer bestimmen und das Flag setzen 1451 nNum = static_cast<sal_uInt16>(rNm.Copy( nNmLen ).ToInt32()); 1452 if( nNum-- && nNum < pSectionFmtTbl->Count() ) 1453 pSetFlags[ nNum / 8 ] |= (0x01 << ( nNum & 0x07 )); 1454 } 1455 if( pChkStr && pChkStr->Equals( rNm ) ) 1456 pChkStr = 0; 1457 } 1458 1459 if( !pChkStr ) 1460 { 1461 // alle Nummern entsprechend geflag, also bestimme die richtige Nummer 1462 nNum = pSectionFmtTbl->Count(); 1463 for( n = 0; n < nFlagSize; ++n ) 1464 if( 0xff != ( nTmp = pSetFlags[ n ] )) 1465 { 1466 // also die Nummer bestimmen 1467 nNum = n * 8; 1468 while( nTmp & 1 ) 1469 ++nNum, nTmp >>= 1; 1470 break; 1471 } 1472 1473 } 1474 delete [] pSetFlags; 1475 if( pChkStr ) 1476 return *pChkStr; 1477 return aName += String::CreateFromInt32( ++nNum ); 1478 } 1479 1480 1481