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