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 <editeng/frmdiritem.hxx>
22 : #include <editeng/protitem.hxx>
23 : #include <tools/gen.hxx>
24 : #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
25 : #include <fmtcntnt.hxx>
26 : #include <fmtanchr.hxx>
27 : #include <frmfmt.hxx>
28 : #include <txtftn.hxx>
29 : #include <ftnfrm.hxx>
30 : #include <doc.hxx>
31 : #include <docary.hxx>
32 : #include <node.hxx>
33 : #include <ndindex.hxx>
34 : #include <numrule.hxx>
35 : #include <swtable.hxx>
36 : #include <ndtxt.hxx>
37 : #include <pam.hxx>
38 : #include <swcache.hxx>
39 : #include <section.hxx>
40 : #include <cntfrm.hxx>
41 : #include <flyfrm.hxx>
42 : #include <txtfrm.hxx>
43 : #include <tabfrm.hxx>
44 : #include <viewsh.hxx>
45 : #include <paratr.hxx>
46 : #include <ftnidx.hxx>
47 : #include <fmtftn.hxx>
48 : #include <fmthdft.hxx>
49 : #include <frmatr.hxx>
50 : #include <fmtautofmt.hxx>
51 : #include <frmtool.hxx>
52 : #include <pagefrm.hxx>
53 : #include <node2lay.hxx>
54 : #include <pagedesc.hxx>
55 : #include <fmtpdsc.hxx>
56 : #include <breakit.hxx>
57 : #include <crsskip.hxx>
58 : #include <SwStyleNameMapper.hxx>
59 : #include <scriptinfo.hxx>
60 : #include <rootfrm.hxx>
61 : #include <istyleaccess.hxx>
62 : #include <IDocumentListItems.hxx>
63 : #include <DocumentSettingManager.hxx>
64 : #include <IDocumentLinksAdministration.hxx>
65 : #include <IDocumentRedlineAccess.hxx>
66 : #include <IDocumentLayoutAccess.hxx>
67 : #include <switerator.hxx>
68 : #include "ndole.hxx"
69 :
70 : using namespace ::com::sun::star::i18n;
71 :
72 1400100 : TYPEINIT2( SwCntntNode, SwModify, SwIndexReg )
73 :
74 : /*
75 : * Some local helper functions for the attribute set handle of a content node.
76 : * Since the attribute set of a content node may not be modified directly,
77 : * we always have to create a new SwAttrSet, do the modifications, and get
78 : * a new handle from the style access
79 : */
80 :
81 : namespace AttrSetHandleHelper
82 : {
83 :
84 142042 : void GetNewAutoStyle( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
85 : const SwCntntNode& rNode,
86 : SwAttrSet& rNewAttrSet )
87 : {
88 142042 : const SwAttrSet* pAttrSet = static_cast<const SwAttrSet*>(rpAttrSet.get());
89 142042 : if( rNode.GetModifyAtAttr() )
90 908 : const_cast<SwAttrSet*>(pAttrSet)->SetModifyAtAttr( 0 );
91 142042 : IStyleAccess& rSA = pAttrSet->GetPool()->GetDoc()->GetIStyleAccess();
92 284084 : rpAttrSet = rSA.getAutomaticStyle( rNewAttrSet, rNode.IsTxtNode() ?
93 : IStyleAccess::AUTO_STYLE_PARA :
94 284084 : IStyleAccess::AUTO_STYLE_NOTXT );
95 142042 : const bool bSetModifyAtAttr = ((SwAttrSet*)rpAttrSet.get())->SetModifyAtAttr( &rNode );
96 142042 : rNode.SetModifyAtAttr( bSetModifyAtAttr );
97 142042 : }
98 :
99 1864 : void SetParent( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
100 : const SwCntntNode& rNode,
101 : const SwFmt* pParentFmt,
102 : const SwFmt* pConditionalFmt )
103 : {
104 1864 : const SwAttrSet* pAttrSet = static_cast<const SwAttrSet*>(rpAttrSet.get());
105 : OSL_ENSURE( pAttrSet, "no SwAttrSet" );
106 : OSL_ENSURE( pParentFmt || !pConditionalFmt, "ConditionalFmt without ParentFmt?" );
107 :
108 1864 : const SwAttrSet* pParentSet = pParentFmt ? &pParentFmt->GetAttrSet() : 0;
109 :
110 1864 : if ( pParentSet != pAttrSet->GetParent() )
111 : {
112 912 : SwAttrSet aNewSet( *pAttrSet );
113 912 : aNewSet.SetParent( pParentSet );
114 912 : aNewSet.ClearItem( RES_FRMATR_STYLE_NAME );
115 912 : aNewSet.ClearItem( RES_FRMATR_CONDITIONAL_STYLE_NAME );
116 1824 : OUString sVal;
117 :
118 912 : if ( pParentFmt )
119 : {
120 912 : SwStyleNameMapper::FillProgName( pParentFmt->GetName(), sVal, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, true );
121 912 : const SfxStringItem aAnyFmtColl( RES_FRMATR_STYLE_NAME, sVal );
122 912 : aNewSet.Put( aAnyFmtColl );
123 :
124 912 : if ( pConditionalFmt != pParentFmt )
125 0 : SwStyleNameMapper::FillProgName( pConditionalFmt->GetName(), sVal, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, true );
126 :
127 1824 : const SfxStringItem aFmtColl( RES_FRMATR_CONDITIONAL_STYLE_NAME, sVal );
128 1824 : aNewSet.Put( aFmtColl );
129 : }
130 :
131 1824 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
132 : }
133 1864 : }
134 :
135 10072 : const SfxPoolItem* Put( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
136 : const SwCntntNode& rNode,
137 : const SfxPoolItem& rAttr )
138 : {
139 10072 : SwAttrSet aNewSet( (SwAttrSet&)*rpAttrSet );
140 10072 : const SfxPoolItem* pRet = aNewSet.Put( rAttr );
141 10072 : if ( pRet )
142 7170 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
143 10072 : return pRet;
144 : }
145 :
146 40088 : bool Put( boost::shared_ptr<const SfxItemSet>& rpAttrSet, const SwCntntNode& rNode,
147 : const SfxItemSet& rSet )
148 : {
149 40088 : SwAttrSet aNewSet( (SwAttrSet&)*rpAttrSet );
150 :
151 : // #i76273# Robust
152 40088 : SfxItemSet* pStyleNames = 0;
153 40088 : if ( SfxItemState::SET == rSet.GetItemState( RES_FRMATR_STYLE_NAME, false ) )
154 : {
155 8290 : pStyleNames = new SfxItemSet( *aNewSet.GetPool(), RES_FRMATR_STYLE_NAME, RES_FRMATR_CONDITIONAL_STYLE_NAME );
156 8290 : pStyleNames->Put( aNewSet );
157 : }
158 :
159 40088 : const bool nRet = aNewSet.Put( rSet );
160 :
161 : // #i76273# Robust
162 40088 : if ( pStyleNames )
163 : {
164 8290 : aNewSet.Put( *pStyleNames );
165 8290 : delete pStyleNames;
166 : }
167 :
168 40088 : if ( nRet )
169 32444 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
170 :
171 40088 : return nRet;
172 : }
173 :
174 6516 : bool Put_BC( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
175 : const SwCntntNode& rNode, const SfxPoolItem& rAttr,
176 : SwAttrSet* pOld, SwAttrSet* pNew )
177 : {
178 6516 : SwAttrSet aNewSet( (SwAttrSet&)*rpAttrSet );
179 :
180 : // for a correct broadcast, we need to do a SetModifyAtAttr with the items
181 : // from aNewSet. The 'regular' SetModifyAtAttr is done in GetNewAutoStyle
182 6516 : if( rNode.GetModifyAtAttr() )
183 320 : aNewSet.SetModifyAtAttr( &rNode );
184 :
185 6516 : const bool nRet = aNewSet.Put_BC( rAttr, pOld, pNew );
186 :
187 6516 : if ( nRet )
188 6440 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
189 :
190 6516 : return nRet;
191 : }
192 :
193 93864 : bool Put_BC( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
194 : const SwCntntNode& rNode, const SfxItemSet& rSet,
195 : SwAttrSet* pOld, SwAttrSet* pNew )
196 : {
197 93864 : SwAttrSet aNewSet( (SwAttrSet&)*rpAttrSet );
198 :
199 : // #i76273# Robust
200 93864 : SfxItemSet* pStyleNames = 0;
201 93864 : if ( SfxItemState::SET == rSet.GetItemState( RES_FRMATR_STYLE_NAME, false ) )
202 : {
203 894 : pStyleNames = new SfxItemSet( *aNewSet.GetPool(), RES_FRMATR_STYLE_NAME, RES_FRMATR_CONDITIONAL_STYLE_NAME );
204 894 : pStyleNames->Put( aNewSet );
205 : }
206 :
207 : // for a correct broadcast, we need to do a SetModifyAtAttr with the items
208 : // from aNewSet. The 'regular' SetModifyAtAttr is done in GetNewAutoStyle
209 93864 : if( rNode.GetModifyAtAttr() )
210 126 : aNewSet.SetModifyAtAttr( &rNode );
211 :
212 93864 : const bool nRet = aNewSet.Put_BC( rSet, pOld, pNew );
213 :
214 : // #i76273# Robust
215 93864 : if ( pStyleNames )
216 : {
217 894 : aNewSet.Put( *pStyleNames );
218 894 : delete pStyleNames;
219 : }
220 :
221 93864 : if ( nRet )
222 83212 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
223 :
224 93864 : return nRet;
225 : }
226 :
227 68140 : sal_uInt16 ClearItem_BC( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
228 : const SwCntntNode& rNode, sal_uInt16 nWhich,
229 : SwAttrSet* pOld, SwAttrSet* pNew )
230 : {
231 68140 : SwAttrSet aNewSet( (SwAttrSet&)*rpAttrSet );
232 68140 : if( rNode.GetModifyAtAttr() )
233 30184 : aNewSet.SetModifyAtAttr( &rNode );
234 68140 : const sal_uInt16 nRet = aNewSet.ClearItem_BC( nWhich, pOld, pNew );
235 68140 : if ( nRet )
236 6880 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
237 68140 : return nRet;
238 : }
239 :
240 22938 : sal_uInt16 ClearItem_BC( boost::shared_ptr<const SfxItemSet>& rpAttrSet,
241 : const SwCntntNode& rNode,
242 : sal_uInt16 nWhich1, sal_uInt16 nWhich2,
243 : SwAttrSet* pOld, SwAttrSet* pNew )
244 : {
245 22938 : SwAttrSet aNewSet( (SwAttrSet&)*rpAttrSet );
246 22938 : if( rNode.GetModifyAtAttr() )
247 4 : aNewSet.SetModifyAtAttr( &rNode );
248 22938 : const sal_uInt16 nRet = aNewSet.ClearItem_BC( nWhich1, nWhich2, pOld, pNew );
249 22938 : if ( nRet )
250 1772 : GetNewAutoStyle( rpAttrSet, rNode, aNewSet );
251 22938 : return nRet;
252 : }
253 :
254 : }
255 :
256 : /** Returns the section level at the position given by aIndex.
257 : *
258 : * We use the following logic:
259 : * S = Start, E = End, C = CntntNode
260 : * Level 0 = E
261 : * 1 = S E
262 : * 2 = SC
263 : *
264 : * All EndNodes of the BaseSection have level 0
265 : * All StartNodes of the BaseSection have level 1
266 : */
267 8 : sal_uInt16 SwNode::GetSectionLevel() const
268 : {
269 : // EndNode of a BaseSection? They are always 0!
270 8 : if( IsEndNode() && 0 == pStartOfSection->StartOfSectionIndex() )
271 0 : return 0;
272 :
273 : sal_uInt16 nLevel;
274 8 : const SwNode* pNode = IsStartNode() ? this : pStartOfSection;
275 22 : for( nLevel = 1; 0 != pNode->StartOfSectionIndex(); ++nLevel )
276 14 : pNode = pNode->pStartOfSection;
277 8 : return IsEndNode() ? nLevel-1 : nLevel;
278 : }
279 :
280 : #ifdef DBG_UTIL
281 : long SwNode::s_nSerial = 0;
282 : #endif
283 :
284 167992 : SwNode::SwNode( const SwNodeIndex &rWhere, const sal_uInt8 nNdType )
285 : : nNodeType( nNdType )
286 : , nAFmtNumLvl( 0 )
287 : , bSetNumLSpace( false )
288 : , bIgnoreDontExpand( false)
289 : #ifdef DBG_UTIL
290 : , m_nSerial( s_nSerial++)
291 : #endif
292 167992 : , pStartOfSection( 0 )
293 : {
294 167992 : if( rWhere.GetIndex() )
295 : {
296 167992 : SwNodes& rNodes = const_cast<SwNodes&> (rWhere.GetNodes());
297 167992 : SwNode* pNd = rNodes[ rWhere.GetIndex() -1 ];
298 167992 : rNodes.InsertNode( this, rWhere );
299 167992 : if( 0 == ( pStartOfSection = pNd->GetStartNode()) )
300 : {
301 120794 : pStartOfSection = pNd->pStartOfSection;
302 120794 : if( pNd->GetEndNode() ) // Skip EndNode ? Section
303 : {
304 32744 : pNd = pStartOfSection;
305 32744 : pStartOfSection = pNd->pStartOfSection;
306 : }
307 : }
308 : }
309 167992 : }
310 :
311 : /** Inserts a node into the rNodes array at the rWhere position
312 : *
313 : * @param rNodes the variable array in that the node will be inserted
314 : * @param nPos position within the array where the node will be inserted
315 : * @param nNdType the type of node to insert
316 : */
317 101048 : SwNode::SwNode( SwNodes& rNodes, sal_uLong nPos, const sal_uInt8 nNdType )
318 : : nNodeType( nNdType )
319 : , nAFmtNumLvl( 0 )
320 : , bSetNumLSpace( false )
321 : , bIgnoreDontExpand( false)
322 : #ifdef DBG_UTIL
323 : , m_nSerial( s_nSerial++)
324 : #endif
325 101048 : , pStartOfSection( 0 )
326 : {
327 101048 : if( nPos )
328 : {
329 90944 : SwNode* pNd = rNodes[ nPos - 1 ];
330 90944 : rNodes.InsertNode( this, nPos );
331 90944 : if( 0 == ( pStartOfSection = pNd->GetStartNode()) )
332 : {
333 40416 : pStartOfSection = pNd->pStartOfSection;
334 40416 : if( pNd->GetEndNode() ) // Skip EndNode ? Section!
335 : {
336 40416 : pNd = pStartOfSection;
337 40416 : pStartOfSection = pNd->pStartOfSection;
338 : }
339 : }
340 : }
341 101048 : }
342 :
343 268781 : SwNode::~SwNode()
344 : {
345 268781 : }
346 :
347 : /// Find the TableNode in which it is located.
348 : /// If we're not in a table: return 0
349 1065543 : SwTableNode* SwNode::FindTableNode()
350 : {
351 1065543 : if( IsTableNode() )
352 2 : return GetTableNode();
353 1065541 : SwStartNode* pTmp = pStartOfSection;
354 3278441 : while( !pTmp->IsTableNode() && pTmp->GetIndex() )
355 1147359 : pTmp = pTmp->pStartOfSection;
356 1065541 : return pTmp->GetTableNode();
357 : }
358 :
359 : /// Is the node located in the visible area of the Shell?
360 0 : bool SwNode::IsInVisibleArea( SwViewShell const * pSh ) const
361 : {
362 0 : bool bRet = false;
363 : const SwCntntNode* pNd;
364 :
365 0 : if( ND_STARTNODE & nNodeType )
366 : {
367 0 : SwNodeIndex aIdx( *this );
368 0 : pNd = GetNodes().GoNext( &aIdx );
369 : }
370 0 : else if( ND_ENDNODE & nNodeType )
371 : {
372 0 : SwNodeIndex aIdx( *EndOfSectionNode() );
373 0 : pNd = GetNodes().GoPrevious( &aIdx );
374 : }
375 : else
376 0 : pNd = GetCntntNode();
377 :
378 0 : if( !pSh )
379 : // Get the Shell from the Doc
380 0 : pSh = GetDoc()->getIDocumentLayoutAccess().GetCurrentViewShell();
381 :
382 0 : if( pSh )
383 : {
384 : const SwFrm* pFrm;
385 0 : if( pNd && 0 != ( pFrm = pNd->getLayoutFrm( pSh->GetLayout(), 0, 0, false ) ) )
386 : {
387 :
388 0 : if ( pFrm->IsInTab() )
389 0 : pFrm = pFrm->FindTabFrm();
390 :
391 0 : if( !pFrm->IsValid() )
392 0 : do
393 0 : { pFrm = pFrm->FindPrev();
394 0 : } while ( pFrm && !pFrm->IsValid() );
395 :
396 0 : if( !pFrm || pSh->VisArea().IsOver( pFrm->Frm() ) )
397 0 : bRet = true;
398 : }
399 : }
400 :
401 0 : return bRet;
402 : }
403 :
404 33120 : bool SwNode::IsInProtectSect() const
405 : {
406 33120 : const SwNode* pNd = ND_SECTIONNODE == nNodeType ? pStartOfSection : this;
407 33120 : const SwSectionNode* pSectNd = pNd->FindSectionNode();
408 33120 : return pSectNd && pSectNd->GetSection().IsProtectFlag();
409 : }
410 :
411 : /// Does the node contain anything protected?
412 : /// I.e.: Area/Frame/Table rows/... including the Anchor for
413 : /// Frames/Footnotes/...
414 6820 : bool SwNode::IsProtect() const
415 : {
416 6820 : const SwNode* pNd = ND_SECTIONNODE == nNodeType ? pStartOfSection : this;
417 6820 : const SwStartNode* pSttNd = pNd->FindSectionNode();
418 6820 : if( pSttNd && ((SwSectionNode*)pSttNd)->GetSection().IsProtectFlag() )
419 0 : return true;
420 :
421 6820 : if( 0 != ( pSttNd = FindTableBoxStartNode() ) )
422 : {
423 : SwCntntFrm* pCFrm;
424 6780 : if( IsCntntNode() && 0 != (pCFrm = ((SwCntntNode*)this)->getLayoutFrm( GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout() ) ))
425 118 : return pCFrm->IsProtected();
426 :
427 6662 : const SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().
428 13324 : GetTblBox( pSttNd->GetIndex() );
429 : //Robust #149568
430 6662 : if( pBox && pBox->GetFrmFmt()->GetProtect().IsCntntProtected() )
431 0 : return true;
432 : }
433 :
434 6702 : SwFrmFmt* pFlyFmt = GetFlyFmt();
435 6702 : if( pFlyFmt )
436 : {
437 168 : if( pFlyFmt->GetProtect().IsCntntProtected() )
438 0 : return true;
439 168 : const SwFmtAnchor& rAnchor = pFlyFmt->GetAnchor();
440 168 : return rAnchor.GetCntntAnchor()
441 40 : ? rAnchor.GetCntntAnchor()->nNode.GetNode().IsProtect()
442 208 : : sal_False;
443 : }
444 :
445 6534 : if( 0 != ( pSttNd = FindFootnoteStartNode() ) )
446 : {
447 0 : const SwTxtFtn* pTFtn = GetDoc()->GetFtnIdxs().SeekEntry(
448 0 : SwNodeIndex( *pSttNd ) );
449 0 : if( pTFtn )
450 0 : return pTFtn->GetTxtNode().IsProtect();
451 : }
452 :
453 6534 : return false;
454 : }
455 :
456 : /// Find the PageDesc that is used to format this node. If the Layout is available,
457 : /// we search through that. Else we can only do it the hard way by searching onwards through the nodes.
458 27656 : const SwPageDesc* SwNode::FindPageDesc( bool bCalcLay,
459 : sal_uInt32* pPgDescNdIdx ) const
460 : {
461 27656 : if ( !GetNodes().IsDocNodes() )
462 : {
463 0 : return 0;
464 : }
465 :
466 27656 : const SwPageDesc* pPgDesc = 0;
467 :
468 : const SwCntntNode* pNode;
469 27656 : if( ND_STARTNODE & nNodeType )
470 : {
471 112 : SwNodeIndex aIdx( *this );
472 112 : pNode = GetNodes().GoNext( &aIdx );
473 : }
474 27544 : else if( ND_ENDNODE & nNodeType )
475 : {
476 0 : SwNodeIndex aIdx( *EndOfSectionNode() );
477 0 : pNode = GetNodes().GoPrevious( &aIdx );
478 : }
479 : else
480 : {
481 27544 : pNode = GetCntntNode();
482 27544 : if( pNode )
483 27544 : pPgDesc = ((SwFmtPageDesc&)pNode->GetAttr( RES_PAGEDESC )).GetPageDesc();
484 : }
485 :
486 : // Are we going through the layout?
487 27656 : if( !pPgDesc )
488 : {
489 : const SwFrm* pFrm;
490 : const SwPageFrm* pPage;
491 26512 : if( pNode && 0 != ( pFrm = pNode->getLayoutFrm( pNode->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), 0, 0, bCalcLay ) ) &&
492 : 0 != ( pPage = pFrm->FindPageFrm() ) )
493 : {
494 20416 : pPgDesc = pPage->GetPageDesc();
495 20416 : if ( pPgDescNdIdx )
496 : {
497 8 : *pPgDescNdIdx = pNode->GetIndex();
498 : }
499 : }
500 : }
501 :
502 27656 : if( !pPgDesc )
503 : {
504 : // Thus via the nodes array
505 6096 : const SwDoc* pDoc = GetDoc();
506 6096 : const SwNode* pNd = this;
507 : const SwStartNode* pSttNd;
508 6096 : if( pNd->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() &&
509 : 0 != ( pSttNd = pNd->FindFlyStartNode() ) )
510 : {
511 : // Find the right Anchor first
512 290 : const SwFrmFmt* pFmt = 0;
513 290 : const SwFrmFmts& rFmts = *pDoc->GetSpzFrmFmts();
514 : sal_uInt16 n;
515 :
516 850 : for( n = 0; n < rFmts.size(); ++n )
517 : {
518 850 : SwFrmFmt* pFrmFmt = rFmts[ n ];
519 850 : const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
520 1600 : if( rCntnt.GetCntntIdx() &&
521 750 : &rCntnt.GetCntntIdx()->GetNode() == (SwNode*)pSttNd )
522 : {
523 290 : pFmt = pFrmFmt;
524 290 : break;
525 : }
526 : }
527 :
528 290 : if( pFmt )
529 : {
530 290 : const SwFmtAnchor* pAnchor = &pFmt->GetAnchor();
531 580 : if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) &&
532 290 : pAnchor->GetCntntAnchor() )
533 : {
534 290 : pNd = &pAnchor->GetCntntAnchor()->nNode.GetNode();
535 290 : const SwNode* pFlyNd = pNd->FindFlyStartNode();
536 580 : while( pFlyNd )
537 : {
538 : // Get up through the Anchor
539 0 : for( n = 0; n < rFmts.size(); ++n )
540 : {
541 0 : const SwFrmFmt* pFrmFmt = rFmts[ n ];
542 0 : const SwNodeIndex* pIdx = pFrmFmt->GetCntnt().
543 0 : GetCntntIdx();
544 0 : if( pIdx && pFlyNd == &pIdx->GetNode() )
545 : {
546 0 : if( pFmt == pFrmFmt )
547 : {
548 0 : pNd = pFlyNd;
549 0 : pFlyNd = 0;
550 0 : break;
551 : }
552 0 : pAnchor = &pFrmFmt->GetAnchor();
553 0 : if ((FLY_AT_PAGE == pAnchor->GetAnchorId()) ||
554 0 : !pAnchor->GetCntntAnchor() )
555 : {
556 0 : pFlyNd = 0;
557 0 : break;
558 : }
559 :
560 0 : pFlyNd = pAnchor->GetCntntAnchor()->nNode.
561 0 : GetNode().FindFlyStartNode();
562 0 : break;
563 : }
564 : }
565 0 : if( n >= rFmts.size() )
566 : {
567 : OSL_ENSURE( false, "FlySection, but no Format found" );
568 0 : return 0;
569 : }
570 : }
571 : }
572 : }
573 : // pNd should now contain the correct Anchor or it's still this
574 : }
575 :
576 6096 : if( pNd->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() )
577 : {
578 1362 : if( pNd->GetIndex() > GetNodes().GetEndOfAutotext().GetIndex() )
579 : {
580 0 : pPgDesc = &pDoc->GetPageDesc( 0 );
581 0 : pNd = 0;
582 : }
583 : else
584 : {
585 : // Find the Body text node
586 1362 : if( 0 != ( pSttNd = pNd->FindHeaderStartNode() ) ||
587 : 0 != ( pSttNd = pNd->FindFooterStartNode() ))
588 : {
589 : // Then find this StartNode in the PageDescs
590 : sal_uInt16 nId;
591 : UseOnPage eAskUse;
592 1362 : if( SwHeaderStartNode == pSttNd->GetStartNodeType())
593 : {
594 690 : nId = RES_HEADER;
595 690 : eAskUse = nsUseOnPage::PD_HEADERSHARE;
596 : }
597 : else
598 : {
599 672 : nId = RES_FOOTER;
600 672 : eAskUse = nsUseOnPage::PD_FOOTERSHARE;
601 : }
602 :
603 5796 : for( sal_uInt16 n = pDoc->GetPageDescCnt(); n && !pPgDesc; )
604 : {
605 3072 : const SwPageDesc& rPgDsc = pDoc->GetPageDesc( --n );
606 3072 : const SwFrmFmt* pFmt = &rPgDsc.GetMaster();
607 3072 : int nStt = 0, nLast = 1;
608 3072 : if( !( eAskUse & rPgDsc.ReadUseOn() )) ++nLast;
609 :
610 5260 : for( ; nStt < nLast; ++nStt, pFmt = &rPgDsc.GetLeft() )
611 : {
612 : const SwFrmFmt * pHdFtFmt = nId == RES_HEADER
613 : ? static_cast<SwFmtHeader const &>(
614 1820 : pFmt->GetFmtAttr(nId)).GetHeaderFmt()
615 : : static_cast<SwFmtFooter const &>(
616 5370 : pFmt->GetFmtAttr(nId)).GetFooterFmt();
617 3550 : if( pHdFtFmt )
618 : {
619 2780 : const SwFmtCntnt& rCntnt = pHdFtFmt->GetCntnt();
620 5560 : if( rCntnt.GetCntntIdx() &&
621 2780 : &rCntnt.GetCntntIdx()->GetNode() ==
622 : (SwNode*)pSttNd )
623 : {
624 1362 : pPgDesc = &rPgDsc;
625 1362 : break;
626 : }
627 : }
628 : }
629 : }
630 :
631 1362 : if( !pPgDesc )
632 0 : pPgDesc = &pDoc->GetPageDesc( 0 );
633 1362 : pNd = 0;
634 : }
635 0 : else if( 0 != ( pSttNd = pNd->FindFootnoteStartNode() ))
636 : {
637 : // the Anchor can only be in the Body text
638 : const SwTxtFtn* pTxtFtn;
639 0 : const SwFtnIdxs& rFtnArr = pDoc->GetFtnIdxs();
640 0 : for( sal_uInt16 n = 0; n < rFtnArr.size(); ++n )
641 0 : if( 0 != ( pTxtFtn = rFtnArr[ n ])->GetStartNode() &&
642 : (SwNode*)pSttNd ==
643 0 : &pTxtFtn->GetStartNode()->GetNode() )
644 : {
645 0 : pNd = &pTxtFtn->GetTxtNode();
646 0 : break;
647 : }
648 : }
649 : else
650 : {
651 : // Can only be a page-bound Fly (or something newer).
652 : // we can only return the standard here
653 : OSL_ENSURE( pNd->FindFlyStartNode(),
654 : "Where is this Node?" );
655 :
656 0 : pPgDesc = &pDoc->GetPageDesc( 0 );
657 0 : pNd = 0;
658 : }
659 : }
660 : }
661 :
662 6096 : if( pNd )
663 : {
664 4734 : SwFindNearestNode aInfo( *pNd );
665 : // Over all Nodes of all PageDescs
666 : const SfxPoolItem* pItem;
667 4734 : sal_uInt32 i, nMaxItems = pDoc->GetAttrPool().GetItemCount2( RES_PAGEDESC );
668 122706 : for( i = 0; i < nMaxItems; ++i )
669 218084 : if( 0 != (pItem = pDoc->GetAttrPool().GetItem2( RES_PAGEDESC, i ) ) &&
670 100112 : ((SwFmtPageDesc*)pItem)->GetDefinedIn() )
671 : {
672 65306 : const SwModify* pMod = ((SwFmtPageDesc*)pItem)->GetDefinedIn();
673 65306 : if( pMod->ISA( SwCntntNode ) )
674 26228 : aInfo.CheckNode( *(SwCntntNode*)pMod );
675 39078 : else if( pMod->ISA( SwFmt ))
676 39078 : ((SwFmt*)pMod)->GetInfo( aInfo );
677 : }
678 :
679 4734 : if( 0 != ( pNd = aInfo.GetFoundNode() ))
680 : {
681 4498 : if( pNd->IsCntntNode() )
682 : pPgDesc = ((SwFmtPageDesc&)pNd->GetCntntNode()->
683 2708 : GetAttr( RES_PAGEDESC )).GetPageDesc();
684 1790 : else if( pNd->IsTableNode() )
685 1790 : pPgDesc = pNd->GetTableNode()->GetTable().
686 1790 : GetFrmFmt()->GetPageDesc().GetPageDesc();
687 0 : else if( pNd->IsSectionNode() )
688 0 : pPgDesc = pNd->GetSectionNode()->GetSection().
689 0 : GetFmt()->GetPageDesc().GetPageDesc();
690 4498 : if ( pPgDescNdIdx )
691 : {
692 0 : *pPgDescNdIdx = pNd->GetIndex();
693 : }
694 : }
695 4734 : if( !pPgDesc )
696 236 : pPgDesc = &pDoc->GetPageDesc( 0 );
697 : }
698 : }
699 27656 : return pPgDesc;
700 : }
701 :
702 : /// If the node is located in a Fly, we return it formatted accordingly
703 27888 : SwFrmFmt* SwNode::GetFlyFmt() const
704 : {
705 27888 : SwFrmFmt* pRet = 0;
706 27888 : const SwNode* pSttNd = FindFlyStartNode();
707 27888 : if( pSttNd )
708 : {
709 3612 : if( IsCntntNode() )
710 : {
711 3530 : SwCntntFrm* pFrm = SwIterator<SwCntntFrm,SwCntntNode>::FirstElement( *(SwCntntNode*)this );
712 3530 : if( pFrm )
713 1580 : pRet = pFrm->FindFlyFrm()->GetFmt();
714 : }
715 3612 : if( !pRet )
716 : {
717 : // The hard way through the Doc is our last way out
718 2032 : const SwFrmFmts& rFrmFmtTbl = *GetDoc()->GetSpzFrmFmts();
719 12998 : for( sal_uInt16 n = 0; n < rFrmFmtTbl.size(); ++n )
720 : {
721 12998 : SwFrmFmt* pFmt = rFrmFmtTbl[n];
722 12998 : const SwFmtCntnt& rCntnt = pFmt->GetCntnt();
723 23454 : if( rCntnt.GetCntntIdx() &&
724 10456 : &rCntnt.GetCntntIdx()->GetNode() == pSttNd )
725 : {
726 2032 : pRet = pFmt;
727 2032 : break;
728 : }
729 : }
730 : }
731 : }
732 27888 : return pRet;
733 : }
734 :
735 1232 : SwTableBox* SwNode::GetTblBox() const
736 : {
737 1232 : SwTableBox* pBox = 0;
738 1232 : const SwNode* pSttNd = FindTableBoxStartNode();
739 1232 : if( pSttNd )
740 1232 : pBox = (SwTableBox*)pSttNd->FindTableNode()->GetTable().GetTblBox(
741 2464 : pSttNd->GetIndex() );
742 1232 : return pBox;
743 : }
744 :
745 628732 : SwStartNode* SwNode::FindSttNodeByType( SwStartNodeType eTyp )
746 : {
747 628732 : SwStartNode* pTmp = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
748 :
749 1607620 : while( eTyp != pTmp->GetStartNodeType() && pTmp->GetIndex() )
750 350156 : pTmp = pTmp->pStartOfSection;
751 628732 : return eTyp == pTmp->GetStartNodeType() ? pTmp : 0;
752 : }
753 :
754 4 : const SwTxtNode* SwNode::FindOutlineNodeOfLevel( sal_uInt8 nLvl ) const
755 : {
756 4 : const SwTxtNode* pRet = 0;
757 4 : const SwOutlineNodes& rONds = GetNodes().GetOutLineNds();
758 4 : if( MAXLEVEL > nLvl && !rONds.empty() )
759 : {
760 : sal_uInt16 nPos;
761 0 : SwNode* pNd = (SwNode*)this;
762 0 : bool bCheckFirst = false;
763 0 : if( !rONds.Seek_Entry( pNd, &nPos ))
764 : {
765 0 : if( nPos )
766 0 : nPos = nPos-1;
767 : else
768 0 : bCheckFirst = true;
769 : }
770 :
771 0 : if( bCheckFirst )
772 : {
773 : // The first OutlineNode comes after the one asking. Test if it points to the same node.
774 : // If not it's invalid.
775 0 : pRet = rONds[0]->GetTxtNode();
776 :
777 0 : const SwCntntNode* pCNd = GetCntntNode();
778 :
779 0 : Point aPt( 0, 0 );
780 0 : const SwFrm* pFrm = pRet->getLayoutFrm( pRet->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, 0, false ),
781 0 : * pMyFrm = pCNd ? pCNd->getLayoutFrm( pCNd->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, 0, false ) : 0;
782 0 : const SwPageFrm* pPgFrm = pFrm ? pFrm->FindPageFrm() : 0;
783 0 : if( pPgFrm && pMyFrm &&
784 0 : pPgFrm->Frm().Top() > pMyFrm->Frm().Top() )
785 : {
786 : // The one asking precedes the Page, thus its invalid
787 0 : pRet = 0;
788 : }
789 : }
790 : else
791 : {
792 : // Or at the Field and get it from there!
793 0 : while( nPos &&
794 0 : nLvl < ( pRet = rONds[nPos]->GetTxtNode() )
795 0 : ->GetAttrOutlineLevel() - 1 )
796 0 : --nPos;
797 :
798 0 : if( !nPos ) // Get separately when 0
799 0 : pRet = rONds[0]->GetTxtNode();
800 : }
801 : }
802 4 : return pRet;
803 : }
804 :
805 42996 : inline bool IsValidNextPrevNd( const SwNode& rNd )
806 : {
807 85878 : return ND_TABLENODE == rNd.GetNodeType() ||
808 86264 : ( ND_CONTENTNODE & rNd.GetNodeType() ) ||
809 24108 : ( ND_ENDNODE == rNd.GetNodeType() && rNd.StartOfSectionNode() &&
810 49130 : ND_TABLENODE == rNd.StartOfSectionNode()->GetNodeType() );
811 : }
812 :
813 14332 : sal_uInt8 SwNode::HasPrevNextLayNode() const
814 : {
815 : // assumption: <this> node is a node inside the document nodes array section.
816 :
817 14332 : sal_uInt8 nRet = 0;
818 14332 : if( IsValidNextPrevNd( *this ))
819 : {
820 14332 : SwNodeIndex aIdx( *this, -1 );
821 : // #i77805# - skip section start and end nodes
822 43386 : while ( aIdx.GetNode().IsSectionNode() ||
823 14736 : ( aIdx.GetNode().IsEndNode() &&
824 338 : aIdx.GetNode().StartOfSectionNode()->IsSectionNode() ) )
825 : {
826 162 : --aIdx;
827 : }
828 14332 : if( IsValidNextPrevNd( aIdx.GetNode() ))
829 8626 : nRet |= ND_HAS_PREV_LAYNODE;
830 : // #i77805# - skip section start and end nodes
831 14332 : aIdx = SwNodeIndex( *this, +1 );
832 43428 : while ( aIdx.GetNode().IsSectionNode() ||
833 20386 : ( aIdx.GetNode().IsEndNode() &&
834 5958 : aIdx.GetNode().StartOfSectionNode()->IsSectionNode() ) )
835 : {
836 168 : ++aIdx;
837 : }
838 14332 : if( IsValidNextPrevNd( aIdx.GetNode() ))
839 8470 : nRet |= ND_HAS_NEXT_LAYNODE;
840 : }
841 14332 : return nRet;
842 : }
843 :
844 36662 : SwStartNode::SwStartNode( const SwNodeIndex &rWhere, const sal_uInt8 nNdType,
845 : SwStartNodeType eSttNd )
846 36662 : : SwNode( rWhere, nNdType ), eSttNdTyp( eSttNd )
847 : {
848 36662 : if( !rWhere.GetIndex() )
849 : {
850 0 : SwNodes& rNodes = const_cast<SwNodes&> (rWhere.GetNodes());
851 0 : rNodes.InsertNode( this, rWhere );
852 0 : pStartOfSection = this;
853 : }
854 : // Just do this temporarily until the EndNode is inserted
855 36662 : pEndOfSection = (SwEndNode*)this;
856 36662 : }
857 :
858 50528 : SwStartNode::SwStartNode( SwNodes& rNodes, sal_uLong nPos )
859 50528 : : SwNode( rNodes, nPos, ND_STARTNODE ), eSttNdTyp( SwNormalStartNode )
860 : {
861 50528 : if( !nPos )
862 : {
863 10104 : rNodes.InsertNode( this, nPos );
864 10104 : pStartOfSection = this;
865 : }
866 : // Just do this temporarily until the EndNode is inserted
867 50528 : pEndOfSection = (SwEndNode*)this;
868 50528 : }
869 :
870 1578 : void SwStartNode::CheckSectionCondColl() const
871 : {
872 : //FEATURE::CONDCOLL
873 1578 : SwNodeIndex aIdx( *this );
874 1578 : sal_uLong nEndIdx = EndOfSectionIndex();
875 1578 : const SwNodes& rNds = GetNodes();
876 : SwCntntNode* pCNd;
877 6286 : while( 0 != ( pCNd = rNds.GoNext( &aIdx )) && pCNd->GetIndex() < nEndIdx )
878 4708 : pCNd->ChkCondColl();
879 : //FEATURE::CONDCOLL
880 1578 : }
881 :
882 : /** Insert a node into the array
883 : *
884 : * The StartOfSection pointer is set to the given node.
885 : *
886 : * The EndOfSection pointer of the corresponding start node is set to this node.
887 : *
888 : * @param rWhere position where the node shoul be inserted
889 : * @param rSttNd the start note of the section
890 : */
891 :
892 36662 : SwEndNode::SwEndNode( const SwNodeIndex &rWhere, SwStartNode& rSttNd )
893 36662 : : SwNode( rWhere, ND_ENDNODE )
894 : {
895 36662 : pStartOfSection = &rSttNd;
896 36662 : pStartOfSection->pEndOfSection = this;
897 36662 : }
898 :
899 50520 : SwEndNode::SwEndNode( SwNodes& rNds, sal_uLong nPos, SwStartNode& rSttNd )
900 50520 : : SwNode( rNds, nPos, ND_ENDNODE )
901 : {
902 50520 : pStartOfSection = &rSttNd;
903 50520 : pStartOfSection->pEndOfSection = this;
904 50520 : }
905 :
906 94650 : SwCntntNode::SwCntntNode( const SwNodeIndex &rWhere, const sal_uInt8 nNdType,
907 : SwFmtColl *pColl )
908 : : SwModify( pColl ), // CrsrsShell, FrameFmt,
909 : SwNode( rWhere, nNdType ),
910 : pCondColl( 0 ),
911 94650 : mbSetModifyAtAttr( false )
912 : {
913 94650 : }
914 :
915 189110 : SwCntntNode::~SwCntntNode()
916 : {
917 : // The base class SwClient of SwFrm excludes itself from the dependency list!
918 : // Thus, we need to delete all Frames in the dependency list.
919 94555 : DelFrms(false);
920 :
921 94555 : delete pCondColl;
922 :
923 94555 : if ( mpAttrSet.get() && mbSetModifyAtAttr )
924 4238 : ((SwAttrSet*)mpAttrSet.get())->SetModifyAtAttr( 0 );
925 94555 : }
926 :
927 665551 : void SwCntntNode::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
928 : {
929 : sal_uInt16 nWhich = pOldValue ? pOldValue->Which() :
930 665551 : pNewValue ? pNewValue->Which() : 0 ;
931 :
932 665551 : switch( nWhich )
933 : {
934 : case RES_OBJECTDYING :
935 0 : if (pNewValue)
936 : {
937 0 : SwFmt * pFmt = (SwFmt *) ((SwPtrMsgPoolItem *)pNewValue)->pObject;
938 :
939 : // Do not mangle pointers if it is the upper-most format!
940 0 : if( GetRegisteredIn() == pFmt )
941 : {
942 0 : if( pFmt->GetRegisteredIn() )
943 : {
944 : // If Parent, register anew in the new Parent
945 0 : ((SwModify*)pFmt->GetRegisteredIn())->Add( this );
946 0 : if ( GetpSwAttrSet() )
947 0 : AttrSetHandleHelper::SetParent( mpAttrSet, *this, GetFmtColl(), GetFmtColl() );
948 : }
949 : else
950 : {
951 : // Else register anyways when dying
952 0 : ((SwModify*)GetRegisteredIn())->Remove( this );
953 0 : if ( GetpSwAttrSet() )
954 0 : AttrSetHandleHelper::SetParent( mpAttrSet, *this, 0, 0 );
955 : }
956 : }
957 : }
958 0 : break;
959 :
960 : case RES_FMT_CHG:
961 : // If the Format parent was switched, register the Attrset at the new one
962 : // Skip own Modify!
963 38388 : if( GetpSwAttrSet() && pNewValue &&
964 958 : ((SwFmtChg*)pNewValue)->pChangedFmt == GetRegisteredIn() )
965 : {
966 : // Attach Set to the new parent
967 952 : AttrSetHandleHelper::SetParent( mpAttrSet, *this, GetFmtColl(), GetFmtColl() );
968 : }
969 37430 : break;
970 :
971 : //FEATURE::CONDCOLL
972 : case RES_CONDCOLL_CONDCHG:
973 0 : if( pNewValue && ((SwCondCollCondChg*)pNewValue)->pChangedFmt == GetRegisteredIn() &&
974 0 : &GetNodes() == &GetDoc()->GetNodes() )
975 : {
976 0 : ChkCondColl();
977 : }
978 665551 : return ; // Do not pass through to the base class/Frames
979 : //FEATURE::CONDCOLL
980 :
981 : case RES_ATTRSET_CHG:
982 478228 : if (GetNodes().IsDocNodes() && IsTxtNode() && pOldValue)
983 : {
984 754604 : if( SfxItemState::SET == ((SwAttrSetChg*)pOldValue)->GetChgSet()->GetItemState(
985 377302 : RES_CHRATR_HIDDEN, false ) )
986 : {
987 62 : ((SwTxtNode*)this)->SetCalcHiddenCharFlags();
988 : }
989 : }
990 478228 : break;
991 :
992 : case RES_UPDATE_ATTR:
993 144281 : if (GetNodes().IsDocNodes() && IsTxtNode() && pNewValue)
994 : {
995 144265 : const sal_uInt16 nTmp = ((SwUpdateAttr*)pNewValue)->getWhichAttr();
996 144265 : if ( RES_ATTRSET_CHG == nTmp )
997 : {
998 : // TODO: anybody wants to do some optimization here?
999 10452 : ((SwTxtNode*)this)->SetCalcHiddenCharFlags();
1000 : }
1001 : }
1002 144281 : break;
1003 : }
1004 :
1005 665551 : NotifyClients( pOldValue, pNewValue );
1006 : }
1007 :
1008 28429 : bool SwCntntNode::InvalidateNumRule()
1009 : {
1010 28429 : SwNumRule* pRule = 0;
1011 : const SfxPoolItem* pItem;
1012 84594 : if( GetNodes().IsDocNodes() &&
1013 154 : 0 != ( pItem = GetNoCondAttr( RES_PARATR_NUMRULE, true )) &&
1014 28727 : !((SwNumRuleItem*)pItem)->GetValue().isEmpty() &&
1015 : 0 != (pRule = GetDoc()->FindNumRulePtr(
1016 144 : ((SwNumRuleItem*)pItem)->GetValue() ) ) )
1017 : {
1018 144 : pRule->SetInvalidRule( true );
1019 : }
1020 28429 : return 0 != pRule;
1021 : }
1022 :
1023 1162892 : SwCntntFrm *SwCntntNode::getLayoutFrm( const SwRootFrm* _pRoot,
1024 : const Point* pPoint, const SwPosition *pPos, const bool bCalcFrm ) const
1025 : {
1026 : return (SwCntntFrm*) ::GetFrmOfModify( _pRoot, *(SwModify*)this, FRM_CNTNT,
1027 1162892 : pPoint, pPos, bCalcFrm );
1028 : }
1029 :
1030 1540 : SwRect SwCntntNode::FindLayoutRect( const bool bPrtArea, const Point* pPoint,
1031 : const bool bCalcFrm ) const
1032 : {
1033 1540 : SwRect aRet;
1034 : SwCntntFrm* pFrm = (SwCntntFrm*)::GetFrmOfModify( 0, *(SwModify*)this,
1035 1540 : FRM_CNTNT, pPoint, 0, bCalcFrm );
1036 1540 : if( pFrm )
1037 1482 : aRet = bPrtArea ? pFrm->Prt() : pFrm->Frm();
1038 1540 : return aRet;
1039 : }
1040 :
1041 210 : SwRect SwCntntNode::FindPageFrmRect( const bool bPrtArea, const Point* pPoint,
1042 : const bool bCalcFrm ) const
1043 : {
1044 210 : SwRect aRet;
1045 : SwFrm* pFrm = ::GetFrmOfModify( 0, *(SwModify*)this,
1046 210 : FRM_CNTNT, pPoint, 0, bCalcFrm );
1047 210 : if( pFrm && 0 != ( pFrm = pFrm->FindPageFrm() ))
1048 210 : aRet = bPrtArea ? pFrm->Prt() : pFrm->Frm();
1049 210 : return aRet;
1050 : }
1051 :
1052 8 : sal_Int32 SwCntntNode::Len() const { return 0; }
1053 :
1054 20318 : SwFmtColl *SwCntntNode::ChgFmtColl( SwFmtColl *pNewColl )
1055 : {
1056 : OSL_ENSURE( pNewColl, "Collectionpointer is 0." );
1057 20318 : SwFmtColl *pOldColl = GetFmtColl();
1058 :
1059 20318 : if( pNewColl != pOldColl )
1060 : {
1061 20318 : pNewColl->Add( this );
1062 :
1063 : // Set the Parent of out AutoAttributes to the new Collection
1064 20318 : if( GetpSwAttrSet() )
1065 912 : AttrSetHandleHelper::SetParent( mpAttrSet, *this, pNewColl, pNewColl );
1066 :
1067 : //FEATURE::CONDCOLL
1068 : // TODO: HACK: We need to recheck this condition according to the new template!
1069 : if( true /*pNewColl */ )
1070 : {
1071 20318 : SetCondFmtColl( 0 );
1072 : }
1073 : //FEATURE::CONDCOLL
1074 :
1075 20318 : if( !IsModifyLocked() )
1076 : {
1077 20318 : SwFmtChg aTmp1( pOldColl );
1078 40636 : SwFmtChg aTmp2( pNewColl );
1079 40636 : SwCntntNode::Modify( &aTmp1, &aTmp2 );
1080 : }
1081 : }
1082 20318 : if ( IsInCache() )
1083 : {
1084 0 : SwFrm::GetCache().Delete( this );
1085 0 : SetInCache( false );
1086 : }
1087 20318 : return pOldColl;
1088 : }
1089 :
1090 101148 : bool SwCntntNode::GoNext(SwIndex * pIdx, sal_uInt16 nMode ) const
1091 : {
1092 101148 : bool bRet = true;
1093 101148 : if( pIdx->GetIndex() < Len() )
1094 : {
1095 96554 : if( !IsTxtNode() )
1096 0 : ++(*pIdx);
1097 : else
1098 : {
1099 96554 : const SwTxtNode& rTNd = *GetTxtNode();
1100 96554 : sal_Int32 nPos = pIdx->GetIndex();
1101 96554 : if( g_pBreakIt->GetBreakIter().is() )
1102 : {
1103 96554 : sal_Int32 nDone = 0;
1104 96554 : sal_uInt16 nItrMode = ( CRSR_SKIP_CELLS & nMode ) ?
1105 : CharacterIteratorMode::SKIPCELL :
1106 96554 : CharacterIteratorMode::SKIPCONTROLCHARACTER;
1107 289662 : nPos = g_pBreakIt->GetBreakIter()->nextCharacters( rTNd.GetTxt(), nPos,
1108 96554 : g_pBreakIt->GetLocale( rTNd.GetLang( nPos ) ),
1109 193108 : nItrMode, 1, nDone );
1110 :
1111 : // Check if nPos is inside hidden text range:
1112 96554 : if ( CRSR_SKIP_HIDDEN & nMode )
1113 : {
1114 : sal_Int32 nHiddenStart;
1115 : sal_Int32 nHiddenEnd;
1116 34 : SwScriptInfo::GetBoundsOfHiddenRange( rTNd, nPos, nHiddenStart, nHiddenEnd );
1117 34 : if ( nHiddenStart != COMPLETE_STRING && nHiddenStart != nPos )
1118 0 : nPos = nHiddenEnd;
1119 : }
1120 :
1121 96554 : if( 1 == nDone )
1122 96554 : *pIdx = nPos;
1123 : else
1124 0 : bRet = false;
1125 : }
1126 0 : else if (nPos < rTNd.GetTxt().getLength())
1127 0 : ++(*pIdx);
1128 : else
1129 0 : bRet = false;
1130 : }
1131 : }
1132 : else
1133 4594 : bRet = false;
1134 101148 : return bRet;
1135 : }
1136 :
1137 128840 : bool SwCntntNode::GoPrevious(SwIndex * pIdx, sal_uInt16 nMode ) const
1138 : {
1139 128840 : bool bRet = true;
1140 128840 : if( pIdx->GetIndex() > 0 )
1141 : {
1142 69994 : if( !IsTxtNode() )
1143 0 : (*pIdx)--;
1144 : else
1145 : {
1146 69994 : const SwTxtNode& rTNd = *GetTxtNode();
1147 69994 : sal_Int32 nPos = pIdx->GetIndex();
1148 69994 : if( g_pBreakIt->GetBreakIter().is() )
1149 : {
1150 69994 : sal_Int32 nDone = 0;
1151 69994 : sal_uInt16 nItrMode = ( CRSR_SKIP_CELLS & nMode ) ?
1152 : CharacterIteratorMode::SKIPCELL :
1153 69994 : CharacterIteratorMode::SKIPCONTROLCHARACTER;
1154 209982 : nPos = g_pBreakIt->GetBreakIter()->previousCharacters( rTNd.GetTxt(), nPos,
1155 69994 : g_pBreakIt->GetLocale( rTNd.GetLang( nPos ) ),
1156 139988 : nItrMode, 1, nDone );
1157 :
1158 : // Check if nPos is inside hidden text range:
1159 69994 : if ( CRSR_SKIP_HIDDEN & nMode )
1160 : {
1161 : sal_Int32 nHiddenStart;
1162 : sal_Int32 nHiddenEnd;
1163 32 : SwScriptInfo::GetBoundsOfHiddenRange( rTNd, nPos, nHiddenStart, nHiddenEnd );
1164 32 : if ( nHiddenStart != COMPLETE_STRING )
1165 0 : nPos = nHiddenStart;
1166 : }
1167 :
1168 69994 : if( 1 == nDone )
1169 69994 : *pIdx = nPos;
1170 : else
1171 0 : bRet = false;
1172 : }
1173 0 : else if( nPos )
1174 0 : (*pIdx)--;
1175 : else
1176 0 : bRet = false;
1177 : }
1178 : }
1179 : else
1180 58846 : bRet = false;
1181 128840 : return bRet;
1182 : }
1183 :
1184 : /**
1185 : * Creates all Views for the Doc for this Node.
1186 : * The created ContentFrames are attached to the corresponding Layout.
1187 : */
1188 4774 : void SwCntntNode::MakeFrms( SwCntntNode& rNode )
1189 : {
1190 : OSL_ENSURE( &rNode != this,
1191 : "No ContentNode or CopyNode and new Node identical." );
1192 :
1193 4774 : if( !GetDepends() || &rNode == this ) // Do we actually have Frames?
1194 5218 : return;
1195 :
1196 : SwFrm *pFrm, *pNew;
1197 : SwLayoutFrm *pUpper;
1198 : // Create Frames for Nodes which come after the Table?
1199 : OSL_ENSURE( FindTableNode() == rNode.FindTableNode(), "Table confusion" );
1200 :
1201 4330 : SwNode2Layout aNode2Layout( *this, rNode.GetIndex() );
1202 :
1203 12830 : while( 0 != (pUpper = aNode2Layout.UpperFrm( pFrm, rNode )) )
1204 : {
1205 4170 : pNew = rNode.MakeFrm( pUpper );
1206 4170 : pNew->Paste( pUpper, pFrm );
1207 : // #i27138#
1208 : // notify accessibility paragraphs objects about changed
1209 : // CONTENT_FLOWS_FROM/_TO relation.
1210 : // Relation CONTENT_FLOWS_FROM for next paragraph will change
1211 : // and relation CONTENT_FLOWS_TO for previous paragraph will change.
1212 4170 : if ( pNew->IsTxtFrm() )
1213 : {
1214 4170 : SwViewShell* pViewShell( pNew->getRootFrm()->GetCurrShell() );
1215 8340 : if ( pViewShell && pViewShell->GetLayout() &&
1216 4170 : pViewShell->GetLayout()->IsAnyShellAccessible() )
1217 : {
1218 : pViewShell->InvalidateAccessibleParaFlowRelation(
1219 0 : dynamic_cast<SwTxtFrm*>(pNew->FindNextCnt( true )),
1220 0 : dynamic_cast<SwTxtFrm*>(pNew->FindPrevCnt( true )) );
1221 : }
1222 : }
1223 4330 : }
1224 : }
1225 :
1226 : /**
1227 : * Deletes all Views from the Doc for this Node.
1228 : * The ContentFrames are removed from the corresponding Layout.
1229 : *
1230 : * An input param to identify if the acc table should be disposed.
1231 : */
1232 128109 : void SwCntntNode::DelFrms( bool bIsDisposeAccTable )
1233 : {
1234 128109 : if( !GetDepends() )
1235 234746 : return;
1236 :
1237 21472 : SwIterator<SwCntntFrm,SwCntntNode> aIter( *this );
1238 22098 : for( SwCntntFrm* pFrm = aIter.First(); pFrm; pFrm = aIter.Next() )
1239 : {
1240 : // #i27138#
1241 : // notify accessibility paragraphs objects about changed
1242 : // CONTENT_FLOWS_FROM/_TO relation.
1243 : // Relation CONTENT_FLOWS_FROM for current next paragraph will change
1244 : // and relation CONTENT_FLOWS_TO for current previous paragraph will change.
1245 626 : if ( pFrm->IsTxtFrm() )
1246 : {
1247 626 : SwViewShell* pViewShell( pFrm->getRootFrm()->GetCurrShell() );
1248 1252 : if ( pViewShell && pViewShell->GetLayout() &&
1249 626 : pViewShell->GetLayout()->IsAnyShellAccessible() )
1250 : {
1251 : pViewShell->InvalidateAccessibleParaFlowRelation(
1252 0 : dynamic_cast<SwTxtFrm*>(pFrm->FindNextCnt( true )),
1253 0 : dynamic_cast<SwTxtFrm*>(pFrm->FindPrevCnt( true )) );
1254 : }
1255 : }
1256 :
1257 626 : if( pFrm->IsFollow() )
1258 : {
1259 2 : SwCntntFrm* pMaster = (SwTxtFrm*)pFrm->FindMaster();
1260 2 : pMaster->SetFollow( pFrm->GetFollow() );
1261 : }
1262 626 : pFrm->SetFollow( 0 );//So it doesn't get funny ideas.
1263 : //Otherwise it could be possible that a follow
1264 : //gets destroyed before its master. Following
1265 : //the now invalid pointer will then lead to an
1266 : //illegal memory access. The chain can be
1267 : //crushed here because we'll destroy all of it
1268 : //anyway.
1269 :
1270 632 : if( pFrm->GetUpper() && pFrm->IsInFtn() && !pFrm->GetIndNext() &&
1271 6 : !pFrm->GetIndPrev() )
1272 : {
1273 0 : SwFtnFrm *pFtn = pFrm->FindFtnFrm();
1274 : OSL_ENSURE( pFtn, "You promised a FtnFrm?" );
1275 : SwCntntFrm* pCFrm;
1276 0 : if( !pFtn->GetFollow() && !pFtn->GetMaster() &&
1277 0 : 0 != ( pCFrm = pFtn->GetRefFromAttr()) && pCFrm->IsFollow() )
1278 : {
1279 : OSL_ENSURE( pCFrm->IsTxtFrm(), "NoTxtFrm has Footnote?" );
1280 0 : ((SwTxtFrm*)pCFrm->FindMaster())->Prepare( PREP_FTN_GONE );
1281 : }
1282 : }
1283 : //Set acc table dispose state
1284 626 : pFrm->SetAccTableDispose( bIsDisposeAccTable );
1285 626 : pFrm->Cut();
1286 : //Set acc table dispose state to default value
1287 626 : pFrm->SetAccTableDispose( true );
1288 626 : delete pFrm;
1289 : }
1290 :
1291 21472 : if( bIsDisposeAccTable && IsTxtNode() )
1292 : {
1293 16228 : static_cast<SwTxtNode *>(this)->DelFrms_TxtNodePart();
1294 21472 : }
1295 : }
1296 :
1297 0 : SwCntntNode *SwCntntNode::JoinNext()
1298 : {
1299 0 : return this;
1300 : }
1301 :
1302 0 : SwCntntNode *SwCntntNode::JoinPrev()
1303 : {
1304 0 : return this;
1305 : }
1306 :
1307 : /// Get info from Modify
1308 514272 : bool SwCntntNode::GetInfo( SfxPoolItem& rInfo ) const
1309 : {
1310 514272 : switch( rInfo.Which() )
1311 : {
1312 : case RES_AUTOFMT_DOCNODE:
1313 57754 : if( &GetNodes() == ((SwAutoFmtGetDocNode&)rInfo).pNodes )
1314 : {
1315 39326 : ((SwAutoFmtGetDocNode&)rInfo).pCntntNode = this;
1316 39326 : return false;
1317 : }
1318 18428 : break;
1319 :
1320 : case RES_FINDNEARESTNODE:
1321 455910 : if( ((SwFmtPageDesc&)GetAttr( RES_PAGEDESC )).GetPageDesc() )
1322 17368 : ((SwFindNearestNode&)rInfo).CheckNode( *this );
1323 455910 : return true;
1324 :
1325 : case RES_CONTENT_VISIBLE:
1326 : {
1327 : ((SwPtrMsgPoolItem&)rInfo).pObject =
1328 0 : SwIterator<SwFrm,SwCntntNode>::FirstElement(*this);
1329 : }
1330 0 : return false;
1331 : }
1332 :
1333 19036 : return SwModify::GetInfo( rInfo );
1334 : }
1335 :
1336 : /// @param rAttr the attribute to set
1337 16588 : bool SwCntntNode::SetAttr(const SfxPoolItem& rAttr )
1338 : {
1339 16588 : if( !GetpSwAttrSet() ) // Have the Nodes created by the corresponding AttrSets
1340 5708 : NewAttrSet( GetDoc()->GetAttrPool() );
1341 :
1342 : OSL_ENSURE( GetpSwAttrSet(), "Why did't we create an AttrSet?");
1343 :
1344 16588 : if ( IsInCache() )
1345 : {
1346 54 : SwFrm::GetCache().Delete( this );
1347 54 : SetInCache( false );
1348 : }
1349 :
1350 16588 : bool bRet = false;
1351 : // If Modify is locked, we do not send any Modifys
1352 43246 : if( IsModifyLocked() ||
1353 27254 : ( !GetDepends() && RES_PARATR_NUMRULE != rAttr.Which() ))
1354 : {
1355 10072 : bRet = 0 != AttrSetHandleHelper::Put( mpAttrSet, *this, rAttr );
1356 : }
1357 : else
1358 : {
1359 6516 : SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ),
1360 13032 : aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() );
1361 6516 : if( ( bRet = AttrSetHandleHelper::Put_BC( mpAttrSet, *this, rAttr, &aOld, &aNew ) ) )
1362 : {
1363 6440 : SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld );
1364 12880 : SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew );
1365 12880 : ModifyNotification( &aChgOld, &aChgNew ); // Send all changed ones
1366 6516 : }
1367 : }
1368 16588 : return bRet;
1369 : }
1370 :
1371 : #include <svl/itemiter.hxx>
1372 :
1373 138866 : bool SwCntntNode::SetAttr( const SfxItemSet& rSet )
1374 : {
1375 138866 : if ( IsInCache() )
1376 : {
1377 3000 : SwFrm::GetCache().Delete( this );
1378 3000 : SetInCache( false );
1379 : }
1380 :
1381 138866 : const SfxPoolItem* pFnd = 0;
1382 138866 : if( SfxItemState::SET == rSet.GetItemState( RES_AUTO_STYLE, false, &pFnd ) )
1383 : {
1384 : OSL_ENSURE( rSet.Count() == 1, "SetAutoStyle mixed with other attributes?!" );
1385 5080 : const SwFmtAutoFmt* pTmp = static_cast<const SwFmtAutoFmt*>(pFnd);
1386 :
1387 : // If there already is an attribute set (usually containing a numbering
1388 : // item), we have to merge the attribute of the new set into the old set:
1389 5080 : bool bSetParent = true;
1390 5080 : if ( GetpSwAttrSet() )
1391 : {
1392 166 : bSetParent = false;
1393 166 : AttrSetHandleHelper::Put( mpAttrSet, *this, *pTmp->GetStyleHandle() );
1394 : }
1395 : else
1396 : {
1397 4914 : mpAttrSet = pTmp->GetStyleHandle();
1398 : }
1399 :
1400 5080 : if ( bSetParent )
1401 : {
1402 : // If the content node has a conditional style, we have to set the
1403 : // string item containing the correct conditional style name (the
1404 : // style name property has already been set during the import!)
1405 : // In case we do not have a conditional style, we make use of the
1406 : // fact that nobody else uses the attribute set behind the handle.
1407 : // FME 2007-07-10 #i78124# If autostyle does not have a parent,
1408 : // the string is empty.
1409 4914 : const SfxPoolItem* pNameItem = 0;
1410 14742 : if ( 0 != GetCondFmtColl() ||
1411 9828 : SfxItemState::SET != mpAttrSet->GetItemState( RES_FRMATR_STYLE_NAME, false, &pNameItem ) ||
1412 4914 : static_cast<const SfxStringItem*>(pNameItem)->GetValue().isEmpty() )
1413 0 : AttrSetHandleHelper::SetParent( mpAttrSet, *this, &GetAnyFmtColl(), GetFmtColl() );
1414 : else
1415 4914 : const_cast<SfxItemSet*>(mpAttrSet.get())->SetParent( &GetFmtColl()->GetAttrSet() );
1416 : }
1417 :
1418 5080 : return true;
1419 : }
1420 :
1421 133786 : if( !GetpSwAttrSet() ) // Have the AttrsSets created by the corresponding Nodes
1422 48676 : NewAttrSet( GetDoc()->GetAttrPool() );
1423 :
1424 133786 : bool bRet = false;
1425 : // If Modify is locked, do not send any Modifys
1426 304706 : if ( IsModifyLocked() ||
1427 168926 : ( !GetDepends() &&
1428 37928 : SfxItemState::SET != rSet.GetItemState( RES_PARATR_NUMRULE, false ) ) )
1429 : {
1430 : // Some special treatment for Attributes
1431 39922 : bRet = AttrSetHandleHelper::Put( mpAttrSet, *this, rSet );
1432 : }
1433 : else
1434 : {
1435 93864 : SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ),
1436 187728 : aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() );
1437 93864 : if( (bRet = AttrSetHandleHelper::Put_BC( mpAttrSet, *this, rSet, &aOld, &aNew )) )
1438 : {
1439 : // Some special treatment for Attributes
1440 83212 : SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld );
1441 166424 : SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew );
1442 166424 : ModifyNotification( &aChgOld, &aChgNew ); // Send out all changed ones
1443 93864 : }
1444 : }
1445 133786 : return bRet;
1446 : }
1447 :
1448 : // With nWhich it takes the Hint from the Delta array
1449 328098 : bool SwCntntNode::ResetAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 )
1450 : {
1451 328098 : if( !GetpSwAttrSet() )
1452 305160 : return false;
1453 :
1454 22938 : if ( IsInCache() )
1455 : {
1456 18 : SwFrm::GetCache().Delete( this );
1457 18 : SetInCache( false );
1458 : }
1459 :
1460 : // If Modify is locked, do not send out any Modifys
1461 22938 : if( IsModifyLocked() )
1462 : {
1463 0 : sal_uInt16 nDel = 0;
1464 0 : if ( !nWhich2 || nWhich2 < nWhich1 )
1465 : {
1466 0 : std::vector<sal_uInt16> aClearWhichIds;
1467 0 : aClearWhichIds.push_back( nWhich1 );
1468 0 : nDel = ClearItemsFromAttrSet( aClearWhichIds );
1469 : }
1470 : else
1471 0 : nDel = AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, nWhich1, nWhich2, 0, 0 );
1472 :
1473 0 : if( !GetpSwAttrSet()->Count() ) // Empt? Delete
1474 0 : mpAttrSet.reset();
1475 0 : return 0 != nDel;
1476 : }
1477 :
1478 : // No valid area defined?
1479 22938 : if( !nWhich2 || nWhich2 < nWhich1 )
1480 22936 : nWhich2 = nWhich1; // Then set only this Item to 1st Id
1481 :
1482 22938 : SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ),
1483 45876 : aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() );
1484 22938 : bool bRet = 0 != AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, nWhich1, nWhich2, &aOld, &aNew );
1485 :
1486 22938 : if( bRet )
1487 : {
1488 1772 : SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld );
1489 3544 : SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew );
1490 1772 : ModifyNotification( &aChgOld, &aChgNew ); // All changed ones are sent
1491 :
1492 1772 : if( !GetpSwAttrSet()->Count() ) // Empty?, delete it
1493 1774 : mpAttrSet.reset();
1494 : }
1495 45876 : return bRet;
1496 : }
1497 :
1498 7534 : bool SwCntntNode::ResetAttr( const std::vector<sal_uInt16>& rWhichArr )
1499 : {
1500 7534 : if( !GetpSwAttrSet() )
1501 884 : return false;
1502 :
1503 6650 : if ( IsInCache() )
1504 : {
1505 24 : SwFrm::GetCache().Delete( this );
1506 24 : SetInCache( false );
1507 : }
1508 :
1509 : // If Modify is locked, do not send out any Modifys
1510 6650 : sal_uInt16 nDel = 0;
1511 6650 : if( IsModifyLocked() )
1512 : {
1513 5220 : std::vector<sal_uInt16> aClearWhichIds(rWhichArr);
1514 5220 : nDel = ClearItemsFromAttrSet( aClearWhichIds );
1515 : }
1516 : else
1517 : {
1518 1430 : SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ),
1519 2860 : aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() );
1520 :
1521 1430 : std::vector<sal_uInt16>::const_iterator it;
1522 64350 : for ( it = rWhichArr.begin(); it != rWhichArr.end(); ++it )
1523 62920 : if( AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, *it, &aOld, &aNew ))
1524 1660 : ++nDel;
1525 :
1526 1430 : if( nDel )
1527 : {
1528 430 : SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld );
1529 860 : SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew );
1530 860 : ModifyNotification( &aChgOld, &aChgNew ); // All changed ones are sent
1531 1430 : }
1532 : }
1533 6650 : if( !GetpSwAttrSet()->Count() ) // Empty?, delete it
1534 0 : mpAttrSet.reset();
1535 6650 : return 0 != nDel ;
1536 : }
1537 :
1538 11384 : sal_uInt16 SwCntntNode::ResetAllAttr()
1539 : {
1540 11384 : if( !GetpSwAttrSet() )
1541 6164 : return 0;
1542 :
1543 5220 : if ( IsInCache() )
1544 : {
1545 0 : SwFrm::GetCache().Delete( this );
1546 0 : SetInCache( false );
1547 : }
1548 :
1549 : // If Modify is locked, do not send out any Modifys
1550 5220 : if( IsModifyLocked() )
1551 : {
1552 0 : std::vector<sal_uInt16> aClearWhichIds;
1553 0 : aClearWhichIds.push_back(0);
1554 0 : sal_uInt16 nDel = ClearItemsFromAttrSet( aClearWhichIds );
1555 0 : if( !GetpSwAttrSet()->Count() ) // Empty? Delete
1556 0 : mpAttrSet.reset();
1557 0 : return nDel;
1558 : }
1559 :
1560 5220 : SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ),
1561 10440 : aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() );
1562 5220 : bool bRet = 0 != AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, 0, &aOld, &aNew );
1563 :
1564 5220 : if( bRet )
1565 : {
1566 5220 : SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld );
1567 10440 : SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew );
1568 5220 : ModifyNotification( &aChgOld, &aChgNew ); // All changed ones are sent
1569 :
1570 5220 : if( !GetpSwAttrSet()->Count() ) // Empty? Delete
1571 10440 : mpAttrSet.reset();
1572 : }
1573 10440 : return aNew.Count();
1574 : }
1575 :
1576 320206 : bool SwCntntNode::GetAttr( SfxItemSet& rSet, bool bInParent ) const
1577 : {
1578 320206 : if( rSet.Count() )
1579 9056 : rSet.ClearItem();
1580 :
1581 320206 : const SwAttrSet& rAttrSet = GetSwAttrSet();
1582 320206 : if( bInParent )
1583 320206 : return rSet.Set( rAttrSet, true ) ? sal_True : sal_False;
1584 :
1585 0 : rSet.Put( rAttrSet );
1586 0 : return rSet.Count() ? sal_True : sal_False;
1587 : }
1588 :
1589 6298 : sal_uInt16 SwCntntNode::ClearItemsFromAttrSet( const std::vector<sal_uInt16>& rWhichIds )
1590 : {
1591 6298 : sal_uInt16 nRet = 0;
1592 6298 : if ( 0 == rWhichIds.size() )
1593 2432 : return nRet;
1594 :
1595 : OSL_ENSURE( GetpSwAttrSet(), "no item set" );
1596 3866 : SwAttrSet aNewAttrSet( *GetpSwAttrSet() );
1597 26082 : for ( std::vector<sal_uInt16>::const_iterator aIter = rWhichIds.begin();
1598 17388 : aIter != rWhichIds.end();
1599 : ++aIter )
1600 : {
1601 4828 : nRet = nRet + aNewAttrSet.ClearItem( *aIter );
1602 : }
1603 3866 : if ( nRet )
1604 3212 : AttrSetHandleHelper::GetNewAutoStyle( mpAttrSet, *this, aNewAttrSet );
1605 :
1606 3866 : return nRet;
1607 : }
1608 :
1609 1410988 : const SfxPoolItem* SwCntntNode::GetNoCondAttr( sal_uInt16 nWhich,
1610 : bool bInParents ) const
1611 : {
1612 1410988 : const SfxPoolItem* pFnd = 0;
1613 1410988 : if( pCondColl && pCondColl->GetRegisteredIn() )
1614 : {
1615 0 : if( !GetpSwAttrSet() || ( SfxItemState::SET != GetpSwAttrSet()->GetItemState(
1616 0 : nWhich, false, &pFnd ) && bInParents ))
1617 0 : ((SwFmt*)GetRegisteredIn())->GetItemState( nWhich, bInParents, &pFnd );
1618 : }
1619 : // undo change of issue #i51029#
1620 : // Note: <GetSwAttrSet()> returns <mpAttrSet>, if set, otherwise it returns
1621 : // the attribute set of the paragraph style, which is valid for the
1622 : // content node - see file <node.hxx>
1623 : else
1624 : {
1625 1410988 : GetSwAttrSet().GetItemState( nWhich, bInParents, &pFnd );
1626 : }
1627 1410988 : return pFnd;
1628 : }
1629 :
1630 11030 : static bool lcl_CheckMaxLength(SwNode const& rPrev, SwNode const& rNext)
1631 : {
1632 11030 : if (rPrev.GetNodeType() != rNext.GetNodeType())
1633 : {
1634 0 : return false;
1635 : }
1636 11030 : if (!rPrev.IsTxtNode())
1637 : {
1638 0 : return true;
1639 : }
1640 :
1641 : // Check if a node can contain the other (order is not significant)
1642 11030 : return static_cast<const SwTxtNode&>(rPrev).GetSpaceLeft() >
1643 11030 : static_cast<const SwTxtNode&>(rNext).Len();
1644 : }
1645 :
1646 : /// Can we join two Nodes?
1647 : /// We can return the 2nd position in pIdx.
1648 10718 : bool SwCntntNode::CanJoinNext( SwNodeIndex* pIdx ) const
1649 : {
1650 10718 : const SwNodes& rNds = GetNodes();
1651 10718 : SwNodeIndex aIdx( *this, 1 );
1652 :
1653 10718 : const SwNode* pNd = this;
1654 33210 : while( aIdx < rNds.Count()-1 &&
1655 22136 : (( pNd = &aIdx.GetNode())->IsSectionNode() ||
1656 11414 : ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode() )))
1657 352 : ++aIdx;
1658 :
1659 10718 : if (rNds.Count()-1 == aIdx.GetIndex())
1660 0 : return false;
1661 10718 : if (!lcl_CheckMaxLength(*this, *pNd))
1662 : {
1663 0 : return false;
1664 : }
1665 10718 : if( pIdx )
1666 10712 : *pIdx = aIdx;
1667 10718 : return true;
1668 : }
1669 :
1670 : /// Can we join two Nodes?
1671 : /// We can return the 2nd position in pIdx.
1672 312 : bool SwCntntNode::CanJoinPrev( SwNodeIndex* pIdx ) const
1673 : {
1674 312 : SwNodeIndex aIdx( *this, -1 );
1675 :
1676 312 : const SwNode* pNd = this;
1677 972 : while( aIdx.GetIndex() &&
1678 648 : (( pNd = &aIdx.GetNode())->IsSectionNode() ||
1679 336 : ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode() )))
1680 12 : aIdx--;
1681 :
1682 312 : if (0 == aIdx.GetIndex())
1683 0 : return false;
1684 312 : if (!lcl_CheckMaxLength(*pNd, *this))
1685 : {
1686 0 : return false;
1687 : }
1688 312 : if( pIdx )
1689 208 : *pIdx = aIdx;
1690 312 : return true;
1691 : }
1692 :
1693 : //FEATURE::CONDCOLL
1694 20318 : void SwCntntNode::SetCondFmtColl( SwFmtColl* pColl )
1695 : {
1696 20318 : if( (!pColl && pCondColl) || ( pColl && !pCondColl ) ||
1697 0 : ( pColl && pColl != pCondColl->GetRegisteredIn() ) )
1698 : {
1699 0 : SwFmtColl* pOldColl = GetCondFmtColl();
1700 0 : delete pCondColl;
1701 0 : if( pColl )
1702 0 : pCondColl = new SwDepend( this, pColl );
1703 : else
1704 0 : pCondColl = 0;
1705 :
1706 0 : if( GetpSwAttrSet() )
1707 : {
1708 0 : AttrSetHandleHelper::SetParent( mpAttrSet, *this, &GetAnyFmtColl(), GetFmtColl() );
1709 : }
1710 :
1711 0 : if( !IsModifyLocked() )
1712 : {
1713 0 : SwFmtChg aTmp1( pOldColl ? pOldColl : GetFmtColl() );
1714 0 : SwFmtChg aTmp2( pColl ? pColl : GetFmtColl() );
1715 0 : NotifyClients( &aTmp1, &aTmp2 );
1716 : }
1717 0 : if( IsInCache() )
1718 : {
1719 0 : SwFrm::GetCache().Delete( this );
1720 0 : SetInCache( false );
1721 : }
1722 : }
1723 20318 : }
1724 :
1725 576 : bool SwCntntNode::IsAnyCondition( SwCollCondition& rTmp ) const
1726 : {
1727 576 : const SwNodes& rNds = GetNodes();
1728 : {
1729 576 : int nCond = 0;
1730 576 : const SwStartNode* pSttNd = StartOfSectionNode();
1731 2116 : while( pSttNd )
1732 : {
1733 1058 : switch( pSttNd->GetNodeType() )
1734 : {
1735 0 : case ND_TABLENODE: nCond = PARA_IN_TABLEBODY; break;
1736 70 : case ND_SECTIONNODE: nCond = PARA_IN_SECTION; break;
1737 :
1738 : default:
1739 988 : switch( pSttNd->GetStartNodeType() )
1740 : {
1741 : case SwTableBoxStartNode:
1742 : {
1743 12 : nCond = PARA_IN_TABLEBODY;
1744 12 : const SwTableNode* pTblNd = pSttNd->FindTableNode();
1745 : const SwTableBox* pBox;
1746 24 : if( pTblNd && 0 != ( pBox = pTblNd->GetTable().
1747 36 : GetTblBox( pSttNd->GetIndex() ) ) && pBox &&
1748 12 : pBox->IsInHeadline( &pTblNd->GetTable() ) )
1749 12 : nCond = PARA_IN_TABLEHEAD;
1750 : }
1751 12 : break;
1752 12 : case SwFlyStartNode: nCond = PARA_IN_FRAME; break;
1753 : case SwFootnoteStartNode:
1754 : {
1755 0 : nCond = PARA_IN_FOOTENOTE;
1756 0 : const SwFtnIdxs& rFtnArr = rNds.GetDoc()->GetFtnIdxs();
1757 : const SwTxtFtn* pTxtFtn;
1758 0 : const SwNode* pSrchNd = pSttNd;
1759 :
1760 0 : for( sal_uInt16 n = 0; n < rFtnArr.size(); ++n )
1761 0 : if( 0 != ( pTxtFtn = rFtnArr[ n ])->GetStartNode() &&
1762 0 : pSrchNd == &pTxtFtn->GetStartNode()->GetNode() )
1763 : {
1764 0 : if( pTxtFtn->GetFtn().IsEndNote() )
1765 0 : nCond = PARA_IN_ENDNOTE;
1766 0 : break;
1767 : }
1768 : }
1769 0 : break;
1770 0 : case SwHeaderStartNode: nCond = PARA_IN_HEADER; break;
1771 0 : case SwFooterStartNode: nCond = PARA_IN_FOOTER; break;
1772 964 : case SwNormalStartNode: break;
1773 : }
1774 : }
1775 :
1776 1058 : if( nCond )
1777 : {
1778 94 : rTmp.SetCondition( (Master_CollConditions)nCond, 0 );
1779 94 : return true;
1780 : }
1781 964 : pSttNd = pSttNd->GetIndex()
1782 482 : ? pSttNd->StartOfSectionNode()
1783 1446 : : 0;
1784 : }
1785 : }
1786 :
1787 : {
1788 : sal_uInt16 nPos;
1789 482 : const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds();
1790 482 : if( !rOutlNds.empty() )
1791 : {
1792 66 : if( !rOutlNds.Seek_Entry( (SwCntntNode*)this, &nPos ) && nPos )
1793 66 : --nPos;
1794 132 : if( nPos < rOutlNds.size() &&
1795 66 : rOutlNds[ nPos ]->GetIndex() < GetIndex() )
1796 : {
1797 66 : SwTxtNode* pOutlNd = rOutlNds[ nPos ]->GetTxtNode();
1798 :
1799 66 : if( pOutlNd->IsOutline())
1800 : {
1801 66 : rTmp.SetCondition( PARA_IN_OUTLINE, pOutlNd->GetAttrOutlineLevel() - 1 );
1802 66 : return true;
1803 : }
1804 : }
1805 : }
1806 : }
1807 :
1808 416 : return false;
1809 : }
1810 :
1811 3688 : void SwCntntNode::ChkCondColl()
1812 : {
1813 : // Check, just to be sure
1814 3688 : if( RES_CONDTXTFMTCOLL == GetFmtColl()->Which() )
1815 : {
1816 576 : SwCollCondition aTmp( 0, 0, 0 );
1817 : const SwCollCondition* pCColl;
1818 :
1819 576 : bool bDone = false;
1820 :
1821 576 : if( IsAnyCondition( aTmp ))
1822 : {
1823 160 : pCColl = static_cast<SwConditionTxtFmtColl*>(GetFmtColl())
1824 160 : ->HasCondition( aTmp );
1825 :
1826 160 : if (pCColl)
1827 : {
1828 0 : SetCondFmtColl( pCColl->GetTxtFmtColl() );
1829 0 : bDone = true;
1830 : }
1831 : }
1832 :
1833 576 : if (!bDone)
1834 : {
1835 576 : if( IsTxtNode() && ((SwTxtNode*)this)->GetNumRule())
1836 : {
1837 : // Is at which Level in a list?
1838 : aTmp.SetCondition( PARA_IN_LIST,
1839 0 : ((SwTxtNode*)this)->GetActualListLevel() );
1840 0 : pCColl = ((SwConditionTxtFmtColl*)GetFmtColl())->
1841 0 : HasCondition( aTmp );
1842 : }
1843 : else
1844 576 : pCColl = 0;
1845 :
1846 576 : if( pCColl )
1847 0 : SetCondFmtColl( pCColl->GetTxtFmtColl() );
1848 576 : else if( pCondColl )
1849 0 : SetCondFmtColl( 0 );
1850 576 : }
1851 : }
1852 3688 : }
1853 :
1854 : // #i42921#
1855 75168 : short SwCntntNode::GetTextDirection( const SwPosition& rPos,
1856 : const Point* pPt ) const
1857 : {
1858 75168 : short nRet = -1;
1859 :
1860 75168 : Point aPt;
1861 75168 : if( pPt )
1862 17690 : aPt = *pPt;
1863 :
1864 : // #i72024# - No format of the frame, because this can cause recursive layout actions
1865 75168 : SwFrm* pFrm = getLayoutFrm( GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, &rPos, false );
1866 :
1867 75168 : if ( pFrm )
1868 : {
1869 70878 : if ( pFrm->IsVertical() )
1870 : {
1871 0 : if ( pFrm->IsRightToLeft() )
1872 0 : nRet = FRMDIR_VERT_TOP_LEFT;
1873 : else
1874 0 : nRet = FRMDIR_VERT_TOP_RIGHT;
1875 : }
1876 : else
1877 : {
1878 70878 : if ( pFrm->IsRightToLeft() )
1879 96 : nRet = FRMDIR_HORI_RIGHT_TOP;
1880 : else
1881 70782 : nRet = FRMDIR_HORI_LEFT_TOP;
1882 : }
1883 : }
1884 :
1885 75168 : return nRet;
1886 : }
1887 :
1888 136 : SwOLENodes* SwCntntNode::CreateOLENodesArray( const SwFmtColl& rColl, bool bOnlyWithInvalidSize )
1889 : {
1890 136 : SwOLENodes *pNodes = 0;
1891 136 : SwIterator<SwCntntNode,SwFmtColl> aIter( rColl );
1892 428 : for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() )
1893 : {
1894 292 : SwOLENode *pONd = pNd->GetOLENode();
1895 292 : if ( pONd && (!bOnlyWithInvalidSize || pONd->IsOLESizeInvalid()) )
1896 : {
1897 10 : if ( !pNodes )
1898 8 : pNodes = new SwOLENodes;
1899 10 : pNodes->push_back( pONd );
1900 : }
1901 : }
1902 :
1903 136 : return pNodes;
1904 : }
1905 :
1906 : //UUUU
1907 1776 : drawinglayer::attribute::SdrAllFillAttributesHelperPtr SwCntntNode::getSdrAllFillAttributesHelper() const
1908 : {
1909 1776 : return drawinglayer::attribute::SdrAllFillAttributesHelperPtr();
1910 : }
1911 :
1912 : /*
1913 : * Document Interface Access
1914 : */
1915 3093782 : const IDocumentSettingAccess* SwNode::getIDocumentSettingAccess() const { return &GetDoc()->GetDocumentSettingManager(); }
1916 274416 : const IDocumentDeviceAccess* SwNode::getIDocumentDeviceAccess() const { return &GetDoc()->getIDocumentDeviceAccess(); }
1917 606822 : const IDocumentRedlineAccess* SwNode::getIDocumentRedlineAccess() const { return &GetDoc()->getIDocumentRedlineAccess(); }
1918 324 : const IDocumentStylePoolAccess* SwNode::getIDocumentStylePoolAccess() const { return &GetDoc()->getIDocumentStylePoolAccess(); }
1919 64313 : const IDocumentDrawModelAccess* SwNode::getIDocumentDrawModelAccess() const { return & GetDoc()->getIDocumentDrawModelAccess(); }
1920 0 : const IDocumentLayoutAccess* SwNode::getIDocumentLayoutAccess() const { return &GetDoc()->getIDocumentLayoutAccess(); }
1921 318980 : IDocumentLayoutAccess* SwNode::getIDocumentLayoutAccess() { return &GetDoc()->getIDocumentLayoutAccess(); }
1922 278 : const IDocumentLinksAdministration* SwNode::getIDocumentLinksAdministration() const { return &GetDoc()->getIDocumentLinksAdministration(); }
1923 16 : IDocumentLinksAdministration* SwNode::getIDocumentLinksAdministration() { return &GetDoc()->getIDocumentLinksAdministration(); }
1924 0 : const IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() const { return &GetDoc()->getIDocumentFieldsAccess(); }
1925 22556 : IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() { return &GetDoc()->getIDocumentFieldsAccess(); }
1926 0 : IDocumentContentOperations* SwNode::getIDocumentContentOperations() { return &GetDoc()->getIDocumentContentOperations(); }
1927 15340 : IDocumentListItems& SwNode::getIDocumentListItems() { return GetDoc()->getIDocumentListItems(); } // #i83479#
1928 :
1929 240201 : const IDocumentMarkAccess* SwNode::getIDocumentMarkAccess() const { return GetDoc()->getIDocumentMarkAccess(); }
1930 17468 : IStyleAccess& SwNode::getIDocumentStyleAccess() { return GetDoc()->GetIStyleAccess(); }
1931 :
1932 36838 : bool SwNode::IsInRedlines() const
1933 : {
1934 36838 : const SwDoc * pDoc = GetDoc();
1935 36838 : bool bResult = false;
1936 :
1937 36838 : if (pDoc != NULL)
1938 36838 : bResult = pDoc->getIDocumentRedlineAccess().IsInRedlines(*this);
1939 :
1940 36838 : return bResult;
1941 270 : }
1942 :
1943 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
