Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include <comphelper/string.hxx>
22 : #include <svl/itemiter.hxx>
23 : #include <editeng/lrspitem.hxx>
24 : #include <editeng/adjustitem.hxx>
25 : #include <editeng/formatbreakitem.hxx>
26 : #include <svx/svdobj.hxx>
27 : #include <crsrsh.hxx>
28 : #include <doc.hxx>
29 : #include <IDocumentUndoRedo.hxx>
30 : #include <IDocumentRedlineAccess.hxx>
31 : #include <IDocumentFieldsAccess.hxx>
32 : #include <IDocumentLayoutAccess.hxx>
33 : #include <pagefrm.hxx>
34 : #include <cntfrm.hxx>
35 : #include <rootfrm.hxx>
36 : #include <pam.hxx>
37 : #include <ndtxt.hxx>
38 : #include <fldbas.hxx>
39 : #include <swtable.hxx>
40 : #include <docary.hxx>
41 : #include <txtfld.hxx>
42 : #include <fmtfld.hxx>
43 : #include <txtftn.hxx>
44 : #include <txtinet.hxx>
45 : #include <fmtinfmt.hxx>
46 : #include <txttxmrk.hxx>
47 : #include <frmfmt.hxx>
48 : #include <flyfrm.hxx>
49 : #include <viscrs.hxx>
50 : #include <callnk.hxx>
51 : #include <doctxm.hxx>
52 : #include <docfld.hxx>
53 : #include <expfld.hxx>
54 : #include <reffld.hxx>
55 : #include <flddat.hxx>
56 : #include <cellatr.hxx>
57 : #include <swundo.hxx>
58 : #include <redline.hxx>
59 : #include <fmtcntnt.hxx>
60 : #include <fmthdft.hxx>
61 : #include <pagedesc.hxx>
62 : #include <fesh.hxx>
63 : #include <charfmt.hxx>
64 : #include <fmturl.hxx>
65 : #include "txtfrm.hxx"
66 : #include <wrong.hxx>
67 : #include <calbck.hxx>
68 : #include <vcl/window.hxx>
69 : #include <docufld.hxx>
70 :
71 : using namespace ::com::sun::star;
72 :
73 0 : void SwCrsrShell::MoveCrsrToNum()
74 : {
75 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
76 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
77 0 : if( ActionPend() )
78 0 : return;
79 0 : SET_CURR_SHELL( this );
80 : // try to set cursor onto this position, at half of the char-
81 : // SRectangle's height
82 0 : Point aPt( m_pCurCrsr->GetPtPos() );
83 0 : SwContentFrm * pFrm = m_pCurCrsr->GetContentNode()->getLayoutFrm( GetLayout(), &aPt,
84 0 : m_pCurCrsr->GetPoint() );
85 0 : pFrm->GetCharRect( m_aCharRect, *m_pCurCrsr->GetPoint() );
86 0 : pFrm->Calc();
87 0 : if( pFrm->IsVertical() )
88 : {
89 0 : aPt.setX(m_aCharRect.Center().getX());
90 0 : aPt.setY(pFrm->Frm().Top() + GetUpDownX());
91 : }
92 : else
93 : {
94 0 : aPt.setY(m_aCharRect.Center().getY());
95 0 : aPt.setX(pFrm->Frm().Left() + GetUpDownX());
96 : }
97 0 : pFrm->GetCrsrOfst( m_pCurCrsr->GetPoint(), aPt );
98 0 : if ( !m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE |
99 0 : nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ))
100 : {
101 : UpdateCrsr(SwCrsrShell::UPDOWN |
102 : SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
103 0 : SwCrsrShell::READONLY );
104 0 : }
105 : }
106 :
107 : /// go to next/previous point on the same level
108 0 : bool SwCrsrShell::GotoNextNum()
109 : {
110 0 : if (!SwDoc::GotoNextNum( *m_pCurCrsr->GetPoint() ))
111 0 : return false;
112 0 : MoveCrsrToNum();
113 0 : return true;
114 : }
115 :
116 0 : bool SwCrsrShell::GotoPrevNum()
117 : {
118 0 : if (!SwDoc::GotoPrevNum( *m_pCurCrsr->GetPoint() ))
119 0 : return false;
120 0 : MoveCrsrToNum();
121 0 : return true;
122 : }
123 :
124 : /// jump from content to header
125 0 : bool SwCrsrShell::GotoHeaderText()
126 : {
127 0 : const SwFrm* pFrm = GetCurrFrm()->FindPageFrm();
128 0 : while( pFrm && !pFrm->IsHeaderFrm() )
129 0 : pFrm = pFrm->GetLower();
130 : // found header, search 1. content frame
131 0 : while( pFrm && !pFrm->IsContentFrm() )
132 0 : pFrm = pFrm->GetLower();
133 :
134 0 : if( pFrm )
135 : {
136 0 : SET_CURR_SHELL( this );
137 : // get header frame
138 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
139 0 : SwCursor *pTmpCrsr = getShellCrsr( true );
140 0 : SwCrsrSaveState aSaveState( *pTmpCrsr );
141 0 : pFrm->Calc();
142 0 : Point aPt( pFrm->Frm().Pos() + pFrm->Prt().Pos() );
143 0 : pFrm->GetCrsrOfst( pTmpCrsr->GetPoint(), aPt );
144 0 : if( !pTmpCrsr->IsSelOvr() )
145 0 : UpdateCrsr();
146 : else
147 0 : pFrm = 0;
148 : }
149 0 : return 0 != pFrm;
150 : }
151 :
152 : /// jump from content to footer
153 0 : bool SwCrsrShell::GotoFooterText()
154 : {
155 0 : const SwPageFrm* pFrm = GetCurrFrm()->FindPageFrm();
156 0 : if( pFrm )
157 : {
158 0 : const SwFrm* pLower = pFrm->GetLastLower();
159 :
160 0 : while( pLower && !pLower->IsFooterFrm() )
161 0 : pLower = pLower->GetLower();
162 : // found footer, search 1. content frame
163 0 : while( pLower && !pLower->IsContentFrm() )
164 0 : pLower = pLower->GetLower();
165 :
166 0 : if( pLower )
167 : {
168 0 : SwCursor *pTmpCrsr = getShellCrsr( true );
169 0 : SET_CURR_SHELL( this );
170 : // get position in footer
171 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
172 0 : SwCrsrSaveState aSaveState( *pTmpCrsr );
173 0 : pLower->Calc();
174 0 : Point aPt( pLower->Frm().Pos() + pLower->Prt().Pos() );
175 0 : pLower->GetCrsrOfst( pTmpCrsr->GetPoint(), aPt );
176 0 : if( !pTmpCrsr->IsSelOvr() )
177 0 : UpdateCrsr();
178 : else
179 0 : pFrm = 0;
180 : }
181 : else
182 0 : pFrm = 0;
183 : }
184 : else
185 0 : pFrm = 0;
186 0 : return 0 != pFrm;
187 : }
188 :
189 0 : bool SwCrsrShell::SetCrsrInHdFt( size_t nDescNo, bool bInHeader )
190 : {
191 0 : bool bRet = false;
192 0 : SwDoc *pMyDoc = GetDoc();
193 0 : const SwPageDesc* pDesc = NULL;
194 :
195 0 : SET_CURR_SHELL( this );
196 :
197 0 : if( SIZE_MAX == nDescNo )
198 : {
199 : // take the current one
200 0 : const SwPageFrm* pPage = GetCurrFrm()->FindPageFrm();
201 0 : if( pPage && pMyDoc->ContainsPageDesc(
202 0 : pPage->GetPageDesc(), &nDescNo) )
203 0 : pDesc = pPage->GetPageDesc();
204 : }
205 : else
206 0 : if (nDescNo < pMyDoc->GetPageDescCnt())
207 0 : pDesc = &pMyDoc->GetPageDesc( nDescNo );
208 :
209 0 : if( pDesc )
210 : {
211 : // check if the attribute exists
212 0 : const SwFormatContent* pCnt = 0;
213 0 : if( bInHeader )
214 : {
215 : // mirrored pages? ignore for now
216 0 : const SwFormatHeader& rHd = pDesc->GetMaster().GetHeader();
217 0 : if( rHd.GetHeaderFormat() )
218 0 : pCnt = &rHd.GetHeaderFormat()->GetContent();
219 : }
220 : else
221 : {
222 0 : const SwFormatFooter& rFt = pDesc->GetMaster().GetFooter();
223 0 : if( rFt.GetFooterFormat() )
224 0 : pCnt = &rFt.GetFooterFormat()->GetContent();
225 : }
226 :
227 0 : if( pCnt && pCnt->GetContentIdx() )
228 : {
229 0 : SwNodeIndex aIdx( *pCnt->GetContentIdx(), 1 );
230 0 : SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
231 0 : if( !pCNd )
232 0 : pCNd = pMyDoc->GetNodes().GoNext( &aIdx );
233 :
234 0 : Point aPt( m_pCurCrsr->GetPtPos() );
235 :
236 0 : if( pCNd && 0 != pCNd->getLayoutFrm( GetLayout(), &aPt, 0, false ) )
237 : {
238 : // then we can set the cursor in here
239 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
240 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
241 :
242 0 : ClearMark();
243 :
244 0 : SwPosition& rPos = *m_pCurCrsr->GetPoint();
245 0 : rPos.nNode = *pCNd;
246 0 : rPos.nContent.Assign( pCNd, 0 );
247 :
248 0 : bRet = !m_pCurCrsr->IsSelOvr();
249 0 : if( bRet )
250 : UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
251 0 : SwCrsrShell::READONLY );
252 0 : }
253 : }
254 : }
255 0 : return bRet;
256 : }
257 :
258 : /// jump to the next index
259 0 : bool SwCrsrShell::GotoNextTOXBase( const OUString* pName )
260 : {
261 0 : bool bRet = false;
262 :
263 0 : const SwSectionFormats& rFormats = GetDoc()->GetSections();
264 0 : SwContentNode* pFnd = 0;
265 0 : for( SwSectionFormats::size_type n = rFormats.size(); n; )
266 : {
267 0 : const SwSection* pSect = rFormats[ --n ]->GetSection();
268 0 : if (TOX_CONTENT_SECTION == pSect->GetType())
269 : {
270 : SwSectionNode const*const pSectNd(
271 0 : pSect->GetFormat()->GetSectionNode());
272 0 : if ( pSectNd
273 0 : && m_pCurCrsr->GetPoint()->nNode < pSectNd->GetIndex()
274 0 : && (!pFnd || pFnd->GetIndex() > pSectNd->GetIndex())
275 0 : && (!pName || *pName ==
276 0 : static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()))
277 : {
278 0 : SwNodeIndex aIdx(*pSectNd, 1);
279 0 : SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
280 0 : if (!pCNd)
281 0 : pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
282 0 : if (pCNd &&
283 0 : pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex())
284 : {
285 : SwContentFrm const*const pCFrm(
286 0 : pCNd->getLayoutFrm(GetLayout()));
287 0 : if (pCFrm &&
288 0 : (IsReadOnlyAvailable() || !pCFrm->IsProtected()))
289 : {
290 0 : pFnd = pCNd;
291 : }
292 0 : }
293 : }
294 : }
295 : }
296 0 : if( pFnd )
297 : {
298 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
299 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
300 0 : m_pCurCrsr->GetPoint()->nNode = *pFnd;
301 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pFnd, 0 );
302 0 : bRet = !m_pCurCrsr->IsSelOvr();
303 0 : if( bRet )
304 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
305 : }
306 0 : return bRet;
307 : }
308 :
309 : /// jump to previous index
310 0 : bool SwCrsrShell::GotoPrevTOXBase( const OUString* pName )
311 : {
312 0 : bool bRet = false;
313 :
314 0 : const SwSectionFormats& rFormats = GetDoc()->GetSections();
315 0 : SwContentNode* pFnd = 0;
316 0 : for( SwSectionFormats::size_type n = rFormats.size(); n; )
317 : {
318 0 : const SwSection* pSect = rFormats[ --n ]->GetSection();
319 0 : if (TOX_CONTENT_SECTION == pSect->GetType())
320 : {
321 : SwSectionNode const*const pSectNd(
322 0 : pSect->GetFormat()->GetSectionNode());
323 0 : if ( pSectNd
324 0 : && m_pCurCrsr->GetPoint()->nNode > pSectNd->EndOfSectionIndex()
325 0 : && (!pFnd || pFnd->GetIndex() < pSectNd->GetIndex())
326 0 : && (!pName || *pName ==
327 0 : static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()))
328 : {
329 0 : SwNodeIndex aIdx(*pSectNd, 1);
330 0 : SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
331 0 : if (!pCNd)
332 0 : pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
333 0 : if (pCNd &&
334 0 : pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex())
335 : {
336 : SwContentFrm const*const pCFrm(
337 0 : pCNd->getLayoutFrm(GetLayout()));
338 0 : if (pCFrm &&
339 0 : (IsReadOnlyAvailable() || !pCFrm->IsProtected()))
340 : {
341 0 : pFnd = pCNd;
342 : }
343 0 : }
344 : }
345 : }
346 : }
347 :
348 0 : if( pFnd )
349 : {
350 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
351 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
352 0 : m_pCurCrsr->GetPoint()->nNode = *pFnd;
353 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pFnd, 0 );
354 0 : bRet = !m_pCurCrsr->IsSelOvr();
355 0 : if( bRet )
356 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
357 : }
358 0 : return bRet;
359 : }
360 :
361 : /// jump to index of TOXMark
362 0 : bool SwCrsrShell::GotoTOXMarkBase()
363 : {
364 0 : bool bRet = false;
365 :
366 0 : SwTOXMarks aMarks;
367 0 : sal_uInt16 nCnt = SwDoc::GetCurTOXMark( *m_pCurCrsr->GetPoint(), aMarks );
368 0 : if( nCnt )
369 : {
370 : // Take the 1. and get the index type. Search in its dependency list
371 : // for the actual index
372 0 : const SwTOXType* pType = aMarks[0]->GetTOXType();
373 0 : SwIterator<SwTOXBase,SwTOXType> aIter( *pType );
374 : const SwSectionNode* pSectNd;
375 : const SwSectionFormat* pSectFormat;
376 :
377 0 : for( SwTOXBase* pTOX = aIter.First(); pTOX; pTOX = aIter.Next() )
378 : {
379 0 : if( pTOX->ISA( SwTOXBaseSection ) &&
380 0 : 0 != ( pSectFormat = static_cast<SwTOXBaseSection*>(pTOX)->GetFormat() ) &&
381 : 0 != ( pSectNd = pSectFormat->GetSectionNode() ))
382 : {
383 0 : SwNodeIndex aIdx( *pSectNd, 1 );
384 0 : SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
385 0 : if( !pCNd )
386 0 : pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
387 : const SwContentFrm* pCFrm;
388 0 : if( pCNd &&
389 0 : pCNd->EndOfSectionIndex() < pSectNd->EndOfSectionIndex() &&
390 0 : 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout() ) ) &&
391 0 : ( IsReadOnlyAvailable() || !pCFrm->IsProtected() ))
392 : {
393 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
394 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
395 0 : m_pCurCrsr->GetPoint()->nNode = *pCNd;
396 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 );
397 0 : bRet = !m_pCurCrsr->IsInProtectTable() &&
398 0 : !m_pCurCrsr->IsSelOvr();
399 0 : if( bRet )
400 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
401 0 : break;
402 0 : }
403 : }
404 0 : }
405 : }
406 0 : return bRet;
407 : }
408 :
409 : /// Jump to next/previous table formula
410 : /// Optionally it is possible to also jump to broken formulas
411 0 : bool SwCrsrShell::GotoNxtPrvTableFormula( bool bNext, bool bOnlyErrors )
412 : {
413 0 : if( IsTableMode() )
414 0 : return false;
415 :
416 0 : bool bFnd = false;
417 0 : SwPosition& rPos = *m_pCurCrsr->GetPoint();
418 :
419 0 : Point aPt;
420 0 : SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() );
421 0 : if( !bNext )
422 0 : aFndPos.nNode = 0;
423 0 : _SetGetExpField aFndGEF( aFndPos ), aCurGEF( rPos );
424 :
425 : {
426 0 : const SwNode* pSttNd = rPos.nNode.GetNode().FindTableBoxStartNode();
427 0 : if( pSttNd )
428 : {
429 0 : const SwTableBox* pTBox = pSttNd->FindTableNode()->GetTable().
430 0 : GetTableBox( pSttNd->GetIndex() );
431 0 : if( pTBox )
432 0 : aCurGEF = _SetGetExpField( *pTBox );
433 : }
434 : }
435 :
436 0 : if( rPos.nNode < GetDoc()->GetNodes().GetEndOfExtras() )
437 : // also at collection use only the first frame
438 0 : aCurGEF.SetBodyPos( *rPos.nNode.GetNode().GetContentNode()->getLayoutFrm( GetLayout(),
439 0 : &aPt, &rPos, false ) );
440 : {
441 : const SfxPoolItem* pItem;
442 : const SwTableBox* pTBox;
443 0 : sal_uInt32 n, nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_BOXATR_FORMULA );
444 :
445 0 : for( n = 0; n < nMaxItems; ++n )
446 0 : if( 0 != (pItem = GetDoc()->GetAttrPool().GetItem2(
447 0 : RES_BOXATR_FORMULA, n ) ) &&
448 0 : 0 != (pTBox = static_cast<const SwTableBoxFormula*>(pItem)->GetTableBox() ) &&
449 0 : pTBox->GetSttNd() &&
450 0 : pTBox->GetSttNd()->GetNodes().IsDocNodes() &&
451 0 : ( !bOnlyErrors ||
452 0 : !static_cast<const SwTableBoxFormula*>(pItem)->HasValidBoxes() ) )
453 : {
454 : const SwContentFrm* pCFrm;
455 0 : SwNodeIndex aIdx( *pTBox->GetSttNd() );
456 0 : const SwContentNode* pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
457 0 : if( pCNd && 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout(), &aPt, 0, false ) ) &&
458 0 : (IsReadOnlyAvailable() || !pCFrm->IsProtected() ))
459 : {
460 0 : _SetGetExpField aCmp( *pTBox );
461 0 : aCmp.SetBodyPos( *pCFrm );
462 :
463 0 : if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF )
464 0 : : ( aCmp < aCurGEF && aFndGEF < aCmp ))
465 : {
466 0 : aFndGEF = aCmp;
467 0 : bFnd = true;
468 : }
469 0 : }
470 : }
471 : }
472 :
473 0 : if( bFnd )
474 : {
475 0 : SET_CURR_SHELL( this );
476 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
477 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
478 :
479 0 : aFndGEF.GetPosOfContent( rPos );
480 0 : m_pCurCrsr->DeleteMark();
481 :
482 0 : bFnd = !m_pCurCrsr->IsSelOvr();
483 0 : if( bFnd )
484 : UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
485 0 : SwCrsrShell::READONLY );
486 : }
487 0 : return bFnd;
488 : }
489 :
490 : /// jump to next/previous index marker
491 0 : bool SwCrsrShell::GotoNxtPrvTOXMark( bool bNext )
492 : {
493 0 : if( IsTableMode() )
494 0 : return false;
495 :
496 0 : bool bFnd = false;
497 0 : SwPosition& rPos = *m_pCurCrsr->GetPoint();
498 :
499 0 : Point aPt;
500 0 : SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() );
501 0 : if( !bNext )
502 0 : aFndPos.nNode = 0;
503 0 : _SetGetExpField aFndGEF( aFndPos ), aCurGEF( rPos );
504 :
505 0 : if( rPos.nNode.GetIndex() < GetDoc()->GetNodes().GetEndOfExtras().GetIndex() )
506 : // also at collection use only the first frame
507 0 : aCurGEF.SetBodyPos( *rPos.nNode.GetNode().
508 0 : GetContentNode()->getLayoutFrm( GetLayout(), &aPt, &rPos, false ) );
509 :
510 : {
511 : const SwTextNode* pTextNd;
512 : const SwTextTOXMark* pTextTOX;
513 0 : sal_uInt32 n, nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_TXTATR_TOXMARK );
514 :
515 0 : for( n = 0; n < nMaxItems; ++n )
516 : {
517 : const SfxPoolItem* pItem;
518 : const SwContentFrm* pCFrm;
519 :
520 0 : if( 0 != (pItem = GetDoc()->GetAttrPool().GetItem2(
521 0 : RES_TXTATR_TOXMARK, n ) ) &&
522 0 : 0 != (pTextTOX = static_cast<const SwTOXMark*>(pItem)->GetTextTOXMark() ) &&
523 0 : ( pTextNd = &pTextTOX->GetTextNode())->GetNodes().IsDocNodes() &&
524 0 : 0 != ( pCFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt, 0, false )) &&
525 0 : ( IsReadOnlyAvailable() || !pCFrm->IsProtected() ))
526 : {
527 0 : SwNodeIndex aNdIndex( *pTextNd ); // UNIX needs this object
528 0 : _SetGetExpField aCmp( aNdIndex, *pTextTOX, 0 );
529 0 : aCmp.SetBodyPos( *pCFrm );
530 :
531 0 : if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF )
532 0 : : ( aCmp < aCurGEF && aFndGEF < aCmp ))
533 : {
534 0 : aFndGEF = aCmp;
535 0 : bFnd = true;
536 0 : }
537 : }
538 : }
539 : }
540 :
541 0 : if( bFnd )
542 : {
543 0 : SET_CURR_SHELL( this );
544 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
545 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
546 :
547 0 : aFndGEF.GetPosOfContent( rPos );
548 :
549 0 : bFnd = !m_pCurCrsr->IsSelOvr();
550 0 : if( bFnd )
551 : UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
552 0 : SwCrsrShell::READONLY );
553 : }
554 0 : return bFnd;
555 : }
556 :
557 : /// traveling between marks
558 0 : const SwTOXMark& SwCrsrShell::GotoTOXMark( const SwTOXMark& rStart,
559 : SwTOXSearch eDir )
560 : {
561 0 : SET_CURR_SHELL( this );
562 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
563 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
564 :
565 : const SwTOXMark& rNewMark = GetDoc()->GotoTOXMark( rStart, eDir,
566 0 : IsReadOnlyAvailable() );
567 : // set position
568 0 : SwPosition& rPos = *GetCrsr()->GetPoint();
569 0 : rPos.nNode = rNewMark.GetTextTOXMark()->GetTextNode();
570 0 : rPos.nContent.Assign( rPos.nNode.GetNode().GetContentNode(),
571 0 : rNewMark.GetTextTOXMark()->GetStart() );
572 :
573 0 : if( !m_pCurCrsr->IsSelOvr() )
574 : UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
575 0 : SwCrsrShell::READONLY );
576 :
577 0 : return rNewMark;
578 : }
579 :
580 : /// jump to next/previous field type
581 0 : void lcl_MakeFieldLst(
582 : _SetGetExpFields& rLst,
583 : const SwFieldType& rFieldType,
584 : const bool bInReadOnly,
585 : const bool bChkInpFlag = false )
586 : {
587 : // always search the 1. frame
588 0 : Point aPt;
589 0 : SwTextField* pTextField = NULL;
590 0 : SwIterator<SwFormatField,SwFieldType> aIter(rFieldType);
591 0 : for( SwFormatField* pFormatField = aIter.First(); pFormatField; pFormatField = aIter.Next() )
592 : {
593 0 : pTextField = pFormatField->GetTextField();
594 0 : if ( pTextField != NULL
595 0 : && ( !bChkInpFlag
596 0 : || static_cast<const SwSetExpField*>(pTextField->GetFormatField().GetField())->GetInputFlag() ) )
597 : {
598 0 : const SwTextNode& rTextNode = pTextField->GetTextNode();
599 : const SwContentFrm* pCFrm =
600 0 : rTextNode.getLayoutFrm( rTextNode.GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, 0, false );
601 0 : if ( pCFrm != NULL
602 0 : && ( bInReadOnly || !pCFrm->IsProtected() ) )
603 : {
604 0 : _SetGetExpField* pNew = new _SetGetExpField( SwNodeIndex( rTextNode ), pTextField );
605 0 : pNew->SetBodyPos( *pCFrm );
606 0 : rLst.insert( pNew );
607 : }
608 : }
609 0 : }
610 0 : }
611 :
612 : static _SetGetExpFields::const_iterator
613 0 : lcl_FindField(bool & o_rFound, _SetGetExpFields const& rSrtLst,
614 : SwRootFrm *const pLayout, SwTextNode *const pTextNode,
615 : SwTextField *const pTextField, SwPosition const& rPos,
616 : sal_Int32 const nContentOffset)
617 : {
618 0 : boost::scoped_ptr<_SetGetExpField> pSrch;
619 0 : boost::scoped_ptr<SwIndex> pIndex;
620 0 : if (-1 == nContentOffset)
621 : {
622 0 : pSrch.reset(new _SetGetExpField(rPos.nNode, pTextField, &rPos.nContent));
623 : }
624 : else
625 : {
626 0 : pIndex.reset(new SwIndex(rPos.nNode.GetNode().GetContentNode(), nContentOffset));
627 0 : pSrch.reset(new _SetGetExpField(rPos.nNode, pTextField, pIndex.get()));
628 : }
629 :
630 0 : if (rPos.nNode.GetIndex() < pTextNode->GetNodes().GetEndOfExtras().GetIndex())
631 : {
632 : // also at collection use only the first frame
633 0 : Point aPt;
634 0 : pSrch->SetBodyPos(*pTextNode->getLayoutFrm(pLayout, &aPt, &rPos, false));
635 : }
636 :
637 0 : _SetGetExpFields::const_iterator it = rSrtLst.lower_bound(pSrch.get());
638 :
639 0 : o_rFound = (it != rSrtLst.end()) && (**it == *pSrch);
640 0 : return it;
641 : }
642 :
643 0 : bool SwCrsrShell::MoveFieldType(
644 : const SwFieldType* pFieldType,
645 : const bool bNext,
646 : const sal_uInt16 nResType,
647 : const bool bAddSetExpressionFieldsToInputFields )
648 : {
649 : // sorted list of all fields
650 0 : _SetGetExpFields aSrtLst;
651 :
652 0 : if ( pFieldType )
653 : {
654 0 : if( RES_INPUTFLD != pFieldType->Which() && !pFieldType->HasWriterListeners() )
655 : {
656 0 : return false;
657 : }
658 :
659 : // found Modify object, add all fields to array
660 0 : ::lcl_MakeFieldLst( aSrtLst, *pFieldType, IsReadOnlyAvailable() );
661 :
662 0 : if( RES_INPUTFLD == pFieldType->Which() && bAddSetExpressionFieldsToInputFields )
663 : {
664 : // there are hidden input fields in the set exp. fields
665 0 : const SwFieldTypes& rFieldTypes = *mpDoc->getIDocumentFieldsAccess().GetFieldTypes();
666 0 : const size_t nSize = rFieldTypes.size();
667 0 : for( size_t i=0; i < nSize; ++i )
668 : {
669 0 : pFieldType = rFieldTypes[ i ];
670 0 : if ( RES_SETEXPFLD == pFieldType->Which() )
671 : {
672 0 : ::lcl_MakeFieldLst( aSrtLst, *pFieldType, IsReadOnlyAvailable(), true );
673 : }
674 : }
675 : }
676 : }
677 : else
678 : {
679 0 : const SwFieldTypes& rFieldTypes = *mpDoc->getIDocumentFieldsAccess().GetFieldTypes();
680 0 : const size_t nSize = rFieldTypes.size();
681 0 : for( size_t i=0; i < nSize; ++i )
682 : {
683 0 : pFieldType = rFieldTypes[ i ];
684 0 : if( nResType == pFieldType->Which() )
685 : {
686 0 : ::lcl_MakeFieldLst( aSrtLst, *pFieldType, IsReadOnlyAvailable() );
687 : }
688 : }
689 : }
690 :
691 : // found no fields?
692 0 : if( aSrtLst.empty() )
693 0 : return false;
694 :
695 0 : _SetGetExpFields::const_iterator it;
696 0 : SwCursor* pCrsr = getShellCrsr( true );
697 : {
698 : // (1998): Always use field for search so that the right one is found as
699 : // well some are in frames that are anchored to a paragraph that has a
700 : // field
701 0 : const SwPosition& rPos = *pCrsr->GetPoint();
702 :
703 0 : SwTextNode* pTNd = rPos.nNode.GetNode().GetTextNode();
704 : OSL_ENSURE( pTNd, "No ContentNode" );
705 :
706 0 : SwTextField * pTextField = pTNd->GetFieldTextAttrAt( rPos.nContent.GetIndex(), true );
707 0 : const bool bDelField = ( pTextField == NULL );
708 0 : sal_Int32 nContentOffset = -1;
709 :
710 0 : if( bDelField )
711 : {
712 : // create dummy for the search
713 : SwFormatField* pFormatField = new SwFormatField( SwDateTimeField(
714 0 : static_cast<SwDateTimeFieldType*>(mpDoc->getIDocumentFieldsAccess().GetSysFieldType( RES_DATETIMEFLD ) ) ) );
715 :
716 0 : pTextField = new SwTextField( *pFormatField, rPos.nContent.GetIndex(),
717 0 : mpDoc->IsClipBoard() );
718 0 : pTextField->ChgTextNode( pTNd );
719 : }
720 : else
721 : {
722 : // the cursor might be anywhere inside the input field,
723 : // but we will be searching for the field start
724 0 : if (pTextField->Which() == RES_TXTATR_INPUTFIELD
725 0 : && rPos.nContent.GetIndex() != pTextField->GetStart())
726 0 : nContentOffset = pTextField->GetStart();
727 : }
728 : bool isSrch;
729 : it = lcl_FindField(isSrch, aSrtLst,
730 0 : GetLayout(), pTNd, pTextField, rPos, nContentOffset);
731 :
732 0 : if( bDelField )
733 : {
734 0 : delete static_cast<SwFormatField*>(&pTextField->GetAttr());
735 0 : delete pTextField;
736 : }
737 :
738 0 : if( it != aSrtLst.end() && isSrch ) // found
739 : {
740 0 : if( bNext )
741 : {
742 0 : if( ++it == aSrtLst.end() )
743 0 : return false; // already at the end
744 : }
745 : else
746 : {
747 0 : if( it == aSrtLst.begin() )
748 0 : return false; // no more steps backward possible
749 0 : --it;
750 : }
751 : }
752 : else // not found
753 : {
754 0 : if( bNext )
755 : {
756 0 : if( it == aSrtLst.end() )
757 0 : return false;
758 : }
759 : else
760 : {
761 0 : if( it == aSrtLst.begin() )
762 0 : return false; // no more steps backward possible
763 0 : --it;
764 : }
765 : }
766 : }
767 0 : const _SetGetExpField& rFnd = **it;
768 :
769 0 : SET_CURR_SHELL( this );
770 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
771 0 : SwCrsrSaveState aSaveState( *pCrsr );
772 :
773 0 : rFnd.GetPosOfContent( *pCrsr->GetPoint() );
774 : bool bRet = !m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
775 0 : nsSwCursorSelOverFlags::SELOVER_TOGGLE );
776 0 : if( bRet )
777 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
778 0 : return bRet;
779 : }
780 :
781 0 : bool SwCrsrShell::GotoFormatField( const SwFormatField& rField )
782 : {
783 0 : bool bRet = false;
784 0 : if( rField.GetTextField() )
785 : {
786 0 : SET_CURR_SHELL( this );
787 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
788 :
789 0 : SwCursor* pCrsr = getShellCrsr( true );
790 0 : SwCrsrSaveState aSaveState( *pCrsr );
791 :
792 0 : SwTextNode* pTNd = rField.GetTextField()->GetpTextNode();
793 0 : pCrsr->GetPoint()->nNode = *pTNd;
794 0 : pCrsr->GetPoint()->nContent.Assign( pTNd, rField.GetTextField()->GetStart() );
795 :
796 0 : bRet = !pCrsr->IsSelOvr();
797 0 : if( bRet )
798 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
799 : }
800 0 : return bRet;
801 : }
802 :
803 102422 : SwTextField * SwCrsrShell::GetTextFieldAtPos(
804 : const SwPosition* pPos,
805 : const bool bIncludeInputFieldAtStart )
806 : {
807 102422 : SwTextField* pTextField = NULL;
808 :
809 102422 : SwTextNode * const pNode = pPos->nNode.GetNode().GetTextNode();
810 102422 : if ( pNode != NULL )
811 : {
812 102422 : pTextField = pNode->GetFieldTextAttrAt( pPos->nContent.GetIndex(), bIncludeInputFieldAtStart );
813 : }
814 :
815 102422 : return pTextField;
816 : }
817 :
818 12195 : SwField* SwCrsrShell::GetFieldAtCrsr(
819 : const SwPaM* pCrsr,
820 : const bool bIncludeInputFieldAtStart )
821 : {
822 12195 : SwField* pFieldAtCrsr = NULL;
823 :
824 12195 : SwTextField* pTextField = GetTextFieldAtPos( pCrsr->Start(), bIncludeInputFieldAtStart );
825 12195 : if ( pTextField != NULL
826 12195 : && pCrsr->Start()->nNode == pCrsr->End()->nNode )
827 : {
828 : const sal_Int32 nTextFieldLength =
829 12 : pTextField->End() != NULL
830 0 : ? *(pTextField->End()) - pTextField->GetStart()
831 12 : : 1;
832 12 : if ( ( pCrsr->End()->nContent.GetIndex() - pCrsr->Start()->nContent.GetIndex() ) <= nTextFieldLength )
833 : {
834 12 : pFieldAtCrsr = const_cast<SwField*>(pTextField->GetFormatField().GetField());
835 : }
836 : }
837 :
838 12195 : return pFieldAtCrsr;
839 : }
840 :
841 1390 : SwField* SwCrsrShell::GetCurField( const bool bIncludeInputFieldAtStart ) const
842 : {
843 1390 : SwPaM* pCrsr = GetCrsr();
844 1390 : if ( pCrsr->IsMultiSelection() )
845 : {
846 : // multi selection not handled.
847 4 : return NULL;
848 : }
849 :
850 1386 : SwField* pCurField = GetFieldAtCrsr( pCrsr, bIncludeInputFieldAtStart );;
851 1386 : if ( pCurField != NULL
852 1386 : && RES_TABLEFLD == pCurField->GetTyp()->Which() )
853 : {
854 : // TabellenFormel ? wandel internen in externen Namen um
855 0 : const SwTableNode* pTableNd = IsCrsrInTable();
856 0 : static_cast<SwTableField*>(pCurField)->PtrToBoxNm( pTableNd ? &pTableNd->GetTable() : 0 );
857 : }
858 :
859 1386 : return pCurField;
860 : }
861 :
862 10692 : bool SwCrsrShell::CrsrInsideInputField() const
863 : {
864 21501 : for(SwPaM& rCrsr : GetCrsr()->GetRingContainer())
865 : {
866 10809 : if(dynamic_cast<const SwInputField*>(GetFieldAtCrsr( &rCrsr, false )))
867 0 : return true;
868 : }
869 10692 : return false;
870 : }
871 :
872 1 : bool SwCrsrShell::PosInsideInputField( const SwPosition& rPos )
873 : {
874 1 : return dynamic_cast<const SwTextInputField*>(GetTextFieldAtPos( &rPos, false )) != NULL;
875 : }
876 :
877 0 : bool SwCrsrShell::DocPtInsideInputField( const Point& rDocPt ) const
878 : {
879 0 : SwPosition aPos( *(GetCrsr()->Start()) );
880 0 : Point aDocPt( rDocPt );
881 0 : if ( GetLayout()->GetCrsrOfst( &aPos, aDocPt ) )
882 : {
883 0 : return PosInsideInputField( aPos );
884 : }
885 0 : return false;
886 : }
887 :
888 0 : sal_Int32 SwCrsrShell::StartOfInputFieldAtPos( const SwPosition& rPos )
889 : {
890 0 : const SwTextInputField* pTextInputField = dynamic_cast<const SwTextInputField*>(GetTextFieldAtPos( &rPos, true ));
891 0 : if ( pTextInputField == NULL )
892 : {
893 : OSL_ENSURE( false, "<SwEditShell::StartOfInputFieldAtPos(..)> - no Input Field at given position" );
894 0 : return 0;
895 : }
896 0 : return pTextInputField->GetStart();
897 : }
898 :
899 0 : sal_Int32 SwCrsrShell::EndOfInputFieldAtPos( const SwPosition& rPos )
900 : {
901 0 : const SwTextInputField* pTextInputField = dynamic_cast<const SwTextInputField*>(GetTextFieldAtPos( &rPos, true ));
902 0 : if ( pTextInputField == NULL )
903 : {
904 : OSL_ENSURE( false, "<SwEditShell::EndOfInputFieldAtPos(..)> - no Input Field at given position" );
905 0 : return 0;
906 : }
907 0 : return *(pTextInputField->End());
908 : }
909 :
910 0 : void SwCrsrShell::GotoOutline( sal_uInt16 nIdx )
911 : {
912 0 : SwCursor* pCrsr = getShellCrsr( true );
913 :
914 0 : SET_CURR_SHELL( this );
915 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
916 0 : SwCrsrSaveState aSaveState( *pCrsr );
917 :
918 0 : const SwNodes& rNds = GetDoc()->GetNodes();
919 0 : SwTextNode* pTextNd = rNds.GetOutLineNds()[ nIdx ]->GetTextNode();
920 0 : pCrsr->GetPoint()->nNode = *pTextNd;
921 0 : pCrsr->GetPoint()->nContent.Assign( pTextNd, 0 );
922 :
923 0 : if( !pCrsr->IsSelOvr() )
924 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
925 0 : }
926 :
927 0 : bool SwCrsrShell::GotoOutline( const OUString& rName )
928 : {
929 0 : SwCursor* pCrsr = getShellCrsr( true );
930 :
931 0 : SET_CURR_SHELL( this );
932 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
933 0 : SwCrsrSaveState aSaveState( *pCrsr );
934 :
935 0 : bool bRet = false;
936 0 : if( mpDoc->GotoOutline( *pCrsr->GetPoint(), rName ) && !pCrsr->IsSelOvr() )
937 : {
938 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
939 0 : bRet = true;
940 : }
941 0 : return bRet;
942 : }
943 :
944 : /// jump to next node with outline num.
945 0 : bool SwCrsrShell::GotoNextOutline()
946 : {
947 0 : SwCursor* pCrsr = getShellCrsr( true );
948 0 : const SwNodes& rNds = GetDoc()->GetNodes();
949 :
950 0 : SwNode* pNd = &(pCrsr->GetNode());
951 : sal_uInt16 nPos;
952 0 : if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos ))
953 0 : ++nPos;
954 :
955 0 : if( nPos == rNds.GetOutLineNds().size() )
956 0 : return false;
957 :
958 0 : pNd = rNds.GetOutLineNds()[ nPos ];
959 :
960 0 : SET_CURR_SHELL( this );
961 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
962 0 : SwCrsrSaveState aSaveState( *pCrsr );
963 0 : pCrsr->GetPoint()->nNode = *pNd;
964 0 : pCrsr->GetPoint()->nContent.Assign( pNd->GetTextNode(), 0 );
965 :
966 0 : bool bRet = !pCrsr->IsSelOvr();
967 0 : if( bRet )
968 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
969 0 : return bRet;
970 : }
971 :
972 : /// jump to previous node with outline num.
973 0 : bool SwCrsrShell::GotoPrevOutline()
974 : {
975 0 : SwCursor* pCrsr = getShellCrsr( true );
976 0 : const SwNodes& rNds = GetDoc()->GetNodes();
977 :
978 0 : SwNode* pNd = &(pCrsr->GetNode());
979 : sal_uInt16 nPos;
980 0 : bool bRet = rNds.GetOutLineNds().Seek_Entry(pNd, &nPos);
981 0 : if (bRet && nPos)
982 : {
983 0 : --nPos; // before
984 :
985 0 : pNd = rNds.GetOutLineNds()[ nPos ];
986 0 : if( pNd->GetIndex() > pCrsr->GetPoint()->nNode.GetIndex() )
987 0 : return false;
988 :
989 0 : SET_CURR_SHELL( this );
990 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
991 0 : SwCrsrSaveState aSaveState( *pCrsr );
992 0 : pCrsr->GetPoint()->nNode = *pNd;
993 0 : pCrsr->GetPoint()->nContent.Assign( pNd->GetTextNode(), 0 );
994 :
995 0 : bRet = !pCrsr->IsSelOvr();
996 0 : if( bRet )
997 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
998 : }
999 0 : return bRet;
1000 : }
1001 :
1002 : /// search "outline position" before previous outline node at given level
1003 0 : sal_uInt16 SwCrsrShell::GetOutlinePos( sal_uInt8 nLevel )
1004 : {
1005 0 : SwPaM* pCrsr = getShellCrsr( true );
1006 0 : const SwNodes& rNds = GetDoc()->GetNodes();
1007 :
1008 0 : SwNode* pNd = &(pCrsr->GetNode());
1009 : sal_uInt16 nPos;
1010 0 : if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos ))
1011 0 : nPos++; // is at correct position; take next for while
1012 :
1013 0 : while( nPos-- ) // check the one in front of the current
1014 : {
1015 0 : pNd = rNds.GetOutLineNds()[ nPos ];
1016 :
1017 0 : if( pNd->GetTextNode()->GetAttrOutlineLevel()-1 <= nLevel )
1018 0 : return nPos;
1019 :
1020 : }
1021 0 : return USHRT_MAX; // no more left
1022 : }
1023 :
1024 0 : bool SwCrsrShell::MakeOutlineSel( sal_uInt16 nSttPos, sal_uInt16 nEndPos,
1025 : bool bWithChildren )
1026 : {
1027 0 : const SwNodes& rNds = GetDoc()->GetNodes();
1028 0 : const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds();
1029 0 : if( rOutlNds.empty() )
1030 0 : return false;
1031 :
1032 0 : SET_CURR_SHELL( this );
1033 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1034 :
1035 0 : if( nSttPos > nEndPos ) // parameters switched?
1036 : {
1037 : OSL_ENSURE( false, "Start > End for array access" );
1038 0 : sal_uInt16 nTmp = nSttPos;
1039 0 : nSttPos = nEndPos;
1040 0 : nEndPos = nTmp;
1041 : }
1042 :
1043 0 : SwNode* pSttNd = rOutlNds[ nSttPos ];
1044 0 : SwNode* pEndNd = rOutlNds[ nEndPos ];
1045 :
1046 0 : if( bWithChildren )
1047 : {
1048 0 : const int nLevel = pEndNd->GetTextNode()->GetAttrOutlineLevel()-1;
1049 0 : for( ++nEndPos; nEndPos < rOutlNds.size(); ++nEndPos )
1050 : {
1051 0 : pEndNd = rOutlNds[ nEndPos ];
1052 0 : const int nNxtLevel = pEndNd->GetTextNode()->GetAttrOutlineLevel()-1;
1053 0 : if( nNxtLevel <= nLevel )
1054 0 : break; // EndPos is now on the next one
1055 : }
1056 : }
1057 : // if without children then set onto next one
1058 0 : else if( ++nEndPos < rOutlNds.size() )
1059 0 : pEndNd = rOutlNds[ nEndPos ];
1060 :
1061 0 : if( nEndPos == rOutlNds.size() ) // no end found
1062 0 : pEndNd = &rNds.GetEndOfContent();
1063 :
1064 0 : KillPams();
1065 :
1066 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1067 :
1068 : // set end to the end of the previous content node
1069 0 : m_pCurCrsr->GetPoint()->nNode = *pSttNd;
1070 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pSttNd->GetContentNode(), 0 );
1071 0 : m_pCurCrsr->SetMark();
1072 0 : m_pCurCrsr->GetPoint()->nNode = *pEndNd;
1073 0 : m_pCurCrsr->Move( fnMoveBackward, fnGoNode ); // end of predecessor
1074 :
1075 : // and everything is already selected
1076 0 : bool bRet = !m_pCurCrsr->IsSelOvr();
1077 0 : if( bRet )
1078 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
1079 0 : return bRet;
1080 : }
1081 :
1082 : /// jump to reference marker
1083 0 : bool SwCrsrShell::GotoRefMark( const OUString& rRefMark, sal_uInt16 nSubType,
1084 : sal_uInt16 nSeqNo )
1085 : {
1086 0 : SET_CURR_SHELL( this );
1087 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1088 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1089 :
1090 0 : sal_Int32 nPos = -1;
1091 : SwTextNode* pTextNd = SwGetRefFieldType::FindAnchor( GetDoc(), rRefMark,
1092 0 : nSubType, nSeqNo, &nPos );
1093 0 : if( pTextNd && pTextNd->GetNodes().IsDocNodes() )
1094 : {
1095 0 : m_pCurCrsr->GetPoint()->nNode = *pTextNd;
1096 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pTextNd, nPos );
1097 :
1098 0 : if( !m_pCurCrsr->IsSelOvr() )
1099 : {
1100 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
1101 0 : return true;
1102 : }
1103 : }
1104 0 : return false;
1105 : }
1106 :
1107 2191 : bool SwCrsrShell::IsPageAtPos( const Point &rPt ) const
1108 : {
1109 2191 : if( GetLayout() )
1110 2191 : return 0 != GetLayout()->GetPageAtPos( rPt );
1111 0 : return false;
1112 : }
1113 :
1114 9 : bool SwCrsrShell::GetContentAtPos( const Point& rPt,
1115 : SwContentAtPos& rContentAtPos,
1116 : bool bSetCrsr,
1117 : SwRect* pFieldRect )
1118 : {
1119 9 : SET_CURR_SHELL( this );
1120 9 : bool bRet = false;
1121 :
1122 9 : if( !IsTableMode() )
1123 : {
1124 9 : Point aPt( rPt );
1125 9 : SwPosition aPos( *m_pCurCrsr->GetPoint() );
1126 :
1127 : SwTextNode* pTextNd;
1128 9 : SwContentFrm *pFrm(0);
1129 : SwTextAttr* pTextAttr;
1130 9 : SwCrsrMoveState aTmpState;
1131 9 : aTmpState.bFieldInfo = true;
1132 9 : aTmpState.bExactOnly = !( SwContentAtPos::SW_OUTLINE & rContentAtPos.eContentAtPos );
1133 9 : aTmpState.bContentCheck = (SwContentAtPos::SW_CONTENT_CHECK & rContentAtPos.eContentAtPos) != 0;
1134 9 : aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
1135 :
1136 9 : SwSpecialPos aSpecialPos;
1137 9 : aTmpState.pSpecialPos = ( SwContentAtPos::SW_SMARTTAG & rContentAtPos.eContentAtPos ) ?
1138 9 : &aSpecialPos : 0;
1139 :
1140 9 : const bool bCrsrFoundExact = GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState );
1141 9 : pTextNd = aPos.nNode.GetNode().GetTextNode();
1142 :
1143 9 : const SwNodes& rNds = GetDoc()->GetNodes();
1144 9 : if( pTextNd
1145 9 : && SwContentAtPos::SW_OUTLINE & rContentAtPos.eContentAtPos
1146 9 : && !rNds.GetOutLineNds().empty() )
1147 : {
1148 0 : const SwTextNode* pONd = pTextNd->FindOutlineNodeOfLevel( MAXLEVEL-1);
1149 0 : if( pONd )
1150 : {
1151 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_OUTLINE;
1152 0 : rContentAtPos.sStr = pONd->GetExpandText( 0, -1, true, true );
1153 0 : bRet = true;
1154 : }
1155 : }
1156 9 : else if ( SwContentAtPos::SW_CONTENT_CHECK & rContentAtPos.eContentAtPos
1157 0 : && bCrsrFoundExact )
1158 : {
1159 0 : bRet = true;
1160 : }
1161 9 : else if( pTextNd
1162 9 : && SwContentAtPos::SW_NUMLABEL & rContentAtPos.eContentAtPos)
1163 : {
1164 4 : bRet = aTmpState.bInNumPortion;
1165 4 : rContentAtPos.aFnd.pNode = pTextNd;
1166 :
1167 4 : Size aSizeLogic(aTmpState.nInNumPostionOffset, 0);
1168 4 : Size aSizePixel = GetWin()->LogicToPixel(aSizeLogic);
1169 4 : rContentAtPos.nDist = aSizePixel.Width();
1170 : }
1171 5 : else if( bCrsrFoundExact && pTextNd )
1172 : {
1173 5 : if( !aTmpState.bPosCorr )
1174 : {
1175 0 : if ( !bRet
1176 0 : && SwContentAtPos::SW_SMARTTAG & rContentAtPos.eContentAtPos
1177 0 : && !aTmpState.bFootnoteNoInfo )
1178 : {
1179 0 : const SwWrongList* pSmartTagList = pTextNd->GetSmartTags();
1180 0 : sal_Int32 nCurrent = aPos.nContent.GetIndex();
1181 0 : const sal_Int32 nBegin = nCurrent;
1182 0 : sal_Int32 nLen = 1;
1183 :
1184 0 : if ( pSmartTagList && pSmartTagList->InWrongWord( nCurrent, nLen ) && !pTextNd->IsSymbol(nBegin) )
1185 : {
1186 0 : const sal_uInt16 nIndex = pSmartTagList->GetWrongPos( nBegin );
1187 0 : const SwWrongList* pSubList = pSmartTagList->SubList( nIndex );
1188 0 : if ( pSubList )
1189 : {
1190 0 : nCurrent = aTmpState.pSpecialPos->nCharOfst;
1191 :
1192 0 : if ( pSubList->InWrongWord( nCurrent, nLen ) )
1193 0 : bRet = true;
1194 : }
1195 : else
1196 0 : bRet = true;
1197 :
1198 0 : if( bRet && bSetCrsr )
1199 : {
1200 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1201 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1202 0 : m_pCurCrsr->DeleteMark();
1203 0 : *m_pCurCrsr->GetPoint() = aPos;
1204 0 : if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | nsSwCursorSelOverFlags::SELOVER_TOGGLE) )
1205 0 : bRet = false;
1206 : else
1207 0 : UpdateCrsr();
1208 : }
1209 0 : if( bRet )
1210 : {
1211 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_SMARTTAG;
1212 :
1213 0 : if( pFieldRect && 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt ) ) )
1214 0 : pFrm->GetCharRect( *pFieldRect, aPos, &aTmpState );
1215 : }
1216 : }
1217 : }
1218 :
1219 0 : if ( !bRet
1220 0 : && ( SwContentAtPos::SW_FIELD | SwContentAtPos::SW_CLICKFIELD ) & rContentAtPos.eContentAtPos
1221 0 : && !aTmpState.bFootnoteNoInfo )
1222 : {
1223 0 : pTextAttr = pTextNd->GetFieldTextAttrAt( aPos.nContent.GetIndex() );
1224 : const SwField* pField = pTextAttr != NULL
1225 0 : ? pTextAttr->GetFormatField().GetField()
1226 0 : : 0;
1227 0 : if ( SwContentAtPos::SW_CLICKFIELD & rContentAtPos.eContentAtPos
1228 0 : && pField && !pField->HasClickHdl() )
1229 : {
1230 0 : pField = 0;
1231 : }
1232 :
1233 0 : if ( pField )
1234 : {
1235 0 : if( pFieldRect && 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt ) ) )
1236 0 : pFrm->GetCharRect( *pFieldRect, aPos, &aTmpState );
1237 :
1238 0 : if( bSetCrsr )
1239 : {
1240 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1241 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1242 0 : m_pCurCrsr->DeleteMark();
1243 0 : *m_pCurCrsr->GetPoint() = aPos;
1244 0 : if( m_pCurCrsr->IsSelOvr() )
1245 : {
1246 : // allow click fields in protected sections
1247 : // only placeholder is not possible
1248 0 : if( SwContentAtPos::SW_FIELD & rContentAtPos.eContentAtPos
1249 0 : || RES_JUMPEDITFLD == pField->Which() )
1250 0 : pField = 0;
1251 : }
1252 : else
1253 0 : UpdateCrsr();
1254 : }
1255 0 : else if( RES_TABLEFLD == pField->Which() &&
1256 0 : static_cast<const SwTableField*>(pField)->IsIntrnlName() )
1257 : {
1258 : // create from internal (for CORE) the external
1259 : // (for UI) formula
1260 0 : const SwTableNode* pTableNd = pTextNd->FindTableNode();
1261 0 : if( pTableNd ) // steht in einer Tabelle
1262 0 : const_cast<SwTableField*>(static_cast<const SwTableField*>(pField))->PtrToBoxNm( &pTableNd->GetTable() );
1263 : }
1264 : }
1265 :
1266 0 : if( pField )
1267 : {
1268 0 : rContentAtPos.aFnd.pField = pField;
1269 0 : rContentAtPos.pFndTextAttr = pTextAttr;
1270 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_FIELD;
1271 0 : bRet = true;
1272 : }
1273 : }
1274 :
1275 0 : if( !bRet && SwContentAtPos::SW_FORMCTRL & rContentAtPos.eContentAtPos )
1276 : {
1277 0 : IDocumentMarkAccess* pMarksAccess = GetDoc()->getIDocumentMarkAccess( );
1278 0 : sw::mark::IFieldmark* pFieldBookmark = pMarksAccess->getFieldmarkFor( aPos );
1279 0 : if( bCrsrFoundExact && pTextNd && pFieldBookmark) {
1280 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_FORMCTRL;
1281 0 : rContentAtPos.aFnd.pFieldmark = pFieldBookmark;
1282 0 : bRet=true;
1283 : }
1284 : }
1285 :
1286 0 : if( !bRet && SwContentAtPos::SW_FTN & rContentAtPos.eContentAtPos )
1287 : {
1288 0 : if( aTmpState.bFootnoteNoInfo )
1289 : {
1290 : // over the footnote's char
1291 0 : bRet = true;
1292 0 : if( bSetCrsr )
1293 : {
1294 0 : *m_pCurCrsr->GetPoint() = aPos;
1295 0 : if( !GotoFootnoteAnchor() )
1296 0 : bRet = false;
1297 : }
1298 0 : if( bRet )
1299 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_FTN;
1300 : }
1301 0 : else if ( 0 != ( pTextAttr = pTextNd->GetTextAttrForCharAt(
1302 0 : aPos.nContent.GetIndex(), RES_TXTATR_FTN )) )
1303 : {
1304 0 : bRet = true;
1305 0 : if( bSetCrsr )
1306 : {
1307 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1308 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1309 0 : m_pCurCrsr->GetPoint()->nNode = *static_cast<SwTextFootnote*>(pTextAttr)->GetStartNode();
1310 0 : SwContentNode* pCNd = GetDoc()->GetNodes().GoNextSection(
1311 0 : &m_pCurCrsr->GetPoint()->nNode,
1312 0 : true, !IsReadOnlyAvailable() );
1313 :
1314 0 : if( pCNd )
1315 : {
1316 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 );
1317 0 : if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
1318 0 : nsSwCursorSelOverFlags::SELOVER_TOGGLE ))
1319 0 : bRet = false;
1320 : else
1321 0 : UpdateCrsr();
1322 : }
1323 : else
1324 0 : bRet = false;
1325 : }
1326 :
1327 0 : if( bRet )
1328 : {
1329 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_FTN;
1330 0 : rContentAtPos.pFndTextAttr = pTextAttr;
1331 0 : rContentAtPos.aFnd.pAttr = &pTextAttr->GetAttr();
1332 :
1333 0 : if( pFieldRect && 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt ) ) )
1334 0 : pFrm->GetCharRect( *pFieldRect, aPos, &aTmpState );
1335 : }
1336 : }
1337 : }
1338 :
1339 0 : if( !bRet
1340 0 : && ( SwContentAtPos::SW_TOXMARK | SwContentAtPos::SW_REFMARK ) & rContentAtPos.eContentAtPos
1341 0 : && !aTmpState.bFootnoteNoInfo )
1342 : {
1343 0 : pTextAttr = 0;
1344 0 : if( SwContentAtPos::SW_TOXMARK & rContentAtPos.eContentAtPos )
1345 : {
1346 : ::std::vector<SwTextAttr *> const marks(
1347 : pTextNd->GetTextAttrsAt(
1348 0 : aPos.nContent.GetIndex(), RES_TXTATR_TOXMARK));
1349 0 : if (marks.size())
1350 : { // hmm... can only return 1 here
1351 0 : pTextAttr = *marks.begin();
1352 0 : }
1353 : }
1354 :
1355 0 : if( !pTextAttr &&
1356 0 : SwContentAtPos::SW_REFMARK & rContentAtPos.eContentAtPos )
1357 : {
1358 : ::std::vector<SwTextAttr *> const marks(
1359 : pTextNd->GetTextAttrsAt(
1360 0 : aPos.nContent.GetIndex(), RES_TXTATR_REFMARK));
1361 0 : if (marks.size())
1362 : { // hmm... can only return 1 here
1363 0 : pTextAttr = *marks.begin();
1364 0 : }
1365 : }
1366 :
1367 0 : if( pTextAttr )
1368 : {
1369 0 : bRet = true;
1370 0 : if( bSetCrsr )
1371 : {
1372 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1373 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1374 0 : m_pCurCrsr->DeleteMark();
1375 0 : *m_pCurCrsr->GetPoint() = aPos;
1376 0 : if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | nsSwCursorSelOverFlags::SELOVER_TOGGLE ) )
1377 0 : bRet = false;
1378 : else
1379 0 : UpdateCrsr();
1380 : }
1381 :
1382 0 : if( bRet )
1383 : {
1384 0 : const sal_Int32* pEnd = pTextAttr->GetEnd();
1385 0 : if( pEnd )
1386 0 : rContentAtPos.sStr =
1387 0 : pTextNd->GetExpandText( pTextAttr->GetStart(), *pEnd - pTextAttr->GetStart() );
1388 0 : else if( RES_TXTATR_TOXMARK == pTextAttr->Which())
1389 0 : rContentAtPos.sStr =
1390 0 : pTextAttr->GetTOXMark().GetAlternativeText();
1391 :
1392 : rContentAtPos.eContentAtPos =
1393 0 : RES_TXTATR_TOXMARK == pTextAttr->Which()
1394 : ? SwContentAtPos::SW_TOXMARK
1395 0 : : SwContentAtPos::SW_REFMARK;
1396 0 : rContentAtPos.pFndTextAttr = pTextAttr;
1397 0 : rContentAtPos.aFnd.pAttr = &pTextAttr->GetAttr();
1398 :
1399 0 : if( pFieldRect && 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt ) ) )
1400 0 : pFrm->GetCharRect( *pFieldRect, aPos, &aTmpState );
1401 : }
1402 : }
1403 : }
1404 :
1405 0 : if ( !bRet
1406 0 : && SwContentAtPos::SW_INETATTR & rContentAtPos.eContentAtPos
1407 0 : && !aTmpState.bFootnoteNoInfo )
1408 : {
1409 : pTextAttr = pTextNd->GetTextAttrAt(
1410 0 : aPos.nContent.GetIndex(), RES_TXTATR_INETFMT);
1411 : // "detect" only INetAttrs with URLs
1412 0 : if( pTextAttr && !pTextAttr->GetINetFormat().GetValue().isEmpty() )
1413 : {
1414 0 : bRet = true;
1415 0 : if( bSetCrsr )
1416 : {
1417 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1418 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1419 0 : m_pCurCrsr->DeleteMark();
1420 0 : *m_pCurCrsr->GetPoint() = aPos;
1421 0 : if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
1422 0 : nsSwCursorSelOverFlags::SELOVER_TOGGLE) )
1423 0 : bRet = false;
1424 : else
1425 0 : UpdateCrsr();
1426 : }
1427 0 : if( bRet )
1428 : {
1429 0 : rContentAtPos.sStr = pTextNd->GetExpandText(
1430 0 : pTextAttr->GetStart(),
1431 0 : *pTextAttr->GetEnd() - pTextAttr->GetStart() );
1432 :
1433 0 : rContentAtPos.aFnd.pAttr = &pTextAttr->GetAttr();
1434 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_INETATTR;
1435 0 : rContentAtPos.pFndTextAttr = pTextAttr;
1436 :
1437 0 : if( pFieldRect && 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt ) ) )
1438 0 : pFrm->GetCharRect( *pFieldRect, aPos, &aTmpState );
1439 : }
1440 : }
1441 : }
1442 :
1443 0 : if( !bRet && SwContentAtPos::SW_REDLINE & rContentAtPos.eContentAtPos )
1444 : {
1445 0 : const SwRangeRedline* pRedl = GetDoc()->getIDocumentRedlineAccess().GetRedline(aPos, NULL);
1446 0 : if( pRedl )
1447 : {
1448 0 : rContentAtPos.aFnd.pRedl = pRedl;
1449 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_REDLINE;
1450 0 : rContentAtPos.pFndTextAttr = 0;
1451 0 : bRet = true;
1452 :
1453 0 : if( pFieldRect && 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt ) ) )
1454 0 : pFrm->GetCharRect( *pFieldRect, aPos, &aTmpState );
1455 : }
1456 : }
1457 : }
1458 :
1459 5 : if( !bRet
1460 5 : && ( SwContentAtPos::SW_TABLEBOXFML & rContentAtPos.eContentAtPos
1461 : #ifdef DBG_UTIL
1462 : || SwContentAtPos::SW_TABLEBOXVALUE & rContentAtPos.eContentAtPos
1463 : #endif
1464 : ) )
1465 : {
1466 : const SwTableNode* pTableNd;
1467 : const SwTableBox* pBox;
1468 0 : const SwStartNode* pSttNd = pTextNd->FindTableBoxStartNode();
1469 : const SfxPoolItem* pItem;
1470 0 : if( pSttNd && 0 != ( pTableNd = pTextNd->FindTableNode()) &&
1471 0 : 0 != ( pBox = pTableNd->GetTable().GetTableBox(
1472 0 : pSttNd->GetIndex() )) &&
1473 : #ifdef DBG_UTIL
1474 : ( SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
1475 : RES_BOXATR_FORMULA, false, &pItem ) ||
1476 : SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
1477 : RES_BOXATR_VALUE, false, &pItem ))
1478 : #else
1479 0 : SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
1480 0 : RES_BOXATR_FORMULA, false, &pItem )
1481 : #endif
1482 : )
1483 : {
1484 0 : SwFrm* pF = pTextNd->getLayoutFrm( GetLayout(), &aPt );
1485 0 : if( pF )
1486 : {
1487 : // then the CellFrame
1488 0 : pFrm = static_cast<SwContentFrm*>(pF);
1489 0 : while( pF && !pF->IsCellFrm() )
1490 0 : pF = pF->GetUpper();
1491 : }
1492 :
1493 0 : if( aTmpState.bPosCorr )
1494 : {
1495 0 : if( pF && !pF->Frm().IsInside( aPt ))
1496 0 : pF = 0;
1497 : }
1498 0 : else if( !pF )
1499 0 : pF = pFrm;
1500 :
1501 0 : if( pF ) // only then it is valid
1502 : {
1503 : // create from internal (for CORE) the external
1504 : // (for UI) formula
1505 0 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_TABLEBOXFML;
1506 : #ifdef DBG_UTIL
1507 : if( RES_BOXATR_VALUE == pItem->Which() )
1508 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_TABLEBOXVALUE;
1509 : else
1510 : #endif
1511 0 : const_cast<SwTableBoxFormula*>(static_cast<const SwTableBoxFormula*>(pItem))->PtrToBoxNm( &pTableNd->GetTable() );
1512 :
1513 0 : bRet = true;
1514 0 : if( bSetCrsr )
1515 : {
1516 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1517 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1518 0 : *m_pCurCrsr->GetPoint() = aPos;
1519 0 : if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
1520 0 : nsSwCursorSelOverFlags::SELOVER_TOGGLE) )
1521 0 : bRet = false;
1522 : else
1523 0 : UpdateCrsr();
1524 : }
1525 :
1526 0 : if( bRet )
1527 : {
1528 0 : if( pFieldRect )
1529 : {
1530 0 : *pFieldRect = pF->Prt();
1531 0 : *pFieldRect += pF->Frm().Pos();
1532 : }
1533 0 : rContentAtPos.pFndTextAttr = 0;
1534 0 : rContentAtPos.aFnd.pAttr = pItem;
1535 : }
1536 : }
1537 : }
1538 : }
1539 :
1540 : #ifdef DBG_UTIL
1541 : if( !bRet && SwContentAtPos::SW_CURR_ATTRS & rContentAtPos.eContentAtPos )
1542 : {
1543 : const sal_Int32 n = aPos.nContent.GetIndex();
1544 : SfxItemSet aSet( GetDoc()->GetAttrPool(), POOLATTR_BEGIN,
1545 : POOLATTR_END - 1 );
1546 : if( pTextNd->GetpSwpHints() )
1547 : {
1548 : for( size_t i = 0; i < pTextNd->GetSwpHints().Count(); ++i )
1549 : {
1550 : const SwTextAttr* pHt = pTextNd->GetSwpHints()[i];
1551 : const sal_Int32 nAttrStart = pHt->GetStart();
1552 : if( nAttrStart > n ) // over the section
1553 : break;
1554 :
1555 : if( 0 != pHt->End() && (
1556 : ( nAttrStart < n &&
1557 : ( pHt->DontExpand() ? n < *pHt->End()
1558 : : n <= *pHt->End() )) ||
1559 : ( n == nAttrStart &&
1560 : ( nAttrStart == *pHt->End() || !n ))) )
1561 : {
1562 : aSet.Put( pHt->GetAttr() );
1563 : }
1564 : }
1565 : if( pTextNd->HasSwAttrSet() &&
1566 : pTextNd->GetpSwAttrSet()->Count() )
1567 : {
1568 : SfxItemSet aFormatSet( pTextNd->GetSwAttrSet() );
1569 : // remove all from format set that are also in TextSet
1570 : aFormatSet.Differentiate( aSet );
1571 : // now merge all together
1572 : aSet.Put( aFormatSet );
1573 : }
1574 : }
1575 : else
1576 : pTextNd->SwContentNode::GetAttr( aSet );
1577 :
1578 : rContentAtPos.sStr = "Pos: (";
1579 : rContentAtPos.sStr += OUString::number( aPos.nNode.GetIndex());
1580 : rContentAtPos.sStr += ":";
1581 : rContentAtPos.sStr += OUString::number( aPos.nContent.GetIndex());
1582 : rContentAtPos.sStr += ")";
1583 : rContentAtPos.sStr += "\nParagraph Style: ";
1584 : rContentAtPos.sStr += pTextNd->GetFormatColl()->GetName();
1585 : if( pTextNd->GetCondFormatColl() )
1586 : {
1587 : rContentAtPos.sStr += "\nConditional Style: " + pTextNd->GetCondFormatColl()->GetName();
1588 : }
1589 :
1590 : if( aSet.Count() )
1591 : {
1592 : OUString sAttrs;
1593 : SfxItemIter aIter( aSet );
1594 : const SfxPoolItem* pItem = aIter.FirstItem();
1595 : while( true )
1596 : {
1597 : if( !IsInvalidItem( pItem ))
1598 : {
1599 : OUString aStr;
1600 : GetDoc()->GetAttrPool().GetPresentation( *pItem,
1601 : SFX_MAPUNIT_CM, aStr );
1602 : if (!sAttrs.isEmpty())
1603 : sAttrs += ", ";
1604 : sAttrs += aStr;
1605 : }
1606 : if( aIter.IsAtEnd() )
1607 : break;
1608 : pItem = aIter.NextItem();
1609 : }
1610 : if (!sAttrs.isEmpty())
1611 : {
1612 : if( !rContentAtPos.sStr.isEmpty() )
1613 : rContentAtPos.sStr += "\n";
1614 : rContentAtPos.sStr += "Attr: " + sAttrs;
1615 : }
1616 : }
1617 : bRet = true;
1618 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_CURR_ATTRS;
1619 : }
1620 : #endif
1621 9 : }
1622 : }
1623 :
1624 9 : if( !bRet )
1625 : {
1626 9 : rContentAtPos.eContentAtPos = SwContentAtPos::SW_NOTHING;
1627 9 : rContentAtPos.aFnd.pField = 0;
1628 : }
1629 9 : return bRet;
1630 : }
1631 :
1632 : // #i90516#
1633 12312 : const SwPostItField* SwCrsrShell::GetPostItFieldAtCursor() const
1634 : {
1635 12312 : const SwPostItField* pPostItField = 0;
1636 :
1637 12312 : if ( !IsTableMode() )
1638 : {
1639 12297 : const SwPosition* pCursorPos = _GetCrsr()->GetPoint();
1640 12297 : const SwTextNode* pTextNd = pCursorPos->nNode.GetNode().GetTextNode();
1641 12297 : if ( pTextNd )
1642 : {
1643 12297 : SwTextAttr* pTextAttr = pTextNd->GetFieldTextAttrAt( pCursorPos->nContent.GetIndex() );
1644 12297 : const SwField* pField = pTextAttr != NULL ? pTextAttr->GetFormatField().GetField() : 0;
1645 12297 : if ( pField && pField->Which()== RES_POSTITFLD )
1646 : {
1647 10 : pPostItField = static_cast<const SwPostItField*>(pField);
1648 : }
1649 : }
1650 : }
1651 :
1652 12312 : return pPostItField;
1653 : }
1654 :
1655 : /// is the node in a protected section?
1656 0 : bool SwContentAtPos::IsInProtectSect() const
1657 : {
1658 0 : const SwTextNode* pNd = 0;
1659 0 : if( pFndTextAttr )
1660 : {
1661 0 : switch( eContentAtPos )
1662 : {
1663 : case SW_FIELD:
1664 : case SW_CLICKFIELD:
1665 0 : pNd = static_txtattr_cast<SwTextField const*>(pFndTextAttr)->GetpTextNode();
1666 0 : break;
1667 :
1668 : case SW_FTN:
1669 0 : pNd = &static_cast<const SwTextFootnote*>(pFndTextAttr)->GetTextNode();
1670 0 : break;
1671 :
1672 : case SW_INETATTR:
1673 0 : pNd = static_txtattr_cast<SwTextINetFormat const*>(pFndTextAttr)->GetpTextNode();
1674 0 : break;
1675 :
1676 : default:
1677 0 : break;
1678 : }
1679 : }
1680 :
1681 : const SwContentFrm* pFrm;
1682 0 : return pNd && ( pNd->IsInProtectSect() ||
1683 0 : ( 0 != ( pFrm = pNd->getLayoutFrm( pNd->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), 0, 0, false)) &&
1684 0 : pFrm->IsProtected() ));
1685 : }
1686 :
1687 0 : bool SwContentAtPos::IsInRTLText()const
1688 : {
1689 0 : bool bRet = false;
1690 0 : const SwTextNode* pNd = 0;
1691 0 : if (pFndTextAttr && (eContentAtPos == SW_FTN))
1692 : {
1693 0 : const SwTextFootnote* pTextFootnote = static_cast<const SwTextFootnote*>(pFndTextAttr);
1694 0 : if(pTextFootnote->GetStartNode())
1695 : {
1696 0 : SwStartNode* pSttNd = pTextFootnote->GetStartNode()->GetNode().GetStartNode();
1697 0 : SwPaM aTemp( *pSttNd );
1698 0 : aTemp.Move(fnMoveForward, fnGoNode);
1699 0 : SwContentNode* pContentNode = aTemp.GetContentNode();
1700 0 : if(pContentNode && pContentNode->IsTextNode())
1701 0 : pNd = pContentNode->GetTextNode();
1702 : }
1703 : }
1704 0 : if(pNd)
1705 : {
1706 0 : SwIterator<SwTextFrm,SwTextNode> aIter(*pNd);
1707 0 : SwTextFrm* pTmpFrm = aIter.First();
1708 0 : while( pTmpFrm )
1709 : {
1710 0 : if ( !pTmpFrm->IsFollow())
1711 : {
1712 0 : bRet = pTmpFrm->IsRightToLeft();
1713 0 : break;
1714 : }
1715 0 : pTmpFrm = aIter.Next();
1716 0 : }
1717 : }
1718 0 : return bRet;
1719 : }
1720 :
1721 0 : bool SwCrsrShell::SelectText( const sal_Int32 nStart,
1722 : const sal_Int32 nEnd )
1723 : {
1724 0 : SET_CURR_SHELL( this );
1725 0 : bool bRet = false;
1726 :
1727 0 : SwCallLink aLk( *this );
1728 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1729 :
1730 0 : SwPosition& rPos = *m_pCurCrsr->GetPoint();
1731 0 : m_pCurCrsr->DeleteMark();
1732 0 : rPos.nContent = nStart;
1733 0 : m_pCurCrsr->SetMark();
1734 0 : rPos.nContent = nEnd;
1735 :
1736 0 : if( !m_pCurCrsr->IsSelOvr() )
1737 : {
1738 0 : UpdateCrsr();
1739 0 : bRet = true;
1740 : }
1741 :
1742 0 : return bRet;
1743 : }
1744 :
1745 0 : bool SwCrsrShell::SelectTextAttr( sal_uInt16 nWhich,
1746 : bool bExpand,
1747 : const SwTextAttr* pTextAttr )
1748 : {
1749 0 : SET_CURR_SHELL( this );
1750 0 : bool bRet = false;
1751 :
1752 0 : if( !IsTableMode() )
1753 : {
1754 0 : if( !pTextAttr )
1755 : {
1756 0 : SwPosition& rPos = *m_pCurCrsr->GetPoint();
1757 0 : SwTextNode* pTextNd = rPos.nNode.GetNode().GetTextNode();
1758 : pTextAttr = (pTextNd)
1759 : ? pTextNd->GetTextAttrAt(rPos.nContent.GetIndex(),
1760 : static_cast<RES_TXTATR>(nWhich),
1761 0 : (bExpand) ? SwTextNode::EXPAND : SwTextNode::DEFAULT)
1762 0 : : 0;
1763 : }
1764 :
1765 0 : if( pTextAttr )
1766 : {
1767 0 : const sal_Int32* pEnd = pTextAttr->End();
1768 0 : bRet = SelectText( pTextAttr->GetStart(), ( pEnd ? *pEnd : pTextAttr->GetStart() + 1 ) );
1769 : }
1770 : }
1771 0 : return bRet;
1772 : }
1773 :
1774 0 : bool SwCrsrShell::GotoINetAttr( const SwTextINetFormat& rAttr )
1775 : {
1776 0 : bool bRet = false;
1777 0 : if( rAttr.GetpTextNode() )
1778 : {
1779 0 : SwCursor* pCrsr = getShellCrsr( true );
1780 :
1781 0 : SET_CURR_SHELL( this );
1782 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1783 0 : SwCrsrSaveState aSaveState( *pCrsr );
1784 :
1785 0 : pCrsr->GetPoint()->nNode = *rAttr.GetpTextNode();
1786 0 : pCrsr->GetPoint()->nContent.Assign( const_cast<SwTextNode*>(rAttr.GetpTextNode()),
1787 0 : rAttr.GetStart() );
1788 0 : bRet = !pCrsr->IsSelOvr();
1789 0 : if( bRet )
1790 0 : UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
1791 : }
1792 0 : return bRet;
1793 : }
1794 :
1795 0 : const SwFormatINetFormat* SwCrsrShell::FindINetAttr( const OUString& rName ) const
1796 : {
1797 0 : return mpDoc->FindINetAttr( rName );
1798 : }
1799 :
1800 0 : bool SwCrsrShell::GetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode,
1801 : SwRect& rRect, sal_Int16& rOrient )
1802 : {
1803 :
1804 0 : SET_CURR_SHELL( this );
1805 0 : bool bRet = false;
1806 :
1807 0 : if (!IsTableMode() && !HasSelection()
1808 0 : && GetDoc()->GetIDocumentUndoRedo().DoesUndo())
1809 : {
1810 0 : Point aPt( rPt );
1811 0 : SwPosition aPos( *m_pCurCrsr->GetPoint() );
1812 :
1813 0 : SwFillCrsrPos aFPos( eFillMode );
1814 0 : SwCrsrMoveState aTmpState( &aFPos );
1815 :
1816 0 : if( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ) &&
1817 0 : !aPos.nNode.GetNode().IsProtect())
1818 : {
1819 : // start position in protected section?
1820 0 : rRect = aFPos.aCrsr;
1821 0 : rOrient = aFPos.eOrient;
1822 0 : bRet = true;
1823 0 : }
1824 : }
1825 0 : return bRet;
1826 : }
1827 :
1828 0 : bool SwCrsrShell::SetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode )
1829 : {
1830 0 : SET_CURR_SHELL( this );
1831 0 : bool bRet = false;
1832 :
1833 0 : if (!IsTableMode() && !HasSelection()
1834 0 : && GetDoc()->GetIDocumentUndoRedo().DoesUndo())
1835 : {
1836 0 : Point aPt( rPt );
1837 0 : SwPosition aPos( *m_pCurCrsr->GetPoint() );
1838 :
1839 0 : SwFillCrsrPos aFPos( eFillMode );
1840 0 : SwCrsrMoveState aTmpState( &aFPos );
1841 :
1842 0 : if( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ) )
1843 : {
1844 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1845 0 : StartAction();
1846 :
1847 0 : SwContentNode* pCNd = aPos.nNode.GetNode().GetContentNode();
1848 0 : SwUndoId nUndoId = UNDO_INS_FROM_SHADOWCRSR;
1849 : // If only the paragraph attributes "Adjust" or "LRSpace" are set,
1850 : // then the following should not delete those again.
1851 0 : if( 0 == aFPos.nParaCnt + aFPos.nColumnCnt &&
1852 0 : ( FILL_INDENT == aFPos.eMode ||
1853 0 : ( text::HoriOrientation::NONE != aFPos.eOrient &&
1854 0 : 0 == aFPos.nTabCnt + aFPos.nSpaceCnt )) &&
1855 0 : pCNd && pCNd->Len() )
1856 0 : nUndoId = UNDO_EMPTY;
1857 :
1858 0 : GetDoc()->GetIDocumentUndoRedo().StartUndo( nUndoId, NULL );
1859 :
1860 0 : SwTextFormatColl* pNextFormat = 0;
1861 0 : SwTextNode* pTNd = pCNd ? pCNd->GetTextNode() : NULL;
1862 0 : if( pTNd )
1863 0 : pNextFormat = &pTNd->GetTextColl()->GetNextTextFormatColl();
1864 :
1865 0 : const SwSectionNode* pSectNd = pCNd ? pCNd->FindSectionNode() : NULL;
1866 0 : if( pSectNd && aFPos.nParaCnt )
1867 : {
1868 0 : SwNodeIndex aEnd( aPos.nNode, 1 );
1869 0 : while( aEnd.GetNode().IsEndNode() &&
1870 0 : &aEnd.GetNode() !=
1871 0 : pSectNd->EndOfSectionNode() )
1872 0 : ++aEnd;
1873 :
1874 0 : if( aEnd.GetNode().IsEndNode() &&
1875 0 : pCNd->Len() == aPos.nContent.GetIndex() )
1876 0 : aPos.nNode = *pSectNd->EndOfSectionNode();
1877 : }
1878 :
1879 0 : for( sal_uInt16 n = 0; n < aFPos.nParaCnt + aFPos.nColumnCnt; ++n )
1880 : {
1881 0 : GetDoc()->getIDocumentContentOperations().AppendTextNode( aPos );
1882 0 : if( !n && pNextFormat )
1883 : {
1884 0 : *m_pCurCrsr->GetPoint() = aPos;
1885 0 : GetDoc()->SetTextFormatColl( *m_pCurCrsr, pNextFormat, false );
1886 : }
1887 0 : if( n < aFPos.nColumnCnt )
1888 : {
1889 0 : *m_pCurCrsr->GetPoint() = aPos;
1890 0 : GetDoc()->getIDocumentContentOperations().InsertPoolItem( *m_pCurCrsr,
1891 0 : SvxFormatBreakItem( SVX_BREAK_COLUMN_BEFORE, RES_BREAK ) );
1892 : }
1893 : }
1894 :
1895 0 : *m_pCurCrsr->GetPoint() = aPos;
1896 0 : switch( aFPos.eMode )
1897 : {
1898 : case FILL_INDENT:
1899 0 : if( 0 != (pCNd = aPos.nNode.GetNode().GetContentNode() ))
1900 : {
1901 0 : SfxItemSet aSet( GetDoc()->GetAttrPool(),
1902 : RES_LR_SPACE, RES_LR_SPACE,
1903 : RES_PARATR_ADJUST, RES_PARATR_ADJUST,
1904 0 : 0 );
1905 : SvxLRSpaceItem aLR( static_cast<const SvxLRSpaceItem&>(
1906 0 : pCNd->GetAttr( RES_LR_SPACE ) ) );
1907 0 : aLR.SetTextLeft( aFPos.nTabCnt );
1908 0 : aLR.SetTextFirstLineOfst( 0 );
1909 0 : aSet.Put( aLR );
1910 :
1911 : const SvxAdjustItem& rAdj = static_cast<const SvxAdjustItem&>(pCNd->
1912 0 : GetAttr( RES_PARATR_ADJUST ));
1913 0 : if( SVX_ADJUST_LEFT != rAdj.GetAdjust() )
1914 0 : aSet.Put( SvxAdjustItem( SVX_ADJUST_LEFT, RES_PARATR_ADJUST ) );
1915 :
1916 0 : GetDoc()->getIDocumentContentOperations().InsertItemSet( *m_pCurCrsr, aSet );
1917 : }
1918 : else {
1919 : OSL_ENSURE( false, "No ContentNode" );
1920 : }
1921 0 : break;
1922 :
1923 : case FILL_TAB:
1924 : case FILL_SPACE:
1925 : {
1926 0 : OUStringBuffer sInsert;
1927 0 : if (aFPos.nTabCnt)
1928 0 : comphelper::string::padToLength(sInsert, aFPos.nTabCnt, '\t');
1929 0 : if (aFPos.nSpaceCnt)
1930 0 : comphelper::string::padToLength(sInsert, sInsert.getLength() + aFPos.nSpaceCnt, ' ');
1931 0 : if (!sInsert.isEmpty())
1932 0 : GetDoc()->getIDocumentContentOperations().InsertString( *m_pCurCrsr, sInsert.makeStringAndClear());
1933 : }
1934 : // no break - still need to set orientation
1935 : case FILL_MARGIN:
1936 0 : if( text::HoriOrientation::NONE != aFPos.eOrient )
1937 : {
1938 0 : SvxAdjustItem aAdj( SVX_ADJUST_LEFT, RES_PARATR_ADJUST );
1939 0 : switch( aFPos.eOrient )
1940 : {
1941 : case text::HoriOrientation::CENTER:
1942 0 : aAdj.SetAdjust( SVX_ADJUST_CENTER );
1943 0 : break;
1944 : case text::HoriOrientation::RIGHT:
1945 0 : aAdj.SetAdjust( SVX_ADJUST_RIGHT );
1946 0 : break;
1947 : default:
1948 0 : break;
1949 : }
1950 0 : GetDoc()->getIDocumentContentOperations().InsertPoolItem( *m_pCurCrsr, aAdj );
1951 : }
1952 0 : break;
1953 : }
1954 :
1955 0 : GetDoc()->GetIDocumentUndoRedo().EndUndo( nUndoId, NULL );
1956 0 : EndAction();
1957 :
1958 0 : bRet = true;
1959 0 : }
1960 : }
1961 0 : return bRet;
1962 : }
1963 :
1964 0 : const SwRangeRedline* SwCrsrShell::SelNextRedline()
1965 : {
1966 0 : const SwRangeRedline* pFnd = 0;
1967 0 : if( !IsTableMode() )
1968 : {
1969 0 : SET_CURR_SHELL( this );
1970 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1971 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1972 :
1973 0 : pFnd = GetDoc()->getIDocumentRedlineAccess().SelNextRedline( *m_pCurCrsr );
1974 0 : if( pFnd && !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
1975 0 : UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
1976 : else
1977 0 : pFnd = 0;
1978 : }
1979 0 : return pFnd;
1980 : }
1981 :
1982 0 : const SwRangeRedline* SwCrsrShell::SelPrevRedline()
1983 : {
1984 0 : const SwRangeRedline* pFnd = 0;
1985 0 : if( !IsTableMode() )
1986 : {
1987 0 : SET_CURR_SHELL( this );
1988 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
1989 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
1990 :
1991 0 : pFnd = GetDoc()->getIDocumentRedlineAccess().SelPrevRedline( *m_pCurCrsr );
1992 0 : if( pFnd && !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
1993 0 : UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
1994 : else
1995 0 : pFnd = 0;
1996 : }
1997 0 : return pFnd;
1998 : }
1999 :
2000 0 : const SwRangeRedline* SwCrsrShell::_GotoRedline( sal_uInt16 nArrPos, bool bSelect )
2001 : {
2002 0 : const SwRangeRedline* pFnd = 0;
2003 0 : SwCallLink aLk( *this ); // watch Crsr-Moves
2004 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
2005 :
2006 0 : pFnd = GetDoc()->getIDocumentRedlineAccess().GetRedlineTable()[ nArrPos ];
2007 0 : if( pFnd )
2008 : {
2009 0 : *m_pCurCrsr->GetPoint() = *pFnd->Start();
2010 :
2011 : SwContentNode* pCNd;
2012 0 : SwNodeIndex* pIdx = &m_pCurCrsr->GetPoint()->nNode;
2013 0 : if( !pIdx->GetNode().IsContentNode() &&
2014 0 : 0 != ( pCNd = GetDoc()->GetNodes().GoNextSection( pIdx,
2015 0 : true, IsReadOnlyAvailable() )) )
2016 : {
2017 0 : if( *pIdx <= pFnd->End()->nNode )
2018 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 );
2019 : else
2020 0 : pFnd = 0;
2021 : }
2022 :
2023 0 : if( pFnd && bSelect )
2024 : {
2025 0 : m_pCurCrsr->SetMark();
2026 0 : if( nsRedlineType_t::REDLINE_FMTCOLL == pFnd->GetType() )
2027 : {
2028 0 : pCNd = pIdx->GetNode().GetContentNode();
2029 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
2030 0 : m_pCurCrsr->GetMark()->nContent.Assign( pCNd, 0 );
2031 : }
2032 : else
2033 0 : *m_pCurCrsr->GetPoint() = *pFnd->End();
2034 :
2035 0 : pIdx = &m_pCurCrsr->GetPoint()->nNode;
2036 0 : if( !pIdx->GetNode().IsContentNode() &&
2037 : 0 != ( pCNd = SwNodes::GoPrevSection( pIdx,
2038 0 : true, IsReadOnlyAvailable() )) )
2039 : {
2040 0 : if( *pIdx >= m_pCurCrsr->GetMark()->nNode )
2041 0 : m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
2042 : else
2043 0 : pFnd = 0;
2044 : }
2045 : }
2046 :
2047 0 : if( !pFnd )
2048 : {
2049 0 : m_pCurCrsr->DeleteMark();
2050 0 : m_pCurCrsr->RestoreSavePos();
2051 : }
2052 0 : else if( bSelect && *m_pCurCrsr->GetMark() == *m_pCurCrsr->GetPoint() )
2053 0 : m_pCurCrsr->DeleteMark();
2054 :
2055 0 : if( pFnd && !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
2056 : UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE
2057 0 : | SwCrsrShell::READONLY );
2058 : else
2059 : {
2060 0 : pFnd = 0;
2061 0 : if( bSelect )
2062 0 : m_pCurCrsr->DeleteMark();
2063 : }
2064 : }
2065 0 : return pFnd;
2066 : }
2067 :
2068 0 : const SwRangeRedline* SwCrsrShell::GotoRedline( sal_uInt16 nArrPos, bool bSelect )
2069 : {
2070 0 : const SwRangeRedline* pFnd = 0;
2071 0 : if( !IsTableMode() )
2072 : {
2073 0 : SET_CURR_SHELL( this );
2074 :
2075 0 : const SwRedlineTable& rTable = GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
2076 0 : const SwRangeRedline* pTmp = rTable[ nArrPos ];
2077 0 : sal_uInt16 nSeqNo = pTmp->GetSeqNo();
2078 0 : if( nSeqNo && bSelect )
2079 : {
2080 0 : bool bCheck = false;
2081 0 : int nLoopCnt = 2;
2082 0 : sal_uInt16 nArrSavPos = nArrPos;
2083 :
2084 0 : do {
2085 0 : pTmp = _GotoRedline( nArrPos, true );
2086 :
2087 0 : if( !pFnd )
2088 0 : pFnd = pTmp;
2089 :
2090 0 : if( pTmp && bCheck )
2091 : {
2092 : // Check for overlaps. These can happen when FormatColl-
2093 : // Redlines were stretched over a whole paragraph
2094 0 : SwPaM* pCur = m_pCurCrsr;
2095 0 : SwPaM* pNextPam = pCur->GetNext();
2096 0 : SwPosition* pCStt = pCur->Start(), *pCEnd = pCur->End();
2097 0 : while( pCur != pNextPam )
2098 : {
2099 0 : const SwPosition *pNStt = pNextPam->Start(),
2100 0 : *pNEnd = pNextPam->End();
2101 :
2102 0 : bool bDel = true;
2103 0 : switch( ::ComparePosition( *pCStt, *pCEnd,
2104 0 : *pNStt, *pNEnd ))
2105 : {
2106 : case POS_INSIDE: // Pos1 is completely in Pos2
2107 0 : if( !pCur->HasMark() )
2108 : {
2109 0 : pCur->SetMark();
2110 0 : *pCur->GetMark() = *pNStt;
2111 : }
2112 : else
2113 0 : *pCStt = *pNStt;
2114 0 : *pCEnd = *pNEnd;
2115 0 : break;
2116 :
2117 : case POS_OUTSIDE: // Pos2 is completely in Pos1
2118 : case POS_EQUAL: // Pos1 has same size as Pos2
2119 0 : break;
2120 :
2121 : case POS_OVERLAP_BEFORE: // Pos1 overlaps Pos2 at beginning
2122 0 : if( !pCur->HasMark() )
2123 0 : pCur->SetMark();
2124 0 : *pCEnd = *pNEnd;
2125 0 : break;
2126 : case POS_OVERLAP_BEHIND: // Pos1 overlaps Pos2 at end
2127 0 : if( !pCur->HasMark() )
2128 : {
2129 0 : pCur->SetMark();
2130 0 : *pCur->GetMark() = *pNStt;
2131 : }
2132 : else
2133 0 : *pCStt = *pNStt;
2134 0 : break;
2135 :
2136 : default:
2137 0 : bDel = false;
2138 : }
2139 :
2140 0 : if( bDel )
2141 : {
2142 : // not needed anymore
2143 0 : SwPaM* pPrevPam = static_cast<SwPaM*>(pNextPam->GetPrev());
2144 0 : delete pNextPam;
2145 0 : pNextPam = pPrevPam;
2146 : }
2147 0 : pNextPam = pNextPam->GetNext();
2148 : }
2149 : }
2150 :
2151 : sal_uInt16 nFndPos = 2 == nLoopCnt
2152 0 : ? rTable.FindNextOfSeqNo( nArrPos )
2153 0 : : rTable.FindPrevOfSeqNo( nArrPos );
2154 0 : if( USHRT_MAX != nFndPos ||
2155 0 : ( 0 != ( --nLoopCnt ) && USHRT_MAX != (
2156 0 : nFndPos = rTable.FindPrevOfSeqNo( nArrSavPos ))) )
2157 : {
2158 0 : if( pTmp )
2159 : {
2160 : // create new cursor
2161 0 : CreateCrsr();
2162 0 : bCheck = true;
2163 : }
2164 0 : nArrPos = nFndPos;
2165 : }
2166 : else
2167 0 : nLoopCnt = 0;
2168 :
2169 0 : } while( nLoopCnt );
2170 : }
2171 : else
2172 0 : pFnd = _GotoRedline( nArrPos, bSelect );
2173 : }
2174 0 : return pFnd;
2175 : }
2176 :
2177 0 : bool SwCrsrShell::SelectNxtPrvHyperlink( bool bNext )
2178 : {
2179 0 : SwNodes& rNds = GetDoc()->GetNodes();
2180 0 : const SwNode* pBodyEndNd = &rNds.GetEndOfContent();
2181 0 : const SwNode* pBodySttNd = pBodyEndNd->StartOfSectionNode();
2182 0 : sal_uLong nBodySttNdIdx = pBodySttNd->GetIndex();
2183 0 : Point aPt;
2184 :
2185 0 : _SetGetExpField aCmpPos( SwPosition( bNext ? *pBodyEndNd : *pBodySttNd ) );
2186 0 : _SetGetExpField aCurPos( bNext ? *m_pCurCrsr->End() : *m_pCurCrsr->Start() );
2187 0 : if( aCurPos.GetNode() < nBodySttNdIdx )
2188 : {
2189 0 : const SwContentNode* pCNd = aCurPos.GetNodeFromContent()->GetContentNode();
2190 : SwContentFrm* pFrm;
2191 0 : if( pCNd && 0 != ( pFrm = pCNd->getLayoutFrm( GetLayout(), &aPt )) )
2192 0 : aCurPos.SetBodyPos( *pFrm );
2193 : }
2194 :
2195 : // check first all the hyperlink fields
2196 : {
2197 : const SwTextNode* pTextNd;
2198 0 : const SwCharFormats* pFormats = GetDoc()->GetCharFormats();
2199 0 : for( SwCharFormats::size_type n = pFormats->size(); 1 < n; )
2200 : {
2201 0 : SwIterator<SwTextINetFormat,SwCharFormat> aIter(*(*pFormats)[--n]);
2202 :
2203 0 : for( SwTextINetFormat* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() )
2204 0 : if( 0 != ( pTextNd = pFnd->GetpTextNode()) &&
2205 0 : pTextNd->GetNodes().IsDocNodes() )
2206 : {
2207 0 : SwTextINetFormat& rAttr = *pFnd;
2208 0 : SwPosition aTmpPos( *pTextNd );
2209 0 : _SetGetExpField aPos( aTmpPos.nNode, rAttr );
2210 : SwContentFrm* pFrm;
2211 0 : if( pTextNd->GetIndex() < nBodySttNdIdx &&
2212 0 : 0 != ( pFrm = pTextNd->getLayoutFrm( GetLayout(), &aPt )) )
2213 0 : aPos.SetBodyPos( *pFrm );
2214 :
2215 0 : if( bNext
2216 0 : ? ( aPos < aCmpPos && aCurPos < aPos )
2217 0 : : ( aCmpPos < aPos && aPos < aCurPos ))
2218 : {
2219 0 : OUString sText( pTextNd->GetExpandText( rAttr.GetStart(),
2220 0 : *rAttr.GetEnd() - rAttr.GetStart() ) );
2221 :
2222 0 : sText = comphelper::string::remove(sText, 0x0a);
2223 0 : sText = comphelper::string::strip(sText, ' ');
2224 :
2225 0 : if( !sText.isEmpty() )
2226 0 : aCmpPos = aPos;
2227 0 : }
2228 : }
2229 0 : }
2230 : }
2231 :
2232 : // then check all the Flys with a URL or imapge map
2233 : {
2234 0 : const SwFrameFormats* pFormats = GetDoc()->GetSpzFrameFormats();
2235 0 : for( SwFrameFormats::size_type n = 0, nEnd = pFormats->size(); n < nEnd; ++n )
2236 : {
2237 0 : SwFlyFrameFormat* pFormat = static_cast<SwFlyFrameFormat*>((*pFormats)[ n ]);
2238 0 : const SwFormatURL& rURLItem = pFormat->GetURL();
2239 0 : if( rURLItem.GetMap() || !rURLItem.GetURL().isEmpty() )
2240 : {
2241 0 : SwFlyFrm* pFly = pFormat->GetFrm( &aPt, false );
2242 0 : SwPosition aTmpPos( *pBodySttNd );
2243 0 : if( pFly &&
2244 0 : GetBodyTextNode( *GetDoc(), aTmpPos, *pFly->GetLower() ) )
2245 : {
2246 0 : _SetGetExpField aPos( *pFormat, &aTmpPos );
2247 :
2248 0 : if( bNext
2249 0 : ? ( aPos < aCmpPos && aCurPos < aPos )
2250 0 : : ( aCmpPos < aPos && aPos < aCurPos ))
2251 0 : aCmpPos = aPos;
2252 0 : }
2253 : }
2254 : }
2255 : }
2256 :
2257 : // found any URL ?
2258 0 : bool bRet = false;
2259 0 : const SwTextINetFormat* pFndAttr = aCmpPos.GetINetFormat();
2260 0 : const SwFlyFrameFormat* pFndFormat = aCmpPos.GetFlyFormat();
2261 0 : if( pFndAttr || pFndFormat )
2262 : {
2263 0 : SET_CURR_SHELL( this );
2264 0 : SwCallLink aLk( *this );
2265 :
2266 : // found a text attribute ?
2267 0 : if( pFndAttr )
2268 : {
2269 0 : SwCrsrSaveState aSaveState( *m_pCurCrsr );
2270 :
2271 0 : aCmpPos.GetPosOfContent( *m_pCurCrsr->GetPoint() );
2272 0 : m_pCurCrsr->DeleteMark();
2273 0 : m_pCurCrsr->SetMark();
2274 0 : m_pCurCrsr->GetPoint()->nContent = *pFndAttr->End();
2275 :
2276 0 : if( !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
2277 : {
2278 : UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|
2279 0 : SwCrsrShell::READONLY );
2280 0 : bRet = true;
2281 0 : }
2282 : }
2283 : // found a draw object ?
2284 0 : else if( RES_DRAWFRMFMT == pFndFormat->Which() )
2285 : {
2286 0 : const SdrObject* pSObj = pFndFormat->FindSdrObject();
2287 0 : if (pSObj)
2288 : {
2289 0 : static_cast<SwFEShell*>(this)->SelectObj( pSObj->GetCurrentBoundRect().Center() );
2290 0 : MakeSelVisible();
2291 0 : bRet = true;
2292 : }
2293 : }
2294 : else // then is it a fly
2295 : {
2296 0 : SwFlyFrm* pFly = pFndFormat->GetFrm(&aPt, false );
2297 0 : if( pFly )
2298 : {
2299 0 : static_cast<SwFEShell*>(this)->SelectFlyFrm( *pFly, true );
2300 0 : MakeSelVisible();
2301 0 : bRet = true;
2302 : }
2303 0 : }
2304 : }
2305 0 : return bRet;
2306 177 : }
2307 :
2308 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
