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 <com/sun/star/text/WrapTextMode.hpp>
21 : #include <com/sun/star/text/TextContentAnchorType.hpp>
22 : #include <com/sun/star/container/XIndexContainer.hpp>
23 : #include <com/sun/star/text/TextGridMode.hpp>
24 : #include <svtools/unoimap.hxx>
25 : #include <svtools/imap.hxx>
26 : #include <svtools/imapobj.hxx>
27 : #include <atrfrm.hxx>
28 : #include <unocoll.hxx>
29 : #include <unosett.hxx>
30 : #include <unostyle.hxx>
31 : #include <fmtclds.hxx>
32 : #include <fmtornt.hxx>
33 : #include <fmthdft.hxx>
34 : #include <fmtpdsc.hxx>
35 : #include <fmtcntnt.hxx>
36 : #include <fmtfsize.hxx>
37 : #include <fmtfordr.hxx>
38 : #include <fmtsrnd.hxx>
39 : #include <fmtlsplt.hxx>
40 : #include <fmtrowsplt.hxx>
41 : #include <fmtftntx.hxx>
42 : #include <fmteiro.hxx>
43 : #include <fmturl.hxx>
44 : #include <fmtcnct.hxx>
45 : #include <section.hxx>
46 : #include <fmtline.hxx>
47 : #include <tgrditem.hxx>
48 : #include <hfspacingitem.hxx>
49 : #include <IDocumentUndoRedo.hxx>
50 : #include <IDocumentContentOperations.hxx>
51 : #include <IDocumentLayoutAccess.hxx>
52 : #include <pagefrm.hxx>
53 : #include <rootfrm.hxx>
54 : #include <cntfrm.hxx>
55 : #include <crsrsh.hxx>
56 : #include <dflyobj.hxx>
57 : #include <dcontact.hxx>
58 : #include <frmtool.hxx>
59 : #include <flyfrms.hxx>
60 : #include <pagedesc.hxx>
61 : #include <grfatr.hxx>
62 : #include <ndnotxt.hxx>
63 : #include <docary.hxx>
64 : #include <node2lay.hxx>
65 : #include <fmtclbl.hxx>
66 : #include <swunohelper.hxx>
67 : #include <unoframe.hxx>
68 : #include <unotextbodyhf.hxx>
69 : #include <SwStyleNameMapper.hxx>
70 : #include <editeng/brushitem.hxx>
71 : #include <svtools/grfmgr.hxx>
72 : #include <unomid.h>
73 : #include <comcore.hrc>
74 : #include <svx/svdundo.hxx>
75 : #include <sortedobjs.hxx>
76 : #include <HandleAnchorNodeChg.hxx>
77 : #include <calbck.hxx>
78 : #include <pagedeschint.hxx>
79 : #ifndef NDEBUG
80 : #include <ndtxt.hxx>
81 : #endif
82 :
83 : //UUUU
84 : #include <svx/sdr/attribute/sdrallfillattributeshelper.hxx>
85 : #include <svx/xfillit0.hxx>
86 : #include <svl/itemiter.hxx>
87 :
88 : using namespace ::com::sun::star;
89 :
90 28808 : TYPEINIT1(SwFormatVertOrient, SfxPoolItem);
91 29090 : TYPEINIT1(SwFormatHoriOrient, SfxPoolItem);
92 102972 : TYPEINIT2(SwFormatHeader, SfxPoolItem, SwClient );
93 97919 : TYPEINIT2(SwFormatFooter, SfxPoolItem, SwClient );
94 60660 : TYPEINIT2(SwFormatPageDesc, SfxPoolItem, SwClient );
95 17379 : TYPEINIT1_AUTOFACTORY(SwFormatLineNumber, SfxPoolItem);
96 :
97 5887 : static sal_Int16 lcl_IntToRelation(const uno::Any& rVal)
98 : {
99 5887 : sal_Int16 nVal = text::RelOrientation::FRAME;
100 5887 : if (!(rVal >>= nVal))
101 : SAL_WARN("sw.core", "lcl_IntToRelation: read from Any failed!");
102 5887 : return nVal;
103 : }
104 :
105 15379 : void DelHFFormat( SwClient *pToRemove, SwFrameFormat *pFormat )
106 : {
107 : //If the client is the last one who uses this format, then we have to delete
108 : //it - before this is done, we may need to delete the content-section.
109 15379 : SwDoc* pDoc = pFormat->GetDoc();
110 15379 : pFormat->Remove( pToRemove );
111 15379 : if( pDoc->IsInDtor() )
112 : {
113 1486 : delete pFormat;
114 16865 : return;
115 : }
116 :
117 : // Anything other than frames registered?
118 13893 : bool bDel = true;
119 : {
120 : // nested scope because DTOR of SwClientIter resets the flag bTreeChg.
121 : // It's suboptimal if the format is deleted beforehand.
122 13893 : SwIterator<SwClient,SwFrameFormat> aIter(*pFormat);
123 23409 : for(SwClient* pLast = aIter.First(); bDel && pLast; pLast = aIter.Next())
124 9516 : if(!pLast->IsA(TYPE(SwFrm)) || !SwXHeadFootText::IsXHeadFootText(pLast))
125 23409 : bDel = false;
126 : }
127 :
128 13893 : if ( bDel )
129 : {
130 : // If there is a Crsr registered in one of the nodes, we need to call the
131 : // ParkCrsr in an (arbitrary) shell.
132 4377 : SwFormatContent& rCnt = (SwFormatContent&)pFormat->GetContent();
133 4377 : if ( rCnt.GetContentIdx() )
134 : {
135 4377 : SwNode *pNode = 0;
136 : {
137 : // #i92993#
138 : // Begin with start node of page header/footer to assure that
139 : // complete content is checked for cursors and the complete content
140 : // is deleted on below made method call <pDoc->getIDocumentContentOperations().DeleteSection(pNode)>
141 4377 : SwNodeIndex aIdx( *rCnt.GetContentIdx(), 0 );
142 : // If there is a Crsr registered in one of the nodes, we need to call the
143 : // ParkCrsr in an (arbitrary) shell.
144 4377 : pNode = & aIdx.GetNode();
145 4377 : sal_uInt32 nEnd = pNode->EndOfSectionIndex();
146 20994 : while ( aIdx < nEnd )
147 : {
148 18159 : if ( pNode->IsContentNode() &&
149 5919 : static_cast<SwContentNode*>(pNode)->HasWriterListeners() )
150 : {
151 0 : SwCrsrShell *pShell = SwIterator<SwCrsrShell,SwContentNode>( *static_cast<SwContentNode*>(pNode) ).First();
152 0 : if( pShell )
153 : {
154 0 : pShell->ParkCrsr( aIdx );
155 0 : aIdx = nEnd-1;
156 : }
157 : }
158 12240 : ++aIdx;
159 12240 : pNode = & aIdx.GetNode();
160 4377 : }
161 : }
162 4377 : rCnt.SetNewContentIdx( nullptr );
163 :
164 : // When deleting a header/footer-format, we ALWAYS need to disable
165 : // the undo function (Bug 31069)
166 4377 : ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
167 :
168 : OSL_ENSURE( pNode, "A big problem." );
169 4377 : pDoc->getIDocumentContentOperations().DeleteSection( pNode );
170 : }
171 4377 : delete pFormat;
172 : }
173 : }
174 :
175 : // Partially implemented inline in hxx
176 98675 : SwFormatFrmSize::SwFormatFrmSize( SwFrmSize eSize, SwTwips nWidth, SwTwips nHeight )
177 : : SfxPoolItem( RES_FRM_SIZE ),
178 : m_aSize( nWidth, nHeight ),
179 : m_eFrmHeightType( eSize ),
180 98675 : m_eFrmWidthType( ATT_FIX_SIZE )
181 : {
182 98675 : m_nWidthPercent = m_eWidthPercentRelation = m_nHeightPercent = m_eHeightPercentRelation = 0;
183 98675 : }
184 :
185 249 : SwFormatFrmSize& SwFormatFrmSize::operator=( const SwFormatFrmSize& rCpy )
186 : {
187 249 : m_aSize = rCpy.GetSize();
188 249 : m_eFrmHeightType = rCpy.GetHeightSizeType();
189 249 : m_eFrmWidthType = rCpy.GetWidthSizeType();
190 249 : m_nHeightPercent = rCpy.GetHeightPercent();
191 249 : m_eHeightPercentRelation = rCpy.GetHeightPercentRelation();
192 249 : m_nWidthPercent = rCpy.GetWidthPercent();
193 249 : m_eWidthPercentRelation = rCpy.GetWidthPercentRelation();
194 249 : return *this;
195 : }
196 :
197 1105007 : bool SwFormatFrmSize::operator==( const SfxPoolItem& rAttr ) const
198 : {
199 : assert(SfxPoolItem::operator==(rAttr));
200 1888343 : return( m_eFrmHeightType == static_cast<const SwFormatFrmSize&>(rAttr).m_eFrmHeightType &&
201 1566467 : m_eFrmWidthType == static_cast<const SwFormatFrmSize&>(rAttr).m_eFrmWidthType &&
202 1089383 : m_aSize == static_cast<const SwFormatFrmSize&>(rAttr).GetSize()&&
203 612328 : m_nWidthPercent == static_cast<const SwFormatFrmSize&>(rAttr).GetWidthPercent() &&
204 612152 : m_eWidthPercentRelation == static_cast<const SwFormatFrmSize&>(rAttr).GetWidthPercentRelation() &&
205 1717159 : m_nHeightPercent == static_cast<const SwFormatFrmSize&>(rAttr).GetHeightPercent() &&
206 1411083 : m_eHeightPercentRelation == static_cast<const SwFormatFrmSize&>(rAttr).GetHeightPercentRelation() );
207 : }
208 :
209 23549 : SfxPoolItem* SwFormatFrmSize::Clone( SfxItemPool* ) const
210 : {
211 23549 : return new SwFormatFrmSize( *this );
212 : }
213 :
214 1330 : bool SwFormatFrmSize::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
215 : {
216 : // here we convert always!
217 1330 : nMemberId &= ~CONVERT_TWIPS;
218 1330 : switch ( nMemberId )
219 : {
220 : case MID_FRMSIZE_SIZE:
221 : {
222 82 : awt::Size aTmp;
223 82 : aTmp.Height = convertTwipToMm100(m_aSize.Height());
224 82 : aTmp.Width = convertTwipToMm100(m_aSize.Width());
225 82 : rVal.setValue(&aTmp, ::cppu::UnoType<awt::Size>::get());
226 : }
227 82 : break;
228 : case MID_FRMSIZE_REL_HEIGHT:
229 224 : rVal <<= (sal_Int16)(GetHeightPercent() != 0xFF ? GetHeightPercent() : 0);
230 224 : break;
231 : case MID_FRMSIZE_REL_HEIGHT_RELATION:
232 154 : rVal <<= GetHeightPercentRelation();
233 154 : break;
234 : case MID_FRMSIZE_REL_WIDTH:
235 232 : rVal <<= (sal_Int16)(GetWidthPercent() != 0xFF ? GetWidthPercent() : 0);
236 232 : break;
237 : case MID_FRMSIZE_REL_WIDTH_RELATION:
238 154 : rVal <<= GetWidthPercentRelation();
239 154 : break;
240 : case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH:
241 74 : rVal <<= 0xFF == GetHeightPercent();
242 74 : break;
243 : case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT:
244 74 : rVal <<= 0xFF == GetWidthPercent();
245 74 : break;
246 : case MID_FRMSIZE_WIDTH :
247 126 : rVal <<= (sal_Int32)convertTwipToMm100(m_aSize.Width());
248 126 : break;
249 : case MID_FRMSIZE_HEIGHT:
250 : // #95848# returned size should never be zero.
251 : // (there was a bug that allowed for setting height to 0.
252 : // Thus there some documents existing with that not allowed
253 : // attribute value which may cause problems on import.)
254 77 : rVal <<= (sal_Int32)convertTwipToMm100(m_aSize.Height() < MINLAY ? MINLAY : m_aSize.Height() );
255 77 : break;
256 : case MID_FRMSIZE_SIZE_TYPE:
257 69 : rVal <<= (sal_Int16)GetHeightSizeType();
258 69 : break;
259 : case MID_FRMSIZE_IS_AUTO_HEIGHT:
260 1 : rVal <<= ATT_FIX_SIZE != GetHeightSizeType();
261 1 : break;
262 : case MID_FRMSIZE_WIDTH_TYPE:
263 63 : rVal <<= (sal_Int16)GetWidthSizeType();
264 63 : break;
265 : }
266 1330 : return true;
267 : }
268 :
269 10081 : bool SwFormatFrmSize::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
270 : {
271 10081 : bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
272 10081 : nMemberId &= ~CONVERT_TWIPS;
273 10081 : bool bRet = true;
274 10081 : switch ( nMemberId )
275 : {
276 : case MID_FRMSIZE_SIZE:
277 : {
278 3015 : awt::Size aVal;
279 3015 : if(!(rVal >>= aVal))
280 12 : bRet = false;
281 : else
282 : {
283 3003 : Size aTmp(aVal.Width, aVal.Height);
284 3003 : if(bConvert)
285 : {
286 3003 : aTmp.Height() = convertMm100ToTwip(aTmp.Height());
287 3003 : aTmp.Width() = convertMm100ToTwip(aTmp.Width());
288 : }
289 3003 : if(aTmp.Height() && aTmp.Width())
290 3003 : m_aSize = aTmp;
291 : else
292 0 : bRet = false;
293 : }
294 : }
295 3015 : break;
296 : case MID_FRMSIZE_REL_HEIGHT:
297 : {
298 371 : sal_Int16 nSet = 0;
299 371 : rVal >>= nSet;
300 371 : if(nSet >= 0 && nSet <= 0xfe)
301 371 : SetHeightPercent((sal_uInt8)nSet);
302 : else
303 0 : bRet = false;
304 : }
305 371 : break;
306 : case MID_FRMSIZE_REL_HEIGHT_RELATION:
307 : {
308 9 : sal_Int16 eSet = 0;
309 9 : rVal >>= eSet;
310 9 : SetHeightPercentRelation(eSet);
311 : }
312 9 : break;
313 : case MID_FRMSIZE_REL_WIDTH:
314 : {
315 376 : sal_Int16 nSet = 0;
316 376 : rVal >>= nSet;
317 376 : if(nSet >= 0 && nSet <= 0xfe)
318 376 : SetWidthPercent((sal_uInt8)nSet);
319 : else
320 0 : bRet = false;
321 : }
322 376 : break;
323 : case MID_FRMSIZE_REL_WIDTH_RELATION:
324 : {
325 9 : sal_Int16 eSet = 0;
326 9 : rVal >>= eSet;
327 9 : SetWidthPercentRelation(eSet);
328 : }
329 9 : break;
330 : case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH:
331 : {
332 368 : bool bSet = *static_cast<sal_Bool const *>(rVal.getValue());
333 368 : if(bSet)
334 3 : SetHeightPercent(0xff);
335 365 : else if( 0xff == GetHeightPercent() )
336 0 : SetHeightPercent( 0 );
337 : }
338 368 : break;
339 : case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT:
340 : {
341 368 : bool bSet = *static_cast<sal_Bool const *>(rVal.getValue());
342 368 : if(bSet)
343 1 : SetWidthPercent(0xff);
344 367 : else if( 0xff == GetWidthPercent() )
345 0 : SetWidthPercent(0);
346 : }
347 368 : break;
348 : case MID_FRMSIZE_WIDTH :
349 : {
350 1163 : sal_Int32 nWd = 0;
351 1163 : if(rVal >>= nWd)
352 : {
353 1163 : if(bConvert)
354 1163 : nWd = convertMm100ToTwip(nWd);
355 1163 : if(nWd < MINLAY)
356 59 : nWd = MINLAY;
357 1163 : m_aSize.Width() = nWd;
358 : }
359 : else
360 0 : bRet = false;
361 : }
362 1163 : break;
363 : case MID_FRMSIZE_HEIGHT:
364 : {
365 1128 : sal_Int32 nHg = 0;
366 1128 : if(rVal >>= nHg)
367 : {
368 1128 : if(bConvert)
369 1128 : nHg = convertMm100ToTwip(nHg);
370 1128 : if(nHg < MINLAY)
371 59 : nHg = MINLAY;
372 1128 : m_aSize.Height() = nHg;
373 : }
374 : else
375 0 : bRet = false;
376 : }
377 1128 : break;
378 : case MID_FRMSIZE_SIZE_TYPE:
379 : {
380 2218 : sal_Int16 nType = 0;
381 2218 : if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE )
382 : {
383 2218 : SetHeightSizeType((SwFrmSize)nType);
384 : }
385 : else
386 0 : bRet = false;
387 : }
388 2218 : break;
389 : case MID_FRMSIZE_IS_AUTO_HEIGHT:
390 : {
391 817 : bool bSet = *static_cast<sal_Bool const *>(rVal.getValue());
392 817 : SetHeightSizeType(bSet ? ATT_VAR_SIZE : ATT_FIX_SIZE);
393 : }
394 817 : break;
395 : case MID_FRMSIZE_WIDTH_TYPE:
396 : {
397 239 : sal_Int16 nType = 0;
398 239 : if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE )
399 : {
400 238 : SetWidthSizeType((SwFrmSize)nType);
401 : }
402 : else
403 1 : bRet = false;
404 : }
405 239 : break;
406 : default:
407 0 : bRet = false;
408 : }
409 10081 : return bRet;
410 : }
411 :
412 0 : void SwFormatFrmSize::dumpAsXml(xmlTextWriterPtr pWriter) const
413 : {
414 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatFrmSize"));
415 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
416 :
417 0 : std::stringstream aSize;
418 0 : aSize << m_aSize;
419 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(aSize.str().c_str()));
420 :
421 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eFrmHeightType"), BAD_CAST(OString::number(m_eFrmHeightType).getStr()));
422 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eFrmWidthType"), BAD_CAST(OString::number(m_eFrmWidthType).getStr()));
423 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidthPercent"), BAD_CAST(OString::number(m_nWidthPercent).getStr()));
424 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eWidthPercentRelation"), BAD_CAST(OString::number(m_eWidthPercentRelation).getStr()));
425 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nHeightPercent"), BAD_CAST(OString::number(m_nHeightPercent).getStr()));
426 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eHeightPercentRelation"), BAD_CAST(OString::number(m_eHeightPercentRelation).getStr()));
427 :
428 0 : xmlTextWriterEndElement(pWriter);
429 0 : }
430 :
431 : // Partially implemented inline in hxx
432 7080 : SwFormatFillOrder::SwFormatFillOrder( SwFillOrder nFO )
433 7080 : : SfxEnumItem( RES_FILL_ORDER, sal_uInt16(nFO) )
434 7080 : {}
435 2997 : SfxPoolItem* SwFormatFillOrder::Clone( SfxItemPool* ) const
436 : {
437 2997 : return new SwFormatFillOrder( GetFillOrder() );
438 : }
439 :
440 0 : sal_uInt16 SwFormatFillOrder::GetValueCount() const
441 : {
442 0 : return SW_FILL_ORDER_END - SW_FILL_ORDER_BEGIN;
443 : }
444 :
445 : // Partially implemented inline in hxx
446 61 : SwFormatHeader::SwFormatHeader( SwFrameFormat *pHeaderFormat )
447 : : SfxPoolItem( RES_HEADER ),
448 : SwClient( pHeaderFormat ),
449 61 : bActive( pHeaderFormat )
450 : {
451 61 : }
452 :
453 14978 : SwFormatHeader::SwFormatHeader( const SwFormatHeader &rCpy )
454 : : SfxPoolItem( RES_HEADER ),
455 14978 : SwClient( const_cast<SwModify*>(rCpy.GetRegisteredIn()) ),
456 29956 : bActive( rCpy.IsActive() )
457 : {
458 14978 : }
459 :
460 773 : SwFormatHeader::SwFormatHeader( bool bOn )
461 : : SfxPoolItem( RES_HEADER ),
462 : SwClient( 0 ),
463 773 : bActive( bOn )
464 : {
465 773 : }
466 :
467 43607 : SwFormatHeader::~SwFormatHeader()
468 : {
469 15807 : if ( GetHeaderFormat() )
470 9328 : DelHFFormat( this, GetHeaderFormat() );
471 27800 : }
472 :
473 27366 : bool SwFormatHeader::operator==( const SfxPoolItem& rAttr ) const
474 : {
475 : assert(SfxPoolItem::operator==(rAttr));
476 38526 : return ( GetRegisteredIn() == static_cast<const SwFormatHeader&>(rAttr).GetRegisteredIn() &&
477 38526 : bActive == static_cast<const SwFormatHeader&>(rAttr).IsActive() );
478 : }
479 :
480 11939 : SfxPoolItem* SwFormatHeader::Clone( SfxItemPool* ) const
481 : {
482 11939 : return new SwFormatHeader( *this );
483 : }
484 :
485 3438 : void SwFormatHeader::RegisterToFormat( SwFormat& rFormat )
486 : {
487 3438 : rFormat.Add(this);
488 3438 : }
489 :
490 : // Partially implemented inline in hxx
491 58 : SwFormatFooter::SwFormatFooter( SwFrameFormat *pFooterFormat )
492 : : SfxPoolItem( RES_FOOTER ),
493 : SwClient( pFooterFormat ),
494 58 : bActive( pFooterFormat )
495 : {
496 58 : }
497 :
498 12699 : SwFormatFooter::SwFormatFooter( const SwFormatFooter &rCpy )
499 : : SfxPoolItem( RES_FOOTER ),
500 12699 : SwClient( const_cast<SwModify*>(rCpy.GetRegisteredIn()) ),
501 25398 : bActive( rCpy.IsActive() )
502 : {
503 12699 : }
504 :
505 770 : SwFormatFooter::SwFormatFooter( bool bOn )
506 : : SfxPoolItem( RES_FOOTER ),
507 : SwClient( 0 ),
508 770 : bActive( bOn )
509 : {
510 770 : }
511 :
512 37767 : SwFormatFooter::~SwFormatFooter()
513 : {
514 13522 : if ( GetFooterFormat() )
515 6051 : DelHFFormat( this, GetFooterFormat() );
516 24245 : }
517 :
518 2307 : void SwFormatFooter::RegisterToFormat( SwFormat& rFormat )
519 : {
520 2307 : rFormat.Add(this);
521 2307 : }
522 :
523 26060 : bool SwFormatFooter::operator==( const SfxPoolItem& rAttr ) const
524 : {
525 : assert(SfxPoolItem::operator==(rAttr));
526 40119 : return ( GetRegisteredIn() == static_cast<const SwFormatFooter&>(rAttr).GetRegisteredIn() &&
527 40119 : bActive == static_cast<const SwFormatFooter&>(rAttr).IsActive() );
528 : }
529 :
530 10669 : SfxPoolItem* SwFormatFooter::Clone( SfxItemPool* ) const
531 : {
532 10669 : return new SwFormatFooter( *this );
533 : }
534 :
535 : // Partially implemented inline in hxx
536 87387 : SwFormatContent::SwFormatContent( const SwFormatContent &rCpy )
537 87387 : : SfxPoolItem( RES_CNTNT )
538 : {
539 87387 : pStartNode = rCpy.GetContentIdx() ?
540 87387 : new SwNodeIndex( *rCpy.GetContentIdx() ) : 0;
541 87387 : }
542 :
543 8558 : SwFormatContent::SwFormatContent( const SwStartNode *pStartNd )
544 8558 : : SfxPoolItem( RES_CNTNT )
545 : {
546 8558 : pStartNode = pStartNd ? new SwNodeIndex( *pStartNd ) : 0;
547 8558 : }
548 :
549 278639 : SwFormatContent::~SwFormatContent()
550 : {
551 95944 : delete pStartNode;
552 182695 : }
553 :
554 7905 : void SwFormatContent::SetNewContentIdx( const SwNodeIndex *pIdx )
555 : {
556 7905 : delete pStartNode;
557 7905 : pStartNode = pIdx ? new SwNodeIndex( *pIdx ) : 0;
558 7905 : }
559 :
560 283247 : bool SwFormatContent::operator==( const SfxPoolItem& rAttr ) const
561 : {
562 : assert(SfxPoolItem::operator==(rAttr));
563 283247 : if( (bool)pStartNode != (bool)static_cast<const SwFormatContent&>(rAttr).pStartNode )
564 1 : return false;
565 283246 : if( pStartNode )
566 283193 : return ( *pStartNode == *static_cast<const SwFormatContent&>(rAttr).GetContentIdx() );
567 53 : return true;
568 : }
569 :
570 86693 : SfxPoolItem* SwFormatContent::Clone( SfxItemPool* ) const
571 : {
572 86693 : return new SwFormatContent( *this );
573 : }
574 :
575 0 : void SwFormatContent::dumpAsXml(xmlTextWriterPtr pWriter) const
576 : {
577 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatContent"));
578 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
579 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("startNode"), BAD_CAST(OString::number(pStartNode->GetNode().GetIndex()).getStr()));
580 0 : xmlTextWriterEndElement(pWriter);
581 0 : }
582 :
583 : // Partially implemented inline in hxx
584 37068 : SwFormatPageDesc::SwFormatPageDesc( const SwFormatPageDesc &rCpy )
585 : : SfxPoolItem( RES_PAGEDESC ),
586 37068 : SwClient( const_cast<SwPageDesc*>(rCpy.GetPageDesc()) ),
587 : oNumOffset( rCpy.oNumOffset ),
588 : nDescNameIdx( rCpy.nDescNameIdx ),
589 74136 : pDefinedIn( 0 )
590 : {
591 37068 : }
592 :
593 3671 : SwFormatPageDesc::SwFormatPageDesc( const SwPageDesc *pDesc )
594 : : SfxPoolItem( RES_PAGEDESC ),
595 : SwClient( const_cast<SwPageDesc*>(pDesc) ),
596 : nDescNameIdx( 0xFFFF ), // IDX_NO_VALUE
597 3671 : pDefinedIn( 0 )
598 : {
599 3671 : }
600 :
601 0 : SwFormatPageDesc &SwFormatPageDesc::operator=(const SwFormatPageDesc &rCpy)
602 : {
603 0 : if (rCpy.GetPageDesc())
604 0 : RegisterToPageDesc(*const_cast<SwPageDesc*>(rCpy.GetPageDesc()));
605 0 : oNumOffset = rCpy.oNumOffset;
606 0 : nDescNameIdx = rCpy.nDescNameIdx;
607 0 : pDefinedIn = 0;
608 :
609 0 : return *this;
610 : }
611 :
612 77303 : SwFormatPageDesc::~SwFormatPageDesc() {}
613 :
614 5861 : bool SwFormatPageDesc::KnowsPageDesc() const
615 : {
616 5861 : return (GetRegisteredIn() != 0);
617 : }
618 :
619 2613 : bool SwFormatPageDesc::operator==( const SfxPoolItem& rAttr ) const
620 : {
621 : assert(SfxPoolItem::operator==(rAttr));
622 4162 : return ( pDefinedIn == static_cast<const SwFormatPageDesc&>(rAttr).pDefinedIn ) &&
623 3902 : ( oNumOffset == static_cast<const SwFormatPageDesc&>(rAttr).oNumOffset ) &&
624 3902 : ( GetPageDesc() == static_cast<const SwFormatPageDesc&>(rAttr).GetPageDesc() );
625 : }
626 :
627 34143 : SfxPoolItem* SwFormatPageDesc::Clone( SfxItemPool* ) const
628 : {
629 34143 : return new SwFormatPageDesc( *this );
630 : }
631 :
632 5845 : void SwFormatPageDesc::SwClientNotify( const SwModify& rModify, const SfxHint& rHint )
633 : {
634 5845 : SwClient::SwClientNotify(rModify, rHint);
635 5845 : const SwPageDescHint* pHint = dynamic_cast<const SwPageDescHint*>(&rHint);
636 5845 : if ( pHint )
637 : {
638 : // mba: shouldn't that be broadcasted also?
639 0 : SwFormatPageDesc aDfltDesc( pHint->GetPageDesc() );
640 0 : SwPageDesc* pDesc = pHint->GetPageDesc();
641 0 : const SwModify* pMod = GetDefinedIn();
642 0 : if ( pMod )
643 : {
644 0 : if( pMod->ISA( SwContentNode ) )
645 0 : const_cast<SwContentNode*>(static_cast<const SwContentNode*>(pMod))->SetAttr( aDfltDesc );
646 0 : else if( pMod->ISA( SwFormat ))
647 0 : const_cast<SwFormat*>(static_cast<const SwFormat*>(pMod))->SetFormatAttr( aDfltDesc );
648 : else
649 : {
650 : OSL_FAIL( "What kind of SwModify is this?" );
651 0 : RegisterToPageDesc( *pDesc );
652 : }
653 : }
654 : else
655 : // there could be an Undo-copy
656 0 : RegisterToPageDesc( *pDesc );
657 : }
658 5845 : }
659 :
660 2296 : void SwFormatPageDesc::RegisterToPageDesc( SwPageDesc& rDesc )
661 : {
662 2296 : rDesc.Add( this );
663 2296 : }
664 :
665 5845 : void SwFormatPageDesc::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
666 : {
667 5845 : if( !pDefinedIn )
668 9265 : return;
669 :
670 2425 : const sal_uInt16 nWhichId = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
671 2425 : switch( nWhichId )
672 : {
673 : case RES_OBJECTDYING:
674 : //The Pagedesc where I'm registered dies, therefore I unregister
675 : //from that format. During this I get deleted!
676 2425 : if( IS_TYPE( SwFormat, pDefinedIn ))
677 : {
678 : bool const bResult =
679 0 : static_cast<SwFormat*>(pDefinedIn)->ResetFormatAttr(RES_PAGEDESC);
680 : OSL_ENSURE( bResult, "FormatPageDesc not deleted" );
681 : (void) bResult; // unused in non-debug
682 : }
683 2425 : else if( IS_TYPE( SwContentNode, pDefinedIn ))
684 : {
685 : bool const bResult = static_cast<SwContentNode*>(pDefinedIn)
686 0 : ->ResetAttr(RES_PAGEDESC);
687 : OSL_ENSURE( bResult, "FormatPageDesc not deleted" );
688 : (void) bResult; // unused in non-debug
689 : }
690 2425 : break;
691 :
692 : default:
693 : /* do nothing */;
694 : }
695 : }
696 :
697 129 : bool SwFormatPageDesc::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
698 : {
699 : // here we convert always!
700 129 : nMemberId &= ~CONVERT_TWIPS;
701 129 : bool bRet = true;
702 129 : switch ( nMemberId )
703 : {
704 : case MID_PAGEDESC_PAGENUMOFFSET:
705 : {
706 74 : ::boost::optional<sal_uInt16> oOffset = GetNumOffset();
707 74 : if (oOffset)
708 : {
709 4 : rVal <<= (sal_Int16)oOffset.get();
710 : }
711 : else
712 : {
713 70 : rVal.clear();
714 74 : }
715 : }
716 74 : break;
717 :
718 : case MID_PAGEDESC_PAGEDESCNAME:
719 : {
720 55 : const SwPageDesc* pDesc = GetPageDesc();
721 55 : if( pDesc )
722 : {
723 47 : OUString aString;
724 47 : SwStyleNameMapper::FillProgName(pDesc->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, true );
725 47 : rVal <<= aString;
726 : }
727 : else
728 8 : rVal.clear();
729 : }
730 55 : break;
731 : default:
732 : OSL_ENSURE( false, "unknown MemberId" );
733 0 : bRet = false;
734 : }
735 129 : return bRet;
736 : }
737 :
738 344 : bool SwFormatPageDesc::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
739 : {
740 : // here we convert always!
741 344 : nMemberId &= ~CONVERT_TWIPS;
742 344 : bool bRet = true;
743 344 : switch ( nMemberId )
744 : {
745 : case MID_PAGEDESC_PAGENUMOFFSET:
746 : {
747 344 : sal_Int16 nOffset = 0;
748 344 : if (!rVal.hasValue())
749 : {
750 230 : SetNumOffset(boost::none);
751 : }
752 114 : else if (rVal >>= nOffset)
753 114 : SetNumOffset( nOffset );
754 : else
755 0 : bRet = false;
756 : }
757 344 : break;
758 :
759 : case MID_PAGEDESC_PAGEDESCNAME:
760 : /* Doesn't work, because the attribute doesn't need the name but a
761 : * pointer to the PageDesc (it's a client of it). The pointer can
762 : * only be requested from the document using the name.
763 : */
764 : default:
765 : OSL_ENSURE( false, "unknown MemberId" );
766 0 : bRet = false;
767 : }
768 344 : return bRet;
769 : }
770 :
771 0 : void SwFormatPageDesc::dumpAsXml(xmlTextWriterPtr pWriter) const
772 : {
773 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatPageDesc"));
774 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
775 0 : if (oNumOffset)
776 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("oNumOffset"), BAD_CAST(OString::number(*oNumOffset).getStr()));
777 : else
778 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("oNumOffset"), BAD_CAST("none"));
779 0 : xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("pPageDesc"), "%p", GetPageDesc());
780 0 : if (const SwPageDesc* pPageDesc = GetPageDesc())
781 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(pPageDesc->GetName().toUtf8().getStr()));
782 0 : xmlTextWriterEndElement(pWriter);
783 0 : }
784 :
785 : // class SwFormatCol
786 : // Partially implemented inline in hxx
787 :
788 237 : SwColumn::SwColumn() :
789 : nWish ( 0 ),
790 : nUpper( 0 ),
791 : nLower( 0 ),
792 : nLeft ( 0 ),
793 237 : nRight( 0 )
794 : {
795 237 : }
796 :
797 75 : bool SwColumn::operator==( const SwColumn &rCmp ) const
798 : {
799 150 : return nWish == rCmp.GetWishWidth() &&
800 150 : GetLeft() == rCmp.GetLeft() &&
801 113 : GetRight() == rCmp.GetRight() &&
802 151 : GetUpper() == rCmp.GetUpper() &&
803 113 : GetLower() == rCmp.GetLower();
804 : }
805 :
806 0 : void SwColumn::dumpAsXml(xmlTextWriterPtr pWriter) const
807 : {
808 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swColumn"));
809 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWish"), BAD_CAST(OString::number(nWish).getStr()));
810 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(nUpper).getStr()));
811 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(nLower).getStr()));
812 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeft"), BAD_CAST(OString::number(nLeft).getStr()));
813 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRight"), BAD_CAST(OString::number(nRight).getStr()));
814 0 : xmlTextWriterEndElement(pWriter);
815 0 : }
816 :
817 1090 : SwFormatCol::SwFormatCol( const SwFormatCol& rCpy )
818 : : SfxPoolItem( RES_COL ),
819 : m_eLineStyle( rCpy.m_eLineStyle ),
820 : m_nLineWidth( rCpy.m_nLineWidth),
821 : m_aLineColor( rCpy.m_aLineColor),
822 1090 : m_nLineHeight( rCpy.GetLineHeight() ),
823 1090 : m_eAdj( rCpy.GetLineAdj() ),
824 1090 : m_aColumns( (sal_Int8)rCpy.GetNumCols() ),
825 1090 : m_nWidth( rCpy.GetWishWidth() ),
826 : m_aWidthAdjustValue( rCpy.m_aWidthAdjustValue ),
827 5450 : m_bOrtho( rCpy.IsOrtho() )
828 : {
829 1343 : for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i )
830 : {
831 253 : SwColumn *pCol = new SwColumn( rCpy.GetColumns()[i] );
832 253 : m_aColumns.push_back( pCol );
833 : }
834 1090 : }
835 :
836 2470 : SwFormatCol::~SwFormatCol() {}
837 :
838 0 : SwFormatCol& SwFormatCol::operator=( const SwFormatCol& rCpy )
839 : {
840 0 : m_eLineStyle = rCpy.m_eLineStyle;
841 0 : m_nLineWidth = rCpy.m_nLineWidth;
842 0 : m_aLineColor = rCpy.m_aLineColor;
843 0 : m_nLineHeight = rCpy.GetLineHeight();
844 0 : m_eAdj = rCpy.GetLineAdj();
845 0 : m_nWidth = rCpy.GetWishWidth();
846 0 : m_aWidthAdjustValue = rCpy.m_aWidthAdjustValue;
847 0 : m_bOrtho = rCpy.IsOrtho();
848 :
849 0 : if ( !m_aColumns.empty() )
850 0 : m_aColumns.clear();
851 0 : for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i )
852 : {
853 0 : SwColumn *pCol = new SwColumn( rCpy.GetColumns()[i] );
854 0 : m_aColumns.push_back( pCol );
855 : }
856 0 : return *this;
857 : }
858 :
859 418 : SwFormatCol::SwFormatCol()
860 : : SfxPoolItem( RES_COL )
861 : , m_eLineStyle( table::BorderLineStyle::NONE)
862 : ,
863 : m_nLineWidth(0),
864 : m_nLineHeight( 100 ),
865 : m_eAdj( COLADJ_NONE ),
866 : m_nWidth( USHRT_MAX ),
867 : m_aWidthAdjustValue( 0 ),
868 418 : m_bOrtho( true )
869 : {
870 418 : }
871 :
872 1182 : bool SwFormatCol::operator==( const SfxPoolItem& rAttr ) const
873 : {
874 : assert(SfxPoolItem::operator==(rAttr));
875 1182 : const SwFormatCol &rCmp = static_cast<const SwFormatCol&>(rAttr);
876 3546 : if( !(m_eLineStyle == rCmp.m_eLineStyle &&
877 2364 : m_nLineWidth == rCmp.m_nLineWidth &&
878 2364 : m_aLineColor == rCmp.m_aLineColor &&
879 2364 : m_nLineHeight == rCmp.GetLineHeight() &&
880 2358 : m_eAdj == rCmp.GetLineAdj() &&
881 1960 : m_nWidth == rCmp.GetWishWidth() &&
882 1512 : m_bOrtho == rCmp.IsOrtho() &&
883 728 : m_aColumns.size() == rCmp.GetNumCols() &&
884 483 : m_aWidthAdjustValue == rCmp.GetAdjustValue()
885 1665 : ) )
886 699 : return false;
887 :
888 521 : for ( size_t i = 0; i < m_aColumns.size(); ++i )
889 75 : if ( !(m_aColumns[i] == rCmp.GetColumns()[i]) )
890 37 : return false;
891 :
892 446 : return true;
893 : }
894 :
895 570 : SfxPoolItem* SwFormatCol::Clone( SfxItemPool* ) const
896 : {
897 570 : return new SwFormatCol( *this );
898 : }
899 :
900 204 : sal_uInt16 SwFormatCol::GetGutterWidth( bool bMin ) const
901 : {
902 204 : sal_uInt16 nRet = 0;
903 204 : if ( m_aColumns.size() == 2 )
904 24 : nRet = m_aColumns[0].GetRight() + m_aColumns[1].GetLeft();
905 180 : else if ( m_aColumns.size() > 2 )
906 : {
907 10 : bool bSet = false;
908 30 : for ( size_t i = 1; i+1 < m_aColumns.size(); ++i )
909 : {
910 20 : const sal_uInt16 nTmp = m_aColumns[i].GetRight() + m_aColumns[i+1].GetLeft();
911 20 : if ( bSet )
912 : {
913 10 : if ( nTmp != nRet )
914 : {
915 0 : if ( !bMin )
916 0 : return USHRT_MAX;
917 0 : if ( nRet > nTmp )
918 0 : nRet = nTmp;
919 : }
920 : }
921 : else
922 : {
923 10 : bSet = true;
924 10 : nRet = nTmp;
925 : }
926 : }
927 : }
928 204 : return nRet;
929 : }
930 :
931 0 : void SwFormatCol::SetGutterWidth( sal_uInt16 nNew, sal_uInt16 nAct )
932 : {
933 0 : if ( m_bOrtho )
934 0 : Calc( nNew, nAct );
935 : else
936 : {
937 0 : sal_uInt16 nHalf = nNew / 2;
938 0 : for ( size_t i = 0; i < m_aColumns.size(); ++i )
939 : {
940 0 : SwColumn *pCol = &m_aColumns[i];
941 0 : pCol->SetLeft ( nHalf );
942 0 : pCol->SetRight( nHalf );
943 0 : if ( i == 0 )
944 0 : pCol->SetLeft( 0 );
945 0 : else if ( i+1 == m_aColumns.size() )
946 0 : pCol->SetRight( 0 );
947 : }
948 : }
949 0 : }
950 :
951 7 : void SwFormatCol::Init( sal_uInt16 nNumCols, sal_uInt16 nGutterWidth, sal_uInt16 nAct )
952 : {
953 : // Deleting seems to be a bit radical on the first sight; but otherwise we
954 : // have to initialize all values of the remaining SwCloumns.
955 7 : if ( !m_aColumns.empty() )
956 0 : m_aColumns.clear();
957 21 : for ( sal_uInt16 i = 0; i < nNumCols; ++i )
958 : {
959 14 : SwColumn *pCol = new SwColumn;
960 14 : m_aColumns.push_back( pCol );
961 : }
962 7 : m_bOrtho = true;
963 7 : m_nWidth = USHRT_MAX;
964 7 : if( nNumCols )
965 7 : Calc( nGutterWidth, nAct );
966 7 : }
967 :
968 0 : void SwFormatCol::SetOrtho( bool bNew, sal_uInt16 nGutterWidth, sal_uInt16 nAct )
969 : {
970 0 : m_bOrtho = bNew;
971 0 : if ( bNew && !m_aColumns.empty() )
972 0 : Calc( nGutterWidth, nAct );
973 0 : }
974 :
975 764 : sal_uInt16 SwFormatCol::CalcColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const
976 : {
977 : assert(nCol < m_aColumns.size());
978 764 : if ( m_nWidth != nAct )
979 : {
980 717 : long nW = m_aColumns[nCol].GetWishWidth();
981 717 : nW *= nAct;
982 717 : nW /= m_nWidth;
983 717 : return sal_uInt16(nW);
984 : }
985 : else
986 47 : return m_aColumns[nCol].GetWishWidth();
987 : }
988 :
989 59 : sal_uInt16 SwFormatCol::CalcPrtColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const
990 : {
991 : assert(nCol < m_aColumns.size());
992 59 : sal_uInt16 nRet = CalcColWidth( nCol, nAct );
993 59 : const SwColumn *pCol = &m_aColumns[nCol];
994 59 : nRet = nRet - pCol->GetLeft();
995 59 : nRet = nRet - pCol->GetRight();
996 59 : return nRet;
997 : }
998 :
999 7 : void SwFormatCol::Calc( sal_uInt16 nGutterWidth, sal_uInt16 nAct )
1000 : {
1001 7 : if(!GetNumCols())
1002 7 : return;
1003 : //First set the column widths with the current width, then calculate the
1004 : //column's requested width using the requested total width.
1005 :
1006 7 : const sal_uInt16 nGutterHalf = nGutterWidth ? nGutterWidth / 2 : 0;
1007 :
1008 : //Width of PrtAreas is totalwidth - spacings / count
1009 : const sal_uInt16 nPrtWidth =
1010 7 : (nAct - ((GetNumCols()-1) * nGutterWidth)) / GetNumCols();
1011 7 : sal_uInt16 nAvail = nAct;
1012 :
1013 : //The fist column is PrtWidth + (gap width / 2)
1014 7 : const sal_uInt16 nLeftWidth = nPrtWidth + nGutterHalf;
1015 7 : SwColumn *pCol = &m_aColumns.front();
1016 7 : pCol->SetWishWidth( nLeftWidth );
1017 7 : pCol->SetRight( nGutterHalf );
1018 7 : pCol->SetLeft ( 0 );
1019 7 : nAvail = nAvail - nLeftWidth;
1020 :
1021 : //Column 2 to n-1 is PrtWidth + gap width
1022 7 : const sal_uInt16 nMidWidth = nPrtWidth + nGutterWidth;
1023 : sal_uInt16 i;
1024 :
1025 7 : for ( i = 1; i < GetNumCols()-1; ++i )
1026 : {
1027 0 : pCol = &m_aColumns[i];
1028 0 : pCol->SetWishWidth( nMidWidth );
1029 0 : pCol->SetLeft ( nGutterHalf );
1030 0 : pCol->SetRight( nGutterHalf );
1031 0 : nAvail = nAvail - nMidWidth;
1032 : }
1033 :
1034 : //The last column is equivalent to the first one - to compensate rounding
1035 : //errors we add the remaining space of the other columns to the last one.
1036 7 : pCol = &m_aColumns.back();
1037 7 : pCol->SetWishWidth( nAvail );
1038 7 : pCol->SetLeft ( nGutterHalf );
1039 7 : pCol->SetRight( 0 );
1040 :
1041 : //Convert the current width to the requested width.
1042 21 : for ( i = 0; i < m_aColumns.size(); ++i )
1043 : {
1044 14 : pCol = &m_aColumns[i];
1045 14 : long nTmp = pCol->GetWishWidth();
1046 14 : nTmp *= GetWishWidth();
1047 14 : nTmp /= nAct;
1048 14 : pCol->SetWishWidth( sal_uInt16(nTmp) );
1049 : }
1050 : }
1051 :
1052 190 : bool SwFormatCol::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1053 : {
1054 : // here we convert always!
1055 190 : nMemberId &= ~CONVERT_TWIPS;
1056 190 : if(MID_COLUMN_SEPARATOR_LINE == nMemberId)
1057 : {
1058 : OSL_FAIL("not implemented");
1059 : }
1060 : else
1061 : {
1062 190 : uno::Reference< text::XTextColumns > xCols = new SwXTextColumns(*this);
1063 190 : rVal.setValue(&xCols, cppu::UnoType<text::XTextColumns>::get());
1064 : }
1065 190 : return true;
1066 : }
1067 :
1068 237 : bool SwFormatCol::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1069 : {
1070 : // here we convert always!
1071 237 : nMemberId &= ~CONVERT_TWIPS;
1072 237 : bool bRet = false;
1073 237 : if(MID_COLUMN_SEPARATOR_LINE == nMemberId)
1074 : {
1075 : OSL_FAIL("not implemented");
1076 : }
1077 : else
1078 : {
1079 237 : uno::Reference< text::XTextColumns > xCols;
1080 237 : rVal >>= xCols;
1081 237 : if(xCols.is())
1082 : {
1083 237 : uno::Sequence<text::TextColumn> aSetColumns = xCols->getColumns();
1084 237 : const text::TextColumn* pArray = aSetColumns.getConstArray();
1085 237 : m_aColumns.clear();
1086 : //max count is 64k here - this is something the array can't do
1087 237 : sal_uInt16 nCount = std::min( (sal_uInt16)aSetColumns.getLength(),
1088 474 : (sal_uInt16) 0x3fff );
1089 237 : sal_uInt16 nWidthSum = 0;
1090 : // #101224# one column is no column
1091 :
1092 237 : if(nCount > 1)
1093 312 : for(sal_uInt16 i = 0; i < nCount; i++)
1094 : {
1095 223 : SwColumn* pCol = new SwColumn;
1096 223 : pCol->SetWishWidth( static_cast<sal_uInt16>(pArray[i].Width) );
1097 223 : nWidthSum = static_cast<sal_uInt16>(nWidthSum + pArray[i].Width);
1098 223 : pCol->SetLeft ( static_cast<sal_uInt16>(convertMm100ToTwip(pArray[i].LeftMargin)) );
1099 223 : pCol->SetRight( static_cast<sal_uInt16>(convertMm100ToTwip(pArray[i].RightMargin)) );
1100 223 : m_aColumns.insert(m_aColumns.begin() + i, pCol);
1101 : }
1102 237 : bRet = true;
1103 237 : m_nWidth = nWidthSum;
1104 237 : m_bOrtho = false;
1105 :
1106 474 : uno::Reference<lang::XUnoTunnel> xNumTunnel(xCols, uno::UNO_QUERY);
1107 237 : SwXTextColumns* pSwColums = 0;
1108 237 : if(xNumTunnel.is())
1109 : {
1110 : pSwColums = reinterpret_cast< SwXTextColumns * >(
1111 : sal::static_int_cast< sal_IntPtr >(
1112 237 : xNumTunnel->getSomething( SwXTextColumns::getUnoTunnelId() )));
1113 : }
1114 237 : if(pSwColums)
1115 : {
1116 237 : m_bOrtho = pSwColums->IsAutomaticWidth();
1117 237 : m_nLineWidth = pSwColums->GetSepLineWidth();
1118 237 : m_aLineColor.SetColor(pSwColums->GetSepLineColor());
1119 237 : m_nLineHeight = pSwColums->GetSepLineHeightRelative();
1120 237 : switch ( pSwColums->GetSepLineStyle() )
1121 : {
1122 : default:
1123 237 : case 0: m_eLineStyle = table::BorderLineStyle::NONE; break;
1124 0 : case 1: m_eLineStyle = table::BorderLineStyle::SOLID; break;
1125 0 : case 2: m_eLineStyle = table::BorderLineStyle::DOTTED; break;
1126 0 : case 3: m_eLineStyle = table::BorderLineStyle::DASHED; break;
1127 : }
1128 237 : if(!pSwColums->GetSepLineIsOn())
1129 236 : m_eAdj = COLADJ_NONE;
1130 1 : else switch(pSwColums->GetSepLineVertAlign())
1131 : {
1132 0 : case 0: m_eAdj = COLADJ_TOP; break; //VerticalAlignment_TOP
1133 1 : case 1: m_eAdj = COLADJ_CENTER;break; //VerticalAlignment_MIDDLE
1134 0 : case 2: m_eAdj = COLADJ_BOTTOM;break; //VerticalAlignment_BOTTOM
1135 0 : default: OSL_ENSURE( false, "unknown alignment" ); break;
1136 : }
1137 237 : }
1138 237 : }
1139 : }
1140 237 : return bRet;
1141 : }
1142 :
1143 0 : void SwFormatCol::dumpAsXml(xmlTextWriterPtr pWriter) const
1144 : {
1145 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatCol"));
1146 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1147 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLineStyle"), BAD_CAST(OString::number(m_eLineStyle).getStr()));
1148 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLineWidth"), BAD_CAST(OString::number(m_nLineWidth).getStr()));
1149 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aLineColor"), BAD_CAST(m_aLineColor.AsRGBHexString().toUtf8().getStr()));
1150 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLineHeight"), BAD_CAST(OString::number(m_nLineHeight).getStr()));
1151 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eAdj"), BAD_CAST(OString::number(m_eAdj).getStr()));
1152 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(m_nWidth).getStr()));
1153 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidthAdjustValue"), BAD_CAST(OString::number(m_aWidthAdjustValue).getStr()));
1154 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bOrtho"), BAD_CAST(OString::boolean(m_bOrtho).getStr()));
1155 :
1156 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("aColumns"));
1157 0 : for (const SwColumn& rColumn : m_aColumns)
1158 0 : rColumn.dumpAsXml(pWriter);
1159 0 : xmlTextWriterEndElement(pWriter);
1160 :
1161 0 : xmlTextWriterEndElement(pWriter);
1162 0 : }
1163 :
1164 : // Partially implemented inline in hxx
1165 1634 : SwFormatSurround::SwFormatSurround( SwSurround eFly ) :
1166 1634 : SfxEnumItem( RES_SURROUND, sal_uInt16( eFly ) )
1167 : {
1168 1634 : bAnchorOnly = bContour = bOutside = false;
1169 1634 : }
1170 :
1171 7126 : SwFormatSurround::SwFormatSurround( const SwFormatSurround &rCpy ) :
1172 7126 : SfxEnumItem( RES_SURROUND, rCpy.GetValue() )
1173 : {
1174 7126 : bAnchorOnly = rCpy.bAnchorOnly;
1175 7126 : bContour = rCpy.bContour;
1176 7126 : bOutside = rCpy.bOutside;
1177 7126 : }
1178 :
1179 8734 : bool SwFormatSurround::operator==( const SfxPoolItem& rAttr ) const
1180 : {
1181 : assert(SfxPoolItem::operator==(rAttr));
1182 12510 : return ( GetValue() == static_cast<const SwFormatSurround&>(rAttr).GetValue() &&
1183 7548 : bAnchorOnly== static_cast<const SwFormatSurround&>(rAttr).bAnchorOnly &&
1184 16234 : bContour== static_cast<const SwFormatSurround&>(rAttr).bContour &&
1185 12462 : bOutside== static_cast<const SwFormatSurround&>(rAttr).bOutside );
1186 : }
1187 :
1188 6623 : SfxPoolItem* SwFormatSurround::Clone( SfxItemPool* ) const
1189 : {
1190 6623 : return new SwFormatSurround( *this );
1191 : }
1192 :
1193 0 : sal_uInt16 SwFormatSurround::GetValueCount() const
1194 : {
1195 0 : return SURROUND_END - SURROUND_BEGIN;
1196 : }
1197 :
1198 : namespace
1199 : {
1200 187 : text::WrapTextMode SwSurroundToWrapMode(SwSurround eSurround)
1201 : {
1202 : text::WrapTextMode eRet;
1203 187 : switch(eSurround)
1204 : {
1205 : case SURROUND_THROUGHT:
1206 153 : eRet = css::text::WrapTextMode_THROUGHT;
1207 153 : break;
1208 : case SURROUND_PARALLEL:
1209 19 : eRet = css::text::WrapTextMode_PARALLEL;
1210 19 : break;
1211 : case SURROUND_IDEAL:
1212 9 : eRet = css::text::WrapTextMode_DYNAMIC;
1213 9 : break;
1214 : case SURROUND_LEFT:
1215 0 : eRet = css::text::WrapTextMode_LEFT;
1216 0 : break;
1217 : case SURROUND_RIGHT:
1218 0 : eRet = css::text::WrapTextMode_RIGHT;
1219 0 : break;
1220 : default:
1221 6 : eRet = css::text::WrapTextMode_NONE;
1222 6 : break;
1223 : }
1224 187 : return eRet;
1225 : }
1226 : }
1227 :
1228 438 : bool SwFormatSurround::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1229 : {
1230 : // here we convert always!
1231 438 : nMemberId &= ~CONVERT_TWIPS;
1232 438 : bool bRet = true;
1233 438 : switch ( nMemberId )
1234 : {
1235 : case MID_SURROUND_SURROUNDTYPE:
1236 187 : rVal <<= SwSurroundToWrapMode(GetSurround());
1237 187 : break;
1238 : case MID_SURROUND_ANCHORONLY:
1239 121 : rVal <<= IsAnchorOnly();
1240 121 : break;
1241 : case MID_SURROUND_CONTOUR:
1242 65 : rVal <<= IsContour();
1243 65 : break;
1244 : case MID_SURROUND_CONTOUROUTSIDE:
1245 65 : rVal <<= IsOutside();
1246 65 : break;
1247 : default:
1248 : OSL_ENSURE( false, "unknown MemberId" );
1249 0 : bRet = false;
1250 : }
1251 438 : return bRet;
1252 : }
1253 :
1254 4530 : bool SwFormatSurround::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1255 : {
1256 : // here we convert always!
1257 4530 : nMemberId &= ~CONVERT_TWIPS;
1258 4530 : bool bRet = true;
1259 4530 : switch ( nMemberId )
1260 : {
1261 : case MID_SURROUND_SURROUNDTYPE:
1262 : {
1263 3062 : sal_Int32 eVal = SWUnoHelper::GetEnumAsInt32( rVal );
1264 3062 : if( eVal >= 0 && eVal < SURROUND_END )
1265 3062 : SetValue( static_cast<sal_uInt16>(eVal) );
1266 : else {
1267 : //exception
1268 : ;
1269 : }
1270 : }
1271 3062 : break;
1272 :
1273 : case MID_SURROUND_ANCHORONLY:
1274 281 : SetAnchorOnly( *static_cast<sal_Bool const *>(rVal.getValue()) );
1275 281 : break;
1276 : case MID_SURROUND_CONTOUR:
1277 1096 : SetContour( *static_cast<sal_Bool const *>(rVal.getValue()) );
1278 1096 : break;
1279 : case MID_SURROUND_CONTOUROUTSIDE:
1280 91 : SetOutside( *static_cast<sal_Bool const *>(rVal.getValue()) );
1281 91 : break;
1282 : default:
1283 : OSL_ENSURE( false, "unknown MemberId" );
1284 0 : bRet = false;
1285 : }
1286 4530 : return bRet;
1287 : }
1288 :
1289 0 : void SwFormatSurround::dumpAsXml(xmlTextWriterPtr pWriter) const
1290 : {
1291 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatSurround"));
1292 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1293 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
1294 :
1295 0 : OUString aPresentation;
1296 0 : GetPresentation(SFX_ITEM_PRESENTATION_NAMELESS, SFX_MAPUNIT_100TH_MM, SFX_MAPUNIT_100TH_MM, aPresentation);
1297 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
1298 :
1299 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAnchorOnly"), BAD_CAST(OString::boolean(bAnchorOnly).getStr()));
1300 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContour"), BAD_CAST(OString::boolean(bContour).getStr()));
1301 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bOutside"), BAD_CAST(OString::boolean(bOutside).getStr()));
1302 :
1303 0 : xmlTextWriterEndElement(pWriter);
1304 0 : }
1305 :
1306 0 : SvStream& SwFormatVertOrient::Store(SvStream &rStream, sal_uInt16 /*version*/) const
1307 : {
1308 : #if SAL_TYPES_SIZEOFLONG == 8
1309 0 : rStream.WriteInt64(m_nYPos);
1310 : #else
1311 : rStream.WriteInt32(m_nYPos);
1312 : #endif
1313 0 : rStream.WriteInt16( m_eOrient ).WriteInt16( m_eRelation );
1314 0 : return rStream;
1315 : }
1316 :
1317 0 : SfxPoolItem* SwFormatVertOrient::Create(SvStream &rStream, sal_uInt16 /*itemVersion*/) const
1318 : {
1319 0 : SwTwips yPos(0);
1320 0 : sal_Int16 orient(0);
1321 0 : sal_Int16 relation(0);
1322 : // compatibility hack for Table Auto Format: SwTwips is "long" :(
1323 : // (this means that the file format is platform dependent)
1324 : #if SAL_TYPES_SIZEOFLONG == 8
1325 0 : rStream.ReadInt64(yPos);
1326 : #else
1327 : sal_Int32 n;
1328 : rStream.ReadInt32(n);
1329 : yPos = n;
1330 : #endif
1331 0 : rStream.ReadInt16( orient ).ReadInt16( relation );
1332 :
1333 0 : return new SwFormatVertOrient(yPos, orient, relation);
1334 : }
1335 :
1336 : // Partially implemented inline in hxx
1337 6798842 : SwFormatVertOrient::SwFormatVertOrient( SwTwips nY, sal_Int16 eVert,
1338 : sal_Int16 eRel )
1339 : : SfxPoolItem( RES_VERT_ORIENT ),
1340 : m_nYPos( nY ),
1341 : m_eOrient( eVert ),
1342 6798842 : m_eRelation( eRel )
1343 6798842 : {}
1344 :
1345 59121 : bool SwFormatVertOrient::operator==( const SfxPoolItem& rAttr ) const
1346 : {
1347 : assert(SfxPoolItem::operator==(rAttr));
1348 77967 : return ( m_nYPos == static_cast<const SwFormatVertOrient&>(rAttr).m_nYPos &&
1349 71658 : m_eOrient == static_cast<const SwFormatVertOrient&>(rAttr).m_eOrient &&
1350 71658 : m_eRelation == static_cast<const SwFormatVertOrient&>(rAttr).m_eRelation );
1351 : }
1352 :
1353 14224 : SfxPoolItem* SwFormatVertOrient::Clone( SfxItemPool* ) const
1354 : {
1355 14224 : return new SwFormatVertOrient( m_nYPos, m_eOrient, m_eRelation );
1356 : }
1357 :
1358 10868 : bool SwFormatVertOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1359 : {
1360 : // here we convert always!
1361 10868 : nMemberId &= ~CONVERT_TWIPS;
1362 10868 : bool bRet = true;
1363 10868 : switch ( nMemberId )
1364 : {
1365 : case MID_VERTORIENT_ORIENT:
1366 : {
1367 963 : rVal <<= (sal_Int16)m_eOrient;
1368 : }
1369 963 : break;
1370 : case MID_VERTORIENT_RELATION:
1371 662 : rVal <<= (sal_Int16)m_eRelation;
1372 662 : break;
1373 : case MID_VERTORIENT_POSITION:
1374 9243 : rVal <<= (sal_Int32)convertTwipToMm100(GetPos());
1375 9243 : break;
1376 : default:
1377 : OSL_ENSURE( false, "unknown MemberId" );
1378 0 : bRet = false;
1379 : }
1380 10868 : return bRet;
1381 : }
1382 :
1383 9737 : bool SwFormatVertOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1384 : {
1385 9737 : bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
1386 9737 : nMemberId &= ~CONVERT_TWIPS;
1387 9737 : bool bRet = true;
1388 9737 : switch ( nMemberId )
1389 : {
1390 : case MID_VERTORIENT_ORIENT:
1391 : {
1392 4446 : sal_uInt16 nVal = text::VertOrientation::NONE;
1393 4446 : rVal >>= nVal;
1394 4446 : m_eOrient = nVal;
1395 : }
1396 4446 : break;
1397 : case MID_VERTORIENT_RELATION:
1398 : {
1399 3274 : m_eRelation = lcl_IntToRelation(rVal);
1400 : }
1401 3274 : break;
1402 : case MID_VERTORIENT_POSITION:
1403 : {
1404 2017 : sal_Int32 nVal = 0;
1405 2017 : rVal >>= nVal;
1406 2017 : if(bConvert)
1407 2017 : nVal = convertMm100ToTwip(nVal);
1408 2017 : SetPos( nVal );
1409 : }
1410 2017 : break;
1411 : default:
1412 : OSL_ENSURE( false, "unknown MemberId" );
1413 0 : bRet = false;
1414 : }
1415 9737 : return bRet;
1416 : }
1417 :
1418 0 : void SwFormatVertOrient::dumpAsXml(xmlTextWriterPtr pWriter) const
1419 : {
1420 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatVertOrient"));
1421 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1422 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nYPos"), BAD_CAST(OString::number(m_nYPos).getStr()));
1423 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eOrient"), BAD_CAST(OString::number(m_eOrient).getStr()));
1424 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eRelation"), BAD_CAST(OString::number(m_eRelation).getStr()));
1425 0 : xmlTextWriterEndElement(pWriter);
1426 0 : }
1427 :
1428 : // Partially implemented inline in hxx
1429 17302 : SwFormatHoriOrient::SwFormatHoriOrient( SwTwips nX, sal_Int16 eHori,
1430 : sal_Int16 eRel, bool bPos )
1431 : : SfxPoolItem( RES_HORI_ORIENT ),
1432 : m_nXPos( nX ),
1433 : m_eOrient( eHori ),
1434 : m_eRelation( eRel ),
1435 17302 : m_bPosToggle( bPos )
1436 17302 : {}
1437 :
1438 62451 : bool SwFormatHoriOrient::operator==( const SfxPoolItem& rAttr ) const
1439 : {
1440 : assert(SfxPoolItem::operator==(rAttr));
1441 76738 : return ( m_nXPos == static_cast<const SwFormatHoriOrient&>(rAttr).m_nXPos &&
1442 24707 : m_eOrient == static_cast<const SwFormatHoriOrient&>(rAttr).m_eOrient &&
1443 80467 : m_eRelation == static_cast<const SwFormatHoriOrient&>(rAttr).m_eRelation &&
1444 70047 : m_bPosToggle == static_cast<const SwFormatHoriOrient&>(rAttr).m_bPosToggle );
1445 : }
1446 :
1447 13329 : SfxPoolItem* SwFormatHoriOrient::Clone( SfxItemPool* ) const
1448 : {
1449 13329 : return new SwFormatHoriOrient( m_nXPos, m_eOrient, m_eRelation, m_bPosToggle );
1450 : }
1451 :
1452 11054 : bool SwFormatHoriOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1453 : {
1454 : // here we convert always!
1455 11054 : nMemberId &= ~CONVERT_TWIPS;
1456 11054 : bool bRet = true;
1457 11054 : switch ( nMemberId )
1458 : {
1459 : case MID_HORIORIENT_ORIENT:
1460 : {
1461 947 : rVal <<= (sal_Int16)m_eOrient;
1462 : }
1463 947 : break;
1464 : case MID_HORIORIENT_RELATION:
1465 662 : rVal <<= (sal_Int16)m_eRelation;
1466 662 : break;
1467 : case MID_HORIORIENT_POSITION:
1468 9246 : rVal <<= (sal_Int32)convertTwipToMm100(GetPos());
1469 9246 : break;
1470 : case MID_HORIORIENT_PAGETOGGLE:
1471 199 : rVal <<= IsPosToggle();
1472 199 : break;
1473 : default:
1474 : OSL_ENSURE( false, "unknown MemberId" );
1475 0 : bRet = false;
1476 : }
1477 11054 : return bRet;
1478 : }
1479 :
1480 9382 : bool SwFormatHoriOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1481 : {
1482 9382 : bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
1483 9382 : nMemberId &= ~CONVERT_TWIPS;
1484 9382 : bool bRet = true;
1485 9382 : switch ( nMemberId )
1486 : {
1487 : case MID_HORIORIENT_ORIENT:
1488 : {
1489 3269 : sal_Int16 nVal = text::HoriOrientation::NONE;
1490 3269 : rVal >>= nVal;
1491 3269 : m_eOrient = nVal;
1492 : }
1493 3269 : break;
1494 : case MID_HORIORIENT_RELATION:
1495 : {
1496 2613 : m_eRelation = lcl_IntToRelation(rVal);
1497 : }
1498 2613 : break;
1499 : case MID_HORIORIENT_POSITION:
1500 : {
1501 2046 : sal_Int32 nVal = 0;
1502 2046 : if(!(rVal >>= nVal))
1503 0 : bRet = false;
1504 2046 : if(bConvert)
1505 2046 : nVal = convertMm100ToTwip(nVal);
1506 2046 : SetPos( nVal );
1507 : }
1508 2046 : break;
1509 : case MID_HORIORIENT_PAGETOGGLE:
1510 1454 : SetPosToggle( *static_cast<sal_Bool const *>(rVal.getValue()));
1511 1454 : break;
1512 : default:
1513 : OSL_ENSURE( false, "unknown MemberId" );
1514 0 : bRet = false;
1515 : }
1516 9382 : return bRet;
1517 : }
1518 :
1519 0 : void SwFormatHoriOrient::dumpAsXml(xmlTextWriterPtr pWriter) const
1520 : {
1521 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatHoriOrient"));
1522 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1523 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nXPos"), BAD_CAST(OString::number(m_nXPos).getStr()));
1524 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eOrient"), BAD_CAST(OString::number(m_eOrient).getStr()));
1525 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eRelation"), BAD_CAST(OString::number(m_eRelation).getStr()));
1526 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bPosToggle"), BAD_CAST(OString::boolean(m_bPosToggle).getStr()));
1527 0 : xmlTextWriterEndElement(pWriter);
1528 0 : }
1529 :
1530 : // Partially implemented inline in hxx
1531 4198 : SwFormatAnchor::SwFormatAnchor( RndStdIds nRnd, sal_uInt16 nPage )
1532 : : SfxPoolItem( RES_ANCHOR ),
1533 : nAnchorId( nRnd ),
1534 : nPageNum( nPage ),
1535 : // OD 2004-05-05 #i28701# - get always new increased order number
1536 4198 : mnOrder( ++mnOrderCounter )
1537 4198 : {}
1538 :
1539 100684 : SwFormatAnchor::SwFormatAnchor( const SwFormatAnchor &rCpy )
1540 : : SfxPoolItem( RES_ANCHOR )
1541 100684 : , m_pContentAnchor( (rCpy.GetContentAnchor())
1542 65082 : ? new SwPosition( *rCpy.GetContentAnchor() ) : 0 )
1543 100684 : , nAnchorId( rCpy.GetAnchorId() )
1544 100684 : , nPageNum( rCpy.GetPageNum() )
1545 : // OD 2004-05-05 #i28701# - get always new increased order number
1546 467818 : , mnOrder( ++mnOrderCounter )
1547 : {
1548 100684 : }
1549 :
1550 189524 : SwFormatAnchor::~SwFormatAnchor()
1551 : {
1552 189524 : }
1553 :
1554 14547 : void SwFormatAnchor::SetAnchor( const SwPosition *pPos )
1555 : {
1556 : // anchor only to paragraphs, or start nodes in case of FLY_AT_FLY
1557 : // also allow table node, this is used when a table is selected and is converted to a frame by the UI
1558 : assert(!pPos
1559 : || ((FLY_AT_FLY == nAnchorId) &&
1560 : dynamic_cast<SwStartNode*>(&pPos->nNode.GetNode()))
1561 : || (FLY_AT_PARA == nAnchorId && dynamic_cast<SwTableNode*>(&pPos->nNode.GetNode()))
1562 : || dynamic_cast<SwTextNode*>(&pPos->nNode.GetNode()));
1563 14547 : m_pContentAnchor .reset( (pPos) ? new SwPosition( *pPos ) : 0 );
1564 : // Flys anchored AT paragraph should not point into the paragraph content
1565 28737 : if (m_pContentAnchor &&
1566 33855 : ((FLY_AT_PARA == nAnchorId) || (FLY_AT_FLY == nAnchorId)))
1567 : {
1568 3027 : m_pContentAnchor->nContent.Assign( 0, 0 );
1569 : }
1570 14547 : }
1571 :
1572 117 : SwFormatAnchor& SwFormatAnchor::operator=(const SwFormatAnchor& rAnchor)
1573 : {
1574 117 : nAnchorId = rAnchor.GetAnchorId();
1575 117 : nPageNum = rAnchor.GetPageNum();
1576 : // OD 2004-05-05 #i28701# - get always new increased order number
1577 117 : mnOrder = ++mnOrderCounter;
1578 :
1579 117 : m_pContentAnchor.reset( (rAnchor.GetContentAnchor())
1580 0 : ? new SwPosition(*(rAnchor.GetContentAnchor()))
1581 117 : : 0 );
1582 117 : return *this;
1583 : }
1584 :
1585 34358 : bool SwFormatAnchor::operator==( const SfxPoolItem& rAttr ) const
1586 : {
1587 : assert(SfxPoolItem::operator==(rAttr));
1588 34358 : SwFormatAnchor const& rFormatAnchor(static_cast<SwFormatAnchor const&>(rAttr));
1589 : // OD 2004-05-05 #i28701# - Note: <mnOrder> hasn't to be considered.
1590 64007 : return ( nAnchorId == rFormatAnchor.GetAnchorId() &&
1591 85464 : nPageNum == rFormatAnchor.GetPageNum() &&
1592 : // compare anchor: either both do not point into a textnode or
1593 : // both do (valid m_pContentAnchor) and the positions are equal
1594 57066 : ((m_pContentAnchor.get() == rFormatAnchor.m_pContentAnchor.get()) ||
1595 79372 : (m_pContentAnchor && rFormatAnchor.GetContentAnchor() &&
1596 58780 : (*m_pContentAnchor == *rFormatAnchor.GetContentAnchor()))));
1597 : }
1598 :
1599 84385 : SfxPoolItem* SwFormatAnchor::Clone( SfxItemPool* ) const
1600 : {
1601 84385 : return new SwFormatAnchor( *this );
1602 : }
1603 :
1604 : // OD 2004-05-05 #i28701#
1605 : sal_uInt32 SwFormatAnchor::mnOrderCounter = 0;
1606 :
1607 : // OD 2004-05-05 #i28701#
1608 :
1609 10665 : bool SwFormatAnchor::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1610 : {
1611 : // here we convert always!
1612 10665 : nMemberId &= ~CONVERT_TWIPS;
1613 10665 : bool bRet = true;
1614 10665 : switch ( nMemberId )
1615 : {
1616 : case MID_ANCHOR_ANCHORTYPE:
1617 :
1618 : text::TextContentAnchorType eRet;
1619 10652 : switch (GetAnchorId())
1620 : {
1621 : case FLY_AT_CHAR:
1622 1706 : eRet = text::TextContentAnchorType_AT_CHARACTER;
1623 1706 : break;
1624 : case FLY_AT_PAGE:
1625 1596 : eRet = text::TextContentAnchorType_AT_PAGE;
1626 1596 : break;
1627 : case FLY_AT_FLY:
1628 9 : eRet = text::TextContentAnchorType_AT_FRAME;
1629 9 : break;
1630 : case FLY_AS_CHAR:
1631 4423 : eRet = text::TextContentAnchorType_AS_CHARACTER;
1632 4423 : break;
1633 : //case FLY_AT_PARA:
1634 : default:
1635 2918 : eRet = text::TextContentAnchorType_AT_PARAGRAPH;
1636 : }
1637 10652 : rVal <<= eRet;
1638 21317 : break;
1639 : case MID_ANCHOR_PAGENUM:
1640 13 : rVal <<= (sal_Int16)GetPageNum();
1641 13 : break;
1642 : case MID_ANCHOR_ANCHORFRAME:
1643 : {
1644 0 : if (m_pContentAnchor && FLY_AT_FLY == nAnchorId)
1645 : {
1646 0 : SwFrameFormat* pFormat = m_pContentAnchor->nNode.GetNode().GetFlyFormat();
1647 0 : if(pFormat)
1648 : {
1649 : uno::Reference<text::XTextFrame> const xRet(
1650 0 : SwXTextFrame::CreateXTextFrame(*pFormat->GetDoc(), pFormat));
1651 0 : rVal <<= xRet;
1652 : }
1653 : }
1654 : }
1655 0 : break;
1656 : default:
1657 : OSL_ENSURE( false, "unknown MemberId" );
1658 0 : bRet = false;
1659 : }
1660 10665 : return bRet;
1661 : }
1662 :
1663 4550 : bool SwFormatAnchor::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1664 : {
1665 : // here we convert always!
1666 4550 : nMemberId &= ~CONVERT_TWIPS;
1667 4550 : bool bRet = true;
1668 4550 : switch ( nMemberId )
1669 : {
1670 : case MID_ANCHOR_ANCHORTYPE:
1671 : {
1672 : RndStdIds eAnchor;
1673 4427 : switch( SWUnoHelper::GetEnumAsInt32( rVal ) )
1674 : {
1675 : case text::TextContentAnchorType_AS_CHARACTER:
1676 2012 : eAnchor = FLY_AS_CHAR;
1677 2012 : break;
1678 : case text::TextContentAnchorType_AT_PAGE:
1679 134 : eAnchor = FLY_AT_PAGE;
1680 134 : if( GetPageNum() > 0 )
1681 : {
1682 : // If the anchor type is page and a valid page number
1683 : // has been set, the content position isn't required
1684 : // any longer.
1685 96 : m_pContentAnchor.reset();
1686 : }
1687 134 : break;
1688 : case text::TextContentAnchorType_AT_FRAME:
1689 9 : eAnchor = FLY_AT_FLY;
1690 9 : break;
1691 : case text::TextContentAnchorType_AT_CHARACTER:
1692 999 : eAnchor = FLY_AT_CHAR;
1693 999 : break;
1694 : //case text::TextContentAnchorType_AT_PARAGRAPH:
1695 : default:
1696 1273 : eAnchor = FLY_AT_PARA;
1697 1273 : break;
1698 : }
1699 4427 : SetType( eAnchor );
1700 : }
1701 4427 : break;
1702 : case MID_ANCHOR_PAGENUM:
1703 : {
1704 123 : sal_Int16 nVal = 0;
1705 123 : if((rVal >>= nVal) && nVal > 0)
1706 : {
1707 123 : SetPageNum( nVal );
1708 123 : if (FLY_AT_PAGE == GetAnchorId())
1709 : {
1710 : // If the anchor type is page and a valid page number
1711 : // is set, the content paoition has to be deleted to not
1712 : // confuse the layout (frmtool.cxx). However, if the
1713 : // anchor type is not page, any content position will
1714 : // be kept.
1715 113 : m_pContentAnchor.reset();
1716 : }
1717 : }
1718 : else
1719 0 : bRet = false;
1720 : }
1721 123 : break;
1722 : case MID_ANCHOR_ANCHORFRAME:
1723 : //no break here!;
1724 : default:
1725 : OSL_ENSURE( false, "unknown MemberId" );
1726 0 : bRet = false;
1727 : }
1728 4550 : return bRet;
1729 : }
1730 :
1731 0 : void SwFormatAnchor::dumpAsXml(xmlTextWriterPtr pWriter) const
1732 : {
1733 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatAnchor"));
1734 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1735 :
1736 0 : if (m_pContentAnchor)
1737 : {
1738 0 : std::stringstream aContentAnchor;
1739 0 : aContentAnchor << *m_pContentAnchor;
1740 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pContentAnchor"), BAD_CAST(aContentAnchor.str().c_str()));
1741 : }
1742 : else
1743 0 : xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("pContentAnchor"), "%p", m_pContentAnchor.get());
1744 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nAnchorType"), BAD_CAST(OString::number(nAnchorId).getStr()));
1745 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPageNum"), BAD_CAST(OString::number(nPageNum).getStr()));
1746 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nOrder"), BAD_CAST(OString::number(mnOrder).getStr()));
1747 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nOrderCounter"), BAD_CAST(OString::number(mnOrderCounter).getStr()));
1748 0 : OUString aPresentation;
1749 0 : GetPresentation(SFX_ITEM_PRESENTATION_NAMELESS, SFX_MAPUNIT_100TH_MM, SFX_MAPUNIT_100TH_MM, aPresentation);
1750 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
1751 :
1752 0 : xmlTextWriterEndElement(pWriter);
1753 0 : }
1754 :
1755 : // Partially implemented inline in hxx
1756 59 : SwFormatURL::SwFormatURL() :
1757 : SfxPoolItem( RES_URL ),
1758 : pMap( 0 ),
1759 59 : bIsServerMap( false )
1760 : {
1761 59 : }
1762 :
1763 70 : SwFormatURL::SwFormatURL( const SwFormatURL &rURL) :
1764 : SfxPoolItem( RES_URL ),
1765 : sTargetFrameName( rURL.GetTargetFrameName() ),
1766 : sURL( rURL.GetURL() ),
1767 : sName( rURL.GetName() ),
1768 70 : bIsServerMap( rURL.IsServerMap() )
1769 : {
1770 70 : pMap = rURL.GetMap() ? new ImageMap( *rURL.GetMap() ) : 0;
1771 70 : }
1772 :
1773 334 : SwFormatURL::~SwFormatURL()
1774 : {
1775 129 : delete pMap;
1776 205 : }
1777 :
1778 65 : bool SwFormatURL::operator==( const SfxPoolItem &rAttr ) const
1779 : {
1780 : assert(SfxPoolItem::operator==(rAttr));
1781 65 : const SwFormatURL &rCmp = static_cast<const SwFormatURL&>(rAttr);
1782 195 : bool bRet = bIsServerMap == rCmp.IsServerMap() &&
1783 386 : sURL == rCmp.GetURL() &&
1784 443 : sTargetFrameName == rCmp.GetTargetFrameName() &&
1785 187 : sName == rCmp.GetName();
1786 65 : if ( bRet )
1787 : {
1788 57 : if ( pMap && rCmp.GetMap() )
1789 1 : bRet = *pMap == *rCmp.GetMap();
1790 : else
1791 56 : bRet = pMap == rCmp.GetMap();
1792 : }
1793 65 : return bRet;
1794 : }
1795 :
1796 17 : SfxPoolItem* SwFormatURL::Clone( SfxItemPool* ) const
1797 : {
1798 17 : return new SwFormatURL( *this );
1799 : }
1800 :
1801 5 : void SwFormatURL::SetURL(const OUString &rURL, bool bServerMap)
1802 : {
1803 5 : sURL = rURL;
1804 5 : bIsServerMap = bServerMap;
1805 5 : }
1806 :
1807 0 : void SwFormatURL::SetMap( const ImageMap *pM )
1808 : {
1809 0 : delete pMap;
1810 0 : pMap = pM ? new ImageMap( *pM ) : 0;
1811 0 : }
1812 :
1813 75 : bool SwFormatURL::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1814 : {
1815 : // here we convert always!
1816 75 : nMemberId &= ~CONVERT_TWIPS;
1817 75 : bool bRet = true;
1818 75 : switch ( nMemberId )
1819 : {
1820 : case MID_URL_URL:
1821 0 : rVal <<= GetURL();
1822 0 : break;
1823 : case MID_URL_TARGET:
1824 0 : rVal <<= GetTargetFrameName();
1825 0 : break;
1826 : case MID_URL_HYPERLINKNAME:
1827 0 : rVal <<= GetName();
1828 0 : break;
1829 : case MID_URL_CLIENTMAP:
1830 : {
1831 75 : uno::Reference< uno::XInterface > xInt;
1832 75 : if(pMap)
1833 : {
1834 0 : xInt = SvUnoImageMap_createInstance( *pMap, sw_GetSupportedMacroItems() );
1835 : }
1836 : else
1837 : {
1838 75 : ImageMap aEmptyMap;
1839 75 : xInt = SvUnoImageMap_createInstance( aEmptyMap, sw_GetSupportedMacroItems() );
1840 : }
1841 150 : uno::Reference< container::XIndexContainer > xCont(xInt, uno::UNO_QUERY);
1842 150 : rVal <<= xCont;
1843 : }
1844 75 : break;
1845 : case MID_URL_SERVERMAP:
1846 0 : rVal <<= IsServerMap();
1847 0 : break;
1848 : default:
1849 : OSL_ENSURE( false, "unknown MemberId" );
1850 0 : bRet = false;
1851 : }
1852 75 : return bRet;
1853 : }
1854 :
1855 9 : bool SwFormatURL::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1856 : {
1857 : // here we convert always!
1858 9 : nMemberId &= ~CONVERT_TWIPS;
1859 9 : bool bRet = true;
1860 9 : switch ( nMemberId )
1861 : {
1862 : case MID_URL_URL:
1863 : {
1864 2 : OUString sTmp;
1865 2 : rVal >>= sTmp;
1866 2 : SetURL( sTmp, bIsServerMap );
1867 : }
1868 2 : break;
1869 : case MID_URL_TARGET:
1870 : {
1871 2 : OUString sTmp;
1872 2 : rVal >>= sTmp;
1873 2 : SetTargetFrameName( sTmp );
1874 : }
1875 2 : break;
1876 : case MID_URL_HYPERLINKNAME:
1877 : {
1878 2 : OUString sTmp;
1879 2 : rVal >>= sTmp;
1880 2 : SetName( sTmp );
1881 : }
1882 2 : break;
1883 : case MID_URL_CLIENTMAP:
1884 : {
1885 1 : uno::Reference<container::XIndexContainer> xCont;
1886 1 : if(!rVal.hasValue())
1887 0 : DELETEZ(pMap);
1888 1 : else if(rVal >>= xCont)
1889 : {
1890 1 : if(!pMap)
1891 1 : pMap = new ImageMap;
1892 1 : bRet = SvUnoImageMap_fillImageMap( xCont, *pMap );
1893 : }
1894 : else
1895 0 : bRet = false;
1896 : }
1897 1 : break;
1898 : case MID_URL_SERVERMAP:
1899 2 : bIsServerMap = *static_cast<sal_Bool const *>(rVal.getValue());
1900 2 : break;
1901 : default:
1902 : OSL_ENSURE( false, "unknown MemberId" );
1903 0 : bRet = false;
1904 : }
1905 9 : return bRet;
1906 : }
1907 :
1908 174 : SfxPoolItem* SwFormatEditInReadonly::Clone( SfxItemPool* ) const
1909 : {
1910 174 : return new SwFormatEditInReadonly( Which(), GetValue() );
1911 : }
1912 :
1913 5 : SfxPoolItem* SwFormatLayoutSplit::Clone( SfxItemPool* ) const
1914 : {
1915 5 : return new SwFormatLayoutSplit( GetValue() );
1916 : }
1917 :
1918 4377 : SfxPoolItem* SwFormatRowSplit::Clone( SfxItemPool* ) const
1919 : {
1920 4377 : return new SwFormatRowSplit( GetValue() );
1921 : }
1922 :
1923 63 : SfxPoolItem* SwFormatNoBalancedColumns::Clone( SfxItemPool* ) const
1924 : {
1925 63 : return new SwFormatNoBalancedColumns( GetValue() );
1926 : }
1927 :
1928 0 : void SwFormatNoBalancedColumns::dumpAsXml(xmlTextWriterPtr pWriter) const
1929 : {
1930 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatNoBalancedColumns"));
1931 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1932 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
1933 0 : xmlTextWriterEndElement(pWriter);
1934 0 : }
1935 :
1936 : // class SwFormatFootnoteEndAtTextEnd
1937 :
1938 0 : sal_uInt16 SwFormatFootnoteEndAtTextEnd::GetValueCount() const
1939 : {
1940 0 : return sal_uInt16( FTNEND_ATTXTEND_END );
1941 : }
1942 :
1943 4 : SwFormatFootnoteEndAtTextEnd& SwFormatFootnoteEndAtTextEnd::operator=(
1944 : const SwFormatFootnoteEndAtTextEnd& rAttr )
1945 : {
1946 4 : SfxEnumItem::SetValue( rAttr.GetValue() );
1947 4 : aFormat = rAttr.aFormat;
1948 4 : nOffset = rAttr.nOffset;
1949 4 : sPrefix = rAttr.sPrefix;
1950 4 : sSuffix = rAttr.sSuffix;
1951 4 : return *this;
1952 : }
1953 :
1954 106 : bool SwFormatFootnoteEndAtTextEnd::operator==( const SfxPoolItem& rItem ) const
1955 : {
1956 106 : const SwFormatFootnoteEndAtTextEnd& rAttr = static_cast<const SwFormatFootnoteEndAtTextEnd&>(rItem);
1957 212 : return SfxEnumItem::operator==( rAttr ) &&
1958 212 : aFormat.GetNumberingType() == rAttr.aFormat.GetNumberingType() &&
1959 212 : nOffset == rAttr.nOffset &&
1960 318 : sPrefix == rAttr.sPrefix &&
1961 212 : sSuffix == rAttr.sSuffix;
1962 : }
1963 :
1964 0 : bool SwFormatFootnoteEndAtTextEnd::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1965 : {
1966 0 : nMemberId &= ~CONVERT_TWIPS;
1967 0 : switch(nMemberId)
1968 : {
1969 : case MID_COLLECT :
1970 0 : rVal <<= GetValue() >= FTNEND_ATTXTEND;
1971 0 : break;
1972 : case MID_RESTART_NUM :
1973 0 : rVal <<= GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ;
1974 0 : break;
1975 0 : case MID_NUM_START_AT: rVal <<= (sal_Int16) nOffset; break;
1976 : case MID_OWN_NUM :
1977 0 : rVal <<= GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT;
1978 0 : break;
1979 0 : case MID_NUM_TYPE : rVal <<= aFormat.GetNumberingType(); break;
1980 0 : case MID_PREFIX : rVal <<= OUString(sPrefix); break;
1981 0 : case MID_SUFFIX : rVal <<= OUString(sSuffix); break;
1982 0 : default: return false;
1983 : }
1984 0 : return true;
1985 : }
1986 :
1987 28 : bool SwFormatFootnoteEndAtTextEnd::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1988 : {
1989 28 : bool bRet = true;
1990 28 : nMemberId &= ~CONVERT_TWIPS;
1991 28 : switch(nMemberId)
1992 : {
1993 : case MID_COLLECT :
1994 : {
1995 4 : bool bVal = *static_cast<sal_Bool const *>(rVal.getValue());
1996 4 : if(!bVal && GetValue() >= FTNEND_ATTXTEND)
1997 0 : SetValue(FTNEND_ATPGORDOCEND);
1998 4 : else if(bVal && GetValue() < FTNEND_ATTXTEND)
1999 4 : SetValue(FTNEND_ATTXTEND);
2000 : }
2001 4 : break;
2002 : case MID_RESTART_NUM :
2003 : {
2004 4 : bool bVal = *static_cast<sal_Bool const *>(rVal.getValue());
2005 4 : if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ)
2006 0 : SetValue(FTNEND_ATTXTEND);
2007 4 : else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMSEQ)
2008 4 : SetValue(FTNEND_ATTXTEND_OWNNUMSEQ);
2009 : }
2010 4 : break;
2011 : case MID_NUM_START_AT:
2012 : {
2013 4 : sal_Int16 nVal = 0;
2014 4 : rVal >>= nVal;
2015 4 : if(nVal >= 0)
2016 4 : nOffset = nVal;
2017 : else
2018 0 : bRet = false;
2019 : }
2020 4 : break;
2021 : case MID_OWN_NUM :
2022 : {
2023 4 : bool bVal = *static_cast<sal_Bool const *>(rVal.getValue());
2024 4 : if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT)
2025 0 : SetValue(FTNEND_ATTXTEND_OWNNUMSEQ);
2026 4 : else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMANDFMT)
2027 0 : SetValue(FTNEND_ATTXTEND_OWNNUMANDFMT);
2028 : }
2029 4 : break;
2030 : case MID_NUM_TYPE :
2031 : {
2032 4 : sal_Int16 nVal = 0;
2033 4 : rVal >>= nVal;
2034 8 : if(nVal >= 0 &&
2035 4 : (nVal <= SVX_NUM_ARABIC ||
2036 0 : SVX_NUM_CHARS_UPPER_LETTER_N == nVal ||
2037 0 : SVX_NUM_CHARS_LOWER_LETTER_N == nVal ))
2038 4 : aFormat.SetNumberingType(nVal);
2039 : else
2040 0 : bRet = false;
2041 : }
2042 4 : break;
2043 : case MID_PREFIX :
2044 : {
2045 4 : OUString sVal; rVal >>= sVal;
2046 4 : sPrefix = sVal;
2047 : }
2048 4 : break;
2049 : case MID_SUFFIX :
2050 : {
2051 4 : OUString sVal; rVal >>= sVal;
2052 4 : sSuffix = sVal;
2053 : }
2054 4 : break;
2055 0 : default: bRet = false;
2056 : }
2057 28 : return bRet;
2058 : }
2059 :
2060 : // class SwFormatFootnoteAtTextEnd
2061 :
2062 2 : SfxPoolItem* SwFormatFootnoteAtTextEnd::Clone( SfxItemPool* ) const
2063 : {
2064 2 : SwFormatFootnoteAtTextEnd* pNew = new SwFormatFootnoteAtTextEnd;
2065 2 : *pNew = *this;
2066 2 : return pNew;
2067 : }
2068 :
2069 : // class SwFormatEndAtTextEnd
2070 :
2071 2 : SfxPoolItem* SwFormatEndAtTextEnd::Clone( SfxItemPool* ) const
2072 : {
2073 2 : SwFormatEndAtTextEnd* pNew = new SwFormatEndAtTextEnd;
2074 2 : *pNew = *this;
2075 2 : return pNew;
2076 : }
2077 :
2078 : //class SwFormatChain
2079 :
2080 57 : bool SwFormatChain::operator==( const SfxPoolItem &rAttr ) const
2081 : {
2082 : assert(SfxPoolItem::operator==(rAttr));
2083 :
2084 114 : return GetPrev() == static_cast<const SwFormatChain&>(rAttr).GetPrev() &&
2085 114 : GetNext() == static_cast<const SwFormatChain&>(rAttr).GetNext();
2086 : }
2087 :
2088 4 : SwFormatChain::SwFormatChain( const SwFormatChain &rCpy ) :
2089 4 : SfxPoolItem( RES_CHAIN )
2090 : {
2091 4 : SetPrev( rCpy.GetPrev() );
2092 4 : SetNext( rCpy.GetNext() );
2093 4 : }
2094 :
2095 34 : SfxPoolItem* SwFormatChain::Clone( SfxItemPool* ) const
2096 : {
2097 34 : SwFormatChain *pRet = new SwFormatChain;
2098 34 : pRet->SetPrev( GetPrev() );
2099 34 : pRet->SetNext( GetNext() );
2100 34 : return pRet;
2101 : }
2102 :
2103 50 : void SwFormatChain::SetPrev( SwFlyFrameFormat *pFormat )
2104 : {
2105 50 : if ( pFormat )
2106 29 : pFormat->Add( &aPrev );
2107 21 : else if ( aPrev.GetRegisteredIn() )
2108 4 : static_cast<SwModify*>(aPrev.GetRegisteredIn())->Remove( &aPrev );
2109 50 : }
2110 :
2111 46 : void SwFormatChain::SetNext( SwFlyFrameFormat *pFormat )
2112 : {
2113 46 : if ( pFormat )
2114 17 : pFormat->Add( &aNext );
2115 29 : else if ( aNext.GetRegisteredIn() )
2116 0 : static_cast<SwModify*>(aNext.GetRegisteredIn())->Remove( &aNext );
2117 46 : }
2118 :
2119 409 : bool SwFormatChain::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2120 : {
2121 : // here we convert always!
2122 409 : nMemberId &= ~CONVERT_TWIPS;
2123 409 : bool bRet = true;
2124 409 : OUString aRet;
2125 409 : switch ( nMemberId )
2126 : {
2127 : case MID_CHAIN_PREVNAME:
2128 175 : if ( GetPrev() )
2129 2 : aRet = GetPrev()->GetName();
2130 175 : break;
2131 : case MID_CHAIN_NEXTNAME:
2132 234 : if ( GetNext() )
2133 2 : aRet = GetNext()->GetName();
2134 234 : break;
2135 : default:
2136 : OSL_ENSURE( false, "unknown MemberId" );
2137 0 : bRet = false;
2138 : }
2139 409 : rVal <<= aRet;
2140 409 : return bRet;
2141 : }
2142 :
2143 6908 : SwFormatLineNumber::SwFormatLineNumber() :
2144 6908 : SfxPoolItem( RES_LINENUMBER )
2145 : {
2146 6908 : nStartValue = 0;
2147 6908 : bCountLines = true;
2148 6908 : }
2149 :
2150 19601 : SwFormatLineNumber::~SwFormatLineNumber()
2151 : {
2152 19601 : }
2153 :
2154 9914 : bool SwFormatLineNumber::operator==( const SfxPoolItem &rAttr ) const
2155 : {
2156 : assert(SfxPoolItem::operator==(rAttr));
2157 :
2158 19809 : return nStartValue == static_cast<const SwFormatLineNumber&>(rAttr).GetStartValue() &&
2159 19809 : bCountLines == static_cast<const SwFormatLineNumber&>(rAttr).IsCount();
2160 : }
2161 :
2162 6323 : SfxPoolItem* SwFormatLineNumber::Clone( SfxItemPool* ) const
2163 : {
2164 6323 : return new SwFormatLineNumber( *this );
2165 : }
2166 :
2167 402 : bool SwFormatLineNumber::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2168 : {
2169 : // here we convert always!
2170 402 : nMemberId &= ~CONVERT_TWIPS;
2171 402 : bool bRet = true;
2172 402 : switch ( nMemberId )
2173 : {
2174 : case MID_LINENUMBER_COUNT:
2175 201 : rVal <<= IsCount();
2176 201 : break;
2177 : case MID_LINENUMBER_STARTVALUE:
2178 201 : rVal <<= (sal_Int32)GetStartValue();
2179 201 : break;
2180 : default:
2181 : OSL_ENSURE( false, "unknown MemberId" );
2182 0 : bRet = false;
2183 : }
2184 402 : return bRet;
2185 : }
2186 :
2187 3084 : bool SwFormatLineNumber::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2188 : {
2189 : // here we convert always!
2190 3084 : nMemberId &= ~CONVERT_TWIPS;
2191 3084 : bool bRet = true;
2192 3084 : switch ( nMemberId )
2193 : {
2194 : case MID_LINENUMBER_COUNT:
2195 2235 : SetCountLines( *static_cast<sal_Bool const *>(rVal.getValue()) );
2196 2235 : break;
2197 : case MID_LINENUMBER_STARTVALUE:
2198 : {
2199 849 : sal_Int32 nVal = 0;
2200 849 : if(rVal >>= nVal)
2201 849 : SetStartValue( nVal );
2202 : else
2203 0 : bRet = false;
2204 : }
2205 849 : break;
2206 : default:
2207 : OSL_ENSURE( false, "unknown MemberId" );
2208 0 : bRet = false;
2209 : }
2210 3084 : return bRet;
2211 : }
2212 :
2213 200 : SwTextGridItem::SwTextGridItem()
2214 : : SfxPoolItem( RES_TEXTGRID ), m_aColor( COL_LIGHTGRAY ), m_nLines( 20 )
2215 : , m_nBaseHeight( 400 ), m_nRubyHeight( 200 ), m_eGridType( GRID_NONE )
2216 : , m_bRubyTextBelow( false ), m_bPrintGrid( true ), m_bDisplayGrid( true )
2217 200 : , m_nBaseWidth(400), m_bSnapToChars( true ), m_bSquaredMode(true)
2218 : {
2219 200 : }
2220 :
2221 87908 : SwTextGridItem::~SwTextGridItem()
2222 : {
2223 87908 : }
2224 :
2225 74293 : bool SwTextGridItem::operator==( const SfxPoolItem& rAttr ) const
2226 : {
2227 : assert(SfxPoolItem::operator==(rAttr));
2228 74293 : SwTextGridItem const& rOther(static_cast<SwTextGridItem const&>(rAttr));
2229 74293 : return m_eGridType == rOther.GetGridType()
2230 73911 : && m_nLines == rOther.GetLines()
2231 39874 : && m_nBaseHeight == rOther.GetBaseHeight()
2232 33459 : && m_nRubyHeight == rOther.GetRubyHeight()
2233 30237 : && m_bRubyTextBelow == rOther.GetRubyTextBelow()
2234 30237 : && m_bDisplayGrid == rOther.GetDisplayGrid()
2235 25398 : && m_bPrintGrid == rOther.GetPrintGrid()
2236 20416 : && m_aColor == rOther.GetColor()
2237 20416 : && m_nBaseWidth == rOther.GetBaseWidth()
2238 20328 : && m_bSnapToChars == rOther.GetSnapToChars()
2239 94621 : && m_bSquaredMode == rOther.GetSquaredMode();
2240 : }
2241 :
2242 41671 : SfxPoolItem* SwTextGridItem::Clone( SfxItemPool* ) const
2243 : {
2244 41671 : return new SwTextGridItem( *this );
2245 : }
2246 :
2247 0 : SwTextGridItem& SwTextGridItem::operator=( const SwTextGridItem& rCpy )
2248 : {
2249 0 : m_aColor = rCpy.GetColor();
2250 0 : m_nLines = rCpy.GetLines();
2251 0 : m_nBaseHeight = rCpy.GetBaseHeight();
2252 0 : m_nRubyHeight = rCpy.GetRubyHeight();
2253 0 : m_eGridType = rCpy.GetGridType();
2254 0 : m_bRubyTextBelow = rCpy.GetRubyTextBelow();
2255 0 : m_bPrintGrid = rCpy.GetPrintGrid();
2256 0 : m_bDisplayGrid = rCpy.GetDisplayGrid();
2257 0 : m_nBaseWidth = rCpy.GetBaseWidth();
2258 0 : m_bSnapToChars = rCpy.GetSnapToChars();
2259 0 : m_bSquaredMode = rCpy.GetSquaredMode();
2260 :
2261 0 : return *this;
2262 : }
2263 :
2264 396 : bool SwTextGridItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2265 : {
2266 396 : bool bRet = true;
2267 :
2268 396 : switch( nMemberId & ~CONVERT_TWIPS )
2269 : {
2270 : case MID_GRID_COLOR:
2271 29 : rVal <<= GetColor().GetColor();
2272 29 : break;
2273 : case MID_GRID_LINES:
2274 29 : rVal <<= GetLines();
2275 29 : break;
2276 : case MID_GRID_RUBY_BELOW:
2277 29 : rVal <<= m_bRubyTextBelow;
2278 29 : break;
2279 : case MID_GRID_PRINT:
2280 29 : rVal <<= m_bPrintGrid;
2281 29 : break;
2282 : case MID_GRID_DISPLAY:
2283 29 : rVal <<= m_bDisplayGrid;
2284 29 : break;
2285 : case MID_GRID_BASEHEIGHT:
2286 : OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
2287 : "This value needs TWIPS-MM100 conversion" );
2288 29 : rVal <<= (sal_Int32) convertTwipToMm100(m_nBaseHeight);
2289 29 : break;
2290 : case MID_GRID_BASEWIDTH:
2291 : OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
2292 : "This value needs TWIPS-MM100 conversion" );
2293 29 : rVal <<= (sal_Int32) convertTwipToMm100(m_nBaseWidth);
2294 29 : break;
2295 : case MID_GRID_RUBYHEIGHT:
2296 : OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
2297 : "This value needs TWIPS-MM100 conversion" );
2298 29 : rVal <<= (sal_Int32)convertTwipToMm100(m_nRubyHeight);
2299 29 : break;
2300 : case MID_GRID_TYPE:
2301 31 : switch( GetGridType() )
2302 : {
2303 : case GRID_NONE:
2304 29 : rVal <<= text::TextGridMode::NONE;
2305 29 : break;
2306 : case GRID_LINES_ONLY:
2307 0 : rVal <<= text::TextGridMode::LINES;
2308 0 : break;
2309 : case GRID_LINES_CHARS:
2310 2 : rVal <<= text::TextGridMode::LINES_AND_CHARS;
2311 2 : break;
2312 : default:
2313 : OSL_FAIL("unknown SwTextGrid value");
2314 0 : bRet = false;
2315 0 : break;
2316 : }
2317 31 : break;
2318 : case MID_GRID_SNAPTOCHARS:
2319 31 : rVal <<= m_bSnapToChars;
2320 31 : break;
2321 : case MID_GRID_STANDARD_MODE:
2322 102 : rVal <<= !m_bSquaredMode;
2323 102 : break;
2324 : default:
2325 : OSL_FAIL("Unknown SwTextGridItem member");
2326 0 : bRet = false;
2327 0 : break;
2328 : }
2329 :
2330 396 : return bRet;
2331 : }
2332 :
2333 16781 : bool SwTextGridItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2334 : {
2335 16781 : bool bRet = true;
2336 16781 : switch( nMemberId & ~CONVERT_TWIPS )
2337 : {
2338 : case MID_GRID_COLOR:
2339 : {
2340 76 : sal_Int32 nTmp = 0;
2341 76 : bRet = (rVal >>= nTmp);
2342 76 : if( bRet )
2343 76 : SetColor( Color(nTmp) );
2344 : }
2345 76 : break;
2346 : case MID_GRID_LINES:
2347 : {
2348 2344 : sal_Int16 nTmp = 0;
2349 2344 : bRet = (rVal >>= nTmp);
2350 2344 : if( bRet && (nTmp >= 0) )
2351 2344 : SetLines( (sal_uInt16)nTmp );
2352 : else
2353 0 : bRet = false;
2354 : }
2355 2344 : break;
2356 : case MID_GRID_RUBY_BELOW:
2357 76 : SetRubyTextBelow( *static_cast<sal_Bool const *>(rVal.getValue()) );
2358 76 : break;
2359 : case MID_GRID_PRINT:
2360 2393 : SetPrintGrid( *static_cast<sal_Bool const *>(rVal.getValue()) );
2361 2393 : break;
2362 : case MID_GRID_DISPLAY:
2363 2393 : SetDisplayGrid( *static_cast<sal_Bool const *>(rVal.getValue()) );
2364 2393 : break;
2365 : case MID_GRID_BASEHEIGHT:
2366 : case MID_GRID_BASEWIDTH:
2367 : case MID_GRID_RUBYHEIGHT:
2368 : {
2369 : OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
2370 : "This value needs TWIPS-MM100 conversion" );
2371 4740 : sal_Int32 nTmp = 0;
2372 4740 : bRet = (rVal >>= nTmp);
2373 4740 : nTmp = convertMm100ToTwip( nTmp );
2374 4740 : if( bRet && (nTmp >= 0) && ( nTmp <= USHRT_MAX) )
2375 : {
2376 : // rhbz#1043551 round up to 5pt -- 0 causes divide-by-zero
2377 : // in layout; 1pt ties the painting code up in knots for
2378 : // minutes with bazillion lines...
2379 : #define MIN_TEXTGRID_SIZE 100
2380 9480 : if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEHEIGHT )
2381 : {
2382 2344 : nTmp = std::max<sal_Int32>(nTmp, MIN_TEXTGRID_SIZE);
2383 2344 : SetBaseHeight( (sal_uInt16)nTmp );
2384 : }
2385 2396 : else if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEWIDTH )
2386 : {
2387 52 : nTmp = std::max<sal_Int32>(nTmp, MIN_TEXTGRID_SIZE);
2388 52 : SetBaseWidth( (sal_uInt16)nTmp );
2389 : }
2390 : else
2391 2344 : SetRubyHeight( (sal_uInt16)nTmp );
2392 : }
2393 : else
2394 0 : bRet = false;
2395 : }
2396 4740 : break;
2397 : case MID_GRID_TYPE:
2398 : {
2399 2393 : sal_Int16 nTmp = 0;
2400 2393 : bRet = (rVal >>= nTmp);
2401 2393 : if( bRet )
2402 : {
2403 2393 : switch( nTmp )
2404 : {
2405 : case text::TextGridMode::NONE:
2406 2367 : SetGridType( GRID_NONE );
2407 2367 : break;
2408 : case text::TextGridMode::LINES:
2409 23 : SetGridType( GRID_LINES_ONLY );
2410 23 : break;
2411 : case text::TextGridMode::LINES_AND_CHARS:
2412 3 : SetGridType( GRID_LINES_CHARS );
2413 3 : break;
2414 : default:
2415 0 : bRet = false;
2416 0 : break;
2417 : }
2418 : }
2419 2393 : break;
2420 : }
2421 : case MID_GRID_SNAPTOCHARS:
2422 55 : SetSnapToChars( *static_cast<sal_Bool const *>(rVal.getValue()) );
2423 55 : break;
2424 : case MID_GRID_STANDARD_MODE:
2425 : {
2426 2311 : bool bStandard = *static_cast<sal_Bool const *>(rVal.getValue());
2427 2311 : SetSquaredMode( !bStandard );
2428 2311 : break;
2429 : }
2430 : default:
2431 : OSL_FAIL("Unknown SwTextGridItem member");
2432 0 : bRet = false;
2433 : }
2434 :
2435 16781 : return bRet;
2436 : }
2437 :
2438 2268 : void SwTextGridItem::SwitchPaperMode(bool bNew)
2439 : {
2440 2268 : if (bNew == m_bSquaredMode)
2441 : {
2442 : //same paper mode, not switch
2443 2254 : return;
2444 : }
2445 :
2446 : // use default value when grid is disable
2447 14 : if (m_eGridType == GRID_NONE)
2448 : {
2449 14 : m_bSquaredMode = bNew;
2450 14 : Init();
2451 14 : return;
2452 : }
2453 :
2454 0 : if (m_bSquaredMode)
2455 : {
2456 : //switch from "squared mode" to "standard mode"
2457 0 : m_nBaseWidth = m_nBaseHeight;
2458 0 : m_nBaseHeight = m_nBaseHeight + m_nRubyHeight;
2459 0 : m_nRubyHeight = 0;
2460 : }
2461 : else
2462 : {
2463 : //switch from "standard mode" to "squared mode"
2464 0 : m_nRubyHeight = m_nBaseHeight/3;
2465 0 : m_nBaseHeight = m_nBaseHeight - m_nRubyHeight;
2466 0 : m_nBaseWidth = m_nBaseHeight;
2467 : }
2468 0 : m_bSquaredMode = !m_bSquaredMode;
2469 : }
2470 :
2471 2055 : void SwTextGridItem::Init()
2472 : {
2473 2055 : if (m_bSquaredMode)
2474 : {
2475 0 : m_nLines = 20;
2476 0 : m_nBaseHeight = 400;
2477 0 : m_nRubyHeight = 200;
2478 0 : m_eGridType = GRID_NONE;
2479 0 : m_bRubyTextBelow = false;
2480 0 : m_bPrintGrid = true;
2481 0 : m_bDisplayGrid = true;
2482 0 : m_bSnapToChars = true;
2483 0 : m_nBaseWidth = 400;
2484 : }
2485 : else
2486 : {
2487 2055 : m_nLines = 44;
2488 2055 : m_nBaseHeight = 312;
2489 2055 : m_nRubyHeight = 0;
2490 2055 : m_eGridType = GRID_NONE;
2491 2055 : m_bRubyTextBelow = false;
2492 2055 : m_bPrintGrid = true;
2493 2055 : m_bDisplayGrid = true;
2494 2055 : m_nBaseWidth = 210;
2495 2055 : m_bSnapToChars = true;
2496 : }
2497 2055 : }
2498 :
2499 1415 : SfxPoolItem* SwHeaderAndFooterEatSpacingItem::Clone( SfxItemPool* ) const
2500 : {
2501 1415 : return new SwHeaderAndFooterEatSpacingItem( Which(), GetValue() );
2502 : }
2503 :
2504 : // Partially implemented inline in hxx
2505 180536 : TYPEINIT1( SwFrameFormat, SwFormat );
2506 39875 : IMPL_FIXEDMEMPOOL_NEWDEL_DLL( SwFrameFormat )
2507 :
2508 14738 : SwFrameFormat::SwFrameFormat(
2509 : SwAttrPool& rPool,
2510 : const sal_Char* pFormatNm,
2511 : SwFrameFormat *pDrvdFrm,
2512 : sal_uInt16 nFormatWhich,
2513 : const sal_uInt16* pWhichRange)
2514 : : SwFormat(rPool, pFormatNm, (pWhichRange ? pWhichRange : aFrameFormatSetRange), pDrvdFrm, nFormatWhich),
2515 : m_wXObject(),
2516 14738 : maFillAttributes()
2517 : {
2518 14738 : }
2519 :
2520 303625 : SwFrameFormat::SwFrameFormat(
2521 : SwAttrPool& rPool,
2522 : const OUString &rFormatNm,
2523 : SwFrameFormat *pDrvdFrm,
2524 : sal_uInt16 nFormatWhich,
2525 : const sal_uInt16* pWhichRange)
2526 : : SwFormat(rPool, rFormatNm, (pWhichRange ? pWhichRange : aFrameFormatSetRange), pDrvdFrm, nFormatWhich),
2527 : m_wXObject(),
2528 303625 : maFillAttributes()
2529 : {
2530 303625 : }
2531 :
2532 718379 : SwFrameFormat::~SwFrameFormat()
2533 : {
2534 349415 : if( !GetDoc()->IsInDtor())
2535 : {
2536 41739 : const SwFormatAnchor& rAnchor = GetAnchor();
2537 41739 : if (rAnchor.GetContentAnchor() != nullptr)
2538 : {
2539 838 : rAnchor.GetContentAnchor()->nNode.GetNode().RemoveAnchoredFly(this);
2540 : }
2541 : }
2542 368964 : }
2543 :
2544 377455 : bool SwFrameFormat::supportsFullDrawingLayerFillAttributeSet() const
2545 : {
2546 377455 : return true;
2547 : }
2548 :
2549 1551191 : void SwFrameFormat::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
2550 : {
2551 1551191 : SwFormatHeader const *pH = 0;
2552 1551191 : SwFormatFooter const *pF = 0;
2553 :
2554 1551191 : const sal_uInt16 nWhich = pNew ? pNew->Which() : 0;
2555 :
2556 1551191 : if( RES_ATTRSET_CHG == nWhich )
2557 : {
2558 1525248 : static_cast<const SwAttrSetChg*>(pNew)->GetChgSet()->GetItemState(
2559 1525248 : RES_HEADER, false, reinterpret_cast<const SfxPoolItem**>(&pH) );
2560 1525248 : static_cast<const SwAttrSetChg*>(pNew)->GetChgSet()->GetItemState(
2561 1525248 : RES_FOOTER, false, reinterpret_cast<const SfxPoolItem**>(&pF) );
2562 :
2563 : //UUUU reset fill information
2564 1525248 : if (maFillAttributes.get() && supportsFullDrawingLayerFillAttributeSet())
2565 : {
2566 609 : SfxItemIter aIter(*static_cast<const SwAttrSetChg*>(pNew)->GetChgSet());
2567 609 : bool bReset(false);
2568 :
2569 1481 : for(const SfxPoolItem* pItem = aIter.FirstItem(); pItem && !bReset; pItem = aIter.NextItem())
2570 : {
2571 872 : bReset = !IsInvalidItem(pItem) && pItem->Which() >= XATTR_FILL_FIRST && pItem->Which() <= XATTR_FILL_LAST;
2572 : }
2573 :
2574 609 : if(bReset)
2575 : {
2576 4 : maFillAttributes.reset();
2577 609 : }
2578 : }
2579 : }
2580 25943 : else if(RES_FMT_CHG == nWhich)
2581 : {
2582 : //UUUU reset fill information on format change (e.g. style changed)
2583 22962 : if (maFillAttributes.get() && supportsFullDrawingLayerFillAttributeSet())
2584 : {
2585 37 : maFillAttributes.reset();
2586 : }
2587 : }
2588 2981 : else if( RES_HEADER == nWhich )
2589 0 : pH = static_cast<const SwFormatHeader*>(pNew);
2590 2981 : else if( RES_FOOTER == nWhich )
2591 0 : pF = static_cast<const SwFormatFooter*>(pNew);
2592 :
2593 1551191 : if( pH && pH->IsActive() && !pH->GetHeaderFormat() )
2594 : { //If he doesn't have one, I'll add one
2595 709 : SwFrameFormat *pFormat = GetDoc()->getIDocumentLayoutAccess().MakeLayoutFormat( RND_STD_HEADER, 0 );
2596 709 : const_cast<SwFormatHeader *>(pH)->RegisterToFormat( *pFormat );
2597 : }
2598 :
2599 1551191 : if( pF && pF->IsActive() && !pF->GetFooterFormat() )
2600 : { //If he doesn't have one, I'll add one
2601 708 : SwFrameFormat *pFormat = GetDoc()->getIDocumentLayoutAccess().MakeLayoutFormat( RND_STD_FOOTER, 0 );
2602 708 : const_cast<SwFormatFooter *>(pF)->RegisterToFormat( *pFormat );
2603 : }
2604 :
2605 1551191 : SwFormat::Modify( pOld, pNew );
2606 :
2607 1551191 : if (pOld && (RES_REMOVE_UNO_OBJECT == pOld->Which()))
2608 : { // invalidate cached uno object
2609 1122 : SetXObject(uno::Reference<uno::XInterface>(0));
2610 : }
2611 :
2612 1551191 : const SwPosition* oldAnchorPosition = NULL;
2613 1551191 : const SwPosition* newAnchorPosition = NULL;
2614 1551191 : if( pNew && pNew->Which() == RES_ATTRSET_CHG )
2615 : {
2616 1525248 : const SfxPoolItem* tmp = NULL;
2617 1525248 : static_cast< const SwAttrSetChg* >(pNew)->GetChgSet()->GetItemState( RES_ANCHOR, false, &tmp );
2618 1525248 : if( tmp )
2619 13399 : newAnchorPosition = static_cast< const SwFormatAnchor* >( tmp )->GetContentAnchor();
2620 : }
2621 1551191 : if( pNew && pNew->Which() == RES_ANCHOR )
2622 0 : newAnchorPosition = static_cast< const SwFormatAnchor* >( pNew )->GetContentAnchor();
2623 1551191 : if( pOld && pOld->Which() == RES_ATTRSET_CHG )
2624 : {
2625 1525248 : const SfxPoolItem* tmp = NULL;
2626 1525248 : static_cast< const SwAttrSetChg* >(pOld)->GetChgSet()->GetItemState( RES_ANCHOR, false, &tmp );
2627 1525248 : if( tmp )
2628 13399 : oldAnchorPosition = static_cast< const SwFormatAnchor* >( tmp )->GetContentAnchor();
2629 : }
2630 1551191 : if( pOld && pOld->Which() == RES_ANCHOR )
2631 0 : oldAnchorPosition = static_cast< const SwFormatAnchor* >( pOld )->GetContentAnchor();
2632 1551191 : if( oldAnchorPosition != NULL && ( newAnchorPosition == NULL || oldAnchorPosition->nNode.GetIndex() != newAnchorPosition->nNode.GetIndex()))
2633 : {
2634 1703 : oldAnchorPosition->nNode.GetNode().RemoveAnchoredFly(this);
2635 : }
2636 1551191 : if( newAnchorPosition != NULL && ( oldAnchorPosition == NULL || oldAnchorPosition->nNode.GetIndex() != newAnchorPosition->nNode.GetIndex()))
2637 : {
2638 5925 : newAnchorPosition->nNode.GetNode().AddAnchoredFly(this);
2639 : }
2640 1551191 : }
2641 :
2642 46 : void SwFrameFormat::RegisterToFormat( SwFormat& rFormat )
2643 : {
2644 46 : rFormat.Add( this );
2645 46 : }
2646 :
2647 : /// Delete all Frms that are registered in aDepend.
2648 2262 : void SwFrameFormat::DelFrms()
2649 : {
2650 2262 : SwIterator<SwFrm,SwFormat> aIter( *this );
2651 2262 : SwFrm * pLast = aIter.First();
2652 2262 : if( pLast )
2653 11 : do {
2654 11 : pLast->Cut();
2655 11 : SwFrm::DestroyFrm(pLast);
2656 2262 : } while( 0 != ( pLast = aIter.Next() ));
2657 2262 : }
2658 :
2659 0 : void SwFrameFormat::MakeFrms()
2660 : {
2661 : OSL_ENSURE( false, "Sorry not implemented." );
2662 0 : }
2663 :
2664 2439 : SwRect SwFrameFormat::FindLayoutRect( const bool bPrtArea, const Point* pPoint,
2665 : const bool bCalcFrm ) const
2666 : {
2667 2439 : SwRect aRet;
2668 2439 : SwFrm *pFrm = 0;
2669 2439 : if( ISA( SwSectionFormat ) )
2670 : {
2671 : // get the Frame using Node2Layout
2672 0 : const SwSectionNode* pSectNd = static_cast<const SwSectionFormat*>(this)->GetSectionNode();
2673 0 : if( pSectNd )
2674 : {
2675 0 : SwNode2Layout aTmp( *pSectNd, pSectNd->GetIndex() - 1 );
2676 0 : pFrm = aTmp.NextFrm();
2677 :
2678 0 : if( pFrm && !pFrm->KnowsFormat(*this) )
2679 : {
2680 : // the Section doesn't have his own Frame, so if someone
2681 : // needs the real size, we have to implement this by requesting
2682 : // the matching Frame from the end.
2683 : // PROBLEM: what happens if SectionFrames overlaps multiple
2684 : // pages?
2685 0 : if( bPrtArea )
2686 0 : aRet = pFrm->Prt();
2687 : else
2688 : {
2689 0 : aRet = pFrm->Frm();
2690 0 : --aRet.Pos().Y();
2691 : }
2692 0 : pFrm = 0; // the rect is finished by now
2693 0 : }
2694 : }
2695 : }
2696 : else
2697 : {
2698 2439 : const sal_uInt16 nFrmType = RES_FLYFRMFMT == Which() ? FRM_FLY : USHRT_MAX;
2699 : pFrm = ::GetFrmOfModify( 0, *const_cast<SwModify*>(static_cast<SwModify const *>(this)), nFrmType, pPoint,
2700 2439 : 0, bCalcFrm );
2701 : }
2702 :
2703 2439 : if( pFrm )
2704 : {
2705 2087 : if( bPrtArea )
2706 204 : aRet = pFrm->Prt();
2707 : else
2708 1883 : aRet = pFrm->Frm();
2709 : }
2710 2439 : return aRet;
2711 : }
2712 :
2713 32638 : SwContact* SwFrameFormat::FindContactObj()
2714 : {
2715 32638 : return SwIterator<SwContact,SwFormat>( *this ).First();
2716 : }
2717 :
2718 23273 : SdrObject* SwFrameFormat::FindSdrObject()
2719 : {
2720 : // #i30669# - use method <FindContactObj()> instead of
2721 : // duplicated code.
2722 23273 : SwContact* pFoundContact = FindContactObj();
2723 23273 : return pFoundContact ? pFoundContact->GetMaster() : 0;
2724 : }
2725 :
2726 11304 : SdrObject* SwFrameFormat::FindRealSdrObject()
2727 : {
2728 11304 : if( RES_FLYFRMFMT == Which() )
2729 : {
2730 1630 : Point aNullPt;
2731 : SwFlyFrm* pFly = static_cast<SwFlyFrm*>(::GetFrmOfModify( 0, *this, FRM_FLY,
2732 1630 : &aNullPt, 0, false ));
2733 1630 : return pFly ? pFly->GetVirtDrawObj() : 0;
2734 : }
2735 9674 : return FindSdrObject();
2736 : }
2737 :
2738 8 : bool SwFrameFormat::IsLowerOf( const SwFrameFormat& rFormat ) const
2739 : {
2740 : //Also linking from inside to outside or from outside to inside is not
2741 : //allowed.
2742 8 : SwFlyFrm *pSFly = SwIterator<SwFlyFrm,SwFormat>(*this).First();
2743 8 : if( pSFly )
2744 : {
2745 0 : SwFlyFrm *pAskFly = SwIterator<SwFlyFrm,SwFormat>(rFormat).First();
2746 0 : if( pAskFly )
2747 0 : return pSFly->IsLowerOf( pAskFly );
2748 : }
2749 :
2750 : // let's try it using the node positions
2751 8 : const SwFormatAnchor* pAnchor = &rFormat.GetAnchor();
2752 8 : if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) && pAnchor->GetContentAnchor())
2753 : {
2754 8 : const SwFrameFormats& rFormats = *GetDoc()->GetSpzFrameFormats();
2755 8 : const SwNode* pFlyNd = pAnchor->GetContentAnchor()->nNode.GetNode().
2756 8 : FindFlyStartNode();
2757 16 : while( pFlyNd )
2758 : {
2759 : // then we walk up using the anchor
2760 : size_t n;
2761 0 : for( n = 0; n < rFormats.size(); ++n )
2762 : {
2763 0 : const SwFrameFormat* pFormat = rFormats[ n ];
2764 0 : const SwNodeIndex* pIdx = pFormat->GetContent().GetContentIdx();
2765 0 : if( pIdx && pFlyNd == &pIdx->GetNode() )
2766 : {
2767 0 : if( pFormat == this )
2768 0 : return true;
2769 :
2770 0 : pAnchor = &pFormat->GetAnchor();
2771 0 : if ((FLY_AT_PAGE == pAnchor->GetAnchorId()) ||
2772 0 : !pAnchor->GetContentAnchor() )
2773 : {
2774 0 : return false;
2775 : }
2776 :
2777 0 : pFlyNd = pAnchor->GetContentAnchor()->nNode.GetNode().
2778 0 : FindFlyStartNode();
2779 0 : break;
2780 : }
2781 : }
2782 0 : if( n >= rFormats.size() )
2783 : {
2784 : OSL_ENSURE( false, "Fly section but no format found" );
2785 0 : return false;
2786 : }
2787 : }
2788 : }
2789 8 : return false;
2790 : }
2791 :
2792 : // #i31698#
2793 0 : SwFrameFormat::tLayoutDir SwFrameFormat::GetLayoutDir() const
2794 : {
2795 0 : return SwFrameFormat::HORI_L2R;
2796 : }
2797 :
2798 2214 : void SwFrameFormat::SetLayoutDir( const SwFrameFormat::tLayoutDir )
2799 : {
2800 : // empty body, because default implementation does nothing
2801 2214 : }
2802 :
2803 : // #i28749#
2804 0 : sal_Int16 SwFrameFormat::GetPositionLayoutDir() const
2805 : {
2806 0 : return text::PositionLayoutDir::PositionInLayoutDirOfAnchor;
2807 : }
2808 0 : void SwFrameFormat::SetPositionLayoutDir( const sal_Int16 )
2809 : {
2810 : // empty body, because default implementation does nothing
2811 0 : }
2812 :
2813 0 : OUString SwFrameFormat::GetDescription() const
2814 : {
2815 0 : return SW_RES(STR_FRAME);
2816 : }
2817 :
2818 0 : void SwFrameFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
2819 : {
2820 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swFrameFormat"));
2821 0 : xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
2822 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
2823 0 : xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
2824 :
2825 0 : const char* pWhich = 0;
2826 0 : switch (Which())
2827 : {
2828 : case RES_FLYFRMFMT:
2829 0 : pWhich = "fly frame format";
2830 0 : break;
2831 : case RES_DRAWFRMFMT:
2832 0 : pWhich = "draw frame format";
2833 0 : break;
2834 : }
2835 0 : if (pWhich)
2836 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("which"), BAD_CAST(pWhich));
2837 :
2838 0 : GetAttrSet().dumpAsXml(pWriter);
2839 :
2840 0 : xmlTextWriterEndElement(pWriter);
2841 0 : }
2842 :
2843 0 : void SwFrameFormats::dumpAsXml(xmlTextWriterPtr pWriter, const char* pName) const
2844 : {
2845 0 : xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
2846 0 : for (size_t i = 0; i < size(); ++i)
2847 0 : GetFormat(i)->dumpAsXml(pWriter);
2848 0 : xmlTextWriterEndElement(pWriter);
2849 0 : }
2850 :
2851 : // class SwFlyFrameFormat
2852 : // Partially implemented inline in hxx
2853 :
2854 110733 : TYPEINIT1( SwFlyFrameFormat, SwFrameFormat );
2855 59 : IMPL_FIXEDMEMPOOL_NEWDEL( SwFlyFrameFormat )
2856 :
2857 6867 : SwFlyFrameFormat::~SwFlyFrameFormat()
2858 : {
2859 2289 : SwIterator<SwFlyFrm,SwFormat> aIter( *this );
2860 2289 : SwFlyFrm * pLast = aIter.First();
2861 2289 : if( pLast )
2862 0 : do
2863 : {
2864 0 : SwFrm::DestroyFrm(pLast);
2865 : } while( 0 != ( pLast = aIter.Next() ));
2866 :
2867 4578 : SwIterator<SwFlyDrawContact,SwFormat> a2ndIter( *this );
2868 2289 : SwFlyDrawContact* pC = a2ndIter.First();
2869 2289 : if( pC )
2870 574 : do {
2871 574 : delete pC;
2872 :
2873 2289 : } while( 0 != ( pC = a2ndIter.Next() ));
2874 4578 : }
2875 :
2876 : /// Creates the Frms if the format describes a paragraph-bound frame.
2877 : /// MA: 1994-02-14: creates the Frms also for frames anchored at page.
2878 1474 : void SwFlyFrameFormat::MakeFrms()
2879 : {
2880 : // is there a layout?
2881 1474 : if( !GetDoc()->getIDocumentLayoutAccess().GetCurrentViewShell() )
2882 852 : return;
2883 :
2884 1048 : SwModify *pModify = 0;
2885 : // OD 24.07.2003 #111032# - create local copy of anchor attribute for possible changes.
2886 1048 : SwFormatAnchor aAnchorAttr( GetAnchor() );
2887 1048 : switch( aAnchorAttr.GetAnchorId() )
2888 : {
2889 : case FLY_AS_CHAR:
2890 : case FLY_AT_PARA:
2891 : case FLY_AT_CHAR:
2892 956 : if( aAnchorAttr.GetContentAnchor() )
2893 : {
2894 956 : pModify = aAnchorAttr.GetContentAnchor()->nNode.GetNode().GetContentNode();
2895 : }
2896 956 : break;
2897 :
2898 : case FLY_AT_FLY:
2899 0 : if( aAnchorAttr.GetContentAnchor() )
2900 : {
2901 : //First search in the content because this is O(1)
2902 : //This can go wrong for linked frames because in this case it's
2903 : //possible, that no Frame exists for this content.
2904 : //In such a situation we also need to search from StartNode to
2905 : //FrameFormat.
2906 0 : SwNodeIndex aIdx( aAnchorAttr.GetContentAnchor()->nNode );
2907 0 : SwContentNode *pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
2908 : // #i105535#
2909 0 : if ( pCNd == 0 )
2910 : {
2911 0 : pCNd = aAnchorAttr.GetContentAnchor()->nNode.GetNode().GetContentNode();
2912 : }
2913 0 : if ( pCNd )
2914 : {
2915 0 : if( SwIterator<SwFrm,SwContentNode>( *pCNd ).First() )
2916 : {
2917 0 : pModify = pCNd;
2918 : }
2919 : }
2920 : // #i105535#
2921 0 : if ( pModify == 0 )
2922 : {
2923 0 : const SwNodeIndex &rIdx = aAnchorAttr.GetContentAnchor()->nNode;
2924 0 : SwFrameFormats& rFormats = *GetDoc()->GetSpzFrameFormats();
2925 0 : for( size_t i = 0; i < rFormats.size(); ++i )
2926 : {
2927 0 : SwFrameFormat* pFlyFormat = rFormats[i];
2928 0 : if( pFlyFormat->GetContent().GetContentIdx() &&
2929 0 : rIdx == *pFlyFormat->GetContent().GetContentIdx() )
2930 : {
2931 0 : pModify = pFlyFormat;
2932 0 : break;
2933 : }
2934 : }
2935 0 : }
2936 : }
2937 0 : break;
2938 :
2939 : case FLY_AT_PAGE:
2940 : {
2941 92 : sal_uInt16 nPgNum = aAnchorAttr.GetPageNum();
2942 92 : SwPageFrm *pPage = static_cast<SwPageFrm*>(GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout()->Lower());
2943 92 : if( nPgNum == 0 && aAnchorAttr.GetContentAnchor() )
2944 : {
2945 1 : SwContentNode *pCNd = aAnchorAttr.GetContentAnchor()->nNode.GetNode().GetContentNode();
2946 1 : SwIterator<SwFrm,SwContentNode> aIter( *pCNd );
2947 1 : for ( SwFrm* pFrm = aIter.First(); pFrm != NULL; pFrm = aIter.Next() )
2948 : {
2949 1 : pPage = pFrm->FindPageFrm();
2950 1 : if( pPage )
2951 : {
2952 1 : nPgNum = pPage->GetPhyPageNum();
2953 1 : aAnchorAttr.SetPageNum( nPgNum );
2954 1 : aAnchorAttr.SetAnchor( 0 );
2955 1 : SetFormatAttr( aAnchorAttr );
2956 1 : break;
2957 : }
2958 1 : }
2959 : }
2960 253 : while ( pPage )
2961 : {
2962 92 : if ( pPage->GetPhyPageNum() == nPgNum )
2963 : {
2964 : // #i50432# - adjust synopsis of <PlaceFly(..)>
2965 23 : pPage->PlaceFly( 0, this );
2966 23 : break;
2967 : }
2968 69 : pPage = static_cast<SwPageFrm*>(pPage->GetNext());
2969 : }
2970 : }
2971 92 : break;
2972 : default:
2973 0 : break;
2974 : }
2975 :
2976 1048 : if( pModify )
2977 : {
2978 956 : SwIterator<SwFrm,SwModify> aIter( *pModify );
2979 2037 : for( SwFrm *pFrm = aIter.First(); pFrm; pFrm = aIter.Next() )
2980 : {
2981 2162 : bool bAdd = !pFrm->IsContentFrm() ||
2982 2162 : !static_cast<SwContentFrm*>(pFrm)->IsFollow();
2983 :
2984 1081 : if ( FLY_AT_FLY == aAnchorAttr.GetAnchorId() && !pFrm->IsFlyFrm() )
2985 : {
2986 0 : SwFrm* pFlyFrm = pFrm->FindFlyFrm();
2987 0 : if ( pFlyFrm )
2988 : {
2989 0 : pFrm = pFlyFrm;
2990 : }
2991 : else
2992 : {
2993 0 : aAnchorAttr.SetType( FLY_AT_PARA );
2994 0 : SetFormatAttr( aAnchorAttr );
2995 0 : MakeFrms();
2996 0 : return;
2997 : }
2998 : }
2999 :
3000 1081 : if( pFrm->GetDrawObjs() )
3001 : {
3002 : // #i28701# - new type <SwSortedObjs>
3003 787 : SwSortedObjs &rObjs = *pFrm->GetDrawObjs();
3004 10957 : for( size_t i = 0; i < rObjs.size(); ++i)
3005 : {
3006 : // #i28701# - consider changed type of
3007 : // <SwSortedObjs> entries.
3008 10479 : SwAnchoredObject* pObj = rObjs[i];
3009 14166 : if( pObj->ISA(SwFlyFrm) &&
3010 3687 : (&pObj->GetFrameFormat()) == this )
3011 : {
3012 309 : bAdd = false;
3013 309 : break;
3014 : }
3015 : }
3016 : }
3017 :
3018 1081 : if( bAdd )
3019 : {
3020 : SwFlyFrm *pFly;
3021 772 : switch( aAnchorAttr.GetAnchorId() )
3022 : {
3023 : case FLY_AT_FLY:
3024 0 : pFly = new SwFlyLayFrm( this, pFrm, pFrm );
3025 0 : break;
3026 :
3027 : case FLY_AT_PARA:
3028 : case FLY_AT_CHAR:
3029 711 : pFly = new SwFlyAtCntFrm( this, pFrm, pFrm );
3030 711 : break;
3031 :
3032 : default:
3033 : assert(false && "Neuer Ankertyp" );
3034 : //fall-through
3035 : case FLY_AS_CHAR:
3036 61 : pFly = new SwFlyInCntFrm( this, pFrm, pFrm );
3037 61 : break;
3038 : }
3039 772 : pFrm->AppendFly( pFly );
3040 772 : pFly->GetFormat()->SetObjTitle(GetObjTitle());
3041 772 : pFly->GetFormat()->SetObjDescription(GetObjDescription());
3042 772 : SwPageFrm *pPage = pFly->FindPageFrm();
3043 772 : if( pPage )
3044 772 : ::RegistFlys( pPage, pFly );
3045 : }
3046 956 : }
3047 1048 : }
3048 : }
3049 :
3050 20 : SwFlyFrm* SwFlyFrameFormat::GetFrm( const Point* pPoint, const bool bCalcFrm ) const
3051 : {
3052 : return static_cast<SwFlyFrm*>(::GetFrmOfModify( 0, *const_cast<SwModify*>(static_cast<SwModify const *>(this)), FRM_FLY,
3053 20 : pPoint, 0, bCalcFrm ));
3054 : }
3055 :
3056 0 : SwAnchoredObject* SwFlyFrameFormat::GetAnchoredObj( const Point* pPoint, const bool bCalcFrm ) const
3057 : {
3058 0 : SwFlyFrm* pFlyFrm( GetFrm( pPoint, bCalcFrm ) );
3059 0 : if ( pFlyFrm )
3060 : {
3061 0 : return dynamic_cast<SwAnchoredObject*>(pFlyFrm);
3062 : }
3063 : else
3064 : {
3065 0 : return 0L;
3066 : }
3067 : }
3068 :
3069 73 : bool SwFlyFrameFormat::GetInfo( SfxPoolItem& rInfo ) const
3070 : {
3071 73 : bool bRet = true;
3072 73 : switch( rInfo.Which() )
3073 : {
3074 : case RES_CONTENT_VISIBLE:
3075 : {
3076 0 : static_cast<SwPtrMsgPoolItem&>(rInfo).pObject = SwIterator<SwFrm,SwFormat>( *this ).First();
3077 : }
3078 0 : bRet = false;
3079 0 : break;
3080 :
3081 : default:
3082 73 : bRet = SwFrameFormat::GetInfo( rInfo );
3083 73 : break;
3084 : }
3085 73 : return bRet;
3086 : }
3087 :
3088 : // #i73249#
3089 984 : void SwFlyFrameFormat::SetObjTitle( const OUString& rTitle, bool bBroadcast )
3090 : {
3091 984 : SdrObject* pMasterObject = FindSdrObject();
3092 : OSL_ENSURE( pMasterObject, "<SwFlyFrameFormat::SetObjTitle(..)> - missing <SdrObject> instance" );
3093 984 : msTitle = rTitle;
3094 984 : if ( !pMasterObject )
3095 : {
3096 985 : return;
3097 : }
3098 :
3099 983 : if( bBroadcast )
3100 : {
3101 5 : SwStringMsgPoolItem aOld( RES_TITLE_CHANGED, pMasterObject->GetTitle() );
3102 10 : SwStringMsgPoolItem aNew( RES_TITLE_CHANGED, rTitle );
3103 5 : pMasterObject->SetTitle( rTitle );
3104 10 : ModifyNotification( &aOld, &aNew );
3105 : }
3106 : else
3107 : {
3108 978 : pMasterObject->SetTitle( rTitle );
3109 : }
3110 : }
3111 :
3112 1507 : OUString SwFlyFrameFormat::GetObjTitle() const
3113 : {
3114 1507 : const SdrObject* pMasterObject = FindSdrObject();
3115 : OSL_ENSURE( pMasterObject, "<SwFlyFrameFormat::GetObjTitle(..)> - missing <SdrObject> instance" );
3116 1507 : if ( !pMasterObject )
3117 : {
3118 29 : return msTitle;
3119 : }
3120 1478 : if (!pMasterObject->GetTitle().isEmpty())
3121 1 : return pMasterObject->GetTitle();
3122 : else
3123 1477 : return msTitle;
3124 : }
3125 :
3126 1063 : void SwFlyFrameFormat::SetObjDescription( const OUString& rDescription, bool bBroadcast )
3127 : {
3128 1063 : SdrObject* pMasterObject = FindSdrObject();
3129 : OSL_ENSURE( pMasterObject, "<SwFlyFrameFormat::SetDescription(..)> - missing <SdrObject> instance" );
3130 1063 : msDesc = rDescription;
3131 1063 : if ( !pMasterObject )
3132 : {
3133 1063 : return;
3134 : }
3135 :
3136 1063 : if( bBroadcast )
3137 : {
3138 85 : SwStringMsgPoolItem aOld( RES_DESCRIPTION_CHANGED, pMasterObject->GetDescription() );
3139 170 : SwStringMsgPoolItem aNew( RES_DESCRIPTION_CHANGED, rDescription );
3140 85 : pMasterObject->SetDescription( rDescription );
3141 170 : ModifyNotification( &aOld, &aNew );
3142 : }
3143 : else
3144 : {
3145 978 : pMasterObject->SetDescription( rDescription );
3146 : }
3147 : }
3148 :
3149 1481 : OUString SwFlyFrameFormat::GetObjDescription() const
3150 : {
3151 1481 : const SdrObject* pMasterObject = FindSdrObject();
3152 : OSL_ENSURE( pMasterObject, "<SwFlyFrameFormat::GetDescription(..)> - missing <SdrObject> instance" );
3153 1481 : if ( !pMasterObject )
3154 : {
3155 0 : return msDesc;
3156 : }
3157 1481 : if (!pMasterObject->GetDescription().isEmpty())
3158 131 : return pMasterObject->GetDescription();
3159 : else
3160 1350 : return msDesc;
3161 : }
3162 :
3163 : /** SwFlyFrameFormat::IsBackgroundTransparent - for #99657#
3164 :
3165 : OD 22.08.2002 - overriding virtual method and its default implementation,
3166 : because format of fly frame provides transparent backgrounds.
3167 : Method determines, if background of fly frame is transparent.
3168 :
3169 : @return true, if background color is transparent, but not "no fill"
3170 : or the transparency of a existing background graphic is set.
3171 : */
3172 5841 : bool SwFlyFrameFormat::IsBackgroundTransparent() const
3173 : {
3174 : //UUUU
3175 5841 : if (supportsFullDrawingLayerFillAttributeSet() && getSdrAllFillAttributesHelper())
3176 : {
3177 5841 : return getSdrAllFillAttributesHelper()->isTransparent();
3178 : }
3179 :
3180 : // NOTE: If background color is "no fill"/"auto fill" (COL_TRANSPARENT)
3181 : // and there is no background graphic, it "inherites" the background
3182 : // from its anchor.
3183 0 : SvxBrushItem aBackground(makeBackgroundBrushItem());
3184 0 : if ( (aBackground.GetColor().GetTransparency() != 0) &&
3185 0 : (aBackground.GetColor() != COL_TRANSPARENT)
3186 : )
3187 : {
3188 0 : return true;
3189 : }
3190 : else
3191 : {
3192 : const GraphicObject *pTmpGrf =
3193 0 : static_cast<const GraphicObject*>(aBackground.GetGraphicObject());
3194 0 : if ( (pTmpGrf) &&
3195 0 : (pTmpGrf->GetAttr().GetTransparency() != 0)
3196 : )
3197 : {
3198 0 : return true;
3199 : }
3200 : }
3201 :
3202 0 : return false;
3203 : }
3204 :
3205 : /** SwFlyFrameFormat::IsBackgroundBrushInherited - for #103898#
3206 :
3207 : OD 08.10.2002 - method to determine, if the brush for drawing the
3208 : background is "inherited" from its parent/grandparent.
3209 : This is the case, if no background graphic is set and the background
3210 : color is "no fill"/"auto fill"
3211 : NOTE: condition is "copied" from method <SwFrm::GetBackgroundBrush(..).
3212 :
3213 : @return true, if background brush is "inherited" from parent/grandparent
3214 : */
3215 2008 : bool SwFlyFrameFormat::IsBackgroundBrushInherited() const
3216 : {
3217 : //UUUU
3218 2008 : if (supportsFullDrawingLayerFillAttributeSet() && getSdrAllFillAttributesHelper())
3219 : {
3220 2008 : return !getSdrAllFillAttributesHelper()->isUsed();
3221 : }
3222 : else
3223 : {
3224 0 : SvxBrushItem aBackground(makeBackgroundBrushItem());
3225 0 : if ( (aBackground.GetColor() == COL_TRANSPARENT) &&
3226 0 : !(aBackground.GetGraphicObject()) )
3227 : {
3228 0 : return true;
3229 0 : }
3230 : }
3231 :
3232 0 : return false;
3233 : }
3234 :
3235 : // #125892#
3236 0 : SwHandleAnchorNodeChg::SwHandleAnchorNodeChg( SwFlyFrameFormat& _rFlyFrameFormat,
3237 : const SwFormatAnchor& _rNewAnchorFormat,
3238 : SwFlyFrm* _pKeepThisFlyFrm )
3239 : : mrFlyFrameFormat( _rFlyFrameFormat ),
3240 0 : mbAnchorNodeChanged( false )
3241 : {
3242 0 : const RndStdIds nNewAnchorType( _rNewAnchorFormat.GetAnchorId() );
3243 0 : if ( ((nNewAnchorType == FLY_AT_PARA) ||
3244 0 : (nNewAnchorType == FLY_AT_CHAR)) &&
3245 0 : _rNewAnchorFormat.GetContentAnchor() &&
3246 0 : _rNewAnchorFormat.GetContentAnchor()->nNode.GetNode().GetContentNode() )
3247 : {
3248 0 : const SwFormatAnchor& aOldAnchorFormat( _rFlyFrameFormat.GetAnchor() );
3249 0 : if ( aOldAnchorFormat.GetAnchorId() == nNewAnchorType &&
3250 0 : aOldAnchorFormat.GetContentAnchor() &&
3251 0 : aOldAnchorFormat.GetContentAnchor()->nNode.GetNode().GetContentNode() &&
3252 0 : aOldAnchorFormat.GetContentAnchor()->nNode !=
3253 0 : _rNewAnchorFormat.GetContentAnchor()->nNode )
3254 : {
3255 : // determine 'old' number of anchor frames
3256 0 : sal_uInt32 nOldNumOfAnchFrm( 0L );
3257 0 : SwIterator<SwFrm,SwContentNode> aOldIter( *(aOldAnchorFormat.GetContentAnchor()->nNode.GetNode().GetContentNode()) );
3258 0 : for( SwFrm* pOld = aOldIter.First(); pOld; pOld = aOldIter.Next() )
3259 : {
3260 0 : ++nOldNumOfAnchFrm;
3261 : }
3262 : // determine 'new' number of anchor frames
3263 0 : sal_uInt32 nNewNumOfAnchFrm( 0L );
3264 0 : SwIterator<SwFrm,SwContentNode> aNewIter( *(_rNewAnchorFormat.GetContentAnchor()->nNode.GetNode().GetContentNode()) );
3265 0 : for( SwFrm* pNew = aNewIter.First(); pNew; pNew = aNewIter.Next() )
3266 : {
3267 0 : ++nNewNumOfAnchFrm;
3268 : }
3269 0 : if ( nOldNumOfAnchFrm != nNewNumOfAnchFrm )
3270 : {
3271 : // delete existing fly frames except <_pKeepThisFlyFrm>
3272 0 : SwIterator<SwFrm,SwFormat> aIter( mrFlyFrameFormat );
3273 0 : SwFrm* pFrm = aIter.First();
3274 0 : if ( pFrm )
3275 : {
3276 0 : do {
3277 0 : if ( pFrm != _pKeepThisFlyFrm )
3278 : {
3279 0 : pFrm->Cut();
3280 0 : SwFrm::DestroyFrm(pFrm);
3281 : }
3282 : } while( 0 != ( pFrm = aIter.Next() ));
3283 : }
3284 : // indicate, that re-creation of fly frames necessary
3285 0 : mbAnchorNodeChanged = true;
3286 0 : }
3287 : }
3288 : }
3289 0 : }
3290 :
3291 0 : SwHandleAnchorNodeChg::~SwHandleAnchorNodeChg()
3292 : {
3293 0 : if ( mbAnchorNodeChanged )
3294 : {
3295 0 : mrFlyFrameFormat.MakeFrms();
3296 : }
3297 0 : }
3298 :
3299 : // class SwDrawFrameFormat
3300 : // Partially implemented inline in hxx
3301 :
3302 10298 : TYPEINIT1( SwDrawFrameFormat, SwFrameFormat );
3303 59 : IMPL_FIXEDMEMPOOL_NEWDEL( SwDrawFrameFormat )
3304 :
3305 7329 : SwDrawFrameFormat::~SwDrawFrameFormat()
3306 : {
3307 2443 : SwContact *pContact = FindContactObj();
3308 2443 : delete pContact;
3309 4886 : }
3310 :
3311 1260 : void SwDrawFrameFormat::MakeFrms()
3312 : {
3313 1260 : SwDrawContact *pContact = static_cast<SwDrawContact*>(FindContactObj());
3314 1260 : if ( pContact )
3315 1260 : pContact->ConnectToLayout();
3316 1260 : }
3317 :
3318 4082 : void SwDrawFrameFormat::DelFrms()
3319 : {
3320 4082 : SwDrawContact *pContact = static_cast<SwDrawContact *>(FindContactObj());
3321 4082 : if ( pContact ) //for the reader and other unpredictable things.
3322 4082 : pContact->DisconnectFromLayout();
3323 4082 : }
3324 :
3325 : // #i31698#
3326 4435 : SwFrameFormat::tLayoutDir SwDrawFrameFormat::GetLayoutDir() const
3327 : {
3328 4435 : return meLayoutDir;
3329 : }
3330 :
3331 2180 : void SwDrawFrameFormat::SetLayoutDir( const SwFrameFormat::tLayoutDir _eLayoutDir )
3332 : {
3333 2180 : meLayoutDir = _eLayoutDir;
3334 2180 : }
3335 :
3336 : // #i28749#
3337 1036 : sal_Int16 SwDrawFrameFormat::GetPositionLayoutDir() const
3338 : {
3339 1036 : return mnPositionLayoutDir;
3340 : }
3341 1039 : void SwDrawFrameFormat::SetPositionLayoutDir( const sal_Int16 _nPositionLayoutDir )
3342 : {
3343 1039 : switch ( _nPositionLayoutDir )
3344 : {
3345 : case text::PositionLayoutDir::PositionInHoriL2R:
3346 : case text::PositionLayoutDir::PositionInLayoutDirOfAnchor:
3347 : {
3348 1039 : mnPositionLayoutDir = _nPositionLayoutDir;
3349 : }
3350 1039 : break;
3351 : default:
3352 : {
3353 : OSL_FAIL( "<SwDrawFrameFormat::SetPositionLayoutDir(..)> - invalid attribute value." );
3354 : }
3355 : }
3356 1039 : }
3357 :
3358 0 : OUString SwDrawFrameFormat::GetDescription() const
3359 : {
3360 0 : OUString aResult;
3361 0 : const SdrObject * pSdrObj = FindSdrObject();
3362 :
3363 0 : if (pSdrObj)
3364 : {
3365 0 : if (pSdrObj != pSdrObjCached)
3366 : {
3367 0 : SdrObject * pSdrObjCopy = pSdrObj->Clone();
3368 0 : SdrUndoNewObj * pSdrUndo = new SdrUndoNewObj(*pSdrObjCopy);
3369 0 : sSdrObjCachedComment = pSdrUndo->GetComment();
3370 :
3371 0 : delete pSdrUndo;
3372 :
3373 0 : pSdrObjCached = pSdrObj;
3374 : }
3375 :
3376 0 : aResult = sSdrObjCachedComment;
3377 : }
3378 : else
3379 0 : aResult = SW_RESSTR(STR_GRAPHIC);
3380 :
3381 0 : return aResult;
3382 : }
3383 :
3384 0 : IMapObject* SwFrameFormat::GetIMapObject( const Point& rPoint,
3385 : const SwFlyFrm *pFly ) const
3386 : {
3387 0 : const SwFormatURL &rURL = GetURL();
3388 0 : if( !rURL.GetMap() )
3389 0 : return 0;
3390 :
3391 0 : if( !pFly )
3392 : {
3393 0 : pFly = SwIterator<SwFlyFrm,SwFormat>( *this ).First();
3394 0 : if( !pFly )
3395 0 : return 0;
3396 : }
3397 :
3398 : //Original size for OLE and graphic is TwipSize, otherwise the size of
3399 : //FrameFormat of the Fly.
3400 : const SwFrm *pRef;
3401 0 : const SwNoTextNode *pNd = 0;
3402 0 : Size aOrigSz;
3403 0 : if( pFly->Lower() && pFly->Lower()->IsNoTextFrm() )
3404 : {
3405 0 : pRef = pFly->Lower();
3406 0 : pNd = static_cast<const SwContentFrm*>(pRef)->GetNode()->GetNoTextNode();
3407 0 : aOrigSz = pNd->GetTwipSize();
3408 : }
3409 : else
3410 : {
3411 0 : pRef = pFly;
3412 0 : aOrigSz = pFly->GetFormat()->GetFrmSize().GetSize();
3413 : }
3414 :
3415 0 : if( aOrigSz.Width() != 0 && aOrigSz.Height() != 0 )
3416 : {
3417 0 : Point aPos( rPoint );
3418 0 : Size aActSz ( pRef == pFly ? pFly->Frm().SSize() : pRef->Prt().SSize() );
3419 0 : const MapMode aSrc ( MAP_TWIP );
3420 0 : const MapMode aDest( MAP_100TH_MM );
3421 0 : aOrigSz = OutputDevice::LogicToLogic( aOrigSz, aSrc, aDest );
3422 0 : aActSz = OutputDevice::LogicToLogic( aActSz, aSrc, aDest );
3423 0 : aPos -= pRef->Frm().Pos();
3424 0 : aPos -= pRef->Prt().Pos();
3425 0 : aPos = OutputDevice::LogicToLogic( aPos, aSrc, aDest );
3426 0 : sal_uInt32 nFlags = 0;
3427 0 : if ( pFly != pRef && pNd->IsGrfNode() )
3428 : {
3429 0 : const sal_uInt16 nMirror = pNd->GetSwAttrSet().
3430 0 : GetMirrorGrf().GetValue();
3431 0 : if ( RES_MIRROR_GRAPH_BOTH == nMirror )
3432 0 : nFlags = IMAP_MIRROR_HORZ | IMAP_MIRROR_VERT;
3433 0 : else if ( RES_MIRROR_GRAPH_VERT == nMirror )
3434 0 : nFlags = IMAP_MIRROR_VERT;
3435 0 : else if ( RES_MIRROR_GRAPH_HOR == nMirror )
3436 0 : nFlags = IMAP_MIRROR_HORZ;
3437 :
3438 : }
3439 0 : return const_cast<ImageMap*>(rURL.GetMap())->GetHitIMapObject( aOrigSz,
3440 0 : aActSz, aPos, nFlags );
3441 : }
3442 :
3443 0 : return 0;
3444 : }
3445 :
3446 : //UUUU
3447 142653 : drawinglayer::attribute::SdrAllFillAttributesHelperPtr SwFrameFormat::getSdrAllFillAttributesHelper() const
3448 : {
3449 142653 : if (supportsFullDrawingLayerFillAttributeSet())
3450 : {
3451 : // create FillAttributes on demand
3452 142653 : if(!maFillAttributes.get())
3453 : {
3454 10797 : const_cast< SwFrameFormat* >(this)->maFillAttributes.reset(new drawinglayer::attribute::SdrAllFillAttributesHelper(GetAttrSet()));
3455 : }
3456 : }
3457 : else
3458 : {
3459 : // FALLBACKBREAKHERE assert wrong usage
3460 : OSL_ENSURE(false, "getSdrAllFillAttributesHelper() call only valid for RES_FLYFRMFMT and RES_FRMFMT (!)");
3461 : }
3462 :
3463 142653 : return maFillAttributes;
3464 : }
3465 :
3466 11 : bool IsFlyFrameFormatInHeader(const SwFrameFormat& rFormat)
3467 : {
3468 11 : const SwFlyFrameFormat* pFlyFrameFormat = dynamic_cast<const SwFlyFrameFormat*>(&rFormat);
3469 11 : if (!pFlyFrameFormat)
3470 1 : return false;
3471 10 : SwFlyFrm* pFlyFrm = pFlyFrameFormat->GetFrm();
3472 10 : if (!pFlyFrm) // fdo#54648: "hidden" drawing object has no layout frame
3473 : {
3474 0 : return false;
3475 : }
3476 10 : SwPageFrm* pPageFrm = pFlyFrm->FindPageFrmOfAnchor();
3477 10 : SwFrm* pHeader = pPageFrm->Lower();
3478 10 : if (pHeader->GetType() == FRM_HEADER)
3479 : {
3480 2 : const SwFrm* pFrm = pFlyFrm->GetAnchorFrm();
3481 9 : while (pFrm)
3482 : {
3483 6 : if (pFrm == pHeader)
3484 1 : return true;
3485 5 : pFrm = pFrm->GetUpper();
3486 : }
3487 : }
3488 9 : return false;
3489 : }
3490 :
3491 : namespace sw {
3492 :
3493 912 : void CheckAnchoredFlyConsistency(SwDoc const& rDoc)
3494 : {
3495 : #if OSL_DEBUG_LEVEL > 0
3496 : SwNodes const& rNodes(rDoc.GetNodes());
3497 : sal_uLong const count(rNodes.Count());
3498 : for (sal_uLong i = 0; i != count; ++i)
3499 : {
3500 : SwNode const*const pNode(rNodes[i]);
3501 : std::vector<SwFrameFormat*> const*const pFlys(pNode->GetAnchoredFlys());
3502 : if (pFlys)
3503 : {
3504 : for (auto it = pFlys->begin(); it != pFlys->end(); ++it)
3505 : {
3506 : SwFormatAnchor const& rAnchor((**it).GetAnchor(false));
3507 : assert(&rAnchor.GetContentAnchor()->nNode.GetNode() == pNode);
3508 : }
3509 : }
3510 : }
3511 : SwFrameFormats const*const pSpzFrameFormats(rDoc.GetSpzFrameFormats());
3512 : if (pSpzFrameFormats)
3513 : {
3514 : for (auto it = pSpzFrameFormats->begin(); it != pSpzFrameFormats->end(); ++it)
3515 : {
3516 : SwFormatAnchor const& rAnchor((**it).GetAnchor(false));
3517 : if (FLY_AT_PAGE == rAnchor.GetAnchorId())
3518 : {
3519 : assert(!rAnchor.GetContentAnchor()
3520 : // for invalid documents that lack text:anchor-page-number
3521 : // it may have an anchor before MakeFrms() is called
3522 : || (!SwIterator<SwFrm, SwFrameFormat>(**it).First()));
3523 : }
3524 : else
3525 : {
3526 : SwNode & rNode(rAnchor.GetContentAnchor()->nNode.GetNode());
3527 : std::vector<SwFrameFormat*> const*const pFlys(rNode.GetAnchoredFlys());
3528 : assert(std::find(pFlys->begin(), pFlys->end(), *it) != pFlys->end());
3529 : switch (rAnchor.GetAnchorId())
3530 : {
3531 : case FLY_AT_FLY:
3532 : assert(rNode.IsStartNode());
3533 : break;
3534 : case FLY_AT_PARA:
3535 : assert(rNode.IsTextNode() || rNode.IsTableNode());
3536 : break;
3537 : case FLY_AS_CHAR:
3538 : case FLY_AT_CHAR:
3539 : assert(rNode.IsTextNode());
3540 : break;
3541 : default:
3542 : assert(false);
3543 : break;
3544 : }
3545 : }
3546 : }
3547 : }
3548 : #else
3549 : (void) rDoc;
3550 : #endif
3551 912 : }
3552 :
3553 177 : } // namespace sw
3554 :
3555 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
