xref: /aoo42x/main/sw/source/core/crsr/crstrvl.cxx (revision 870262e3)
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
GotoNextNum()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 
GotoPrevNum()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 
GotoHeaderTxt()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 
GotoFooterTxt()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 
SetCrsrInHdFt(sal_uInt16 nDescNo,sal_Bool bInHeader)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 
GotoNextTOXBase(const String * pName)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 
GotoPrevTOXBase(const String * pName)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 
GotoTOXMarkBase()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
GotoNxtPrvTblFormula(sal_Bool bNext,sal_Bool bOnlyErrors)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
GotoNxtPrvTOXMark(sal_Bool bNext)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 
GotoTOXMark(const SwTOXMark & rStart,SwTOXSearch eDir)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 
lcl_MakeFldLst(_SetGetExpFlds & rLst,const SwFieldType & rFldType,const bool bInReadOnly,const bool bChkInpFlag=false)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 
MoveFldType(const SwFieldType * pFldType,const bool bNext,const sal_uInt16 nResType,const bool bAddSetExpressionFldsToInputFlds)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(), pDoc->IsClipBoard() );
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 
GotoFld(const SwFmtFld & rFld)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 
GetTxtFldAtPos(const SwPosition * pPos,const bool bIncludeInputFldAtStart) const803 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 
GetFieldAtCrsr(const SwPaM * pCrsr,const bool bIncludeInputFldAtStart) const819 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 
GetCurFld(const bool bIncludeInputFldAtStart) const843 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 
CrsrInsideInputFld() const865 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 
PosInsideInputFld(const SwPosition & rPos) const883 bool SwCrsrShell::PosInsideInputFld( const SwPosition& rPos ) const
884 {
885     return dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, false )) != NULL;
886 }
887 
888 
DocPtInsideInputFld(const Point & rDocPt) const889 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 
StartOfInputFldAtPos(const SwPosition & rPos) const901 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 
EndOfInputFldAtPos(const SwPosition & rPos) const913 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 
GotoOutline(sal_uInt16 nIdx)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 
GotoOutline(const String & rName)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 
GotoNextOutline()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 
GotoPrevOutline()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.
GetOutlinePos(sal_uInt8 nLevel)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 
MakeOutlineSel(sal_uInt16 nSttPos,sal_uInt16 nEndPos,sal_Bool bWithChilds)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( sal_False, "Start > End Position in the 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
GotoRefMark(const String & rRefMark,sal_uInt16 nSubType,sal_uInt16 nSeqNo)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 
IsPageAtPos(const Point & rPt) const1133 sal_Bool SwCrsrShell::IsPageAtPos( const Point &rPt ) const
1134 {
1135     if( GetLayout() )
1136         return 0 != GetLayout()->GetPageAtPos( rPt );
1137     return sal_False;
1138 }
1139 
GetContentAtPos(const Point & rPt,SwContentAtPos & rCntntAtPos,sal_Bool bSetCrsr,SwRect * pFldRect)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 
GetPostItFieldAtCursor() const1665 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?
IsInProtectSect() const1688 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 
IsInRTLText() const1719 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 
SelectTxt(const xub_StrLen nStart,const xub_StrLen nEnd)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 
SelectTxtAttr(sal_uInt16 nWhich,sal_Bool bExpand,const SwTxtAttr * pTxtAttr)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 
GotoINetAttr(const SwTxtINetFmt & rAttr)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 
FindINetAttr(const String & rName) const1831 const SwFmtINetFmt* SwCrsrShell::FindINetAttr( const String& rName ) const
1832 {
1833 	return pDoc->FindINetAttr( rName );
1834 }
1835 
GetShadowCrsrPos(const Point & rPt,SwFillMode eFillMode,SwRect & rRect,sal_Int16 & rOrient)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 
SetShadowCrsrPos(const Point & rPt,SwFillMode eFillMode)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( sal_False, "where is my 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 
SelNextRedline()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 
SelPrevRedline()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 
_GotoRedline(sal_uInt16 nArrPos,sal_Bool bSelect)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 
GotoRedline(sal_uInt16 nArrPos,sal_Bool bSelect)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 
SelectNxtPrvHyperlink(sal_Bool bNext)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