?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update credits
[LibreOffice.git] / sw / source / core / doc / doclay.cxx
blob926a8c701f2f0e84ac5df16e4d3700c8460c3a1a
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
21 #include <unotools/linguprops.hxx>
22 #include <unotools/lingucfg.hxx>
23 #include <com/sun/star/embed/EmbedStates.hpp>
24 #include <hintids.hxx>
25 #include <com/sun/star/util/XCloseable.hpp>
26 #include <sfx2/progress.hxx>
27 #include <svx/svdmodel.hxx>
28 #include <svx/svdpage.hxx>
29 #include <editeng/keepitem.hxx>
30 #include <editeng/ulspitem.hxx>
31 #include <editeng/lrspitem.hxx>
32 #include <editeng/boxitem.hxx>
33 #include <editeng/shaditem.hxx>
34 #include <editeng/protitem.hxx>
35 #include <editeng/opaqitem.hxx>
36 #include <editeng/prntitem.hxx>
37 #include <svx/fmglob.hxx>
38 #include <svx/svdouno.hxx>
39 #include <svx/fmpage.hxx>
40 #include <editeng/frmdiritem.hxx>
41
42 #include <swmodule.hxx>
43 #include <modcfg.hxx>
44 #include <com/sun/star/beans/XPropertySet.hpp>
45 #include <rtl/logfile.hxx>
46 #include <SwStyleNameMapper.hxx>
47 #include <fchrfmt.hxx>
48 #include <frmatr.hxx>
49 #include <txatbase.hxx>
50 #include <fmtfld.hxx>
51 #include <fmtornt.hxx>
52 #include <fmtcntnt.hxx>
53 #include <fmtanchr.hxx>
54 #include <fmtfsize.hxx>
55 #include <fmtsrnd.hxx>
56 #include <fmtflcnt.hxx>
57 #include <fmtcnct.hxx>
58 #include <frmfmt.hxx>
59 #include <txtflcnt.hxx>
60 #include <docfld.hxx> // for ExpressionFields
61 #include <pam.hxx>
62 #include <ndtxt.hxx>
63 #include <ndnotxt.hxx>
64 #include <ndole.hxx>
65 #include <doc.hxx>
66 #include <IDocumentUndoRedo.hxx>
67 #include <rootfrm.hxx>
68 #include <pagefrm.hxx>
69 #include <cntfrm.hxx>
70 #include <flyfrm.hxx>
71 #include <fesh.hxx>
72 #include <docsh.hxx>
73 #include <dflyobj.hxx>
74 #include <dcontact.hxx>
75 #include <swundo.hxx>
76 #include <flypos.hxx>
77 #include <UndoInsert.hxx>
78 #include <expfld.hxx> // InsertLabel
79 #include <poolfmt.hxx> // PoolTemplate Ids
80 #include <docary.hxx>
81 #include <swtable.hxx>
82 #include <tblsel.hxx>
83 #include <viewopt.hxx>
84 #include <fldupde.hxx>
85 #include <txtftn.hxx>
86 #include <ftnidx.hxx>
87 #include <ftninfo.hxx>
88 #include <pagedesc.hxx>
89 #include <PostItMgr.hxx>
90 #include <comcore.hrc> // STR ResIds
91
92 #include <unoframe.hxx>
93
94 #include <sortedobjs.hxx>
95
96 #include <vector>
97
98 using namespace ::com::sun::star;
99
100 #define DEF_FLY_WIDTH 2268 // Default width for FlyFrms (2268 == 4cm)
101
102
103 static bool lcl_IsItemSet(const SwCntntNode & rNode, sal_uInt16 which)
104 {
105 bool bResult = false;
106
107 if (SFX_ITEM_SET == rNode.GetSwAttrSet().GetItemState(which))
108 bResult = true;
109
110 return bResult;
111 }
112
113 /** Create a new format whose settings fit to the Request by default.
114
115 The format is put into the respective format array.
116 If there already is a fitting format, it is returned instead. */
117 SwFrmFmt *SwDoc::MakeLayoutFmt( RndStdIds eRequest, const SfxItemSet* pSet )
118 {
119 SwFrmFmt *pFmt = 0;
120 const sal_Bool bMod = IsModified();
121 bool bHeader = false;
122
123 switch ( eRequest )
124 {
125 case RND_STD_HEADER:
126 case RND_STD_HEADERL:
127 case RND_STD_HEADERR:
128 {
129 bHeader = true;
130 // no break, we continue further down
131 }
132 case RND_STD_FOOTER:
133 case RND_STD_FOOTERL:
134 case RND_STD_FOOTERR:
135 {
136 pFmt = new SwFrmFmt( GetAttrPool(),
137 (bHeader ? "Right header" : "Right footer"),
138 GetDfltFrmFmt() );
139
140 SwNodeIndex aTmpIdx( GetNodes().GetEndOfAutotext() );
141 SwStartNode* pSttNd =
142 GetNodes().MakeTextSection
143 ( aTmpIdx,
144 bHeader ? SwHeaderStartNode : SwFooterStartNode,
145 GetTxtCollFromPool(static_cast<sal_uInt16>( bHeader
146 ? ( eRequest == RND_STD_HEADERL
147 ? RES_POOLCOLL_HEADERL
148 : eRequest == RND_STD_HEADERR
149 ? RES_POOLCOLL_HEADERR
150 : RES_POOLCOLL_HEADER )
151 : ( eRequest == RND_STD_FOOTERL
152 ? RES_POOLCOLL_FOOTERL
153 : eRequest == RND_STD_FOOTERR
154 ? RES_POOLCOLL_FOOTERR
155 : RES_POOLCOLL_FOOTER )
156 ) ) );
157 pFmt->SetFmtAttr( SwFmtCntnt( pSttNd ));
158
159 if( pSet ) // Set a few more attributes
160 pFmt->SetFmtAttr( *pSet );
161
162 // Why set it back? Doc has changed, or not?
163 // In any case, wrong for the FlyFrames!
164 if ( !bMod )
165 ResetModified();
166 }
167 break;
168
169 case RND_DRAW_OBJECT:
170 {
171 pFmt = MakeDrawFrmFmt( aEmptyStr, GetDfltFrmFmt() );
172 if( pSet ) // Set a few more attributes
173 pFmt->SetFmtAttr( *pSet );
174
175 if (GetIDocumentUndoRedo().DoesUndo())
176 {
177 GetIDocumentUndoRedo().AppendUndo(
178 new SwUndoInsLayFmt(pFmt, 0, 0));
179 }
180 }
181 break;
182
183 #if OSL_DEBUG_LEVEL > 0
184 case FLY_AT_PAGE:
185 case FLY_AT_CHAR:
186 case FLY_AT_FLY:
187 case FLY_AT_PARA:
188 case FLY_AS_CHAR:
189 OSL_FAIL( "use new interface instead: SwDoc::MakeFlySection!" );
190 break;
191 #endif
192
193 default:
194 OSL_ENSURE( !this,
195 "LayoutFormat was requested with an invalid Request." );
196
197 }
198 return pFmt;
199 }
200
201 /// Deletes the denoted format and its content.
202 void SwDoc::DelLayoutFmt( SwFrmFmt *pFmt )
203 {
204 // A chain of frames needs to be merged, if necessary,
205 // so that the Frame's contents are adjusted accordingly before we destroy the Frames.
206 const SwFmtChain &rChain = pFmt->GetChain();
207 if ( rChain.GetPrev() )
208 {
209 SwFmtChain aChain( rChain.GetPrev()->GetChain() );
210 aChain.SetNext( rChain.GetNext() );
211 SetAttr( aChain, *rChain.GetPrev() );
212 }
213 if ( rChain.GetNext() )
214 {
215 SwFmtChain aChain( rChain.GetNext()->GetChain() );
216 aChain.SetPrev( rChain.GetPrev() );
217 SetAttr( aChain, *rChain.GetNext() );
218 }
219
220 const SwNodeIndex* pCntIdx = pFmt->GetCntnt().GetCntntIdx();
221 if (pCntIdx && !GetIDocumentUndoRedo().DoesUndo())
222 {
223 // Disconnect if it's an OLE object
224 SwOLENode* pOLENd = GetNodes()[ pCntIdx->GetIndex()+1 ]->GetOLENode();
225 if( pOLENd && pOLENd->GetOLEObj().IsOleRef() )
226 {
227
228 // TODO: the old object closed the object and cleared all references to it, but didn't remove it from the container.
229 // I have no idea, why, nobody could explain it - so I do my very best to mimic this behavior
230 //uno::Reference < util::XCloseable > xClose( pOLENd->GetOLEObj().GetOleRef(), uno::UNO_QUERY );
231 //if ( xClose.is() )
232 {
233 try
234 {
235 pOLENd->GetOLEObj().GetOleRef()->changeState( embed::EmbedStates::LOADED );
236 }
237 catch ( uno::Exception& )
238 {
239 }
240 }
241
242 }
243 }
244
245 // Destroy Frames
246 pFmt->DelFrms();
247
248 // Only FlyFrames are undoable at first
249 const sal_uInt16 nWh = pFmt->Which();
250 if (GetIDocumentUndoRedo().DoesUndo() &&
251 (RES_FLYFRMFMT == nWh || RES_DRAWFRMFMT == nWh))
252 {
253 GetIDocumentUndoRedo().AppendUndo( new SwUndoDelLayFmt( pFmt ));
254 }
255 else
256 {
257 // #i32089# - delete at-frame anchored objects
258 if ( nWh == RES_FLYFRMFMT )
259 {
260 // determine frame formats of at-frame anchored objects
261 const SwNodeIndex* pCntntIdx = pFmt->GetCntnt().GetCntntIdx();
262 if ( pCntntIdx )
263 {
264 const SwFrmFmts* pTbl = pFmt->GetDoc()->GetSpzFrmFmts();
265 if ( pTbl )
266 {
267 std::vector<SwFrmFmt*> aToDeleteFrmFmts;
268 const sal_uLong nNodeIdxOfFlyFmt( pCntntIdx->GetIndex() );
269
270 for ( sal_uInt16 i = 0; i < pTbl->size(); ++i )
271 {
272 SwFrmFmt* pTmpFmt = (*pTbl)[i];
273 const SwFmtAnchor &rAnch = pTmpFmt->GetAnchor();
274 if ( rAnch.GetAnchorId() == FLY_AT_FLY &&
275 rAnch.GetCntntAnchor()->nNode.GetIndex() == nNodeIdxOfFlyFmt )
276 {
277 aToDeleteFrmFmts.push_back( pTmpFmt );
278 }
279 }
280
281 // delete found frame formats
282 while ( !aToDeleteFrmFmts.empty() )
283 {
284 SwFrmFmt* pTmpFmt = aToDeleteFrmFmts.back();
285 pFmt->GetDoc()->DelLayoutFmt( pTmpFmt );
286
287 aToDeleteFrmFmts.pop_back();
288 }
289 }
290 }
291 }
292
293 // Delete content
294 if( pCntIdx )
295 {
296 SwNode *pNode = &pCntIdx->GetNode();
297 ((SwFmtCntnt&)pFmt->GetFmtAttr( RES_CNTNT )).SetNewCntntIdx( 0 );
298 DeleteSection( pNode );
299 }
300
301 // Delete the character for FlyFrames anchored as char (if necessary)
302 const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
303 if ((FLY_AS_CHAR == rAnchor.GetAnchorId()) && rAnchor.GetCntntAnchor())
304 {
305 const SwPosition* pPos = rAnchor.GetCntntAnchor();
306 SwTxtNode *pTxtNd = pPos->nNode.GetNode().GetTxtNode();
307
308 // attribute is still in text node, delete it
309 if ( pTxtNd )
310 {
311 SwTxtFlyCnt* const pAttr = static_cast<SwTxtFlyCnt*>(
312 pTxtNd->GetTxtAttrForCharAt( pPos->nContent.GetIndex(),
313 RES_TXTATR_FLYCNT ));
314 if ( pAttr && (pAttr->GetFlyCnt().GetFrmFmt() == pFmt) )
315 {
316 // dont delete, set pointer to 0
317 const_cast<SwFmtFlyCnt&>(pAttr->GetFlyCnt()).SetFlyFmt();
318 SwIndex aIdx( pPos->nContent );
319 pTxtNd->EraseText( aIdx, 1 );
320 }
321 }
322 }
323
324 DelFrmFmt( pFmt );
325 }
326 SetModified();
327 }
328
329 /** Copies the stated format (pSrc) to pDest and returns pDest.
330
331 If there's no pDest, it is created.
332 If the source format is located in another document, also copy correctly
333 in this case.
334 The Anchor attribute's position is always set to 0! */
335 SwFrmFmt *SwDoc::CopyLayoutFmt( const SwFrmFmt& rSource,
336 const SwFmtAnchor& rNewAnchor,
337 bool bSetTxtFlyAtt, bool bMakeFrms )
338 {
339 const bool bFly = RES_FLYFRMFMT == rSource.Which();
340 const bool bDraw = RES_DRAWFRMFMT == rSource.Which();
341 OSL_ENSURE( bFly || bDraw, "this method only works for fly or draw" );
342
343 SwDoc* pSrcDoc = (SwDoc*)rSource.GetDoc();
344
345 // May we copy this object?
346 // We may, unless it's 1) it's a control (and therfore a draw)
347 // 2) anchored in a header/footer
348 // 3) anchored (to paragraph?)
349 bool bMayNotCopy = false;
350 if( bDraw )
351 {
352 const SwDrawContact* pDrawContact =
353 static_cast<const SwDrawContact*>( rSource.FindContactObj() );
354
355 bMayNotCopy =
356 ((FLY_AT_PARA == rNewAnchor.GetAnchorId()) ||
357 (FLY_AT_FLY == rNewAnchor.GetAnchorId()) ||
358 (FLY_AT_CHAR == rNewAnchor.GetAnchorId())) &&
359 rNewAnchor.GetCntntAnchor() &&
360 IsInHeaderFooter( rNewAnchor.GetCntntAnchor()->nNode ) &&
361 pDrawContact != NULL &&
362 pDrawContact->GetMaster() != NULL &&
363 CheckControlLayer( pDrawContact->GetMaster() );
364 }
365
366 // just return if we can't copy this
367 if( bMayNotCopy )
368 return NULL;
369
370 SwFrmFmt* pDest = GetDfltFrmFmt();
371 if( rSource.GetRegisteredIn() != pSrcDoc->GetDfltFrmFmt() )
372 pDest = CopyFrmFmt( *(SwFrmFmt*)rSource.GetRegisteredIn() );
373 if( bFly )
374 {
375 // #i11176#
376 // To do a correct cloning concerning the ZOrder for all objects
377 // it is necessary to actually create a draw object for fly frames, too.
378 // These are then added to the DrawingLayer (which needs to exist).
379 // Together with correct sorting of all drawinglayer based objects
380 // before cloning ZOrder transfer works correctly then.
381 SwFlyFrmFmt *pFormat = MakeFlyFrmFmt( rSource.GetName(), pDest );
382 pDest = pFormat;
383
384 SwXFrame::GetOrCreateSdrObject(pFormat);
385 }
386 else
387 pDest = MakeDrawFrmFmt( aEmptyStr, pDest );
388
389 // Copy all other or new attributes
390 pDest->CopyAttrs( rSource );
391
392 // Do not copy chains
393 pDest->ResetFmtAttr( RES_CHAIN );
394
395 if( bFly )
396 {
397 // Duplicate the content.
398 const SwNode& rCSttNd = rSource.GetCntnt().GetCntntIdx()->GetNode();
399 SwNodeRange aRg( rCSttNd, 1, *rCSttNd.EndOfSectionNode() );
400
401 SwNodeIndex aIdx( GetNodes().GetEndOfAutotext() );
402 SwStartNode* pSttNd = GetNodes().MakeEmptySection( aIdx, SwFlyStartNode );
403
404 // Set the Anchor/CntntIndex first.
405 // Within the copying part, we can access the values (DrawFmt in Headers and Footers)
406 aIdx = *pSttNd;
407 SwFmtCntnt aAttr( rSource.GetCntnt() );
408 aAttr.SetNewCntntIdx( &aIdx );
409 pDest->SetFmtAttr( aAttr );
410 pDest->SetFmtAttr( rNewAnchor );
411
412 if( !mbCopyIsMove || this != pSrcDoc )
413 {
414 if( mbInReading )
415 pDest->SetName( aEmptyStr );
416 else
417 {
418 // Test first if the name is already taken, if so generate a new one.
419 sal_Int8 nNdTyp = aRg.aStart.GetNode().GetNodeType();
420
421 String sOld( pDest->GetName() );
422 pDest->SetName( aEmptyStr );
423 if( FindFlyByName( sOld, nNdTyp ) ) // found one
424 switch( nNdTyp )
425 {
426 case ND_GRFNODE: sOld = GetUniqueGrfName(); break;
427 case ND_OLENODE: sOld = GetUniqueOLEName(); break;
428 default: sOld = GetUniqueFrameName(); break;
429 }
430
431 pDest->SetName( sOld );
432 }
433 }
434
435 if (GetIDocumentUndoRedo().DoesUndo())
436 {
437 GetIDocumentUndoRedo().AppendUndo(new SwUndoInsLayFmt(pDest,0,0));
438 }
439
440 // Make sure that FlyFrames in FlyFrames are copied
441 aIdx = *pSttNd->EndOfSectionNode();
442
443 //fdo#36631 disable (scoped) any undo operations associated with the
444 //contact object itself. They should be managed by SwUndoInsLayFmt.
445 const ::sw::DrawUndoGuard drawUndoGuard(GetIDocumentUndoRedo());
446
447 pSrcDoc->CopyWithFlyInFly( aRg, 0, aIdx, sal_False, sal_True, sal_True );
448 }
449 else
450 {
451 OSL_ENSURE( RES_DRAWFRMFMT == rSource.Which(), "Neither Fly nor Draw." );
452 // #i52780# - Note: moving object to visible layer not needed.
453 SwDrawContact* pSourceContact = (SwDrawContact *)rSource.FindContactObj();
454
455 SwDrawContact* pContact = new SwDrawContact( (SwDrawFrmFmt*)pDest,
456 CloneSdrObj( *pSourceContact->GetMaster(),
457 mbCopyIsMove && this == pSrcDoc ) );
458 // #i49730# - notify draw frame format that position attributes are
459 // already set, if the position attributes are already set at the
460 // source draw frame format.
461 if ( pDest->ISA(SwDrawFrmFmt) &&
462 rSource.ISA(SwDrawFrmFmt) &&
463 static_cast<const SwDrawFrmFmt&>(rSource).IsPosAttrSet() )
464 {
465 static_cast<SwDrawFrmFmt*>(pDest)->PosAttrSet();
466 }
467
468 if( pDest->GetAnchor() == rNewAnchor )
469 {
470 // Do *not* connect to layout, if a <MakeFrms> will not be called.
471 if ( bMakeFrms )
472 {
473 pContact->ConnectToLayout( &rNewAnchor );
474 }
475 }
476 else
477 pDest->SetFmtAttr( rNewAnchor );
478
479 if (GetIDocumentUndoRedo().DoesUndo())
480 {
481 GetIDocumentUndoRedo().AppendUndo(new SwUndoInsLayFmt(pDest,0,0));
482 }
483 }
484
485 if (bSetTxtFlyAtt && (FLY_AS_CHAR == rNewAnchor.GetAnchorId()))
486 {
487 const SwPosition* pPos = rNewAnchor.GetCntntAnchor();
488 SwFmtFlyCnt aFmt( pDest );
489 pPos->nNode.GetNode().GetTxtNode()->InsertItem(
490 aFmt, pPos->nContent.GetIndex(), 0 );
491 }
492
493 if( bMakeFrms )
494 pDest->MakeFrms();
495
496 return pDest;
497 }
498
499 SdrObject* SwDoc::CloneSdrObj( const SdrObject& rObj, bool bMoveWithinDoc,
500 bool bInsInPage )
501 {
502 // #i52858# - method name changed
503 SdrPage *pPg = GetOrCreateDrawModel()->GetPage( 0 );
504 if( !pPg )
505 {
506 pPg = GetDrawModel()->AllocPage( sal_False );
507 GetDrawModel()->InsertPage( pPg );
508 }
509
510 SdrObject *pObj = rObj.Clone();
511 if( bMoveWithinDoc && FmFormInventor == pObj->GetObjInventor() )
512 {
513 // We need to preserve the Name for Controls
514 uno::Reference< awt::XControlModel > xModel = ((SdrUnoObj*)pObj)->GetUnoControlModel();
515 uno::Any aVal;
516 uno::Reference< beans::XPropertySet > xSet(xModel, uno::UNO_QUERY);
517 OUString sName("Name");
518 if( xSet.is() )
519 aVal = xSet->getPropertyValue( sName );
520 if( bInsInPage )
521 pPg->InsertObject( pObj );
522 if( xSet.is() )
523 xSet->setPropertyValue( sName, aVal );
524 }
525 else if( bInsInPage )
526 pPg->InsertObject( pObj );
527
528 // For drawing objects: set layer of cloned object to invisible layer
529 SdrLayerID nLayerIdForClone = rObj.GetLayer();
530 if ( !pObj->ISA(SwFlyDrawObj) &&
531 !pObj->ISA(SwVirtFlyDrawObj) &&
532 !IS_TYPE(SdrObject,pObj) )
533 {
534 if ( IsVisibleLayerId( nLayerIdForClone ) )
535 {
536 nLayerIdForClone = GetInvisibleLayerIdByVisibleOne( nLayerIdForClone );
537 }
538 }
539 pObj->SetLayer( nLayerIdForClone );
540
541
542 return pObj;
543 }
544
545 SwFlyFrmFmt* SwDoc::_MakeFlySection( const SwPosition& rAnchPos,
546 const SwCntntNode& rNode,
547 RndStdIds eRequestId,
548 const SfxItemSet* pFlySet,
549 SwFrmFmt* pFrmFmt )
550 {
551 if( !pFrmFmt )
552 pFrmFmt = GetFrmFmtFromPool( RES_POOLFRM_FRAME );
553
554 String sName;
555 if( !mbInReading )
556 switch( rNode.GetNodeType() )
557 {
558 case ND_GRFNODE: sName = GetUniqueGrfName(); break;
559 case ND_OLENODE: sName = GetUniqueOLEName(); break;
560 default: sName = GetUniqueFrameName(); break;
561 }
562 SwFlyFrmFmt* pFmt = MakeFlyFrmFmt( sName, pFrmFmt );
563
564 // Create content and connect to the format.
565 // Create CntntNode and put it into the autotext selection.
566 SwNodeRange aRange( GetNodes().GetEndOfAutotext(), -1,
567 GetNodes().GetEndOfAutotext() );
568 GetNodes().SectionDown( &aRange, SwFlyStartNode );
569
570 pFmt->SetFmtAttr( SwFmtCntnt( rNode.StartOfSectionNode() ));
571
572
573 const SwFmtAnchor* pAnchor = 0;
574 if( pFlySet )
575 {
576 pFlySet->GetItemState( RES_ANCHOR, sal_False,
577 (const SfxPoolItem**)&pAnchor );
578 if( SFX_ITEM_SET == pFlySet->GetItemState( RES_CNTNT, sal_False ))
579 {
580 SfxItemSet aTmpSet( *pFlySet );
581 aTmpSet.ClearItem( RES_CNTNT );
582 pFmt->SetFmtAttr( aTmpSet );
583 }
584 else
585 pFmt->SetFmtAttr( *pFlySet );
586 }
587
588 // Anchor not yet set?
589 RndStdIds eAnchorId = pAnchor ? pAnchor->GetAnchorId()
590 : pFmt->GetAnchor().GetAnchorId();
591 // #i107811# Assure that at-page anchored fly frames have a page num or a
592 // content anchor set.
593 if ( !pAnchor ||
594 ( FLY_AT_PAGE != pAnchor->GetAnchorId() &&
595 !pAnchor->GetCntntAnchor() ) ||
596 ( FLY_AT_PAGE == pAnchor->GetAnchorId() &&
597 !pAnchor->GetCntntAnchor() &&
598 pAnchor->GetPageNum() == 0 ) )
599 {
600 // set it again, needed for Undo
601 SwFmtAnchor aAnch( pFmt->GetAnchor() );
602 if (pAnchor && (FLY_AT_FLY == pAnchor->GetAnchorId()))
603 {
604 SwPosition aPos( *rAnchPos.nNode.GetNode().FindFlyStartNode() );
605 aAnch.SetAnchor( &aPos );
606 eAnchorId = FLY_AT_FLY;
607 }
608 else
609 {
610 if( eRequestId != aAnch.GetAnchorId() &&
611 SFX_ITEM_SET != pFmt->GetItemState( RES_ANCHOR, sal_True ) )
612 {
613 aAnch.SetType( eRequestId );
614 }
615
616 eAnchorId = aAnch.GetAnchorId();
617 if ( FLY_AT_PAGE != eAnchorId ||
618 ( FLY_AT_PAGE == eAnchorId &&
619 ( !pAnchor ||
620 aAnch.GetPageNum() == 0 ) ) )
621 {
622 aAnch.SetAnchor( &rAnchPos );
623 }
624 }
625 pFmt->SetFmtAttr( aAnch );
626 }
627 else
628 eAnchorId = pFmt->GetAnchor().GetAnchorId();
629
630 if ( FLY_AS_CHAR == eAnchorId )
631 {
632 xub_StrLen nStt = rAnchPos.nContent.GetIndex();
633 SwTxtNode * pTxtNode = rAnchPos.nNode.GetNode().GetTxtNode();
634
635 OSL_ENSURE(pTxtNode!= 0, "There should be a SwTxtNode!");
636
637 if (pTxtNode != NULL)
638 {
639 SwFmtFlyCnt aFmt( pFmt );
640 bool const bSuccess( pTxtNode->InsertItem(aFmt, nStt, nStt) );
641 if (!bSuccess) // may fail if there's no space left or header/ftr
642 { // pFmt is dead now
643 return 0;
644 }
645 }
646 }
647
648 if( SFX_ITEM_SET != pFmt->GetAttrSet().GetItemState( RES_FRM_SIZE ))
649 {
650 SwFmtFrmSize aFmtSize( ATT_VAR_SIZE, 0, DEF_FLY_WIDTH );
651 const SwNoTxtNode* pNoTxtNode = rNode.GetNoTxtNode();
652 if( pNoTxtNode )
653 {
654 // Set size
655 Size aSize( pNoTxtNode->GetTwipSize() );
656 if( MINFLY > aSize.Width() )
657 aSize.Width() = DEF_FLY_WIDTH;
658 aFmtSize.SetWidth( aSize.Width() );
659 if( aSize.Height() )
660 {
661 aFmtSize.SetHeight( aSize.Height() );
662 aFmtSize.SetHeightSizeType( ATT_FIX_SIZE );
663 }
664 }
665 pFmt->SetFmtAttr( aFmtSize );
666 }
667
668 // Set up frames
669 if( GetCurrentViewShell() )
670 pFmt->MakeFrms(); // ??? //swmod 071108//swmod 071225
671
672 if (GetIDocumentUndoRedo().DoesUndo())
673 {
674 sal_uLong nNodeIdx = rAnchPos.nNode.GetIndex();
675 xub_StrLen nCntIdx = rAnchPos.nContent.GetIndex();
676 GetIDocumentUndoRedo().AppendUndo(
677 new SwUndoInsLayFmt( pFmt, nNodeIdx, nCntIdx ));
678 }
679
680 SetModified();
681 return pFmt;
682 }
683
684 SwFlyFrmFmt* SwDoc::MakeFlySection( RndStdIds eAnchorType,
685 const SwPosition* pAnchorPos,
686 const SfxItemSet* pFlySet,
687 SwFrmFmt* pFrmFmt, bool bCalledFromShell )
688 {
689 SwFlyFrmFmt* pFmt = 0;
690 bool bCallMake = true;
691 if ( !pAnchorPos && (FLY_AT_PAGE != eAnchorType) )
692 {
693 const SwFmtAnchor* pAnch;
694 if( (pFlySet && SFX_ITEM_SET == pFlySet->GetItemState(
695 RES_ANCHOR, sal_False, (const SfxPoolItem**)&pAnch )) ||
696 ( pFrmFmt && SFX_ITEM_SET == pFrmFmt->GetItemState(
697 RES_ANCHOR, sal_True, (const SfxPoolItem**)&pAnch )) )
698 {
699 if ( (FLY_AT_PAGE != pAnch->GetAnchorId()) )
700 {
701 pAnchorPos = pAnch->GetCntntAnchor();
702 if (pAnchorPos)
703 {
704 bCallMake = false;
705 }
706 }
707 }
708 }
709
710 if( bCallMake )
711 {
712 if( !pFrmFmt )
713 pFrmFmt = GetFrmFmtFromPool( RES_POOLFRM_FRAME );
714
715 sal_uInt16 nCollId = static_cast<sal_uInt16>(
716 get(IDocumentSettingAccess::HTML_MODE) ? RES_POOLCOLL_TEXT : RES_POOLCOLL_FRAME );
717
718 /* If there is no adjust item in the paragraph style for the content node of the new fly section
719 propagate an existing adjust item at the anchor to the new content node. */
720 SwCntntNode * pNewTxtNd = GetNodes().MakeTxtNode
721 (SwNodeIndex( GetNodes().GetEndOfAutotext()),
722 GetTxtCollFromPool( nCollId ));
723 SwCntntNode * pAnchorNode = pAnchorPos->nNode.GetNode().GetCntntNode();
724
725 const SfxPoolItem * pItem = NULL;
726
727 if (bCalledFromShell && !lcl_IsItemSet(*pNewTxtNd, RES_PARATR_ADJUST) &&
728 SFX_ITEM_SET == pAnchorNode->GetSwAttrSet().
729 GetItemState(RES_PARATR_ADJUST, sal_True, &pItem))
730 {
731 static_cast<SwCntntNode *>(pNewTxtNd)->SetAttr(*pItem);
732 }
733
734 pFmt = _MakeFlySection( *pAnchorPos, *pNewTxtNd,
735 eAnchorType, pFlySet, pFrmFmt );
736 }
737 return pFmt;
738 }
739
740 SwFlyFrmFmt* SwDoc::MakeFlyAndMove( const SwPaM& rPam, const SfxItemSet& rSet,
741 const SwSelBoxes* pSelBoxes,
742 SwFrmFmt *pParent )
743 {
744 SwFmtAnchor& rAnch = (SwFmtAnchor&)rSet.Get( RES_ANCHOR );
745
746 GetIDocumentUndoRedo().StartUndo( UNDO_INSLAYFMT, NULL );
747
748 SwFlyFrmFmt* pFmt = MakeFlySection( rAnch.GetAnchorId(), rPam.GetPoint(),
749 &rSet, pParent );
750
751 // If content is selected, it becomes the new frame's content.
752 // Namely, it is moved into the NodeArray's appropriate section.
753
754 if( pFmt )
755 {
756 do { // middle check loop
757 const SwFmtCntnt &rCntnt = pFmt->GetCntnt();
758 OSL_ENSURE( rCntnt.GetCntntIdx(), "No content prepared." );
759 SwNodeIndex aIndex( *(rCntnt.GetCntntIdx()), 1 );
760 SwCntntNode *pNode = aIndex.GetNode().GetCntntNode();
761
762 // Attention: Do not create an index on the stack, or we
763 // cannot delete CntntNode in the end!
764 SwPosition aPos( aIndex );
765 aPos.nContent.Assign( pNode, 0 );
766
767 if( pSelBoxes && !pSelBoxes->empty() )
768 {
769 // Table selection
770 // Copy parts of a table: create a table with the same width as the
771 // original one and move (copy and delete) the selected boxes.
772 // The size is corrected on a percentage basis.
773
774 SwTableNode* pTblNd = (SwTableNode*)(*pSelBoxes)[0]->
775 GetSttNd()->FindTableNode();
776 if( !pTblNd )
777 break;
778
779 SwTable& rTbl = pTblNd->GetTable();
780
781 // Did we select the whole table?
782 if( pSelBoxes->size() == rTbl.GetTabSortBoxes().size() )
783 {
784 // move the whole table
785 SwNodeRange aRg( *pTblNd, 0, *pTblNd->EndOfSectionNode(), 1 );
786
787 // If we move the whole table and it is located within a
788 // FlyFrame, the we create a TextNode after it.
789 // So that this FlyFrame is preserved.
790 if( aRg.aEnd.GetNode().IsEndNode() )
791 GetNodes().MakeTxtNode( aRg.aStart,
792 (SwTxtFmtColl*)GetDfltTxtFmtColl() );
793
794 MoveNodeRange( aRg, aPos.nNode, DOC_MOVEDEFAULT );
795 }
796 else
797 {
798 rTbl.MakeCopy( this, aPos, *pSelBoxes );
799 // Don't delete a part of a table with row span!!
800 // You could delete the content instead -> ToDo
801 //rTbl.DeleteSel( this, *pSelBoxes, 0, 0, true, true );
802 }
803
804 // If the table is within the frame, then copy without the following TextNode
805 aIndex = rCntnt.GetCntntIdx()->GetNode().EndOfSectionIndex() - 1;
806 OSL_ENSURE( aIndex.GetNode().GetTxtNode(),
807 "a TextNode should be here" );
808 aPos.nContent.Assign( 0, 0 ); // Deregister index!
809 GetNodes().Delete( aIndex, 1 );
810
811 // This is a hack: whilst FlyFrames/Headers/Footers are not undoable we delete all Undo objects
812 if( GetIDocumentUndoRedo().DoesUndo() )
813 {
814 GetIDocumentUndoRedo().DelAllUndoObj();
815 }
816 }
817 else
818 {
819 // copy all Pams and then delete all
820 SwPaM* pTmp = (SwPaM*)&rPam;
821 bool bOldFlag = mbCopyIsMove;
822 bool const bOldUndo = GetIDocumentUndoRedo().DoesUndo();
823 bool const bOldRedlineMove(IsRedlineMove());
824 mbCopyIsMove = true;
825 GetIDocumentUndoRedo().DoUndo(false);
826 SetRedlineMove(true);
827 do {
828 if( pTmp->HasMark() &&
829 *pTmp->GetPoint() != *pTmp->GetMark() )
830 {
831 CopyRange( *pTmp, aPos, false );
832 }
833 pTmp = static_cast<SwPaM*>(pTmp->GetNext());
834 } while ( &rPam != pTmp );
835 SetRedlineMove(bOldRedlineMove);
836 mbCopyIsMove = bOldFlag;
837 GetIDocumentUndoRedo().DoUndo(bOldUndo);
838
839 pTmp = (SwPaM*)&rPam;
840 do {
841 if( pTmp->HasMark() &&
842 *pTmp->GetPoint() != *pTmp->GetMark() )
843 {
844 DeleteAndJoin( *pTmp );
845 }
846 pTmp = static_cast<SwPaM*>(pTmp->GetNext());
847 } while ( &rPam != pTmp );
848 }
849 } while( false );
850 }
851
852 SetModified();
853
854 GetIDocumentUndoRedo().EndUndo( UNDO_INSLAYFMT, NULL );
855
856 return pFmt;
857 }
858
859 /// Insert a DrawObject.
860 /// The Object has to be already registered in the DrawModel.
861 SwDrawFrmFmt* SwDoc::Insert( const SwPaM &rRg,
862 SdrObject& rDrawObj,
863 const SfxItemSet* pFlyAttrSet,
864 SwFrmFmt* pDefFmt )
865 {
866 SwDrawFrmFmt *pFmt = MakeDrawFrmFmt( aEmptyStr,
867 pDefFmt ? pDefFmt : GetDfltFrmFmt() );
868
869 const SwFmtAnchor* pAnchor = 0;
870 if( pFlyAttrSet )
871 {
872 pFlyAttrSet->GetItemState( RES_ANCHOR, sal_False,
873 (const SfxPoolItem**)&pAnchor );
874 pFmt->SetFmtAttr( *pFlyAttrSet );
875 }
876
877 RndStdIds eAnchorId = pAnchor ? pAnchor->GetAnchorId()
878 : pFmt->GetAnchor().GetAnchorId();
879
880 // Didn't set the Anchor yet?
881 // DrawObjecte must never end up in the Header/Footer!
882 const bool bIsAtCntnt = (FLY_AT_PAGE != eAnchorId);
883
884 const SwNodeIndex* pChkIdx = 0;
885 if( !pAnchor )
886 {
887 pChkIdx = &rRg.GetPoint()->nNode;
888 }
889 else if( bIsAtCntnt )
890 {
891 pChkIdx = pAnchor->GetCntntAnchor()
892 ? &pAnchor->GetCntntAnchor()->nNode
893 : &rRg.GetPoint()->nNode;
894 }
895
896 // Allow drawing objects in header/footer, but control objects aren't
897 // allowed in header/footer.
898 if( pChkIdx &&
899 ::CheckControlLayer( &rDrawObj ) &&
900 IsInHeaderFooter( *pChkIdx ) )
901 {
902 pFmt->SetFmtAttr( SwFmtAnchor( eAnchorId = FLY_AT_PAGE ) );
903 }
904 else if( !pAnchor || (bIsAtCntnt && !pAnchor->GetCntntAnchor() ))
905 {
906 // then set it, we need this in the Undo
907 SwFmtAnchor aAnch( pAnchor ? *pAnchor : pFmt->GetAnchor() );
908 eAnchorId = aAnch.GetAnchorId();
909 if( FLY_AT_FLY == eAnchorId )
910 {
911 SwPosition aPos( *rRg.GetNode()->FindFlyStartNode() );
912 aAnch.SetAnchor( &aPos );
913 }
914 else
915 {
916 aAnch.SetAnchor( rRg.GetPoint() );
917 if ( FLY_AT_PAGE == eAnchorId )
918 {
919 eAnchorId = rDrawObj.ISA( SdrUnoObj )
920 ? FLY_AS_CHAR : FLY_AT_PARA;
921 aAnch.SetType( eAnchorId );
922 }
923 }
924 pFmt->SetFmtAttr( aAnch );
925 }
926
927 // For Draws anchored as character we set the attribute in the paragraph
928 if ( FLY_AS_CHAR == eAnchorId )
929 {
930 xub_StrLen nStt = rRg.GetPoint()->nContent.GetIndex();
931 SwFmtFlyCnt aFmt( pFmt );
932 bool const bSuccess( // may fail if there's no space left
933 rRg.GetPoint()->nNode.GetNode().GetTxtNode()->InsertItem(
934 aFmt, nStt, nStt));
935 if (!bSuccess)
936 { // pFmt is dead now
937 return 0;
938 }
939 }
940
941 SwDrawContact* pContact = new SwDrawContact( pFmt, &rDrawObj );
942
943 // Create Frames if necessary
944 if( GetCurrentViewShell() )
945 {
946 pFmt->MakeFrms();
947 // #i42319# - follow-up of #i35635#
948 // move object to visible layer
949 // #i79391#
950 if ( pContact->GetAnchorFrm() )
951 {
952 pContact->MoveObjToVisibleLayer( &rDrawObj );
953 }
954 }
955
956 if (GetIDocumentUndoRedo().DoesUndo())
957 {
958 GetIDocumentUndoRedo().AppendUndo( new SwUndoInsLayFmt(pFmt, 0, 0) );
959 }
960
961 SetModified();
962 return pFmt;
963 }
964
965 /* ---------------------------------------------------------------------------
966 paragraph frames - o.k. if the PaM includes the paragraph from the beginning
967 to the beginning of the next paragraph at least
968 frames at character - o.k. if the PaM starts at least at the same position
969 as the frame
970 ---------------------------------------------------------------------------*/
971 static bool lcl_TstFlyRange( const SwPaM* pPam, const SwPosition* pFlyPos,
972 RndStdIds nAnchorId )
973 {
974 bool bOk = false;
975 const SwPaM* pTmp = pPam;
976 do {
977 const sal_uInt32 nFlyIndex = pFlyPos->nNode.GetIndex();
978 const SwPosition* pPaMStart = pTmp->Start();
979 const SwPosition* pPaMEnd = pTmp->End();
980 const sal_uInt32 nPamStartIndex = pPaMStart->nNode.GetIndex();
981 const sal_uInt32 nPamEndIndex = pPaMEnd->nNode.GetIndex();
982 if (FLY_AT_PARA == nAnchorId)
983 bOk = (nPamStartIndex < nFlyIndex && nPamEndIndex > nFlyIndex) ||
984 (((nPamStartIndex == nFlyIndex) && (pPaMStart->nContent.GetIndex() == 0)) &&
985 (nPamEndIndex > nFlyIndex));
986 else
987 {
988 xub_StrLen nFlyContentIndex = pFlyPos->nContent.GetIndex();
989 xub_StrLen nPamEndContentIndex = pPaMEnd->nContent.GetIndex();
990 bOk = (nPamStartIndex < nFlyIndex &&
991 (( nPamEndIndex > nFlyIndex )||
992 ((nPamEndIndex == nFlyIndex) &&
993 (nPamEndContentIndex > nFlyContentIndex))) )
994 ||
995 (((nPamStartIndex == nFlyIndex) &&
996 (pPaMStart->nContent.GetIndex() <= nFlyContentIndex)) &&
997 ((nPamEndIndex > nFlyIndex) ||
998 (nPamEndContentIndex > nFlyContentIndex )));
999 }
1000
1001 } while( !bOk && pPam != ( pTmp = (const SwPaM*)pTmp->GetNext() ));
1002 return bOk;
1003 }
1004
1005 SwPosFlyFrms SwDoc::GetAllFlyFmts( const SwPaM* pCmpRange, bool bDrawAlso,
1006 bool bAsCharAlso ) const
1007 {
1008 SwPosFlyFrms aRetval;
1009 SwFrmFmt *pFly;
1010
1011 // collect all anchored somehow to paragraphs
1012 for( sal_uInt16 n = 0; n < GetSpzFrmFmts()->size(); ++n )
1013 {
1014 pFly = (*GetSpzFrmFmts())[ n ];
1015 bool bDrawFmt = bDrawAlso ? RES_DRAWFRMFMT == pFly->Which() : false;
1016 bool bFlyFmt = RES_FLYFRMFMT == pFly->Which();
1017 if( bFlyFmt || bDrawFmt )
1018 {
1019 const SwFmtAnchor& rAnchor = pFly->GetAnchor();
1020 SwPosition const*const pAPos = rAnchor.GetCntntAnchor();
1021 if (pAPos &&
1022 ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
1023 (FLY_AT_FLY == rAnchor.GetAnchorId()) ||
1024 (FLY_AT_CHAR == rAnchor.GetAnchorId()) ||
1025 ((FLY_AS_CHAR == rAnchor.GetAnchorId()) && bAsCharAlso)))
1026 {
1027 if( pCmpRange &&
1028 !lcl_TstFlyRange( pCmpRange, pAPos, rAnchor.GetAnchorId() ))
1029 continue; // not a valid FlyFrame
1030 aRetval.insert(SwPosFlyFrmPtr(new SwPosFlyFrm(pAPos->nNode, pFly, aRetval.size())));
1031 }
1032 }
1033 }
1034
1035 // If we don't have a layout we can't get page anchored FlyFrames.
1036 // Also, page anchored FlyFrames are only returned if no range is specified.
1037 if( !GetCurrentViewShell() || pCmpRange ) //swmod 071108//swmod 071225
1038 {
1039 return aRetval;
1040 }
1041
1042 SwPageFrm *pPage = (SwPageFrm*)GetCurrentLayout()->GetLower(); //swmod 080218
1043 while( pPage )
1044 {
1045 if( pPage->GetSortedObjs() )
1046 {
1047 SwSortedObjs &rObjs = *pPage->GetSortedObjs();
1048 for( sal_uInt16 i = 0; i < rObjs.Count(); ++i)
1049 {
1050 SwAnchoredObject* pAnchoredObj = rObjs[i];
1051 if ( pAnchoredObj->ISA(SwFlyFrm) )
1052 pFly = &(pAnchoredObj->GetFrmFmt());
1053 else if ( bDrawAlso )
1054 pFly = &(pAnchoredObj->GetFrmFmt());
1055 else
1056 continue;
1057
1058 const SwFmtAnchor& rAnchor = pFly->GetAnchor();
1059 if ((FLY_AT_PARA != rAnchor.GetAnchorId()) &&
1060 (FLY_AT_FLY != rAnchor.GetAnchorId()) &&
1061 (FLY_AT_CHAR != rAnchor.GetAnchorId()))
1062 {
1063 const SwCntntFrm * pCntntFrm = pPage->FindFirstBodyCntnt();
1064 if ( !pCntntFrm )
1065 {
1066 // Oops! An empty page.
1067 // In order not to loose the whole frame (RTF) we
1068 // look for the last Cntnt before the page.
1069 SwPageFrm *pPrv = (SwPageFrm*)pPage->GetPrev();
1070 while ( !pCntntFrm && pPrv )
1071 {
1072 pCntntFrm = pPrv->FindFirstBodyCntnt();
1073 pPrv = (SwPageFrm*)pPrv->GetPrev();
1074 }
1075 }
1076 if ( pCntntFrm )
1077 {
1078 SwNodeIndex aIdx( *pCntntFrm->GetNode() );
1079 aRetval.insert(SwPosFlyFrmPtr(new SwPosFlyFrm(aIdx, pFly, aRetval.size())));
1080 }
1081 }
1082 }
1083 }
1084 pPage = (SwPageFrm*)pPage->GetNext();
1085 }
1086
1087 return aRetval;
1088 }
1089
1090 /* #i6447# changed behaviour if lcl_CpyAttr:
1091
1092 If the old item set contains the item to set (no inheritance) copy the item
1093 into the new set.
1094
1095 If the old item set contains the item by inheritance and the new set
1096 contains the item, too:
1097 If the two items differ copy the item from the old set to the new set.
1098
1099 Otherwise the new set will not be changed.
1100 */
1101 static void lcl_CpyAttr( SfxItemSet &rNewSet, const SfxItemSet &rOldSet, sal_uInt16 nWhich )
1102 {
1103 const SfxPoolItem *pOldItem = NULL, *pNewItem = NULL;
1104
1105 rOldSet.GetItemState( nWhich, sal_False, &pOldItem);
1106 if (pOldItem != NULL)
1107 rNewSet.Put( *pOldItem );
1108 else
1109 {
1110 pOldItem = rOldSet.GetItem( nWhich, sal_True);
1111 if (pOldItem != NULL)
1112 {
1113 pNewItem = rNewSet.GetItem( nWhich, sal_True);
1114 if (pNewItem != NULL)
1115 {
1116 if (*pOldItem != *pNewItem)
1117 rNewSet.Put( *pOldItem );
1118 }
1119 else {
1120 OSL_FAIL("What am I doing here?");
1121 }
1122 }
1123 else {
1124 OSL_FAIL("What am I doing here?");
1125 }
1126 }
1127
1128 }
1129
1130 static SwFlyFrmFmt *
1131 lcl_InsertLabel(SwDoc & rDoc, SwTxtFmtColls *const pTxtFmtCollTbl,
1132 SwUndoInsertLabel *const pUndo,
1133 SwLabelType const eType, String const& rTxt, String const& rSeparator,
1134 const String& rNumberingSeparator,
1135 const sal_Bool bBefore, const sal_uInt16 nId, const sal_uLong nNdIdx,
1136 const String& rCharacterStyle,
1137 const sal_Bool bCpyBrd )
1138 {
1139 ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
1140
1141 bool bTable = false; // To save some code.
1142
1143 // Get the field first, beause we retrieve the TxtColl via the field's name
1144 OSL_ENSURE( nId == USHRT_MAX || nId < rDoc.GetFldTypes()->size(),
1145 "FldType index out of bounds." );
1146 SwFieldType *pType = (nId != USHRT_MAX) ? (*rDoc.GetFldTypes())[nId] : NULL;
1147 OSL_ENSURE(!pType || pType->Which() == RES_SETEXPFLD, "wrong Id for Label");
1148
1149 SwTxtFmtColl * pColl = NULL;
1150 if( pType )
1151 {
1152 for( sal_uInt16 i = pTxtFmtCollTbl->size(); i; )
1153 {
1154 if( (*pTxtFmtCollTbl)[ --i ]->GetName().Equals(pType->GetName()) )
1155 {
1156 pColl = (*pTxtFmtCollTbl)[i];
1157 break;
1158 }
1159 }
1160 OSL_ENSURE( pColl, "no text collection found" );
1161 }
1162
1163 if( !pColl )
1164 {
1165 pColl = rDoc.GetTxtCollFromPool( RES_POOLCOLL_LABEL );
1166 }
1167
1168 SwTxtNode *pNew = NULL;
1169 SwFlyFrmFmt* pNewFmt = NULL;
1170
1171 switch ( eType )
1172 {
1173 case LTYPE_TABLE:
1174 bTable = true;
1175 // no break here
1176 case LTYPE_FLY:
1177 // At the FlySection's Beginning/End insert the corresponding Node with it's Field.
1178 // The Frame is created automatically.
1179 {
1180 SwStartNode *pSttNd = rDoc.GetNodes()[nNdIdx]->GetStartNode();
1181 OSL_ENSURE( pSttNd, "No StartNode in InsertLabel." );
1182 sal_uLong nNode;
1183 if( bBefore )
1184 {
1185 nNode = pSttNd->GetIndex();
1186 if( !bTable )
1187 ++nNode;
1188 }
1189 else
1190 {
1191 nNode = pSttNd->EndOfSectionIndex();
1192 if( bTable )
1193 ++nNode;
1194 }
1195
1196 if( pUndo )
1197 pUndo->SetNodePos( nNode );
1198
1199 // Create Node for labeling paragraph.
1200 SwNodeIndex aIdx( rDoc.GetNodes(), nNode );
1201 pNew = rDoc.GetNodes().MakeTxtNode( aIdx, pColl );
1202 }
1203 break;
1204
1205 case LTYPE_OBJECT:
1206 {
1207 // Destroy Frame,
1208 // insert new Frame,
1209 // insert the corresponding Node with Field into the new Frame,
1210 // insert the old Frame with the Object (Picture/OLE) paragraph-bound into the new Frame,
1211 // create Frames.
1212
1213 // Get the FlyFrame's Format and decouple the Layout.
1214 SwFrmFmt *pOldFmt = rDoc.GetNodes()[nNdIdx]->GetFlyFmt();
1215 OSL_ENSURE( pOldFmt, "Couldn't find the Fly's Format." );
1216 // #i115719#
1217 // <title> and <description> attributes are lost when calling <DelFrms()>.
1218 // Thus, keep them and restore them after the calling <MakeFrms()>
1219 const bool bIsSwFlyFrmFmtInstance( dynamic_cast<SwFlyFrmFmt*>(pOldFmt) != 0 );
1220 const String sTitle( bIsSwFlyFrmFmtInstance
1221 ? static_cast<SwFlyFrmFmt*>(pOldFmt)->GetObjTitle()
1222 : String() );
1223 const String sDescription( bIsSwFlyFrmFmtInstance
1224 ? static_cast<SwFlyFrmFmt*>(pOldFmt)->GetObjDescription()
1225 : String() );
1226 pOldFmt->DelFrms();
1227
1228 pNewFmt = rDoc.MakeFlyFrmFmt( rDoc.GetUniqueFrameName(),
1229 rDoc.GetFrmFmtFromPool(RES_POOLFRM_FRAME) );
1230
1231 /* #i6447#: Only the selected items are copied from the old
1232 format. */
1233 SfxItemSet* pNewSet = pNewFmt->GetAttrSet().Clone( sal_True );
1234
1235
1236 // Copy only the set attributes.
1237 // The others should apply from the Templates.
1238 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_PRINT );
1239 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_OPAQUE );
1240 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_PROTECT );
1241 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_SURROUND );
1242 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_VERT_ORIENT );
1243 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_HORI_ORIENT );
1244 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_LR_SPACE );
1245 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_UL_SPACE );
1246 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_BACKGROUND );
1247 if( bCpyBrd )
1248 {
1249 // If there's no BoxItem at graphic, but the new Format has one, then set the
1250 // default item in the new Set. Because the graphic's size has never changed!
1251 const SfxPoolItem *pItem;
1252 if( SFX_ITEM_SET == pOldFmt->GetAttrSet().
1253 GetItemState( RES_BOX, sal_True, &pItem ))
1254 pNewSet->Put( *pItem );
1255 else if( SFX_ITEM_SET == pNewFmt->GetAttrSet().
1256 GetItemState( RES_BOX, sal_True ))
1257 pNewSet->Put( *GetDfltAttr( RES_BOX ) );
1258
1259 if( SFX_ITEM_SET == pOldFmt->GetAttrSet().
1260 GetItemState( RES_SHADOW, sal_True, &pItem ))
1261 pNewSet->Put( *pItem );
1262 else if( SFX_ITEM_SET == pNewFmt->GetAttrSet().
1263 GetItemState( RES_SHADOW, sal_True ))
1264 pNewSet->Put( *GetDfltAttr( RES_SHADOW ) );
1265 }
1266 else
1267 {
1268 // Hard-set the attributes, because they could come from the Template
1269 // and then size calculations could not be correct anymore.
1270 pNewSet->Put( SvxBoxItem(RES_BOX) );
1271 pNewSet->Put( SvxShadowItem(RES_SHADOW) );
1272
1273 }
1274
1275 // Always transfer the anchor, which is a hard attribute anyways.
1276 pNewSet->Put( pOldFmt->GetAnchor() );
1277
1278 // The new one should be changeable in it's height.
1279 SwFmtFrmSize aFrmSize( pOldFmt->GetFrmSize() );
1280 aFrmSize.SetHeightSizeType( ATT_MIN_SIZE );
1281 pNewSet->Put( aFrmSize );
1282
1283 SwStartNode* pSttNd = rDoc.GetNodes().MakeTextSection(
1284 SwNodeIndex( rDoc.GetNodes().GetEndOfAutotext() ),
1285 SwFlyStartNode, pColl );
1286 pNewSet->Put( SwFmtCntnt( pSttNd ));
1287
1288 pNewFmt->SetFmtAttr( *pNewSet );
1289
1290 // InCntnts need to be treated in a special way:
1291 // The TxtAttribute needs to be destroyed.
1292 // Unfortunately, this also destroys the Format next to the Frames.
1293 // To avoid this, we disconnect the attribute from the Format.
1294
1295 const SwFmtAnchor& rAnchor = pNewFmt->GetAnchor();
1296 if ( FLY_AS_CHAR == rAnchor.GetAnchorId() )
1297 {
1298 const SwPosition *pPos = rAnchor.GetCntntAnchor();
1299 SwTxtNode *pTxtNode = pPos->nNode.GetNode().GetTxtNode();
1300 OSL_ENSURE( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
1301 const xub_StrLen nIdx = pPos->nContent.GetIndex();
1302 SwTxtAttr * const pHnt =
1303 pTxtNode->GetTxtAttrForCharAt(nIdx, RES_TXTATR_FLYCNT);
1304
1305 OSL_ENSURE( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
1306 "Missing FlyInCnt-Hint." );
1307 OSL_ENSURE( pHnt && pHnt->GetFlyCnt().GetFrmFmt() == pOldFmt,
1308 "Wrong TxtFlyCnt-Hint." );
1309
1310 const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt()).SetFlyFmt(
1311 pNewFmt );
1312 }
1313
1314
1315 // The old one should not have a flow and it should be adjusted to above and
1316 // middle.
1317 // Also, the width should be 100% and it should also adjust the hight, if changed.
1318 pNewSet->ClearItem();
1319
1320 pNewSet->Put( SwFmtSurround( SURROUND_NONE ) );
1321 pNewSet->Put( SvxOpaqueItem( RES_OPAQUE, sal_True ) );
1322
1323 sal_Int16 eVert = bBefore ? text::VertOrientation::BOTTOM : text::VertOrientation::TOP;
1324 pNewSet->Put( SwFmtVertOrient( 0, eVert ) );
1325 pNewSet->Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER ) );
1326
1327 aFrmSize = pOldFmt->GetFrmSize();
1328 aFrmSize.SetWidthPercent( 100 );
1329 aFrmSize.SetHeightPercent( 255 );
1330 pNewSet->Put( aFrmSize );
1331
1332 // Hard-set the attributes, because they could come from the Template
1333 // and then size calculations could not be correct anymore.
1334 if( bCpyBrd )
1335 {
1336 pNewSet->Put( SvxBoxItem(RES_BOX) );
1337 pNewSet->Put( SvxShadowItem(RES_SHADOW) );
1338 }
1339 pNewSet->Put( SvxLRSpaceItem(RES_LR_SPACE) );
1340 pNewSet->Put( SvxULSpaceItem(RES_UL_SPACE) );
1341
1342 // The old one is paragraph-bound to the paragraph in the new one.
1343 SwFmtAnchor aAnch( FLY_AT_PARA );
1344 SwNodeIndex aAnchIdx( *pNewFmt->GetCntnt().GetCntntIdx(), 1 );
1345 pNew = aAnchIdx.GetNode().GetTxtNode();
1346 SwPosition aPos( aAnchIdx );
1347 aAnch.SetAnchor( &aPos );
1348 pNewSet->Put( aAnch );
1349
1350 if( pUndo )
1351 pUndo->SetFlys( *pOldFmt, *pNewSet, *pNewFmt );
1352 else
1353 pOldFmt->SetFmtAttr( *pNewSet );
1354
1355 delete pNewSet;
1356
1357 // Have only the FlyFrames created.
1358 // We leave this to established methods (especially for InCntFlys).
1359 pNewFmt->MakeFrms();
1360 // #i115719#
1361 if ( bIsSwFlyFrmFmtInstance )
1362 {
1363 static_cast<SwFlyFrmFmt*>(pOldFmt)->SetObjTitle( sTitle );
1364 static_cast<SwFlyFrmFmt*>(pOldFmt)->SetObjDescription( sDescription );
1365 }
1366 }
1367 break;
1368
1369 default:
1370 OSL_ENSURE(false, "unknown LabelType?");
1371 }
1372 OSL_ENSURE( pNew, "No Label inserted" );
1373 if( pNew )
1374 {
1375 // #i61007# order of captions
1376 sal_Bool bOrderNumberingFirst = SW_MOD()->GetModuleConfig()->IsCaptionOrderNumberingFirst();
1377 // Work up string
1378 String aTxt;
1379 if( bOrderNumberingFirst )
1380 {
1381 aTxt = rNumberingSeparator;
1382 }
1383 if( pType)
1384 {
1385 aTxt += pType->GetName();
1386 if( !bOrderNumberingFirst )
1387 aTxt += ' ';
1388 }
1389 xub_StrLen nIdx = aTxt.Len();
1390 if( rTxt.Len() > 0 )
1391 {
1392 aTxt += rSeparator;
1393 }
1394 xub_StrLen nSepIdx = aTxt.Len();
1395 aTxt += rTxt;
1396
1397 // Insert string
1398 SwIndex aIdx( pNew, 0 );
1399 pNew->InsertText( aTxt, aIdx );
1400
1401 // Insert field
1402 if(pType)
1403 {
1404 SwSetExpField aFld( (SwSetExpFieldType*)pType, aEmptyStr, SVX_NUM_ARABIC);
1405 if( bOrderNumberingFirst )
1406 nIdx = 0;
1407 SwFmtFld aFmt( aFld );
1408 pNew->InsertItem( aFmt, nIdx, nIdx );
1409 if(rCharacterStyle.Len())
1410 {
1411 SwCharFmt* pCharFmt = rDoc.FindCharFmtByName(rCharacterStyle);
1412 if( !pCharFmt )
1413 {
1414 const sal_uInt16 nMyId = SwStyleNameMapper::GetPoolIdFromUIName(rCharacterStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT);
1415 pCharFmt = rDoc.GetCharFmtFromPool( nMyId );
1416 }
1417 if (pCharFmt)
1418 {
1419 SwFmtCharFmt aCharFmt( pCharFmt );
1420 pNew->InsertItem( aCharFmt, 0,
1421 nSepIdx + 1, nsSetAttrMode::SETATTR_DONTEXPAND );
1422 }
1423 }
1424 }
1425
1426 if ( bTable )
1427 {
1428 if ( bBefore )
1429 {
1430 if ( !pNew->GetSwAttrSet().GetKeep().GetValue() )
1431 pNew->SetAttr( SvxFmtKeepItem( sal_True, RES_KEEP ) );
1432 }
1433 else
1434 {
1435 SwTableNode *const pNd =
1436 rDoc.GetNodes()[nNdIdx]->GetStartNode()->GetTableNode();
1437 SwTable &rTbl = pNd->GetTable();
1438 if ( !rTbl.GetFrmFmt()->GetKeep().GetValue() )
1439 rTbl.GetFrmFmt()->SetFmtAttr( SvxFmtKeepItem( sal_True, RES_KEEP ) );
1440 if ( pUndo )
1441 pUndo->SetUndoKeep();
1442 }
1443 }
1444 rDoc.SetModified();
1445 }
1446
1447 return pNewFmt;
1448 }
1449
1450 SwFlyFrmFmt *
1451 SwDoc::InsertLabel(
1452 SwLabelType const eType, String const& rTxt, String const& rSeparator,
1453 String const& rNumberingSeparator,
1454 sal_Bool const bBefore, sal_uInt16 const nId, sal_uLong const nNdIdx,
1455 String const& rCharacterStyle,
1456 sal_Bool const bCpyBrd )
1457 {
1458 SwUndoInsertLabel * pUndo(0);
1459 if (GetIDocumentUndoRedo().DoesUndo())
1460 {
1461 pUndo = new SwUndoInsertLabel(
1462 eType, rTxt, rSeparator, rNumberingSeparator,
1463 bBefore, nId, rCharacterStyle, bCpyBrd );
1464 }
1465
1466 SwFlyFrmFmt *const pNewFmt = lcl_InsertLabel(*this, mpTxtFmtCollTbl, pUndo,
1467 eType, rTxt, rSeparator, rNumberingSeparator, bBefore,
1468 nId, nNdIdx, rCharacterStyle, bCpyBrd);
1469
1470 if (pUndo)
1471 {
1472 GetIDocumentUndoRedo().AppendUndo(pUndo);
1473 }
1474 else
1475 {
1476 GetIDocumentUndoRedo().DelAllUndoObj();
1477 }
1478
1479 return pNewFmt;
1480 }
1481
1482 static SwFlyFrmFmt *
1483 lcl_InsertDrawLabel( SwDoc & rDoc, SwTxtFmtColls *const pTxtFmtCollTbl,
1484 SwUndoInsertLabel *const pUndo, SwDrawFrmFmt *const pOldFmt,
1485 String const& rTxt,
1486 const String& rSeparator,
1487 const String& rNumberSeparator,
1488 const sal_uInt16 nId,
1489 const String& rCharacterStyle,
1490 SdrObject& rSdrObj )
1491 {
1492 ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
1493 ::sw::DrawUndoGuard const drawUndoGuard(rDoc.GetIDocumentUndoRedo());
1494
1495 // Because we get by the TxtColl's name, we need to create the field first.
1496 OSL_ENSURE( nId == USHRT_MAX || nId < rDoc.GetFldTypes()->size(),
1497 "FldType index out of bounds" );
1498 SwFieldType *pType = nId != USHRT_MAX ? (*rDoc.GetFldTypes())[nId] : 0;
1499 OSL_ENSURE( !pType || pType->Which() == RES_SETEXPFLD, "Wrong label id" );
1500
1501 SwTxtFmtColl *pColl = NULL;
1502 if( pType )
1503 {
1504 for( sal_uInt16 i = pTxtFmtCollTbl->size(); i; )
1505 {
1506 if( (*pTxtFmtCollTbl)[ --i ]->GetName().Equals(pType->GetName()) )
1507 {
1508 pColl = (*pTxtFmtCollTbl)[i];
1509 break;
1510 }
1511 }
1512 OSL_ENSURE( pColl, "no text collection found" );
1513 }
1514
1515 if( !pColl )
1516 {
1517 pColl = rDoc.GetTxtCollFromPool( RES_POOLCOLL_LABEL );
1518 }
1519
1520 SwTxtNode* pNew = NULL;
1521 SwFlyFrmFmt* pNewFmt = NULL;
1522
1523 // Destroy Frame,
1524 // insert new Frame,
1525 // insert the corresponding Node with Field into the new Frame,
1526 // insert the old Frame with the Object (Picture/OLE) paragraph-bound into the new Frame,
1527 // create Frames.
1528
1529 // Keep layer ID of drawing object before removing
1530 // its frames.
1531 // Note: The layer ID is passed to the undo and have to be the correct value.
1532 // Removing the frames of the drawing object changes its layer.
1533 const SdrLayerID nLayerId = rSdrObj.GetLayer();
1534
1535 pOldFmt->DelFrms();
1536
1537 // InCntnts need to be treated in a special way:
1538 // The TxtAttribute needs to be destroyed.
1539 // Unfortunately, this also destroys the Format next to the Frames.
1540 // To avoid this, we disconnect the attribute from the Format.
1541 SfxItemSet* pNewSet = pOldFmt->GetAttrSet().Clone( sal_False );
1542
1543 // Protect the Frame's size and position
1544 if ( rSdrObj.IsMoveProtect() || rSdrObj.IsResizeProtect() )
1545 {
1546 SvxProtectItem aProtect(RES_PROTECT);
1547 aProtect.SetCntntProtect( sal_False );
1548 aProtect.SetPosProtect( rSdrObj.IsMoveProtect() );
1549 aProtect.SetSizeProtect( rSdrObj.IsResizeProtect() );
1550 pNewSet->Put( aProtect );
1551 }
1552
1553 // Take over the text wrap
1554 lcl_CpyAttr( *pNewSet, pOldFmt->GetAttrSet(), RES_SURROUND );
1555
1556 // Send the frame to the back, if needed.
1557 // Consider the 'invisible' hell layer.
1558 if ( rDoc.GetHellId() != nLayerId &&
1559 rDoc.GetInvisibleHellId() != nLayerId )
1560 {
1561 SvxOpaqueItem aOpaque( RES_OPAQUE );
1562 aOpaque.SetValue( sal_True );
1563 pNewSet->Put( aOpaque );
1564 }
1565
1566 // Take over position
1567 // #i26791# - use directly drawing object's positioning attributes
1568 pNewSet->Put( pOldFmt->GetHoriOrient() );
1569 pNewSet->Put( pOldFmt->GetVertOrient() );
1570
1571 pNewSet->Put( pOldFmt->GetAnchor() );
1572
1573 // The new one should be variable in it's height!
1574 Size aSz( rSdrObj.GetCurrentBoundRect().GetSize() );
1575 SwFmtFrmSize aFrmSize( ATT_MIN_SIZE, aSz.Width(), aSz.Height() );
1576 pNewSet->Put( aFrmSize );
1577
1578 // Apply the margin to the new Frame.
1579 // Don't set a border, use the one from the Template.
1580 pNewSet->Put( pOldFmt->GetLRSpace() );
1581 pNewSet->Put( pOldFmt->GetULSpace() );
1582
1583 SwStartNode* pSttNd =
1584 rDoc.GetNodes().MakeTextSection(
1585 SwNodeIndex( rDoc.GetNodes().GetEndOfAutotext() ),
1586 SwFlyStartNode, pColl );
1587
1588 pNewFmt = rDoc.MakeFlyFrmFmt( rDoc.GetUniqueFrameName(),
1589 rDoc.GetFrmFmtFromPool( RES_POOLFRM_FRAME ) );
1590
1591 // Set border and shadow to default if the template contains any.
1592 if( SFX_ITEM_SET == pNewFmt->GetAttrSet().GetItemState( RES_BOX, sal_True ))
1593 pNewSet->Put( *GetDfltAttr( RES_BOX ) );
1594
1595 if( SFX_ITEM_SET == pNewFmt->GetAttrSet().GetItemState(RES_SHADOW,sal_True))
1596 pNewSet->Put( *GetDfltAttr( RES_SHADOW ) );
1597
1598 pNewFmt->SetFmtAttr( SwFmtCntnt( pSttNd ));
1599 pNewFmt->SetFmtAttr( *pNewSet );
1600
1601 const SwFmtAnchor& rAnchor = pNewFmt->GetAnchor();
1602 if ( FLY_AS_CHAR == rAnchor.GetAnchorId() )
1603 {
1604 const SwPosition *pPos = rAnchor.GetCntntAnchor();
1605 SwTxtNode *pTxtNode = pPos->nNode.GetNode().GetTxtNode();
1606 OSL_ENSURE( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
1607 const xub_StrLen nIdx = pPos->nContent.GetIndex();
1608 SwTxtAttr * const pHnt =
1609 pTxtNode->GetTxtAttrForCharAt( nIdx, RES_TXTATR_FLYCNT );
1610
1611 #if OSL_DEBUG_LEVEL > 0
1612 OSL_ENSURE( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
1613 "Missing FlyInCnt-Hint." );
1614 OSL_ENSURE( pHnt && ((SwFmtFlyCnt&)pHnt->GetFlyCnt()).
1615 GetFrmFmt() == (SwFrmFmt*)pOldFmt,
1616 "Wrong TxtFlyCnt-Hint." );
1617 #endif
1618 const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt()).SetFlyFmt( pNewFmt );
1619 }
1620
1621
1622 // The old one should not have a flow
1623 // and it should be adjusted to above and middle.
1624 pNewSet->ClearItem();
1625
1626 pNewSet->Put( SwFmtSurround( SURROUND_NONE ) );
1627 if (nLayerId == rDoc.GetHellId())
1628 {
1629 // Consider drawing objects in the 'invisible' hell layer
1630 rSdrObj.SetLayer( rDoc.GetHeavenId() );
1631 }
1632 else if (nLayerId == rDoc.GetInvisibleHellId())
1633 {
1634 rSdrObj.SetLayer( rDoc.GetInvisibleHeavenId() );
1635 }
1636 pNewSet->Put( SvxLRSpaceItem( RES_LR_SPACE ) );
1637 pNewSet->Put( SvxULSpaceItem( RES_UL_SPACE ) );
1638
1639 // #i26791# - set position of the drawing object, which is labeled.
1640 pNewSet->Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ) );
1641 pNewSet->Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ) );
1642
1643 // The old one is paragraph-bound to the new one's paragraph.
1644 SwFmtAnchor aAnch( FLY_AT_PARA );
1645 SwNodeIndex aAnchIdx( *pNewFmt->GetCntnt().GetCntntIdx(), 1 );
1646 pNew = aAnchIdx.GetNode().GetTxtNode();
1647 SwPosition aPos( aAnchIdx );
1648 aAnch.SetAnchor( &aPos );
1649 pNewSet->Put( aAnch );
1650
1651 if( pUndo )
1652 {
1653 pUndo->SetFlys( *pOldFmt, *pNewSet, *pNewFmt );
1654 // #i26791# - position no longer needed
1655 pUndo->SetDrawObj( nLayerId );
1656 }
1657 else
1658 pOldFmt->SetFmtAttr( *pNewSet );
1659
1660 delete pNewSet;
1661
1662 // Have only the FlyFrames created.
1663 // We leave this to established methods (especially for InCntFlys).
1664 pNewFmt->MakeFrms();
1665
1666 OSL_ENSURE( pNew, "No Label inserted" );
1667
1668 if( pNew )
1669 {
1670 //#i61007# order of captions
1671 sal_Bool bOrderNumberingFirst = SW_MOD()->GetModuleConfig()->IsCaptionOrderNumberingFirst();
1672
1673 // prepare string
1674 String aTxt;
1675 if( bOrderNumberingFirst )
1676 {
1677 aTxt = rNumberSeparator;
1678 }
1679 if ( pType )
1680 {
1681 aTxt += pType->GetName();
1682 if( !bOrderNumberingFirst )
1683 aTxt += ' ';
1684 }
1685 xub_StrLen nIdx = aTxt.Len();
1686 aTxt += rSeparator;
1687 xub_StrLen nSepIdx = aTxt.Len();
1688 aTxt += rTxt;
1689
1690 // insert text
1691 SwIndex aIdx( pNew, 0 );
1692 pNew->InsertText( aTxt, aIdx );
1693
1694 // insert field
1695 if ( pType )
1696 {
1697 SwSetExpField aFld( (SwSetExpFieldType*)pType, aEmptyStr, SVX_NUM_ARABIC );
1698 if( bOrderNumberingFirst )
1699 nIdx = 0;
1700 SwFmtFld aFmt( aFld );
1701 pNew->InsertItem( aFmt, nIdx, nIdx );
1702 if ( rCharacterStyle.Len() )
1703 {
1704 SwCharFmt * pCharFmt = rDoc.FindCharFmtByName(rCharacterStyle);
1705 if ( !pCharFmt )
1706 {
1707 const sal_uInt16 nMyId = SwStyleNameMapper::GetPoolIdFromUIName( rCharacterStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
1708 pCharFmt = rDoc.GetCharFmtFromPool( nMyId );
1709 }
1710 if ( pCharFmt )
1711 {
1712 SwFmtCharFmt aCharFmt( pCharFmt );
1713 pNew->InsertItem( aCharFmt, 0, nSepIdx + 1,
1714 nsSetAttrMode::SETATTR_DONTEXPAND );
1715 }
1716 }
1717 }
1718 }
1719
1720 return pNewFmt;
1721 }
1722
1723 SwFlyFrmFmt* SwDoc::InsertDrawLabel(
1724 String const& rTxt,
1725 String const& rSeparator,
1726 String const& rNumberSeparator,
1727 sal_uInt16 const nId,
1728 String const& rCharacterStyle,
1729 SdrObject& rSdrObj )
1730 {
1731 SwDrawContact *const pContact =
1732 static_cast<SwDrawContact*>(GetUserCall( &rSdrObj ));
1733 OSL_ENSURE( RES_DRAWFRMFMT == pContact->GetFmt()->Which(),
1734 "InsertDrawLabel(): not a DrawFrmFmt" );
1735 if (!pContact)
1736 return 0;
1737
1738 SwDrawFrmFmt* pOldFmt = (SwDrawFrmFmt *)pContact->GetFmt();
1739 if (!pOldFmt)
1740 return 0;
1741
1742 SwUndoInsertLabel * pUndo = 0;
1743 if (GetIDocumentUndoRedo().DoesUndo())
1744 {
1745 GetIDocumentUndoRedo().ClearRedo();
1746 pUndo = new SwUndoInsertLabel(
1747 LTYPE_DRAW, rTxt, rSeparator, rNumberSeparator, sal_False,
1748 nId, rCharacterStyle, sal_False );
1749 }
1750
1751 SwFlyFrmFmt *const pNewFmt = lcl_InsertDrawLabel(
1752 *this, mpTxtFmtCollTbl, pUndo, pOldFmt,
1753 rTxt, rSeparator, rNumberSeparator, nId, rCharacterStyle, rSdrObj);
1754
1755 if (pUndo)
1756 {
1757 GetIDocumentUndoRedo().AppendUndo( pUndo );
1758 }
1759 else
1760 {
1761 GetIDocumentUndoRedo().DelAllUndoObj();
1762 }
1763
1764 return pNewFmt;
1765 }
1766
1767 // IDocumentTimerAccess methods ------------------------------------------
1768
1769 void SwDoc::StartIdling()
1770 {
1771 mbStartIdleTimer = true;
1772 if( !mIdleBlockCount )
1773 maIdleTimer.Start();
1774 }
1775
1776 void SwDoc::StopIdling()
1777 {
1778 mbStartIdleTimer = false;
1779 maIdleTimer.Stop();
1780 }
1781
1782 void SwDoc::BlockIdling()
1783 {
1784 maIdleTimer.Stop();
1785 ++mIdleBlockCount;
1786 }
1787
1788 void SwDoc::UnblockIdling()
1789 {
1790 --mIdleBlockCount;
1791 if( !mIdleBlockCount && mbStartIdleTimer && !maIdleTimer.IsActive() )
1792 maIdleTimer.Start();
1793 }
1794
1795 void SwDoc::StartBackgroundJobs() {
1796 // Trigger DoIdleJobs(), asynchronously.
1797 maIdleTimer.Start();
1798 }
1799
1800 IMPL_LINK( SwDoc, DoIdleJobs, Timer *, pTimer )
1801 {
1802 #ifdef TIMELOG
1803 static ::rtl::Logfile* pModLogFile = 0;
1804 if( !pModLogFile )
1805 pModLogFile = new ::rtl::Logfile( "First DoIdleJobs" );
1806 #endif
1807
1808 SwRootFrm* pTmpRoot = GetCurrentLayout();//swmod 080219
1809 if( pTmpRoot &&
1810 !SfxProgress::GetActiveProgress( mpDocShell ) )
1811 {
1812 ViewShell *pSh, *pStartSh;
1813 pSh = pStartSh = GetCurrentViewShell();
1814 do {
1815 if( pSh->ActionPend() )
1816 {
1817 pTimer->Start();
1818 return 0;
1819 }
1820 pSh = (ViewShell*)pSh->GetNext();
1821 } while( pSh != pStartSh );
1822
1823 if( pTmpRoot->IsNeedGrammarCheck() )
1824 {
1825 sal_Bool bIsOnlineSpell = pSh->GetViewOptions()->IsOnlineSpell();
1826 sal_Bool bIsAutoGrammar = sal_False;
1827 SvtLinguConfig().GetProperty( OUString(
1828 UPN_IS_GRAMMAR_AUTO ) ) >>= bIsAutoGrammar;
1829
1830 if (bIsOnlineSpell && bIsAutoGrammar)
1831 StartGrammarChecking( *this );
1832 }
1833 std::set<SwRootFrm*> aAllLayouts = GetAllLayouts();//swmod 080320
1834 std::set<SwRootFrm*>::iterator pLayIter = aAllLayouts.begin();
1835 for ( ;pLayIter != aAllLayouts.end();++pLayIter )
1836 {
1837 if ((*pLayIter)->IsIdleFormat())
1838 {
1839 (*pLayIter)->GetCurrShell()->LayoutIdle();
1840
1841 // Defer the remaining work.
1842 pTimer->Start();
1843 return 0;
1844 }
1845 }
1846
1847 SwFldUpdateFlags nFldUpdFlag = getFieldUpdateFlags(true);
1848 if( ( AUTOUPD_FIELD_ONLY == nFldUpdFlag
1849 || AUTOUPD_FIELD_AND_CHARTS == nFldUpdFlag ) &&
1850 GetUpdtFlds().IsFieldsDirty()
1851 // If we switch the field name the Fields are not updated.
1852 // So the "backgorund update" should always be carried out
1853 /* && !pStartSh->GetViewOptions()->IsFldName()*/ )
1854 {
1855 if ( GetUpdtFlds().IsInUpdateFlds() ||
1856 IsExpFldsLocked() )
1857 {
1858 pTimer->Start();
1859 return 0;
1860 }
1861
1862 // Action brackets!
1863 GetUpdtFlds().SetInUpdateFlds( true );
1864
1865 pTmpRoot->StartAllAction();
1866
1867 // no jump on update of fields #i85168#
1868 const sal_Bool bOldLockView = pStartSh->IsViewLocked();
1869 pStartSh->LockView( sal_True );
1870
1871 GetSysFldType( RES_CHAPTERFLD )->ModifyNotification( 0, 0 ); // ChapterField
1872 UpdateExpFlds( 0, sal_False ); // Updates ExpressionFields
1873 UpdateTblFlds(NULL); // Tables
1874 UpdateRefFlds(NULL); // References
1875
1876 pTmpRoot->EndAllAction();
1877
1878 pStartSh->LockView( bOldLockView );
1879
1880 GetUpdtFlds().SetInUpdateFlds( false );
1881 GetUpdtFlds().SetFieldsDirty( false );
1882 }
1883 } //swmod 080219
1884 #ifdef TIMELOG
1885 if( pModLogFile && 1 != (long)pModLogFile )
1886 delete pModLogFile, ((long&)pModLogFile) = 1;
1887 #endif
1888 return 0;
1889 }
1890
1891 IMPL_STATIC_LINK( SwDoc, BackgroundDone, SvxBrushItem*, EMPTYARG )
1892 {
1893 ViewShell *pSh, *pStartSh;
1894 pSh = pStartSh = pThis->GetCurrentViewShell(); //swmod 071108//swmod 071225
1895 if( pStartSh )
1896 do {
1897 if( pSh->GetWin() )
1898 {
1899 // Make sure to repaint with virtual device
1900 pSh->LockPaint();
1901 pSh->UnlockPaint( sal_True );
1902 }
1903 pSh = (ViewShell*)pSh->GetNext();
1904 } while( pSh != pStartSh );
1905 return 0;
1906 }
1907
1908 static String lcl_GetUniqueFlyName( const SwDoc* pDoc, sal_uInt16 nDefStrId )
1909 {
1910 ResId aId( nDefStrId, *pSwResMgr );
1911 String aName( aId );
1912 xub_StrLen nNmLen = aName.Len();
1913
1914 const SwFrmFmts& rFmts = *pDoc->GetSpzFrmFmts();
1915
1916 sal_uInt16 nNum, nTmp, nFlagSize = ( rFmts.size() / 8 ) +2;
1917 sal_uInt8* pSetFlags = new sal_uInt8[ nFlagSize ];
1918 sal_uInt16 n;
1919
1920 memset( pSetFlags, 0, nFlagSize );
1921
1922 for( n = 0; n < rFmts.size(); ++n )
1923 {
1924 const SwFrmFmt* pFlyFmt = rFmts[ n ];
1925 if( RES_FLYFRMFMT == pFlyFmt->Which() &&
1926 pFlyFmt->GetName().Match( aName ) == nNmLen )
1927 {
1928 // Only get and set the Flag
1929 nNum = static_cast< sal_uInt16 >( pFlyFmt->GetName().Copy( nNmLen ).ToInt32() );
1930 if( nNum-- && nNum < rFmts.size() )
1931 pSetFlags[ nNum / 8 ] |= (0x01 << ( nNum & 0x07 ));
1932 }
1933 }
1934
1935 // All numbers are flagged accordingly, so determine the right one
1936 nNum = rFmts.size();
1937 for( n = 0; n < nFlagSize; ++n )
1938 if( 0xff != ( nTmp = pSetFlags[ n ] ))
1939 {
1940 // so determine the number
1941 nNum = n * 8;
1942 while( nTmp & 1 )
1943 ++nNum, nTmp >>= 1;
1944 break;
1945 }
1946
1947 delete [] pSetFlags;
1948 return aName += OUString::number( ++nNum );
1949 }
1950
1951 String SwDoc::GetUniqueGrfName() const
1952 {
1953 return lcl_GetUniqueFlyName( this, STR_GRAPHIC_DEFNAME );
1954 }
1955
1956 String SwDoc::GetUniqueOLEName() const
1957 {
1958 return lcl_GetUniqueFlyName( this, STR_OBJECT_DEFNAME );
1959 }
1960
1961 String SwDoc::GetUniqueFrameName() const
1962 {
1963 return lcl_GetUniqueFlyName( this, STR_FRAME_DEFNAME );
1964 }
1965
1966 const SwFlyFrmFmt* SwDoc::FindFlyByName( const String& rName, sal_Int8 nNdTyp ) const
1967 {
1968 const SwFrmFmts& rFmts = *GetSpzFrmFmts();
1969 for( sal_uInt16 n = rFmts.size(); n; )
1970 {
1971 const SwFrmFmt* pFlyFmt = rFmts[ --n ];
1972 const SwNodeIndex* pIdx;
1973 if( RES_FLYFRMFMT == pFlyFmt->Which() && pFlyFmt->GetName() == rName &&
1974 0 != ( pIdx = pFlyFmt->GetCntnt().GetCntntIdx() ) &&
1975 pIdx->GetNode().GetNodes().IsDocNodes() )
1976 {
1977 if( nNdTyp )
1978 {
1979 // query for the right NodeType
1980 const SwNode* pNd = GetNodes()[ pIdx->GetIndex()+1 ];
1981 if( nNdTyp == ND_TEXTNODE
1982 ? !pNd->IsNoTxtNode()
1983 : nNdTyp == pNd->GetNodeType() )
1984 return (SwFlyFrmFmt*)pFlyFmt;
1985 }
1986 else
1987 return (SwFlyFrmFmt*)pFlyFmt;
1988 }
1989 }
1990 return 0;
1991 }
1992
1993 void SwDoc::SetFlyName( SwFlyFrmFmt& rFmt, const String& rName )
1994 {
1995 String sName( rName );
1996 if( !rName.Len() || FindFlyByName( rName ) )
1997 {
1998 sal_uInt16 nTyp = STR_FRAME_DEFNAME;
1999 const SwNodeIndex* pIdx = rFmt.GetCntnt().GetCntntIdx();
2000 if( pIdx && pIdx->GetNode().GetNodes().IsDocNodes() )
2001 switch( GetNodes()[ pIdx->GetIndex() + 1 ]->GetNodeType() )
2002 {
2003 case ND_GRFNODE: nTyp = STR_GRAPHIC_DEFNAME; break;
2004 case ND_OLENODE: nTyp = STR_OBJECT_DEFNAME; break;
2005 }
2006 sName = lcl_GetUniqueFlyName( this, nTyp );
2007 }
2008 rFmt.SetName( sName, sal_True );
2009 SetModified();
2010 }
2011
2012 void SwDoc::SetAllUniqueFlyNames()
2013 {
2014 sal_uInt16 n, nFlyNum = 0, nGrfNum = 0, nOLENum = 0;
2015
2016 ResId nFrmId( STR_FRAME_DEFNAME, *pSwResMgr ),
2017 nGrfId( STR_GRAPHIC_DEFNAME, *pSwResMgr ),
2018 nOLEId( STR_OBJECT_DEFNAME, *pSwResMgr );
2019 String sFlyNm( nFrmId );
2020 String sGrfNm( nGrfId );
2021 String sOLENm( nOLEId );
2022
2023 if( 255 < ( n = GetSpzFrmFmts()->size() ))
2024 n = 255;
2025 SwFrmFmts aArr;
2026 aArr.reserve( n );
2027 SwFrmFmt* pFlyFmt;
2028 bool bContainsAtPageObjWithContentAnchor = false;
2029
2030 for( n = GetSpzFrmFmts()->size(); n; )
2031 {
2032 if( RES_FLYFRMFMT == (pFlyFmt = (*GetSpzFrmFmts())[ --n ])->Which() )
2033 {
2034 sal_uInt16 *pNum = 0;
2035 xub_StrLen nLen;
2036 const String& rNm = pFlyFmt->GetName();
2037 if( rNm.Len() )
2038 {
2039 if( rNm.Match( sGrfNm ) == ( nLen = sGrfNm.Len() ))
2040 pNum = &nGrfNum;
2041 else if( rNm.Match( sFlyNm ) == ( nLen = sFlyNm.Len() ))
2042 pNum = &nFlyNum;
2043 else if( rNm.Match( sOLENm ) == ( nLen = sOLENm.Len() ))
2044 pNum = &nOLENum;
2045
2046 if ( pNum && *pNum < ( nLen = static_cast< xub_StrLen >( rNm.Copy( nLen ).ToInt32() ) ) )
2047 *pNum = nLen;
2048 }
2049 else
2050 // we want to set that afterwards
2051 aArr.push_back( pFlyFmt );
2052
2053 }
2054 if ( !bContainsAtPageObjWithContentAnchor )
2055 {
2056 const SwFmtAnchor& rAnchor = pFlyFmt->GetAnchor();
2057 if ( (FLY_AT_PAGE == rAnchor.GetAnchorId()) &&
2058 rAnchor.GetCntntAnchor() )
2059 {
2060 bContainsAtPageObjWithContentAnchor = true;
2061 }
2062 }
2063 }
2064 SetContainsAtPageObjWithContentAnchor( bContainsAtPageObjWithContentAnchor );
2065
2066 const SwNodeIndex* pIdx;
2067
2068 for( n = aArr.size(); n; )
2069 if( 0 != ( pIdx = ( pFlyFmt = aArr[ --n ])->GetCntnt().GetCntntIdx() )
2070 && pIdx->GetNode().GetNodes().IsDocNodes() )
2071 {
2072 sal_uInt16 nNum;
2073 String sNm;
2074 switch( GetNodes()[ pIdx->GetIndex() + 1 ]->GetNodeType() )
2075 {
2076 case ND_GRFNODE:
2077 sNm = sGrfNm;
2078 nNum = ++nGrfNum;
2079 break;
2080 case ND_OLENODE:
2081 sNm = sOLENm;
2082 nNum = ++nOLENum;
2083 break;
2084 default:
2085 sNm = sFlyNm;
2086 nNum = ++nFlyNum;
2087 break;
2088 }
2089 pFlyFmt->SetName( sNm += OUString::number( nNum ));
2090 }
2091 aArr.clear();
2092
2093 if( !GetFtnIdxs().empty() )
2094 {
2095 SwTxtFtn::SetUniqueSeqRefNo( *this );
2096 // #i52775# Chapter footnotes did not get updated correctly.
2097 // Calling UpdateAllFtn() instead of UpdateFtn() solves this problem,
2098 // but I do not dare to call UpdateAllFtn() in all cases: Safety first.
2099 if ( FTNNUM_CHAPTER == GetFtnInfo().eNum )
2100 {
2101 GetFtnIdxs().UpdateAllFtn();
2102 }
2103 else
2104 {
2105 SwNodeIndex aTmp( GetNodes() );
2106 GetFtnIdxs().UpdateFtn( aTmp );
2107 }
2108 }
2109 }
2110
2111 bool SwDoc::IsInHeaderFooter( const SwNodeIndex& rIdx ) const
2112 {
2113 // If there's a Layout, use it!
2114 // That can also be a Fly in a Fly in the Header.
2115 // Is also used by sw3io, to determine if a Redline object is
2116 // in the Header or Footer.
2117 // Because Redlines are also attached to Start and EndNoden,
2118 // the Index must not necessarily be from a ContentNode.
2119 SwNode* pNd = &rIdx.GetNode();
2120 if( pNd->IsCntntNode() && mpCurrentView )//swmod 071029//swmod 071225
2121 {
2122 const SwFrm *pFrm = pNd->GetCntntNode()->getLayoutFrm( GetCurrentLayout() );
2123 if( pFrm )
2124 {
2125 const SwFrm *pUp = pFrm->GetUpper();
2126 while ( pUp && !pUp->IsHeaderFrm() && !pUp->IsFooterFrm() )
2127 {
2128 if ( pUp->IsFlyFrm() )
2129 pUp = ((SwFlyFrm*)pUp)->GetAnchorFrm();
2130 pUp = pUp->GetUpper();
2131 }
2132 if ( pUp )
2133 return true;
2134
2135 return false;
2136 }
2137 }
2138
2139
2140 const SwNode* pFlyNd = pNd->FindFlyStartNode();
2141 while( pFlyNd )
2142 {
2143 // get up by using the Anchor
2144 sal_uInt16 n;
2145 for( n = 0; n < GetSpzFrmFmts()->size(); ++n )
2146 {
2147 const SwFrmFmt* pFmt = (*GetSpzFrmFmts())[ n ];
2148 const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
2149 if( pIdx && pFlyNd == &pIdx->GetNode() )
2150 {
2151 const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
2152 if ((FLY_AT_PAGE == rAnchor.GetAnchorId()) ||
2153 !rAnchor.GetCntntAnchor() )
2154 {
2155 return false;
2156 }
2157
2158 pNd = &rAnchor.GetCntntAnchor()->nNode.GetNode();
2159 pFlyNd = pNd->FindFlyStartNode();
2160 break;
2161 }
2162 }
2163 if( n >= GetSpzFrmFmts()->size() )
2164 {
2165 OSL_ENSURE( mbInReading, "Found a FlySection but not a Format!" );
2166 return false;
2167 }
2168 }
2169
2170 return 0 != pNd->FindHeaderStartNode() ||
2171 0 != pNd->FindFooterStartNode();
2172 }
2173
2174 short SwDoc::GetTextDirection( const SwPosition& rPos,
2175 const Point* pPt ) const
2176 {
2177 short nRet = -1;
2178
2179 SwCntntNode *pNd = rPos.nNode.GetNode().GetCntntNode();
2180
2181 // #i42921# - use new method <SwCntntNode::GetTextDirection(..)>
2182 if ( pNd )
2183 {
2184 nRet = pNd->GetTextDirection( rPos, pPt );
2185 }
2186 if ( nRet == -1 )
2187 {
2188 const SvxFrameDirectionItem* pItem = 0;
2189 if( pNd )
2190 {
2191 // Are we in a FlyFrame? Then look at that for the correct attribute
2192 const SwFrmFmt* pFlyFmt = pNd->GetFlyFmt();
2193 while( pFlyFmt )
2194 {
2195 pItem = &pFlyFmt->GetFrmDir();
2196 if( FRMDIR_ENVIRONMENT == pItem->GetValue() )
2197 {
2198 pItem = 0;
2199 const SwFmtAnchor* pAnchor = &pFlyFmt->GetAnchor();
2200 if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) &&
2201 pAnchor->GetCntntAnchor())
2202 {
2203 pFlyFmt = pAnchor->GetCntntAnchor()->nNode.
2204 GetNode().GetFlyFmt();
2205 }
2206 else
2207 pFlyFmt = 0;
2208 }
2209 else
2210 pFlyFmt = 0;
2211 }
2212
2213 if( !pItem )
2214 {
2215 const SwPageDesc* pPgDsc = pNd->FindPageDesc( sal_False );
2216 if( pPgDsc )
2217 pItem = &pPgDsc->GetMaster().GetFrmDir();
2218 }
2219 }
2220 if( !pItem )
2221 pItem = (SvxFrameDirectionItem*)&GetAttrPool().GetDefaultItem(
2222 RES_FRAMEDIR );
2223 nRet = pItem->GetValue();
2224 }
2225 return nRet;
2226 }
2227
2228 bool SwDoc::IsInVerticalText( const SwPosition& rPos, const Point* pPt ) const
2229 {
2230 const short nDir = GetTextDirection( rPos, pPt );
2231 return FRMDIR_VERT_TOP_RIGHT == nDir || FRMDIR_VERT_TOP_LEFT == nDir;
2232 }
2233
2234 void SwDoc::SetCurrentViewShell( ViewShell* pNew )
2235 {
2236 mpCurrentView = pNew;
2237 }
2238
2239 SwLayouter* SwDoc::GetLayouter()
2240 {
2241 return mpLayouter;
2242 }
2243
2244 const SwLayouter* SwDoc::GetLayouter() const
2245 {
2246 return mpLayouter;
2247 }
2248
2249 void SwDoc::SetLayouter( SwLayouter* pNew )
2250 {
2251 mpLayouter = pNew;
2252 }
2253
2254 const ViewShell *SwDoc::GetCurrentViewShell() const
2255 {
2256 return mpCurrentView;
2257 }
2258
2259 ViewShell *SwDoc::GetCurrentViewShell()
2260 {
2261 return mpCurrentView;
2262 }
2263
2264 //swmod 080219
2265 // It must be able to communicate to a ViewShell. This is going to be removed later.
2266 const SwRootFrm *SwDoc::GetCurrentLayout() const
2267 {
2268 if(GetCurrentViewShell())
2269 return GetCurrentViewShell()->GetLayout();
2270 return 0;
2271 }
2272
2273 SwRootFrm *SwDoc::GetCurrentLayout()
2274 {
2275 if(GetCurrentViewShell())
2276 return GetCurrentViewShell()->GetLayout();
2277 return 0;
2278 }
2279
2280 bool SwDoc::HasLayout() const
2281 {
2282 // if there is a view, there is always a layout
2283 return (mpCurrentView != 0);
2284 }
2285
2286 std::set<SwRootFrm*> SwDoc::GetAllLayouts()
2287 {
2288 std::set<SwRootFrm*> aAllLayouts;
2289 ViewShell *pStart = GetCurrentViewShell();
2290 ViewShell *pTemp = pStart;
2291 if ( pTemp )
2292 {
2293 do
2294 {
2295 if (pTemp->GetLayout())
2296 {
2297 aAllLayouts.insert(pTemp->GetLayout());
2298 pTemp = (ViewShell*)pTemp->GetNext();
2299 }
2300 } while(pTemp!=pStart);
2301 }
2302
2303 return aAllLayouts;
2304 } //swmod 070825
2305
2306 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE