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