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 28 #include <hintids.hxx> 29 #include <svl/itemiter.hxx> 30 #include <editeng/lrspitem.hxx> 31 #include <editeng/adjitem.hxx> 32 #include <editeng/brkitem.hxx> 33 #include <svx/svdobj.hxx> 34 #include <crsrsh.hxx> 35 #include <doc.hxx> 36 #include <IDocumentUndoRedo.hxx> 37 #include <pagefrm.hxx> 38 #include <cntfrm.hxx> 39 #include <rootfrm.hxx> 40 #include <pam.hxx> 41 #include <ndtxt.hxx> 42 #include <fldbas.hxx> 43 #include <swtable.hxx> 44 #include <docary.hxx> 45 #include <txtfld.hxx> 46 #include <fmtfld.hxx> 47 #include <txtftn.hxx> 48 #include <txtinet.hxx> 49 #include <fmtinfmt.hxx> 50 #include <txttxmrk.hxx> 51 #include <frmfmt.hxx> 52 #include <flyfrm.hxx> 53 #include <viscrs.hxx> 54 #include <callnk.hxx> 55 #include <doctxm.hxx> 56 #include <docfld.hxx> 57 #include <expfld.hxx> 58 #include <reffld.hxx> 59 #include <flddat.hxx> 60 #include <cellatr.hxx> 61 #include <swundo.hxx> 62 #include <redline.hxx> 63 #include <fmtcntnt.hxx> 64 #include <fmthdft.hxx> 65 #include <pagedesc.hxx> 66 #include <fesh.hxx> 67 #include <charfmt.hxx> 68 #include <fmturl.hxx> 69 #include "txtfrm.hxx" 70 #include <wrong.hxx> 71 #include <switerator.hxx> 72 #include <vcl/window.hxx> 73 #include <docufld.hxx> // OD 2008-06-19 #i90516# 74 75 using namespace ::com::sun::star; 76 77 78 // zum naechsten/vorhergehenden Punkt auf gleicher Ebene 79 sal_Bool SwCrsrShell::GotoNextNum() 80 { 81 sal_Bool bRet = GetDoc()->GotoNextNum( *pCurCrsr->GetPoint() ); 82 if( bRet ) 83 { 84 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 85 SwCrsrSaveState aSaveState( *pCurCrsr ); 86 if( !ActionPend() ) 87 { 88 SET_CURR_SHELL( this ); 89 // dann versuche den Cursor auf die Position zu setzen, 90 // auf halber Heohe vom Char-SRectangle 91 Point aPt( pCurCrsr->GetPtPos() ); 92 SwCntntFrm * pFrm = pCurCrsr->GetCntntNode()->getLayoutFrm( GetLayout(), &aPt, 93 pCurCrsr->GetPoint() ); 94 pFrm->GetCharRect( aCharRect, *pCurCrsr->GetPoint() ); 95 pFrm->Calc(); 96 if( pFrm->IsVertical() ) 97 { 98 aPt.X() = aCharRect.Center().X(); 99 aPt.Y() = pFrm->Frm().Top() + nUpDownX; 100 } 101 else 102 { 103 aPt.Y() = aCharRect.Center().Y(); 104 aPt.X() = pFrm->Frm().Left() + nUpDownX; 105 } 106 pFrm->GetCrsrOfst( pCurCrsr->GetPoint(), aPt ); 107 bRet = !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE | 108 nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ); 109 if( bRet ) 110 UpdateCrsr(SwCrsrShell::UPDOWN | 111 SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE | 112 SwCrsrShell::READONLY ); 113 } 114 } 115 return bRet; 116 } 117 118 119 sal_Bool SwCrsrShell::GotoPrevNum() 120 { 121 sal_Bool bRet = GetDoc()->GotoPrevNum( *pCurCrsr->GetPoint() ); 122 if( bRet ) 123 { 124 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 125 SwCrsrSaveState aSaveState( *pCurCrsr ); 126 if( !ActionPend() ) 127 { 128 SET_CURR_SHELL( this ); 129 // dann versuche den Cursor auf die Position zu setzen, 130 // auf halber Heohe vom Char-SRectangle 131 Point aPt( pCurCrsr->GetPtPos() ); 132 SwCntntFrm * pFrm = pCurCrsr->GetCntntNode()->getLayoutFrm( GetLayout(), &aPt, 133 pCurCrsr->GetPoint() ); 134 pFrm->GetCharRect( aCharRect, *pCurCrsr->GetPoint() ); 135 pFrm->Calc(); 136 if( pFrm->IsVertical() ) 137 { 138 aPt.X() = aCharRect.Center().X(); 139 aPt.Y() = pFrm->Frm().Top() + nUpDownX; 140 } 141 else 142 { 143 aPt.Y() = aCharRect.Center().Y(); 144 aPt.X() = pFrm->Frm().Left() + nUpDownX; 145 } 146 pFrm->GetCrsrOfst( pCurCrsr->GetPoint(), aPt ); 147 bRet = !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE | 148 nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ); 149 if( bRet ) 150 UpdateCrsr(SwCrsrShell::UPDOWN | 151 SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE | 152 SwCrsrShell::READONLY ); 153 } 154 } 155 return bRet; 156 } 157 158 // springe aus dem Content zum Header 159 160 sal_Bool SwCrsrShell::GotoHeaderTxt() 161 { 162 const SwFrm* pFrm = GetCurrFrm()->FindPageFrm(); 163 while( pFrm && !pFrm->IsHeaderFrm() ) 164 pFrm = pFrm->GetLower(); 165 // Header gefunden, dann suche den 1.Cntnt-Frame 166 while( pFrm && !pFrm->IsCntntFrm() ) 167 pFrm = pFrm->GetLower(); 168 if( pFrm ) 169 { 170 SET_CURR_SHELL( this ); 171 // hole den Header-Frame 172 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 173 SwCursor *pTmpCrsr = getShellCrsr( true ); 174 SwCrsrSaveState aSaveState( *pTmpCrsr ); 175 pFrm->Calc(); 176 Point aPt( pFrm->Frm().Pos() + pFrm->Prt().Pos() ); 177 pFrm->GetCrsrOfst( pTmpCrsr->GetPoint(), aPt ); 178 if( !pTmpCrsr->IsSelOvr() ) 179 UpdateCrsr(); 180 else 181 pFrm = 0; 182 } 183 return 0 != pFrm; 184 } 185 186 187 // springe aus dem Content zum Footer 188 189 sal_Bool SwCrsrShell::GotoFooterTxt() 190 { 191 const SwPageFrm* pFrm = GetCurrFrm()->FindPageFrm(); 192 if( pFrm ) 193 { 194 const SwFrm* pLower = pFrm->GetLastLower(); 195 196 while( pLower && !pLower->IsFooterFrm() ) 197 pLower = pLower->GetLower(); 198 // Header gefunden, dann suche den 1.Cntnt-Frame 199 while( pLower && !pLower->IsCntntFrm() ) 200 pLower = pLower->GetLower(); 201 202 if( pLower ) 203 { 204 SwCursor *pTmpCrsr = getShellCrsr( true ); 205 SET_CURR_SHELL( this ); 206 // hole eine Position im Footer 207 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 208 SwCrsrSaveState aSaveState( *pTmpCrsr ); 209 pLower->Calc(); 210 Point aPt( pLower->Frm().Pos() + pLower->Prt().Pos() ); 211 pLower->GetCrsrOfst( pTmpCrsr->GetPoint(), aPt ); 212 if( !pTmpCrsr->IsSelOvr() ) 213 UpdateCrsr(); 214 else 215 pFrm = 0; 216 } 217 else 218 pFrm = 0; 219 } 220 else 221 pFrm = 0; 222 return 0 != pFrm; 223 } 224 225 sal_Bool SwCrsrShell::SetCrsrInHdFt( sal_uInt16 nDescNo, sal_Bool bInHeader ) 226 { 227 sal_Bool bRet = sal_False; 228 SwDoc *pMyDoc = GetDoc(); 229 230 SET_CURR_SHELL( this ); 231 232 if( USHRT_MAX == nDescNo ) 233 { 234 // dann den akt. nehmen 235 const SwPageFrm* pPage = GetCurrFrm()->FindPageFrm(); 236 if( pPage ) 237 for( sal_uInt16 i = 0; i < pMyDoc->GetPageDescCnt(); ++i ) 238 if( pPage->GetPageDesc() == 239 &const_cast<const SwDoc *>(pMyDoc)->GetPageDesc( i ) ) 240 { 241 nDescNo = i; 242 break; 243 } 244 } 245 246 if( USHRT_MAX != nDescNo && nDescNo < pMyDoc->GetPageDescCnt() ) 247 { 248 //dann teste mal, ob ueberhaupt das Attribut vorhanden ist. 249 const SwPageDesc& rDesc = const_cast<const SwDoc *>(pMyDoc) 250 ->GetPageDesc( nDescNo ); 251 const SwFmtCntnt* pCnt = 0; 252 if( bInHeader ) 253 { 254 // gespiegelte Seiten??? erstmal nicht beachten 255 const SwFmtHeader& rHd = rDesc.GetMaster().GetHeader(); 256 if( rHd.GetHeaderFmt() ) 257 pCnt = &rHd.GetHeaderFmt()->GetCntnt(); 258 } 259 else 260 { 261 const SwFmtFooter& rFt = rDesc.GetMaster().GetFooter(); 262 if( rFt.GetFooterFmt() ) 263 pCnt = &rFt.GetFooterFmt()->GetCntnt(); 264 } 265 266 if( pCnt && pCnt->GetCntntIdx() ) 267 { 268 SwNodeIndex aIdx( *pCnt->GetCntntIdx(), 1 ); 269 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode(); 270 if( !pCNd ) 271 pCNd = pMyDoc->GetNodes().GoNext( &aIdx ); 272 273 const SwFrm* pFrm; 274 Point aPt( pCurCrsr->GetPtPos() ); 275 276 if( pCNd && 0 != ( pFrm = pCNd->getLayoutFrm( GetLayout(), &aPt, 0, sal_False ) )) 277 { 278 // dann kann der Cursor ja auch hinein gesetzt werden 279 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 280 SwCrsrSaveState aSaveState( *pCurCrsr ); 281 282 ClearMark(); 283 284 SwPosition& rPos = *pCurCrsr->GetPoint(); 285 rPos.nNode = *pCNd; 286 rPos.nContent.Assign( pCNd, 0 ); 287 288 bRet = !pCurCrsr->IsSelOvr(); 289 if( bRet ) 290 UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE | 291 SwCrsrShell::READONLY ); 292 } 293 } 294 } 295 return bRet; 296 } 297 298 // springe zum naechsten Verzeichnis 299 300 sal_Bool SwCrsrShell::GotoNextTOXBase( const String* pName ) 301 { 302 sal_Bool bRet = sal_False; 303 304 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 305 SwCntntNode* pFnd = 0; 306 for( sal_uInt16 n = rFmts.Count(); n; ) 307 { 308 const SwSection* pSect = rFmts[ --n ]->GetSection(); 309 const SwSectionNode* pSectNd; 310 if( TOX_CONTENT_SECTION == pSect->GetType() && 311 0 != ( pSectNd = pSect->GetFmt()->GetSectionNode() ) && 312 pCurCrsr->GetPoint()->nNode < pSectNd->GetIndex() && 313 ( !pFnd || pFnd->GetIndex() > pSectNd->GetIndex() ) && 314 // JP 10.12.96: solange wir nur 3 Typen kennen und UI-seitig keine anderen 315 // einstellbar sind, muss ueber den Titel gesucht werden! 316 // ( !pName || *pName == ((SwTOXBaseSection*)pSect)->GetTypeName() ) && 317 ( !pName || *pName == ((SwTOXBaseSection*)pSect)->GetTOXName() ) 318 ) 319 { 320 SwNodeIndex aIdx( *pSectNd, 1 ); 321 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode(); 322 if( !pCNd ) 323 pCNd = GetDoc()->GetNodes().GoNext( &aIdx ); 324 const SwCntntFrm* pCFrm; 325 if( pCNd && 326 pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex() && 327 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout() ) ) && 328 ( IsReadOnlyAvailable() || !pCFrm->IsProtected() )) 329 { 330 pFnd = pCNd; 331 } 332 } 333 } 334 if( pFnd ) 335 { 336 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 337 SwCrsrSaveState aSaveState( *pCurCrsr ); 338 pCurCrsr->GetPoint()->nNode = *pFnd; 339 pCurCrsr->GetPoint()->nContent.Assign( pFnd, 0 ); 340 bRet = !pCurCrsr->IsSelOvr(); 341 if( bRet ) 342 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 343 } 344 return bRet; 345 } 346 347 // springe zum vorherigen Verzeichnis 348 349 350 sal_Bool SwCrsrShell::GotoPrevTOXBase( const String* pName ) 351 { 352 sal_Bool bRet = sal_False; 353 354 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 355 SwCntntNode* pFnd = 0; 356 for( sal_uInt16 n = rFmts.Count(); n; ) 357 { 358 const SwSection* pSect = rFmts[ --n ]->GetSection(); 359 const SwSectionNode* pSectNd; 360 if( TOX_CONTENT_SECTION == pSect->GetType() && 361 0 != ( pSectNd = pSect->GetFmt()->GetSectionNode() ) && 362 pCurCrsr->GetPoint()->nNode > pSectNd->EndOfSectionIndex() && 363 ( !pFnd || pFnd->GetIndex() < pSectNd->GetIndex() ) && 364 // JP 10.12.96: solange wir nur 3 Typen kennen und UI-seitig keine anderen 365 // einstellbar sind, muss ueber den Titel gesucht werden! 366 // ( !pName || *pName == ((SwTOXBaseSection*)pSect)->GetTypeName() ) && 367 ( !pName || *pName == ((SwTOXBaseSection*)pSect)->GetTOXName() ) 368 ) 369 { 370 SwNodeIndex aIdx( *pSectNd, 1 ); 371 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode(); 372 if( !pCNd ) 373 pCNd = GetDoc()->GetNodes().GoNext( &aIdx ); 374 const SwCntntFrm* pCFrm; 375 if( pCNd && 376 pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex() && 377 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout() ) ) && 378 ( IsReadOnlyAvailable() || !pCFrm->IsProtected() )) 379 { 380 pFnd = pCNd; 381 } 382 } 383 } 384 385 if( pFnd ) 386 { 387 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 388 SwCrsrSaveState aSaveState( *pCurCrsr ); 389 pCurCrsr->GetPoint()->nNode = *pFnd; 390 pCurCrsr->GetPoint()->nContent.Assign( pFnd, 0 ); 391 bRet = !pCurCrsr->IsSelOvr(); 392 if( bRet ) 393 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 394 } 395 return bRet; 396 } 397 398 // springe zum Verzeichnis vom TOXMark 399 400 sal_Bool SwCrsrShell::GotoTOXMarkBase() 401 { 402 sal_Bool bRet = sal_False; 403 404 SwTOXMarks aMarks; 405 sal_uInt16 nCnt = GetDoc()->GetCurTOXMark( *pCurCrsr->GetPoint(), aMarks ); 406 if( nCnt ) 407 { 408 // dann nehme den 1. und hole den Verzeichnis-Typ. 409 // Suche in seiner Abhaengigkeitsliste nach dem eigentlichem 410 // Verzeichnis 411 const SwTOXType* pType = aMarks[0]->GetTOXType(); 412 SwIterator<SwTOXBase,SwTOXType> aIter( *pType ); 413 const SwSectionNode* pSectNd; 414 const SwSectionFmt* pSectFmt; 415 416 for( SwTOXBase* pTOX = aIter.First(); pTOX; pTOX = aIter.Next() ) 417 { 418 if( pTOX->ISA( SwTOXBaseSection ) && 419 0 != ( pSectFmt = ((SwTOXBaseSection*)pTOX)->GetFmt() ) && 420 0 != ( pSectNd = pSectFmt->GetSectionNode() )) 421 { 422 SwNodeIndex aIdx( *pSectNd, 1 ); 423 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode(); 424 if( !pCNd ) 425 pCNd = GetDoc()->GetNodes().GoNext( &aIdx ); 426 const SwCntntFrm* pCFrm; 427 if( pCNd && 428 pCNd->EndOfSectionIndex() < pSectNd->EndOfSectionIndex() && 429 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout() ) ) && 430 ( IsReadOnlyAvailable() || !pCFrm->IsProtected() )) 431 { 432 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 433 SwCrsrSaveState aSaveState( *pCurCrsr ); 434 pCurCrsr->GetPoint()->nNode = *pCNd; 435 pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 ); 436 bRet = !pCurCrsr->IsInProtectTable() && 437 !pCurCrsr->IsSelOvr(); 438 if( bRet ) 439 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 440 break; 441 } 442 } 443 } 444 } 445 return bRet; 446 } 447 448 449 // springe zur naechsten (vorherigen) Tabellenformel 450 // optional auch nur zu kaputten Formeln springen 451 sal_Bool SwCrsrShell::GotoNxtPrvTblFormula( sal_Bool bNext, sal_Bool bOnlyErrors ) 452 { 453 if( IsTableMode() ) 454 return sal_False; 455 456 sal_Bool bFnd = sal_False; 457 SwPosition& rPos = *pCurCrsr->GetPoint(); 458 459 Point aPt; 460 SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() ); 461 if( !bNext ) 462 aFndPos.nNode = 0; 463 _SetGetExpFld aFndGEF( aFndPos ), aCurGEF( rPos ); 464 465 { 466 const SwNode* pSttNd = rPos.nNode.GetNode().FindTableBoxStartNode(); 467 if( pSttNd ) 468 { 469 const SwTableBox* pTBox = pSttNd->FindTableNode()->GetTable(). 470 GetTblBox( pSttNd->GetIndex() ); 471 if( pTBox ) 472 aCurGEF = _SetGetExpFld( *pTBox ); 473 } 474 } 475 476 if( rPos.nNode < GetDoc()->GetNodes().GetEndOfExtras() ) 477 // auch beim Einsammeln wird nur der erste Frame benutzt! 478 aCurGEF.SetBodyPos( *rPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( GetLayout(), 479 &aPt, &rPos, sal_False ) ); 480 { 481 const SfxPoolItem* pItem; 482 const SwTableBox* pTBox; 483 sal_uInt32 n, nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_BOXATR_FORMULA ); 484 485 for( n = 0; n < nMaxItems; ++n ) 486 if( 0 != (pItem = GetDoc()->GetAttrPool().GetItem2( 487 RES_BOXATR_FORMULA, n ) ) && 488 0 != (pTBox = ((SwTblBoxFormula*)pItem)->GetTableBox() ) && 489 pTBox->GetSttNd() && 490 pTBox->GetSttNd()->GetNodes().IsDocNodes() && 491 ( !bOnlyErrors || 492 !((SwTblBoxFormula*)pItem)->HasValidBoxes() ) ) 493 { 494 const SwCntntFrm* pCFrm; 495 SwNodeIndex aIdx( *pTBox->GetSttNd() ); 496 const SwCntntNode* pCNd = GetDoc()->GetNodes().GoNext( &aIdx ); 497 if( pCNd && 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout(), &aPt, 0, sal_False ) ) && 498 (IsReadOnlyAvailable() || !pCFrm->IsProtected() )) 499 { 500 _SetGetExpFld aCmp( *pTBox ); 501 aCmp.SetBodyPos( *pCFrm ); 502 503 if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF ) 504 : ( aCmp < aCurGEF && aFndGEF < aCmp )) 505 { 506 aFndGEF = aCmp; 507 bFnd = sal_True; 508 } 509 } 510 } 511 } 512 513 if( bFnd ) 514 { 515 SET_CURR_SHELL( this ); 516 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 517 SwCrsrSaveState aSaveState( *pCurCrsr ); 518 519 aFndGEF.GetPosOfContent( rPos ); 520 pCurCrsr->DeleteMark(); 521 522 bFnd = !pCurCrsr->IsSelOvr(); 523 if( bFnd ) 524 UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE | 525 SwCrsrShell::READONLY ); 526 } 527 return bFnd; 528 } 529 530 // springe zum naechsten (vorherigen) Verzeichniseintrag 531 sal_Bool SwCrsrShell::GotoNxtPrvTOXMark( sal_Bool bNext ) 532 { 533 if( IsTableMode() ) 534 return sal_False; 535 536 sal_Bool bFnd = sal_False; 537 SwPosition& rPos = *pCurCrsr->GetPoint(); 538 539 Point aPt; 540 SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() ); 541 if( !bNext ) 542 aFndPos.nNode = 0; 543 _SetGetExpFld aFndGEF( aFndPos ), aCurGEF( rPos ); 544 545 if( rPos.nNode.GetIndex() < GetDoc()->GetNodes().GetEndOfExtras().GetIndex() ) 546 // auch beim Einsammeln wird nur der erste Frame benutzt! 547 aCurGEF.SetBodyPos( *rPos.nNode.GetNode(). 548 GetCntntNode()->getLayoutFrm( GetLayout(), &aPt, &rPos, sal_False ) ); 549 { 550 const SfxPoolItem* pItem; 551 const SwCntntFrm* pCFrm; 552 const SwTxtNode* pTxtNd; 553 const SwTxtTOXMark* pTxtTOX; 554 sal_uInt32 n, nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_TXTATR_TOXMARK ); 555 556 for( n = 0; n < nMaxItems; ++n ) 557 if( 0 != (pItem = GetDoc()->GetAttrPool().GetItem2( 558 RES_TXTATR_TOXMARK, n ) ) && 559 0 != (pTxtTOX = ((SwTOXMark*)pItem)->GetTxtTOXMark() ) && 560 ( pTxtNd = &pTxtTOX->GetTxtNode())->GetNodes().IsDocNodes() && 561 0 != ( pCFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt, 0, sal_False )) && 562 ( IsReadOnlyAvailable() || !pCFrm->IsProtected() )) 563 { 564 SwNodeIndex aNdIndex( *pTxtNd ); // UNIX benoetigt dieses Obj. 565 _SetGetExpFld aCmp( aNdIndex, *pTxtTOX, 0 ); 566 aCmp.SetBodyPos( *pCFrm ); 567 568 if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF ) 569 : ( aCmp < aCurGEF && aFndGEF < aCmp )) 570 { 571 aFndGEF = aCmp; 572 bFnd = sal_True; 573 } 574 } 575 } 576 577 if( bFnd ) 578 { 579 SET_CURR_SHELL( this ); 580 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 581 SwCrsrSaveState aSaveState( *pCurCrsr ); 582 583 aFndGEF.GetPosOfContent( rPos ); 584 585 bFnd = !pCurCrsr->IsSelOvr(); 586 if( bFnd ) 587 UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE | 588 SwCrsrShell::READONLY ); 589 } 590 return bFnd; 591 } 592 593 /*-------------------------------------------------------------------- 594 Beschreibung: Traveling zwischen Markierungen 595 --------------------------------------------------------------------*/ 596 597 const SwTOXMark& SwCrsrShell::GotoTOXMark( const SwTOXMark& rStart, 598 SwTOXSearch eDir ) 599 { 600 SET_CURR_SHELL( this ); 601 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 602 SwCrsrSaveState aSaveState( *pCurCrsr ); 603 604 const SwTOXMark& rNewMark = GetDoc()->GotoTOXMark( rStart, eDir, 605 IsReadOnlyAvailable() ); 606 // Position setzen 607 SwPosition& rPos = *GetCrsr()->GetPoint(); 608 rPos.nNode = rNewMark.GetTxtTOXMark()->GetTxtNode(); 609 rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), 610 *rNewMark.GetTxtTOXMark()->GetStart() ); 611 612 if( !pCurCrsr->IsSelOvr() ) 613 UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE | 614 SwCrsrShell::READONLY ); 615 616 return rNewMark; 617 } 618 619 // springe zum naechsten / vorherigen FeldTypen 620 621 void lcl_MakeFldLst( 622 _SetGetExpFlds& rLst, 623 const SwFieldType& rFldType, 624 const bool bInReadOnly, 625 const bool bChkInpFlag = false ) 626 { 627 // es muss immer der 1. Frame gesucht werden 628 Point aPt; 629 SwTxtFld* pTxtFld = NULL; 630 SwIterator<SwFmtFld,SwFieldType> aIter(rFldType); 631 for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) 632 { 633 pTxtFld = pFmtFld->GetTxtFld(); 634 if ( pTxtFld != NULL 635 && ( !bChkInpFlag 636 || ((SwSetExpField*)pTxtFld->GetFmtFld().GetField())->GetInputFlag() ) ) 637 { 638 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode(); 639 const SwCntntFrm* pCFrm = 640 rTxtNode.getLayoutFrm( rTxtNode.GetDoc()->GetCurrentLayout(), &aPt, 0, sal_False ); 641 if ( pCFrm != NULL 642 && ( bInReadOnly || !pCFrm->IsProtected() ) ) 643 { 644 _SetGetExpFld* pNew = new _SetGetExpFld( SwNodeIndex( rTxtNode ), pTxtFld ); 645 pNew->SetBodyPos( *pCFrm ); 646 rLst.Insert( pNew ); 647 } 648 } 649 } 650 } 651 652 653 sal_Bool SwCrsrShell::MoveFldType( 654 const SwFieldType* pFldType, 655 const bool bNext, 656 const sal_uInt16 nResType, 657 const bool bAddSetExpressionFldsToInputFlds ) 658 { 659 // sortierte Liste aller Felder 660 _SetGetExpFlds aSrtLst( 64 ); 661 662 if ( pFldType ) 663 { 664 if( RES_INPUTFLD != pFldType->Which() && !pFldType->GetDepends() ) 665 { 666 return sal_False; 667 } 668 669 // Modify-Object gefunden, trage alle Felder ins Array ein 670 ::lcl_MakeFldLst( aSrtLst, *pFldType, ( IsReadOnlyAvailable() ? true : false ) ); 671 672 if( RES_INPUTFLD == pFldType->Which() && bAddSetExpressionFldsToInputFlds ) 673 { 674 // es gibt noch versteckte InputFelder in den SetExp. Feldern 675 const SwFldTypes& rFldTypes = *pDoc->GetFldTypes(); 676 const sal_uInt16 nSize = rFldTypes.Count(); 677 for( sal_uInt16 i=0; i < nSize; ++i ) 678 { 679 pFldType = rFldTypes[ i ]; 680 if ( RES_SETEXPFLD == pFldType->Which() ) 681 { 682 ::lcl_MakeFldLst( aSrtLst, *pFldType, ( IsReadOnlyAvailable() ? true : false ), true ); 683 } 684 } 685 } 686 } 687 else 688 { 689 const SwFldTypes& rFldTypes = *pDoc->GetFldTypes(); 690 const sal_uInt16 nSize = rFldTypes.Count(); 691 for( sal_uInt16 i=0; i < nSize; ++i ) 692 { 693 pFldType = rFldTypes[ i ]; 694 if( nResType == pFldType->Which() ) 695 { 696 ::lcl_MakeFldLst( aSrtLst, *pFldType, ( IsReadOnlyAvailable() ? true : false ) ); 697 } 698 } 699 } 700 701 // keine Felder gefunden? 702 if( !aSrtLst.Count() ) 703 return sal_False; 704 705 sal_uInt16 nPos; 706 SwCursor* pCrsr = getShellCrsr( true ); 707 { 708 // JP 19.08.98: es muss immer ueber das Feld gesucht werden, damit 709 // auch immer das richtige gefunden wird, wenn welche in 710 // Rahmen stehen, die in einem Absatz verankert sind, 711 // in dem ein Feld steht - siehe auch Bug 55247 712 const SwPosition& rPos = *pCrsr->GetPoint(); 713 714 SwTxtNode* pTNd = rPos.nNode.GetNode().GetTxtNode(); 715 ASSERT( pTNd, "Wo ist mein CntntNode?" ); 716 717 SwTxtFld * pTxtFld = pTNd->GetFldTxtAttrAt( rPos.nContent.GetIndex(), true ); 718 const bool bDelFld = ( pTxtFld == NULL ); 719 if( bDelFld ) 720 { 721 // create dummy for the search 722 SwFmtFld* pFmtFld = new SwFmtFld( SwDateTimeField( 723 (SwDateTimeFieldType*)pDoc->GetSysFldType( RES_DATETIMEFLD ) ) ); 724 725 pTxtFld = new SwTxtFld( *pFmtFld, rPos.nContent.GetIndex() ); 726 pTxtFld->ChgTxtNode( pTNd ); 727 } 728 729 SwIndex aSearchIdx( rPos.nContent ); 730 if ( !bDelFld && pTxtFld->HasContent() ) 731 { 732 aSearchIdx = *(pTxtFld->GetStart()); 733 } 734 _SetGetExpFld aSrch( rPos.nNode, pTxtFld, &aSearchIdx ); 735 if( rPos.nNode.GetIndex() < pDoc->GetNodes().GetEndOfExtras().GetIndex() ) 736 { 737 // auch beim Einsammeln wird nur der erste Frame benutzt! 738 Point aPt; 739 aSrch.SetBodyPos( *pTNd->getLayoutFrm( GetLayout(), &aPt, &rPos, sal_False ) ); 740 } 741 742 sal_Bool bFound = aSrtLst.Seek_Entry( &aSrch, &nPos ); 743 if( bDelFld ) 744 { 745 delete (SwFmtFld*)&pTxtFld->GetAttr(); 746 delete pTxtFld; 747 } 748 749 if( bFound ) // stehe auf einem ? 750 { 751 if( bNext ) 752 { 753 if( ++nPos >= aSrtLst.Count() ) 754 return sal_False; // schon am Ende 755 } 756 else if( !nPos-- ) 757 return sal_False; // weiter nach vorne geht nicht 758 } 759 else if( bNext ? nPos >= aSrtLst.Count() : !nPos--) 760 { 761 return sal_False; 762 } 763 } 764 const _SetGetExpFld& rFnd = **( aSrtLst.GetData() + nPos ); 765 766 767 SET_CURR_SHELL( this ); 768 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 769 SwCrsrSaveState aSaveState( *pCrsr ); 770 771 rFnd.GetPosOfContent( *pCrsr->GetPoint() ); 772 sal_Bool bRet = !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | 773 nsSwCursorSelOverFlags::SELOVER_TOGGLE ); 774 if( bRet ) 775 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 776 return bRet; 777 } 778 779 780 sal_Bool SwCrsrShell::GotoFld( const SwFmtFld& rFld ) 781 { 782 sal_Bool bRet = sal_False; 783 if( rFld.GetTxtFld() ) 784 { 785 SET_CURR_SHELL( this ); 786 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 787 788 SwCursor* pCrsr = getShellCrsr( true ); 789 SwCrsrSaveState aSaveState( *pCrsr ); 790 791 SwTxtNode* pTNd = (SwTxtNode*)rFld.GetTxtFld()->GetpTxtNode(); 792 pCrsr->GetPoint()->nNode = *pTNd; 793 pCrsr->GetPoint()->nContent.Assign( pTNd, *rFld.GetTxtFld()->GetStart() ); 794 795 bRet = !pCrsr->IsSelOvr(); 796 if( bRet ) 797 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 798 } 799 return bRet; 800 } 801 802 803 SwTxtFld * SwCrsrShell::GetTxtFldAtPos( 804 const SwPosition* pPos, 805 const bool bIncludeInputFldAtStart ) const 806 { 807 SwTxtFld* pTxtFld = NULL; 808 809 SwTxtNode * const pNode = pPos->nNode.GetNode().GetTxtNode(); 810 if ( pNode != NULL ) 811 { 812 pTxtFld = pNode->GetFldTxtAttrAt( pPos->nContent.GetIndex(), bIncludeInputFldAtStart ); 813 } 814 815 return pTxtFld; 816 } 817 818 819 SwField* SwCrsrShell::GetFieldAtCrsr( 820 const SwPaM* pCrsr, 821 const bool bIncludeInputFldAtStart ) const 822 { 823 SwField* pFieldAtCrsr = NULL; 824 825 SwTxtFld* pTxtFld = GetTxtFldAtPos( pCrsr->Start(), bIncludeInputFldAtStart ); 826 if ( pTxtFld != NULL 827 && pCrsr->Start()->nNode == pCrsr->End()->nNode ) 828 { 829 const xub_StrLen nTxtFldLength = 830 pTxtFld->End() != NULL 831 ? *(pTxtFld->End()) - *(pTxtFld->GetStart()) 832 : 1; 833 if ( ( pCrsr->End()->nContent.GetIndex() - pCrsr->Start()->nContent.GetIndex() ) <= nTxtFldLength ) 834 { 835 pFieldAtCrsr = (SwField*)pTxtFld->GetFmtFld().GetField(); 836 } 837 } 838 839 return pFieldAtCrsr; 840 } 841 842 843 SwField* SwCrsrShell::GetCurFld( const bool bIncludeInputFldAtStart ) const 844 { 845 SwPaM* pCrsr = GetCrsr(); 846 if ( pCrsr->GetNext() != pCrsr ) 847 { 848 // multi selection not handled. 849 return NULL; 850 } 851 852 SwField* pCurFld = GetFieldAtCrsr( pCrsr, bIncludeInputFldAtStart );; 853 if ( pCurFld != NULL 854 && RES_TABLEFLD == pCurFld->GetTyp()->Which() ) 855 { 856 // TabellenFormel ? wandel internen in externen Namen um 857 const SwTableNode* pTblNd = IsCrsrInTbl(); 858 ((SwTblField*)pCurFld)->PtrToBoxNm( pTblNd ? &pTblNd->GetTable() : 0 ); 859 } 860 861 return pCurFld; 862 } 863 864 865 bool SwCrsrShell::CrsrInsideInputFld() const 866 { 867 bool bCrsrInsideInputFld = false; 868 869 const SwPaM* pCrsr = GetCrsr(); 870 const SwPaM* pFirst = pCrsr; 871 do 872 { 873 bCrsrInsideInputFld = dynamic_cast<const SwInputField*>(GetFieldAtCrsr( pCrsr, false )) != NULL; 874 875 pCrsr = static_cast<SwPaM*>(pCrsr->GetNext()); 876 } while ( !bCrsrInsideInputFld 877 && pCrsr != pFirst ); 878 879 return bCrsrInsideInputFld; 880 } 881 882 883 bool SwCrsrShell::PosInsideInputFld( const SwPosition& rPos ) const 884 { 885 return dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, false )) != NULL; 886 } 887 888 889 bool SwCrsrShell::DocPtInsideInputFld( const Point& rDocPt ) const 890 { 891 SwPosition aPos( *(GetCrsr()->Start()) ); 892 Point aDocPt( rDocPt ); 893 if ( GetLayout()->GetCrsrOfst( &aPos, aDocPt ) ) 894 { 895 return PosInsideInputFld( aPos ); 896 } 897 return false; 898 } 899 900 901 xub_StrLen SwCrsrShell::StartOfInputFldAtPos( const SwPosition& rPos ) const 902 { 903 const SwTxtInputFld* pTxtInputFld = dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, true )); 904 if ( pTxtInputFld == NULL ) 905 { 906 ASSERT( false, "<SwEditShell::StartOfInputFldAtPos(..)> - no Input Field at given position" ); 907 return 0; 908 } 909 return *(pTxtInputFld->GetStart()); 910 } 911 912 913 xub_StrLen SwCrsrShell::EndOfInputFldAtPos( const SwPosition& rPos ) const 914 { 915 const SwTxtInputFld* pTxtInputFld = dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, true )); 916 if ( pTxtInputFld == NULL ) 917 { 918 ASSERT( false, "<SwEditShell::EndOfInputFldAtPos(..)> - no Input Field at given position" ); 919 return 0; 920 } 921 return *(pTxtInputFld->End()); 922 } 923 924 925 void SwCrsrShell::GotoOutline( sal_uInt16 nIdx ) 926 { 927 SwCursor* pCrsr = getShellCrsr( true ); 928 929 SET_CURR_SHELL( this ); 930 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 931 SwCrsrSaveState aSaveState( *pCrsr ); 932 933 const SwNodes& rNds = GetDoc()->GetNodes(); 934 SwTxtNode* pTxtNd = (SwTxtNode*)rNds.GetOutLineNds()[ nIdx ]->GetTxtNode(); 935 pCrsr->GetPoint()->nNode = *pTxtNd; 936 pCrsr->GetPoint()->nContent.Assign( pTxtNd, 0 ); 937 938 if( !pCrsr->IsSelOvr() ) 939 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 940 } 941 942 943 sal_Bool SwCrsrShell::GotoOutline( const String& rName ) 944 { 945 SwCursor* pCrsr = getShellCrsr( true ); 946 947 SET_CURR_SHELL( this ); 948 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 949 SwCrsrSaveState aSaveState( *pCrsr ); 950 951 sal_Bool bRet = sal_False; 952 if( pDoc->GotoOutline( *pCrsr->GetPoint(), rName ) && !pCrsr->IsSelOvr() ) 953 { 954 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 955 bRet = sal_True; 956 } 957 return bRet; 958 } 959 960 961 962 sal_Bool SwCrsrShell::GotoNextOutline() // naechster Node mit Outline-Num. 963 { 964 SwCursor* pCrsr = getShellCrsr( true ); 965 const SwNodes& rNds = GetDoc()->GetNodes(); 966 967 SwNode* pNd = pCrsr->GetNode(); 968 sal_uInt16 nPos; 969 if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos )) 970 ++nPos; 971 972 if( nPos == rNds.GetOutLineNds().Count() ) 973 return sal_False; 974 975 pNd = rNds.GetOutLineNds()[ nPos ]; 976 977 SET_CURR_SHELL( this ); 978 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 979 SwCrsrSaveState aSaveState( *pCrsr ); 980 pCrsr->GetPoint()->nNode = *pNd; 981 pCrsr->GetPoint()->nContent.Assign( (SwTxtNode*)pNd, 0 ); 982 983 sal_Bool bRet = !pCrsr->IsSelOvr(); 984 if( bRet ) 985 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 986 return bRet; 987 } 988 989 990 sal_Bool SwCrsrShell::GotoPrevOutline() // vorheriger Node mit Outline-Num. 991 { 992 SwCursor* pCrsr = getShellCrsr( true ); 993 const SwNodes& rNds = GetDoc()->GetNodes(); 994 995 SwNode* pNd = pCrsr->GetNode(); 996 sal_uInt16 nPos; 997 rNds.GetOutLineNds().Seek_Entry( pNd, &nPos ); 998 999 sal_Bool bRet = sal_False; 1000 if( nPos ) 1001 { 1002 --nPos; // davor 1003 1004 pNd = rNds.GetOutLineNds()[ nPos ]; 1005 if( pNd->GetIndex() > pCrsr->GetPoint()->nNode.GetIndex() ) 1006 return sal_False; 1007 1008 SET_CURR_SHELL( this ); 1009 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1010 SwCrsrSaveState aSaveState( *pCrsr ); 1011 pCrsr->GetPoint()->nNode = *pNd; 1012 pCrsr->GetPoint()->nContent.Assign( (SwTxtNode*)pNd, 0 ); 1013 1014 bRet = !pCrsr->IsSelOvr(); 1015 if( bRet ) 1016 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 1017 } 1018 return bRet; 1019 } 1020 1021 1022 // suche die "Outline-Position" vom vorherigen Outline-Node mit dem 1023 // Level. 1024 sal_uInt16 SwCrsrShell::GetOutlinePos( sal_uInt8 nLevel ) 1025 { 1026 SwPaM* pCrsr = getShellCrsr( true ); 1027 const SwNodes& rNds = GetDoc()->GetNodes(); 1028 1029 SwNode* pNd = pCrsr->GetNode(); 1030 sal_uInt16 nPos; 1031 if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos )) 1032 nPos++; // steht auf der Position, fuers while zum Naechsten 1033 1034 while( nPos-- ) // immer den davor testen ! 1035 { 1036 pNd = rNds.GetOutLineNds()[ nPos ]; 1037 1038 //if( ((SwTxtNode*)pNd)->GetTxtColl()->GetOutlineLevel() <= nLevel )//#outline level,zhaojianwei 1039 if( ((SwTxtNode*)pNd)->GetAttrOutlineLevel()-1 <= nLevel )//<-end,zhaojianwei 1040 return nPos; 1041 1042 } 1043 return USHRT_MAX; // davor keiner mehr also Ende 1044 } 1045 1046 1047 sal_Bool SwCrsrShell::MakeOutlineSel( sal_uInt16 nSttPos, sal_uInt16 nEndPos, 1048 sal_Bool bWithChilds ) 1049 { 1050 const SwNodes& rNds = GetDoc()->GetNodes(); 1051 const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds(); 1052 if( !rOutlNds.Count() ) // wie jetzt ??? 1053 return sal_False; 1054 1055 SET_CURR_SHELL( this ); 1056 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1057 1058 if( nSttPos > nEndPos ) // sollte jemand das vertauscht haben? 1059 { 1060 ASSERT( !this, "Start- > Ende-Position im Array" ); 1061 sal_uInt16 nTmp = nSttPos; 1062 nSttPos = nEndPos; 1063 nEndPos = nTmp; 1064 } 1065 1066 SwNode* pSttNd = rOutlNds[ nSttPos ]; 1067 SwNode* pEndNd = rOutlNds[ nEndPos ]; 1068 1069 if( bWithChilds ) 1070 { 1071 //sal_uInt8 nLevel = pEndNd->GetTxtNode()->GetTxtColl()->GetOutlineLevel();//#outline level,zhaojianwei 1072 const int nLevel = pEndNd->GetTxtNode()->GetAttrOutlineLevel()-1;//<-end.zhaojianwei 1073 for( ++nEndPos; nEndPos < rOutlNds.Count(); ++nEndPos ) 1074 { 1075 pEndNd = rOutlNds[ nEndPos ]; 1076 //sal_uInt8 nNxtLevel = pEndNd->GetTxtNode()->GetTxtColl()->GetOutlineLevel();//#outline level,zhaojianwei 1077 const int nNxtLevel = pEndNd->GetTxtNode()->GetAttrOutlineLevel()-1;//<-end,zhaojianwei 1078 if( nNxtLevel <= nLevel ) 1079 break; // EndPos steht jetzt auf dem naechsten 1080 } 1081 } 1082 // ohne Childs, dann aber zumindest auf den naechsten 1083 else if( ++nEndPos < rOutlNds.Count() ) 1084 pEndNd = rOutlNds[ nEndPos ]; 1085 1086 if( nEndPos == rOutlNds.Count() ) // kein Ende gefunden 1087 pEndNd = &rNds.GetEndOfContent(); 1088 1089 KillPams(); 1090 1091 SwCrsrSaveState aSaveState( *pCurCrsr ); 1092 1093 // Jetzt das Ende ans Ende vom voherigen ContentNode setzen 1094 pCurCrsr->GetPoint()->nNode = *pSttNd; 1095 pCurCrsr->GetPoint()->nContent.Assign( pSttNd->GetCntntNode(), 0 ); 1096 pCurCrsr->SetMark(); 1097 pCurCrsr->GetPoint()->nNode = *pEndNd; 1098 pCurCrsr->Move( fnMoveBackward, fnGoNode ); // ans Ende vom Vorgaenger 1099 1100 // und schon ist alles selektiert 1101 sal_Bool bRet = !pCurCrsr->IsSelOvr(); 1102 if( bRet ) 1103 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 1104 return bRet; 1105 } 1106 1107 1108 // springe zu dieser Refmark 1109 sal_Bool SwCrsrShell::GotoRefMark( const String& rRefMark, sal_uInt16 nSubType, 1110 sal_uInt16 nSeqNo ) 1111 { 1112 SET_CURR_SHELL( this ); 1113 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1114 SwCrsrSaveState aSaveState( *pCurCrsr ); 1115 1116 sal_uInt16 nPos; 1117 SwTxtNode* pTxtNd = SwGetRefFieldType::FindAnchor( GetDoc(), rRefMark, 1118 nSubType, nSeqNo, &nPos ); 1119 if( pTxtNd && pTxtNd->GetNodes().IsDocNodes() ) 1120 { 1121 pCurCrsr->GetPoint()->nNode = *pTxtNd; 1122 pCurCrsr->GetPoint()->nContent.Assign( pTxtNd, nPos ); 1123 1124 if( !pCurCrsr->IsSelOvr() ) 1125 { 1126 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 1127 return sal_True; 1128 } 1129 } 1130 return sal_False; 1131 } 1132 1133 sal_Bool SwCrsrShell::IsPageAtPos( const Point &rPt ) const 1134 { 1135 if( GetLayout() ) 1136 return 0 != GetLayout()->GetPageAtPos( rPt ); 1137 return sal_False; 1138 } 1139 1140 sal_Bool SwCrsrShell::GetContentAtPos( const Point& rPt, 1141 SwContentAtPos& rCntntAtPos, 1142 sal_Bool bSetCrsr, 1143 SwRect* pFldRect ) 1144 { 1145 SET_CURR_SHELL( this ); 1146 sal_Bool bRet = sal_False; 1147 1148 if( !IsTableMode() ) 1149 { 1150 Point aPt( rPt ); 1151 SwPosition aPos( *pCurCrsr->GetPoint() ); 1152 1153 SwTxtNode* pTxtNd; 1154 SwCntntFrm *pFrm(0); 1155 SwTxtAttr* pTxtAttr; 1156 SwCrsrMoveState aTmpState; 1157 aTmpState.bFieldInfo = sal_True; 1158 aTmpState.bExactOnly = !( SwContentAtPos::SW_OUTLINE & rCntntAtPos.eCntntAtPos ); 1159 aTmpState.bCntntCheck = (SwContentAtPos::SW_CONTENT_CHECK & rCntntAtPos.eCntntAtPos) ? sal_True : sal_False; 1160 aTmpState.bSetInReadOnly = IsReadOnlyAvailable(); 1161 1162 SwSpecialPos aSpecialPos; 1163 aTmpState.pSpecialPos = ( SwContentAtPos::SW_SMARTTAG & rCntntAtPos.eCntntAtPos ) ? 1164 &aSpecialPos : 0; 1165 1166 const sal_Bool bCrsrFoundExact = GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ); 1167 pTxtNd = aPos.nNode.GetNode().GetTxtNode(); 1168 1169 const SwNodes& rNds = GetDoc()->GetNodes(); 1170 if( pTxtNd 1171 && SwContentAtPos::SW_OUTLINE & rCntntAtPos.eCntntAtPos 1172 && rNds.GetOutLineNds().Count() ) 1173 { 1174 const SwTxtNode* pONd = pTxtNd->FindOutlineNodeOfLevel( MAXLEVEL-1); 1175 if( pONd ) 1176 { 1177 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_OUTLINE; 1178 rCntntAtPos.sStr = pONd->GetExpandTxt( 0, STRING_LEN, true ); 1179 bRet = sal_True; 1180 } 1181 } 1182 else if ( SwContentAtPos::SW_CONTENT_CHECK & rCntntAtPos.eCntntAtPos 1183 && bCrsrFoundExact ) 1184 { 1185 bRet = sal_True; 1186 } 1187 else if( pTxtNd 1188 && SwContentAtPos::SW_NUMLABEL & rCntntAtPos.eCntntAtPos) 1189 { 1190 bRet = aTmpState.bInNumPortion; 1191 rCntntAtPos.aFnd.pNode = pTxtNd; 1192 1193 Size aSizeLogic(aTmpState.nInNumPostionOffset, 0); 1194 Size aSizePixel = GetWin()->LogicToPixel(aSizeLogic); 1195 rCntntAtPos.nDist = aSizePixel.Width(); 1196 } 1197 else if( bCrsrFoundExact && pTxtNd ) 1198 { 1199 if( !aTmpState.bPosCorr ) 1200 { 1201 if ( !bRet 1202 && SwContentAtPos::SW_SMARTTAG & rCntntAtPos.eCntntAtPos 1203 && !aTmpState.bFtnNoInfo ) 1204 { 1205 const SwWrongList* pSmartTagList = pTxtNd->GetSmartTags(); 1206 xub_StrLen nCurrent = aPos.nContent.GetIndex(); 1207 xub_StrLen nBegin = nCurrent; 1208 xub_StrLen nLen = 1; 1209 1210 if ( pSmartTagList && pSmartTagList->InWrongWord( nCurrent, nLen ) && !pTxtNd->IsSymbol(nBegin) ) 1211 { 1212 const sal_uInt16 nIndex = pSmartTagList->GetWrongPos( nBegin ); 1213 const SwWrongList* pSubList = pSmartTagList->SubList( nIndex ); 1214 if ( pSubList ) 1215 { 1216 nCurrent = aTmpState.pSpecialPos->nCharOfst; 1217 1218 if ( pSubList->InWrongWord( nCurrent, nLen ) ) 1219 bRet = sal_True; 1220 } 1221 else 1222 bRet = sal_True; 1223 1224 if( bRet && bSetCrsr ) 1225 { 1226 SwCrsrSaveState aSaveState( *pCurCrsr ); 1227 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1228 pCurCrsr->DeleteMark(); 1229 *pCurCrsr->GetPoint() = aPos; 1230 if( pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | nsSwCursorSelOverFlags::SELOVER_TOGGLE) ) 1231 bRet = sal_False; 1232 else 1233 UpdateCrsr(); 1234 } 1235 if( bRet ) 1236 { 1237 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_SMARTTAG; 1238 1239 if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) ) 1240 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState ); 1241 } 1242 } 1243 } 1244 1245 if ( !bRet 1246 && ( SwContentAtPos::SW_FIELD | SwContentAtPos::SW_CLICKFIELD ) & rCntntAtPos.eCntntAtPos 1247 && !aTmpState.bFtnNoInfo ) 1248 { 1249 pTxtAttr = pTxtNd->GetFldTxtAttrAt( aPos.nContent.GetIndex() ); 1250 const SwField* pFld = pTxtAttr != NULL 1251 ? pTxtAttr->GetFmtFld().GetField() 1252 : 0; 1253 if ( SwContentAtPos::SW_CLICKFIELD & rCntntAtPos.eCntntAtPos 1254 && pFld && !pFld->HasClickHdl() ) 1255 { 1256 pFld = 0; 1257 } 1258 1259 if ( pFld ) 1260 { 1261 if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) ) 1262 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState ); 1263 1264 if( bSetCrsr ) 1265 { 1266 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1267 SwCrsrSaveState aSaveState( *pCurCrsr ); 1268 pCurCrsr->DeleteMark(); 1269 *pCurCrsr->GetPoint() = aPos; 1270 if( pCurCrsr->IsSelOvr() ) 1271 { 1272 // Click-Felder in geschuetzten Bereichen zulassen 1273 // Nur Platzhalter geht nicht! 1274 if( SwContentAtPos::SW_FIELD & rCntntAtPos.eCntntAtPos 1275 || RES_JUMPEDITFLD == pFld->Which() ) 1276 pFld = 0; 1277 } 1278 else 1279 UpdateCrsr(); 1280 } 1281 else if( RES_TABLEFLD == pFld->Which() && 1282 ((SwTblField*)pFld)->IsIntrnlName() ) 1283 { 1284 // erzeuge aus der internen (fuer CORE) 1285 // die externe (fuer UI) Formel 1286 const SwTableNode* pTblNd = pTxtNd->FindTableNode(); 1287 if( pTblNd ) // steht in einer Tabelle 1288 ((SwTblField*)pFld)->PtrToBoxNm( &pTblNd->GetTable() ); 1289 } 1290 } 1291 1292 if( pFld ) 1293 { 1294 rCntntAtPos.aFnd.pFld = pFld; 1295 rCntntAtPos.pFndTxtAttr = pTxtAttr; 1296 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FIELD; 1297 bRet = sal_True; 1298 } 1299 } 1300 1301 if( !bRet && SwContentAtPos::SW_FORMCTRL & rCntntAtPos.eCntntAtPos ) 1302 { 1303 IDocumentMarkAccess* pMarksAccess = GetDoc()->getIDocumentMarkAccess( ); 1304 sw::mark::IFieldmark* pFldBookmark = pMarksAccess->getFieldmarkFor( aPos ); 1305 if( bCrsrFoundExact && pTxtNd && pFldBookmark) { 1306 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FORMCTRL; 1307 rCntntAtPos.aFnd.pFldmark = pFldBookmark; 1308 bRet=sal_True; 1309 } 1310 } 1311 1312 if( !bRet && SwContentAtPos::SW_FTN & rCntntAtPos.eCntntAtPos ) 1313 { 1314 if( aTmpState.bFtnNoInfo ) 1315 { 1316 // stehe ueber dem Zeichen der Fussnote (??) 1317 bRet = sal_True; 1318 if( bSetCrsr ) 1319 { 1320 *pCurCrsr->GetPoint() = aPos; 1321 if( !GotoFtnAnchor() ) 1322 bRet = sal_False; 1323 } 1324 if( bRet ) 1325 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FTN; 1326 } 1327 else if ( 0 != ( pTxtAttr = pTxtNd->GetTxtAttrForCharAt( 1328 aPos.nContent.GetIndex(), RES_TXTATR_FTN )) ) 1329 { 1330 bRet = sal_True; 1331 if( bSetCrsr ) 1332 { 1333 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 1334 SwCrsrSaveState aSaveState( *pCurCrsr ); 1335 pCurCrsr->GetPoint()->nNode = *((SwTxtFtn*)pTxtAttr)->GetStartNode(); 1336 SwCntntNode* pCNd = GetDoc()->GetNodes().GoNextSection( 1337 &pCurCrsr->GetPoint()->nNode, 1338 sal_True, !IsReadOnlyAvailable() ); 1339 1340 if( pCNd ) 1341 { 1342 pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 ); 1343 if( pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | 1344 nsSwCursorSelOverFlags::SELOVER_TOGGLE )) 1345 bRet = sal_False; 1346 else 1347 UpdateCrsr(); 1348 } 1349 else 1350 bRet = sal_False; 1351 } 1352 1353 if( bRet ) 1354 { 1355 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FTN; 1356 rCntntAtPos.pFndTxtAttr = pTxtAttr; 1357 rCntntAtPos.aFnd.pAttr = &pTxtAttr->GetAttr(); 1358 1359 if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) ) 1360 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState ); 1361 } 1362 } 1363 } 1364 1365 if( !bRet 1366 && ( SwContentAtPos::SW_TOXMARK | SwContentAtPos::SW_REFMARK ) & rCntntAtPos.eCntntAtPos 1367 && !aTmpState.bFtnNoInfo ) 1368 { 1369 pTxtAttr = 0; 1370 if( SwContentAtPos::SW_TOXMARK & rCntntAtPos.eCntntAtPos ) 1371 { 1372 ::std::vector<SwTxtAttr *> const marks( 1373 pTxtNd->GetTxtAttrsAt( 1374 aPos.nContent.GetIndex(), RES_TXTATR_TOXMARK)); 1375 if (marks.size()) 1376 { // hmm... can only return 1 here 1377 pTxtAttr = *marks.begin(); 1378 } 1379 } 1380 1381 if( !pTxtAttr && 1382 SwContentAtPos::SW_REFMARK & rCntntAtPos.eCntntAtPos ) 1383 { 1384 ::std::vector<SwTxtAttr *> const marks( 1385 pTxtNd->GetTxtAttrsAt( 1386 aPos.nContent.GetIndex(), RES_TXTATR_REFMARK)); 1387 if (marks.size()) 1388 { // hmm... can only return 1 here 1389 pTxtAttr = *marks.begin(); 1390 } 1391 } 1392 1393 if( pTxtAttr ) 1394 { 1395 bRet = sal_True; 1396 if( bSetCrsr ) 1397 { 1398 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 1399 SwCrsrSaveState aSaveState( *pCurCrsr ); 1400 pCurCrsr->DeleteMark(); 1401 *pCurCrsr->GetPoint() = aPos; 1402 if( pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | nsSwCursorSelOverFlags::SELOVER_TOGGLE ) ) 1403 bRet = sal_False; 1404 else 1405 UpdateCrsr(); 1406 } 1407 1408 if( bRet ) 1409 { 1410 const xub_StrLen* pEnd = pTxtAttr->End(); 1411 if( pEnd ) 1412 rCntntAtPos.sStr = 1413 pTxtNd->GetExpandTxt( *pTxtAttr->GetStart(), *pEnd - *pTxtAttr->GetStart() ); 1414 else if( RES_TXTATR_TOXMARK == pTxtAttr->Which()) 1415 rCntntAtPos.sStr = 1416 pTxtAttr->GetTOXMark().GetAlternativeText(); 1417 1418 rCntntAtPos.eCntntAtPos = 1419 RES_TXTATR_TOXMARK == pTxtAttr->Which() 1420 ? SwContentAtPos::SW_TOXMARK 1421 : SwContentAtPos::SW_REFMARK; 1422 rCntntAtPos.pFndTxtAttr = pTxtAttr; 1423 rCntntAtPos.aFnd.pAttr = &pTxtAttr->GetAttr(); 1424 1425 if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) ) 1426 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState ); 1427 } 1428 } 1429 } 1430 1431 if ( !bRet 1432 && SwContentAtPos::SW_INETATTR & rCntntAtPos.eCntntAtPos 1433 && !aTmpState.bFtnNoInfo ) 1434 { 1435 pTxtAttr = pTxtNd->GetTxtAttrAt( 1436 aPos.nContent.GetIndex(), RES_TXTATR_INETFMT); 1437 // nur INetAttrs mit URLs "erkennen" 1438 if( pTxtAttr && pTxtAttr->GetINetFmt().GetValue().Len() ) 1439 { 1440 bRet = sal_True; 1441 if( bSetCrsr ) 1442 { 1443 SwCrsrSaveState aSaveState( *pCurCrsr ); 1444 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1445 pCurCrsr->DeleteMark(); 1446 *pCurCrsr->GetPoint() = aPos; 1447 if( pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | 1448 nsSwCursorSelOverFlags::SELOVER_TOGGLE) ) 1449 bRet = sal_False; 1450 else 1451 UpdateCrsr(); 1452 } 1453 if( bRet ) 1454 { 1455 rCntntAtPos.sStr = pTxtNd->GetExpandTxt( 1456 *pTxtAttr->GetStart(), 1457 *pTxtAttr->GetEnd() - *pTxtAttr->GetStart() ); 1458 1459 rCntntAtPos.aFnd.pAttr = &pTxtAttr->GetAttr(); 1460 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_INETATTR; 1461 rCntntAtPos.pFndTxtAttr = pTxtAttr; 1462 1463 if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) ) 1464 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState ); 1465 } 1466 } 1467 } 1468 1469 if( !bRet && SwContentAtPos::SW_REDLINE & rCntntAtPos.eCntntAtPos ) 1470 { 1471 const SwRedline* pRedl = GetDoc()->GetRedline(aPos, NULL); 1472 if( pRedl ) 1473 { 1474 rCntntAtPos.aFnd.pRedl = pRedl; 1475 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_REDLINE; 1476 rCntntAtPos.pFndTxtAttr = 0; 1477 bRet = sal_True; 1478 1479 if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) ) 1480 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState ); 1481 } 1482 } 1483 } 1484 1485 if( !bRet 1486 && ( SwContentAtPos::SW_TABLEBOXFML & rCntntAtPos.eCntntAtPos 1487 #ifdef DBG_UTIL 1488 || SwContentAtPos::SW_TABLEBOXVALUE & rCntntAtPos.eCntntAtPos 1489 #endif 1490 ) ) 1491 { 1492 const SwTableNode* pTblNd; 1493 const SwTableBox* pBox; 1494 const SwStartNode* pSttNd = pTxtNd->FindTableBoxStartNode(); 1495 const SfxPoolItem* pItem; 1496 if( pSttNd && 0 != ( pTblNd = pTxtNd->FindTableNode()) && 1497 0 != ( pBox = pTblNd->GetTable().GetTblBox( 1498 pSttNd->GetIndex() )) && 1499 #ifdef DBG_UTIL 1500 ( SFX_ITEM_SET == pBox->GetFrmFmt()->GetItemState( 1501 RES_BOXATR_FORMULA, sal_False, &pItem ) || 1502 SFX_ITEM_SET == pBox->GetFrmFmt()->GetItemState( 1503 RES_BOXATR_VALUE, sal_False, &pItem )) 1504 #else 1505 SFX_ITEM_SET == pBox->GetFrmFmt()->GetItemState( 1506 RES_BOXATR_FORMULA, sal_False, &pItem ) 1507 #endif 1508 ) 1509 { 1510 SwFrm* pF = pTxtNd->getLayoutFrm( GetLayout(), &aPt ); 1511 if( pF ) 1512 { 1513 // dann aber den CellFrame 1514 pFrm = (SwCntntFrm*)pF; 1515 while( pF && !pF->IsCellFrm() ) 1516 pF = pF->GetUpper(); 1517 } 1518 1519 // es wurde ein 1520 if( aTmpState.bPosCorr ) 1521 { 1522 if( pF && !pF->Frm().IsInside( aPt )) 1523 pF = 0; 1524 } 1525 else if( !pF ) 1526 pF = pFrm; 1527 1528 if( pF ) // nur dann ist es gueltig!! 1529 { 1530 // erzeuge aus der internen (fuer CORE) 1531 // die externe (fuer UI) Formel 1532 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_TABLEBOXFML; 1533 #ifdef DBG_UTIL 1534 if( RES_BOXATR_VALUE == pItem->Which() ) 1535 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_TABLEBOXVALUE; 1536 else 1537 #endif 1538 ((SwTblBoxFormula*)pItem)->PtrToBoxNm( &pTblNd->GetTable() ); 1539 1540 bRet = sal_True; 1541 if( bSetCrsr ) 1542 { 1543 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, 1544 SwCrsrSaveState aSaveState( *pCurCrsr ); 1545 *pCurCrsr->GetPoint() = aPos; 1546 if( pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | 1547 nsSwCursorSelOverFlags::SELOVER_TOGGLE) ) 1548 bRet = sal_False; 1549 else 1550 UpdateCrsr(); 1551 } 1552 1553 if( bRet ) 1554 { 1555 if( pFldRect ) 1556 { 1557 *pFldRect = pF->Prt(); 1558 *pFldRect += pF->Frm().Pos(); 1559 } 1560 rCntntAtPos.pFndTxtAttr = 0; 1561 rCntntAtPos.aFnd.pAttr = pItem; 1562 } 1563 } 1564 } 1565 } 1566 1567 #ifdef DBG_UTIL 1568 if( !bRet && SwContentAtPos::SW_CURR_ATTRS & rCntntAtPos.eCntntAtPos ) 1569 { 1570 xub_StrLen n = aPos.nContent.GetIndex(); 1571 SfxItemSet aSet( GetDoc()->GetAttrPool(), POOLATTR_BEGIN, 1572 POOLATTR_END - 1 ); 1573 if( pTxtNd->GetpSwpHints() ) 1574 { 1575 for( sal_uInt16 i = 0; i < pTxtNd->GetSwpHints().Count(); ++i ) 1576 { 1577 const SwTxtAttr* pHt = pTxtNd->GetSwpHints()[i]; 1578 xub_StrLen nAttrStart = *pHt->GetStart(); 1579 if( nAttrStart > n ) // ueber den Bereich hinaus 1580 break; 1581 1582 if( 0 != pHt->End() && ( 1583 ( nAttrStart < n && 1584 ( pHt->DontExpand() ? n < *pHt->End() 1585 : n <= *pHt->End() )) || 1586 ( n == nAttrStart && 1587 ( nAttrStart == *pHt->End() || !n ))) ) 1588 { 1589 aSet.Put( pHt->GetAttr() ); 1590 } 1591 } 1592 if( pTxtNd->HasSwAttrSet() && 1593 pTxtNd->GetpSwAttrSet()->Count() ) 1594 { 1595 SfxItemSet aFmtSet( pTxtNd->GetSwAttrSet() ); 1596 // aus dem Format-Set alle entfernen, die im TextSet auch gesetzt sind 1597 aFmtSet.Differentiate( aSet ); 1598 // jetzt alle zusammen "mergen" 1599 aSet.Put( aFmtSet ); 1600 } 1601 } 1602 else 1603 pTxtNd->SwCntntNode::GetAttr( aSet ); 1604 1605 rCntntAtPos.sStr.AssignAscii( 1606 RTL_CONSTASCII_STRINGPARAM( "Pos: (" )); 1607 rCntntAtPos.sStr += String::CreateFromInt32( aPos.nNode.GetIndex()); 1608 rCntntAtPos.sStr += ':'; 1609 rCntntAtPos.sStr += String::CreateFromInt32( aPos.nContent.GetIndex()); 1610 rCntntAtPos.sStr += ')'; 1611 rCntntAtPos.sStr.AppendAscii( 1612 RTL_CONSTASCII_STRINGPARAM( "\nAbs.Vorl.: " )); 1613 rCntntAtPos.sStr += pTxtNd->GetFmtColl()->GetName(); 1614 if( pTxtNd->GetCondFmtColl() ) 1615 rCntntAtPos.sStr.AppendAscii( 1616 RTL_CONSTASCII_STRINGPARAM( "\nBed.Vorl.: " )) 1617 += pTxtNd->GetCondFmtColl()->GetName(); 1618 1619 if( aSet.Count() ) 1620 { 1621 String sAttrs; 1622 SfxItemIter aIter( aSet ); 1623 const SfxPoolItem* pItem = aIter.FirstItem(); 1624 while( sal_True ) 1625 { 1626 if( !IsInvalidItem( pItem )) 1627 { 1628 String aStr; 1629 GetDoc()->GetAttrPool().GetPresentation( *pItem, 1630 SFX_ITEM_PRESENTATION_COMPLETE, 1631 SFX_MAPUNIT_CM, aStr ); 1632 if( sAttrs.Len() ) 1633 sAttrs.AppendAscii( 1634 RTL_CONSTASCII_STRINGPARAM( ", " )); 1635 sAttrs += aStr; 1636 } 1637 if( aIter.IsAtEnd() ) 1638 break; 1639 pItem = aIter.NextItem(); 1640 } 1641 if( sAttrs.Len() ) 1642 { 1643 if( rCntntAtPos.sStr.Len() ) 1644 rCntntAtPos.sStr += '\n'; 1645 rCntntAtPos.sStr.AppendAscii( 1646 RTL_CONSTASCII_STRINGPARAM( "Attr: " ) ) 1647 += sAttrs; 1648 } 1649 } 1650 bRet = sal_True; 1651 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_CURR_ATTRS; 1652 } 1653 #endif 1654 } 1655 } 1656 1657 if( !bRet ) 1658 { 1659 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_NOTHING; 1660 rCntntAtPos.aFnd.pFld = 0; 1661 } 1662 return bRet; 1663 } 1664 1665 const SwPostItField* SwCrsrShell::GetPostItFieldAtCursor() const 1666 { 1667 const SwPostItField* pPostItFld = 0; 1668 1669 if ( !IsTableMode() ) 1670 { 1671 const SwPosition* pCursorPos = _GetCrsr()->GetPoint(); 1672 const SwTxtNode* pTxtNd = pCursorPos->nNode.GetNode().GetTxtNode(); 1673 if ( pTxtNd ) 1674 { 1675 SwTxtAttr* pTxtAttr = pTxtNd->GetFldTxtAttrAt( pCursorPos->nContent.GetIndex() ); 1676 const SwField* pFld = pTxtAttr != NULL ? pTxtAttr->GetFmtFld().GetField() : 0; 1677 if ( pFld && pFld->Which()== RES_POSTITFLD ) 1678 { 1679 pPostItFld = static_cast<const SwPostItField*>(pFld); 1680 } 1681 } 1682 } 1683 1684 return pPostItFld; 1685 } 1686 1687 // befindet sich der Node in einem geschuetzten Bereich? 1688 sal_Bool SwContentAtPos::IsInProtectSect() const 1689 { 1690 const SwTxtNode* pNd = 0; 1691 if( pFndTxtAttr ) 1692 { 1693 switch( eCntntAtPos ) 1694 { 1695 case SW_FIELD: 1696 case SW_CLICKFIELD: 1697 pNd = ((SwTxtFld*)pFndTxtAttr)->GetpTxtNode(); 1698 break; 1699 1700 case SW_FTN: 1701 pNd = &((SwTxtFtn*)pFndTxtAttr)->GetTxtNode(); 1702 break; 1703 1704 case SW_INETATTR: 1705 pNd = ((SwTxtINetFmt*)pFndTxtAttr)->GetpTxtNode(); 1706 break; 1707 1708 default: 1709 break; 1710 } 1711 } 1712 1713 const SwCntntFrm* pFrm; 1714 return pNd && ( pNd->IsInProtectSect() || 1715 ( 0 != ( pFrm = pNd->getLayoutFrm( pNd->GetDoc()->GetCurrentLayout(), 0,0,sal_False)) && 1716 pFrm->IsProtected() )); 1717 } 1718 1719 bool SwContentAtPos::IsInRTLText()const 1720 { 1721 bool bRet = false; 1722 const SwTxtNode* pNd = 0; 1723 if (pFndTxtAttr && (eCntntAtPos == SW_FTN)) 1724 { 1725 const SwTxtFtn* pTxtFtn = static_cast<const SwTxtFtn*>(pFndTxtAttr); 1726 if(pTxtFtn->GetStartNode()) 1727 { 1728 SwStartNode* pSttNd = pTxtFtn->GetStartNode()->GetNode().GetStartNode(); 1729 SwPaM aTemp( *pSttNd ); 1730 aTemp.Move(fnMoveForward, fnGoNode); 1731 SwCntntNode* pCntntNode = aTemp.GetCntntNode(); 1732 if(pCntntNode && pCntntNode->IsTxtNode()) 1733 pNd = static_cast<SwTxtNode*>(pCntntNode); 1734 } 1735 } 1736 if(pNd) 1737 { 1738 SwIterator<SwTxtFrm,SwTxtNode> aIter(*pNd); 1739 SwTxtFrm* pTmpFrm = aIter.First(); 1740 while( pTmpFrm ) 1741 { 1742 if ( !pTmpFrm->IsFollow()) 1743 { 1744 bRet = pTmpFrm->IsRightToLeft(); 1745 break; 1746 } 1747 pTmpFrm = aIter.Next(); 1748 } 1749 } 1750 return bRet; 1751 } 1752 1753 1754 sal_Bool SwCrsrShell::SelectTxt( const xub_StrLen nStart, 1755 const xub_StrLen nEnd ) 1756 { 1757 SET_CURR_SHELL( this ); 1758 sal_Bool bRet = sal_False; 1759 1760 SwCallLink aLk( *this ); 1761 SwCrsrSaveState aSaveState( *pCurCrsr ); 1762 1763 SwPosition& rPos = *pCurCrsr->GetPoint(); 1764 pCurCrsr->DeleteMark(); 1765 rPos.nContent = nStart; 1766 pCurCrsr->SetMark(); 1767 rPos.nContent = nEnd; 1768 1769 if( !pCurCrsr->IsSelOvr() ) 1770 { 1771 UpdateCrsr(); 1772 bRet = sal_True; 1773 } 1774 1775 return bRet; 1776 } 1777 1778 1779 sal_Bool SwCrsrShell::SelectTxtAttr( sal_uInt16 nWhich, 1780 sal_Bool bExpand, 1781 const SwTxtAttr* pTxtAttr ) 1782 { 1783 SET_CURR_SHELL( this ); 1784 sal_Bool bRet = sal_False; 1785 1786 if( !IsTableMode() ) 1787 { 1788 if( !pTxtAttr ) 1789 { 1790 SwPosition& rPos = *pCurCrsr->GetPoint(); 1791 SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode(); 1792 pTxtAttr = (pTxtNd) 1793 ? pTxtNd->GetTxtAttrAt(rPos.nContent.GetIndex(), 1794 static_cast<RES_TXTATR>(nWhich), 1795 (bExpand) ? SwTxtNode::EXPAND : SwTxtNode::DEFAULT) 1796 : 0; 1797 } 1798 1799 if( pTxtAttr ) 1800 { 1801 const xub_StrLen* pEnd = pTxtAttr->End(); 1802 bRet = SelectTxt( *pTxtAttr->GetStart(), ( pEnd ? *pEnd : *pTxtAttr->GetStart() + 1 ) ); 1803 } 1804 } 1805 return bRet; 1806 } 1807 1808 1809 sal_Bool SwCrsrShell::GotoINetAttr( const SwTxtINetFmt& rAttr ) 1810 { 1811 sal_Bool bRet = sal_False; 1812 if( rAttr.GetpTxtNode() ) 1813 { 1814 SwCursor* pCrsr = getShellCrsr( true ); 1815 1816 SET_CURR_SHELL( this ); 1817 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 1818 SwCrsrSaveState aSaveState( *pCrsr ); 1819 1820 pCrsr->GetPoint()->nNode = *rAttr.GetpTxtNode(); 1821 pCrsr->GetPoint()->nContent.Assign( (SwTxtNode*)rAttr.GetpTxtNode(), 1822 *rAttr.GetStart() ); 1823 bRet = !pCrsr->IsSelOvr(); 1824 if( bRet ) 1825 UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 1826 } 1827 return bRet; 1828 } 1829 1830 1831 const SwFmtINetFmt* SwCrsrShell::FindINetAttr( const String& rName ) const 1832 { 1833 return pDoc->FindINetAttr( rName ); 1834 } 1835 1836 sal_Bool SwCrsrShell::GetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode, 1837 SwRect& rRect, sal_Int16& rOrient ) 1838 { 1839 1840 SET_CURR_SHELL( this ); 1841 sal_Bool bRet = sal_False; 1842 1843 if (!IsTableMode() && !HasSelection() 1844 && GetDoc()->GetIDocumentUndoRedo().DoesUndo()) 1845 { 1846 Point aPt( rPt ); 1847 SwPosition aPos( *pCurCrsr->GetPoint() ); 1848 1849 SwFillCrsrPos aFPos( eFillMode ); 1850 SwCrsrMoveState aTmpState( &aFPos ); 1851 1852 if( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ) && 1853 !aPos.nNode.GetNode().IsProtect()) 1854 { 1855 // Start-Position im geschuetzten Bereich? 1856 rRect = aFPos.aCrsr; 1857 rOrient = aFPos.eOrient; 1858 bRet = sal_True; 1859 } 1860 } 1861 return bRet; 1862 } 1863 1864 sal_Bool SwCrsrShell::SetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode ) 1865 { 1866 SET_CURR_SHELL( this ); 1867 sal_Bool bRet = sal_False; 1868 1869 if (!IsTableMode() && !HasSelection() 1870 && GetDoc()->GetIDocumentUndoRedo().DoesUndo()) 1871 { 1872 Point aPt( rPt ); 1873 SwPosition aPos( *pCurCrsr->GetPoint() ); 1874 1875 SwFillCrsrPos aFPos( eFillMode ); 1876 SwCrsrMoveState aTmpState( &aFPos ); 1877 1878 if( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ) ) 1879 { 1880 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen 1881 StartAction(); 1882 1883 SwCntntNode* pCNd = aPos.nNode.GetNode().GetCntntNode(); 1884 SwUndoId nUndoId = UNDO_INS_FROM_SHADOWCRSR; 1885 // Werden nur die Absatzattribute Adjust oder LRSpace gesetzt, 1886 // dann sollte der naechste Aufruf die NICHT wieder entfernen. 1887 if( 0 == aFPos.nParaCnt + aFPos.nColumnCnt && 1888 ( FILL_INDENT == aFPos.eMode || 1889 ( text::HoriOrientation::NONE != aFPos.eOrient && 1890 0 == aFPos.nTabCnt + aFPos.nSpaceCnt )) && 1891 pCNd && pCNd->Len() ) 1892 nUndoId = UNDO_EMPTY; 1893 1894 GetDoc()->GetIDocumentUndoRedo().StartUndo( nUndoId, NULL ); 1895 1896 SwTxtFmtColl* pNextFmt = 0; 1897 SwTxtNode* pTNd = pCNd->GetTxtNode(); 1898 if( pTNd ) 1899 pNextFmt = &pTNd->GetTxtColl()->GetNextTxtFmtColl(); 1900 1901 const SwSectionNode* pSectNd = pCNd->FindSectionNode(); 1902 if( pSectNd && aFPos.nParaCnt ) 1903 { 1904 SwNodeIndex aEnd( aPos.nNode, 1 ); 1905 while( aEnd.GetNode().IsEndNode() && 1906 (const SwNode*)&aEnd.GetNode() != 1907 pSectNd->EndOfSectionNode() ) 1908 aEnd++; 1909 1910 if( aEnd.GetNode().IsEndNode() && 1911 pCNd->Len() == aPos.nContent.GetIndex() ) 1912 aPos.nNode = *pSectNd->EndOfSectionNode(); 1913 } 1914 1915 for( sal_uInt16 n = 0; n < aFPos.nParaCnt + aFPos.nColumnCnt; ++n ) 1916 { 1917 GetDoc()->AppendTxtNode( aPos ); 1918 if( !n && pNextFmt ) 1919 { 1920 *pCurCrsr->GetPoint() = aPos; 1921 GetDoc()->SetTxtFmtColl( *pCurCrsr, pNextFmt, false ); 1922 //JP 04.11.97: erstmal keine Folgevorlage der 1923 // Folgevorlage beachten 1924 // pNextFmt = pNextFmt->GetNextTxtFmtColl(); 1925 } 1926 if( n < aFPos.nColumnCnt ) 1927 { 1928 *pCurCrsr->GetPoint() = aPos; 1929 GetDoc()->InsertPoolItem( *pCurCrsr, 1930 SvxFmtBreakItem( SVX_BREAK_COLUMN_BEFORE, RES_BREAK ), 0); 1931 } 1932 } 1933 1934 *pCurCrsr->GetPoint() = aPos; 1935 switch( aFPos.eMode ) 1936 { 1937 case FILL_INDENT: 1938 if( 0 != (pCNd = aPos.nNode.GetNode().GetCntntNode() )) 1939 { 1940 SfxItemSet aSet( GetDoc()->GetAttrPool(), 1941 RES_LR_SPACE, RES_LR_SPACE, 1942 RES_PARATR_ADJUST, RES_PARATR_ADJUST, 1943 0 ); 1944 SvxLRSpaceItem aLR( (SvxLRSpaceItem&) 1945 pCNd->GetAttr( RES_LR_SPACE ) ); 1946 aLR.SetTxtLeft( aFPos.nTabCnt ); 1947 aLR.SetTxtFirstLineOfst( 0 ); 1948 aSet.Put( aLR ); 1949 1950 const SvxAdjustItem& rAdj = (SvxAdjustItem&)pCNd-> 1951 GetAttr( RES_PARATR_ADJUST ); 1952 if( SVX_ADJUST_LEFT != rAdj.GetAdjust() ) 1953 aSet.Put( SvxAdjustItem( SVX_ADJUST_LEFT, RES_PARATR_ADJUST ) ); 1954 1955 GetDoc()->InsertItemSet( *pCurCrsr, aSet, 0 ); 1956 } 1957 else { 1958 ASSERT( !this, "wo ist mein CntntNode?" ); 1959 } 1960 break; 1961 1962 case FILL_TAB: 1963 case FILL_SPACE: 1964 { 1965 String sInsert; 1966 if( aFPos.nTabCnt ) 1967 sInsert.Fill( aFPos.nTabCnt, '\t' ); 1968 if( aFPos.nSpaceCnt ) 1969 { 1970 String sSpace; 1971 sSpace.Fill( aFPos.nSpaceCnt ); 1972 sInsert += sSpace; 1973 } 1974 if( sInsert.Len() ) 1975 { 1976 GetDoc()->InsertString( *pCurCrsr, sInsert ); 1977 } 1978 } 1979 // kein break - Ausrichtung muss noch gesetzt werden 1980 case FILL_MARGIN: 1981 if( text::HoriOrientation::NONE != aFPos.eOrient ) 1982 { 1983 SvxAdjustItem aAdj( SVX_ADJUST_LEFT, RES_PARATR_ADJUST ); 1984 switch( aFPos.eOrient ) 1985 { 1986 case text::HoriOrientation::CENTER: 1987 aAdj.SetAdjust( SVX_ADJUST_CENTER ); 1988 break; 1989 case text::HoriOrientation::RIGHT: 1990 aAdj.SetAdjust( SVX_ADJUST_RIGHT ); 1991 break; 1992 default: 1993 break; 1994 } 1995 GetDoc()->InsertPoolItem( *pCurCrsr, aAdj, 0 ); 1996 } 1997 break; 1998 } 1999 2000 GetDoc()->GetIDocumentUndoRedo().EndUndo( nUndoId, NULL ); 2001 EndAction(); 2002 2003 bRet = sal_True; 2004 } 2005 } 2006 return bRet; 2007 } 2008 2009 const SwRedline* SwCrsrShell::SelNextRedline() 2010 { 2011 const SwRedline* pFnd = 0; 2012 if( !IsTableMode() ) 2013 { 2014 SET_CURR_SHELL( this ); 2015 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 2016 SwCrsrSaveState aSaveState( *pCurCrsr ); 2017 2018 pFnd = GetDoc()->SelNextRedline( *pCurCrsr ); 2019 if( pFnd && !pCurCrsr->IsInProtectTable() && !pCurCrsr->IsSelOvr() ) 2020 UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 2021 else 2022 pFnd = 0; 2023 } 2024 return pFnd; 2025 } 2026 2027 const SwRedline* SwCrsrShell::SelPrevRedline() 2028 { 2029 const SwRedline* pFnd = 0; 2030 if( !IsTableMode() ) 2031 { 2032 SET_CURR_SHELL( this ); 2033 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 2034 SwCrsrSaveState aSaveState( *pCurCrsr ); 2035 2036 pFnd = GetDoc()->SelPrevRedline( *pCurCrsr ); 2037 if( pFnd && !pCurCrsr->IsInProtectTable() && !pCurCrsr->IsSelOvr() ) 2038 UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY); 2039 else 2040 pFnd = 0; 2041 } 2042 return pFnd; 2043 } 2044 2045 const SwRedline* SwCrsrShell::_GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect ) 2046 { 2047 const SwRedline* pFnd = 0; 2048 SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen 2049 SwCrsrSaveState aSaveState( *pCurCrsr ); 2050 2051 pFnd = GetDoc()->GetRedlineTbl()[ nArrPos ]; 2052 if( pFnd ) 2053 { 2054 *pCurCrsr->GetPoint() = *pFnd->Start(); 2055 2056 SwCntntNode* pCNd; 2057 SwNodeIndex* pIdx = &pCurCrsr->GetPoint()->nNode; 2058 if( !pIdx->GetNode().IsCntntNode() && 2059 0 != ( pCNd = GetDoc()->GetNodes().GoNextSection( pIdx, 2060 sal_True, IsReadOnlyAvailable() )) ) 2061 { 2062 if( *pIdx <= pFnd->End()->nNode ) 2063 pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 ); 2064 else 2065 pFnd = 0; 2066 } 2067 2068 if( pFnd && bSelect ) 2069 { 2070 pCurCrsr->SetMark(); 2071 if( nsRedlineType_t::REDLINE_FMTCOLL == pFnd->GetType() ) 2072 { 2073 pCNd = pIdx->GetNode().GetCntntNode(); 2074 pCurCrsr->GetPoint()->nContent.Assign( pCNd, pCNd->Len() ); 2075 pCurCrsr->GetMark()->nContent.Assign( pCNd, 0 ); 2076 } 2077 else 2078 *pCurCrsr->GetPoint() = *pFnd->End(); 2079 2080 pIdx = &pCurCrsr->GetPoint()->nNode; 2081 if( !pIdx->GetNode().IsCntntNode() && 2082 0 != ( pCNd = GetDoc()->GetNodes().GoPrevSection( pIdx, 2083 sal_True, IsReadOnlyAvailable() )) ) 2084 { 2085 if( *pIdx >= pCurCrsr->GetMark()->nNode ) 2086 pCurCrsr->GetPoint()->nContent.Assign( pCNd, pCNd->Len() ); 2087 else 2088 pFnd = 0; 2089 } 2090 } 2091 2092 if( !pFnd ) 2093 { 2094 pCurCrsr->DeleteMark(); 2095 pCurCrsr->RestoreSavePos(); 2096 } 2097 else if( bSelect && *pCurCrsr->GetMark() == *pCurCrsr->GetPoint() ) 2098 pCurCrsr->DeleteMark(); 2099 2100 if( pFnd && !pCurCrsr->IsInProtectTable() && !pCurCrsr->IsSelOvr() ) 2101 UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE 2102 | SwCrsrShell::READONLY ); 2103 else 2104 { 2105 pFnd = 0; 2106 if( bSelect ) 2107 pCurCrsr->DeleteMark(); 2108 } 2109 } 2110 return pFnd; 2111 } 2112 2113 const SwRedline* SwCrsrShell::GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect ) 2114 { 2115 const SwRedline* pFnd = 0; 2116 if( !IsTableMode() ) 2117 { 2118 SET_CURR_SHELL( this ); 2119 2120 const SwRedlineTbl& rTbl = GetDoc()->GetRedlineTbl(); 2121 const SwRedline* pTmp = rTbl[ nArrPos ]; 2122 sal_uInt16 nSeqNo = pTmp->GetSeqNo(); 2123 if( nSeqNo && bSelect ) 2124 { 2125 sal_Bool bCheck = sal_False; 2126 int nLoopCnt = 2; 2127 sal_uInt16 nArrSavPos = nArrPos; 2128 2129 do { 2130 pTmp = _GotoRedline( nArrPos, sal_True ); 2131 2132 if( !pFnd ) 2133 pFnd = pTmp; 2134 2135 if( pTmp && bCheck ) 2136 { 2137 // checke auf Ueberlappungen. Das kann durch 2138 // FmtColl-Redlines kommen, die auf den gesamten Absatz 2139 // aus gedehnt werden. 2140 2141 SwPaM* pCur = pCurCrsr; 2142 SwPaM* pNextPam = (SwPaM*)pCur->GetNext(); 2143 SwPosition* pCStt = pCur->Start(), *pCEnd = pCur->End(); 2144 while( pCur != pNextPam ) 2145 { 2146 const SwPosition *pNStt = pNextPam->Start(), 2147 *pNEnd = pNextPam->End(); 2148 2149 sal_Bool bDel = sal_True; 2150 switch( ::ComparePosition( *pCStt, *pCEnd, 2151 *pNStt, *pNEnd )) 2152 { 2153 case POS_INSIDE: // Pos1 liegt vollstaendig in Pos2 2154 if( !pCur->HasMark() ) 2155 { 2156 pCur->SetMark(); 2157 *pCur->GetMark() = *pNStt; 2158 } 2159 else 2160 *pCStt = *pNStt; 2161 *pCEnd = *pNEnd; 2162 break; 2163 2164 case POS_OUTSIDE: // Pos2 liegt vollstaendig in Pos1 2165 case POS_EQUAL: // Pos1 ist genauso gross wie Pos2 2166 break; 2167 2168 case POS_OVERLAP_BEFORE: // Pos1 ueberlappt Pos2 am Anfang 2169 if( !pCur->HasMark() ) 2170 pCur->SetMark(); 2171 *pCEnd = *pNEnd; 2172 break; 2173 case POS_OVERLAP_BEHIND: // Pos1 ueberlappt Pos2 am Ende 2174 if( !pCur->HasMark() ) 2175 { 2176 pCur->SetMark(); 2177 *pCur->GetMark() = *pNStt; 2178 } 2179 else 2180 *pCStt = *pNStt; 2181 break; 2182 2183 default: 2184 bDel = sal_False; 2185 } 2186 2187 if( bDel ) 2188 { 2189 // den brauchen wir nicht mehr 2190 SwPaM* pPrevPam = (SwPaM*)pNextPam->GetPrev(); 2191 delete pNextPam; 2192 pNextPam = pPrevPam; 2193 } 2194 pNextPam = (SwPaM*)pNextPam->GetNext(); 2195 } 2196 } 2197 2198 sal_uInt16 nFndPos = 2 == nLoopCnt 2199 ? rTbl.FindNextOfSeqNo( nArrPos ) 2200 : rTbl.FindPrevOfSeqNo( nArrPos ); 2201 if( USHRT_MAX != nFndPos || 2202 ( 0 != ( --nLoopCnt ) && USHRT_MAX != ( 2203 nFndPos = rTbl.FindPrevOfSeqNo( nArrSavPos ))) ) 2204 { 2205 if( pTmp ) 2206 { 2207 // neuen Cursor erzeugen 2208 CreateCrsr(); 2209 bCheck = sal_True; 2210 } 2211 nArrPos = nFndPos; 2212 } 2213 else 2214 nLoopCnt = 0; 2215 2216 } while( nLoopCnt ); 2217 } 2218 else 2219 pFnd = _GotoRedline( nArrPos, bSelect ); 2220 } 2221 return pFnd; 2222 } 2223 2224 2225 sal_Bool SwCrsrShell::SelectNxtPrvHyperlink( sal_Bool bNext ) 2226 { 2227 SwNodes& rNds = GetDoc()->GetNodes(); 2228 const SwNode* pBodyEndNd = &rNds.GetEndOfContent(); 2229 const SwNode* pBodySttNd = pBodyEndNd->StartOfSectionNode(); 2230 sal_uLong nBodySttNdIdx = pBodySttNd->GetIndex(); 2231 Point aPt; 2232 2233 _SetGetExpFld aCmpPos( SwPosition( bNext ? *pBodyEndNd : *pBodySttNd ) ); 2234 _SetGetExpFld aCurPos( bNext ? *pCurCrsr->End() : *pCurCrsr->Start() ); 2235 if( aCurPos.GetNode() < nBodySttNdIdx ) 2236 { 2237 const SwCntntNode* pCNd = aCurPos.GetNodeFromCntnt()->GetCntntNode(); 2238 SwCntntFrm* pFrm; 2239 if( pCNd && 0 != ( pFrm = pCNd->getLayoutFrm( GetLayout(), &aPt )) ) 2240 aCurPos.SetBodyPos( *pFrm ); 2241 } 2242 2243 // check first all the hyperlink fields 2244 { 2245 const SwTxtNode* pTxtNd; 2246 const SwCharFmts* pFmts = GetDoc()->GetCharFmts(); 2247 for( sal_uInt16 n = pFmts->Count(); 1 < n; ) 2248 { 2249 SwIterator<SwTxtINetFmt,SwCharFmt> aIter(*(*pFmts)[--n]); 2250 2251 for( SwTxtINetFmt* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() ) 2252 if( 0 != ( pTxtNd = pFnd->GetpTxtNode()) && 2253 pTxtNd->GetNodes().IsDocNodes() ) 2254 { 2255 SwTxtINetFmt& rAttr = *pFnd; 2256 SwPosition aTmpPos( *pTxtNd ); 2257 _SetGetExpFld aPos( aTmpPos.nNode, rAttr ); 2258 SwCntntFrm* pFrm; 2259 if( pTxtNd->GetIndex() < nBodySttNdIdx && 2260 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt )) ) 2261 aPos.SetBodyPos( *pFrm ); 2262 2263 if( bNext 2264 ? ( aPos < aCmpPos && aCurPos < aPos ) 2265 : ( aCmpPos < aPos && aPos < aCurPos )) 2266 { 2267 String sTxt( pTxtNd->GetExpandTxt( *rAttr.GetStart(), 2268 *rAttr.GetEnd() - *rAttr.GetStart() ) ); 2269 2270 sTxt.EraseAllChars( 0x0a ); 2271 sTxt.EraseLeadingChars().EraseTrailingChars(); 2272 2273 if( sTxt.Len() ) 2274 aCmpPos = aPos; 2275 } 2276 } 2277 } 2278 } 2279 // then check all the Flys with a URL or imapge map 2280 { 2281 const SwSpzFrmFmts* pFmts = GetDoc()->GetSpzFrmFmts(); 2282 for( sal_uInt16 n = 0, nEnd = pFmts->Count(); n < nEnd; ++n ) 2283 { 2284 SwFlyFrmFmt* pFmt = (SwFlyFrmFmt*)(*pFmts)[ n ]; 2285 const SwFmtURL& rURLItem = pFmt->GetURL(); 2286 if( rURLItem.GetMap() || rURLItem.GetURL().Len() ) 2287 { 2288 SwFlyFrm* pFly = pFmt->GetFrm( &aPt, sal_False ); 2289 SwPosition aTmpPos( *pBodySttNd ); 2290 if( pFly && 2291 GetBodyTxtNode( *GetDoc(), aTmpPos, *pFly->GetLower() ) ) 2292 { 2293 _SetGetExpFld aPos( *pFmt, &aTmpPos ); 2294 2295 if( bNext 2296 ? ( aPos < aCmpPos && aCurPos < aPos ) 2297 : ( aCmpPos < aPos && aPos < aCurPos )) 2298 aCmpPos = aPos; 2299 } 2300 } 2301 } 2302 } 2303 2304 // found any URL ? 2305 sal_Bool bRet = sal_False; 2306 const SwTxtINetFmt* pFndAttr = aCmpPos.GetINetFmt(); 2307 const SwFlyFrmFmt* pFndFmt = aCmpPos.GetFlyFmt(); 2308 if( pFndAttr || pFndFmt ) 2309 { 2310 SET_CURR_SHELL( this ); 2311 SwCallLink aLk( *this ); 2312 2313 // find a text attribute ? 2314 if( pFndAttr ) 2315 { 2316 SwCrsrSaveState aSaveState( *pCurCrsr ); 2317 2318 aCmpPos.GetPosOfContent( *pCurCrsr->GetPoint() ); 2319 pCurCrsr->DeleteMark(); 2320 pCurCrsr->SetMark(); 2321 pCurCrsr->GetPoint()->nContent = *pFndAttr->End(); 2322 2323 if( !pCurCrsr->IsInProtectTable() && !pCurCrsr->IsSelOvr() ) 2324 { 2325 UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE| 2326 SwCrsrShell::READONLY ); 2327 bRet = sal_True; 2328 } 2329 } 2330 // find a draw object ? 2331 else if( RES_DRAWFRMFMT == pFndFmt->Which() ) 2332 { 2333 const SdrObject* pSObj = pFndFmt->FindSdrObject(); 2334 ((SwFEShell*)this)->SelectObj( pSObj->GetCurrentBoundRect().Center() ); 2335 MakeSelVisible(); 2336 bRet = sal_True; 2337 } 2338 else // then is it a fly 2339 { 2340 SwFlyFrm* pFly = pFndFmt->GetFrm(&aPt, sal_False ); 2341 if( pFly ) 2342 { 2343 ((SwFEShell*)this)->SelectFlyFrm( *pFly, sal_True ); 2344 MakeSelVisible(); 2345 bRet = sal_True; 2346 } 2347 } 2348 } 2349 return bRet; 2350 } 2351 2352