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/uno/Any.hxx>
21 : #include <com/sun/star/drawing/LineStyle.hpp>
22 : #include <com/sun/star/script/Converter.hpp>
23 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
24 : #include <com/sun/star/table/ShadowLocation.hpp>
25 : #include <com/sun/star/table/TableBorder.hpp>
26 : #include <com/sun/star/table/ShadowFormat.hpp>
27 : #include <com/sun/star/table/CellRangeAddress.hpp>
28 : #include <com/sun/star/table/CellContentType.hpp>
29 : #include <com/sun/star/table/TableOrientation.hpp>
30 : #include <com/sun/star/util/SortField.hpp>
31 : #include <com/sun/star/util/SortFieldType.hpp>
32 : #include <com/sun/star/table/BorderLine2.hpp>
33 : #include <com/sun/star/table/BorderLineStyle.hpp>
34 : #include <com/sun/star/table/CellOrientation.hpp>
35 : #include <com/sun/star/table/CellAddress.hpp>
36 : #include <com/sun/star/style/PageStyleLayout.hpp>
37 : #include <com/sun/star/style/BreakType.hpp>
38 : #include <com/sun/star/style/GraphicLocation.hpp>
39 : #include <com/sun/star/awt/Rectangle.hpp>
40 : #include <com/sun/star/awt/Selection.hpp>
41 : #include <com/sun/star/awt/Size.hpp>
42 : #include <com/sun/star/text/WritingMode2.hpp>
43 : #include <com/sun/star/frame/status/UpperLowerMarginScale.hpp>
44 : #include <com/sun/star/drawing/ShadingPattern.hpp>
45 :
46 : #include <i18nutil/unicode.hxx>
47 : #include <unotools/securityoptions.hxx>
48 : #include <unotools/ucbstreamhelper.hxx>
49 : #include <limits.h>
50 : #include <comphelper/processfactory.hxx>
51 : #include <svtools/grfmgr.hxx>
52 : #include <tools/urlobj.hxx>
53 : #include <comphelper/types.hxx>
54 : #include <svl/memberid.hrc>
55 : #include <svl/cntwall.hxx>
56 : #include <svtools/borderhelper.hxx>
57 : #include <rtl/ustring.hxx>
58 : #include <rtl/ustrbuf.hxx>
59 : #include <tools/mapunit.hxx>
60 : #include <vcl/graphicfilter.hxx>
61 : #include <vcl/settings.hxx>
62 : #include <vcl/svapp.hxx>
63 : #include <editeng/editids.hrc>
64 : #include <editeng/editrids.hrc>
65 : #include <editeng/pbinitem.hxx>
66 : #include <editeng/sizeitem.hxx>
67 : #include <editeng/lrspitem.hxx>
68 : #include <editeng/ulspitem.hxx>
69 : #include <editeng/prntitem.hxx>
70 : #include <editeng/opaqitem.hxx>
71 : #include <editeng/protitem.hxx>
72 : #include <editeng/shaditem.hxx>
73 : #include <editeng/boxitem.hxx>
74 : #include <editeng/formatbreakitem.hxx>
75 : #include <editeng/keepitem.hxx>
76 : #include <editeng/lineitem.hxx>
77 : #include <editeng/brushitem.hxx>
78 : #include <editeng/frmdiritem.hxx>
79 : #include <editeng/itemtype.hxx>
80 : #include <editeng/eerdll.hxx>
81 : #include <editeng/unoprnms.hxx>
82 : #include <editeng/memberids.hrc>
83 : #include <editeng/editerr.hxx>
84 : #include <libxml/xmlwriter.h>
85 : #include <o3tl/enumrange.hxx>
86 :
87 : using namespace ::editeng;
88 : using namespace ::com::sun::star;
89 : using namespace ::com::sun::star::drawing;
90 : using namespace ::com::sun::star::table::BorderLineStyle;
91 :
92 : /*
93 : SvxBorderLine is not an SfxPoolItem, and has no Store/Create serialization/deserialization methods.
94 : Since border line information needs to be serialized by the table autoformat code, these file-local
95 : methods are defined to encapsulate the necessary serialization logic.
96 : */
97 : namespace
98 : {
99 : /// Item version for saved border lines. The old version saves the line without style information.
100 : const int BORDER_LINE_OLD_VERSION = 0;
101 : /// Item version for saved border lies. The new version includes line style.
102 : const int BORDER_LINE_WITH_STYLE_VERSION = 1;
103 :
104 : /// Store a border line to a stream.
105 716 : SvStream& StoreBorderLine(SvStream &stream, const SvxBorderLine &l, sal_uInt16 version)
106 : {
107 716 : WriteColor( stream, l.GetColor() );
108 716 : stream.WriteUInt16( l.GetOutWidth() )
109 1432 : .WriteUInt16( l.GetInWidth() )
110 1432 : .WriteUInt16( l.GetDistance() );
111 :
112 716 : if (version >= BORDER_LINE_WITH_STYLE_VERSION)
113 716 : stream.WriteUInt16( l.GetBorderLineStyle() );
114 :
115 716 : return stream;
116 : }
117 :
118 : /// Creates a border line from a stream.
119 616 : SvxBorderLine CreateBorderLine(SvStream &stream, sal_uInt16 version)
120 : {
121 : sal_uInt16 nOutline, nInline, nDistance;
122 616 : sal_uInt16 nStyle = css::table::BorderLineStyle::NONE;
123 616 : Color aColor;
124 616 : ReadColor( stream, aColor ).ReadUInt16( nOutline ).ReadUInt16( nInline ).ReadUInt16( nDistance );
125 :
126 616 : if (version >= BORDER_LINE_WITH_STYLE_VERSION)
127 0 : stream.ReadUInt16( nStyle );
128 :
129 616 : SvxBorderLine border(&aColor);
130 616 : border.GuessLinesWidths(nStyle, nOutline, nInline, nDistance);
131 616 : return border;
132 : }
133 :
134 : /// Retrieves a BORDER_LINE_* version from a BOX_BORDER_* version.
135 1332 : sal_uInt16 BorderLineVersionFromBoxVersion(sal_uInt16 boxVersion)
136 : {
137 1332 : return (boxVersion >= BOX_BORDER_STYLE_VERSION)? BORDER_LINE_WITH_STYLE_VERSION : BORDER_LINE_OLD_VERSION;
138 : }
139 : }
140 :
141 14438 : TYPEINIT1_FACTORY(SvxPaperBinItem, SfxByteItem, new SvxPaperBinItem(0));
142 32720 : TYPEINIT1_FACTORY(SvxSizeItem, SfxPoolItem, new SvxSizeItem(0));
143 602010 : TYPEINIT1_FACTORY(SvxLRSpaceItem, SfxPoolItem, new SvxLRSpaceItem(0));
144 482800 : TYPEINIT1_FACTORY(SvxULSpaceItem, SfxPoolItem, new SvxULSpaceItem(0));
145 9024 : TYPEINIT1_FACTORY(SvxPrintItem, SfxBoolItem, new SvxPrintItem(0));
146 9221 : TYPEINIT1_FACTORY(SvxOpaqueItem, SfxBoolItem, new SvxOpaqueItem(0));
147 15267 : TYPEINIT1_FACTORY(SvxProtectItem, SfxPoolItem, new SvxProtectItem(0));
148 62301 : TYPEINIT1_FACTORY(SvxBrushItem, SfxPoolItem, new SvxBrushItem(0));
149 28218 : TYPEINIT1_FACTORY(SvxShadowItem, SfxPoolItem, new SvxShadowItem(0));
150 159750 : TYPEINIT1_FACTORY(SvxBoxItem, SfxPoolItem, new SvxBoxItem(0));
151 18878 : TYPEINIT1_FACTORY(SvxBoxInfoItem, SfxPoolItem, new SvxBoxInfoItem(0));
152 62186 : TYPEINIT1_FACTORY(SvxFormatBreakItem, SfxEnumItem, new SvxFormatBreakItem(SVX_BREAK_NONE, 0));
153 10558 : TYPEINIT1_FACTORY(SvxFormatKeepItem, SfxBoolItem, new SvxFormatKeepItem(false, 0));
154 45128 : TYPEINIT1_FACTORY(SvxLineItem, SfxPoolItem, new SvxLineItem(0));
155 738566 : TYPEINIT1_FACTORY(SvxFrameDirectionItem, SfxUInt16Item, new SvxFrameDirectionItem(FRMDIR_HORI_LEFT_TOP, 0));
156 :
157 : // class SvxPaperBinItem ------------------------------------------------
158 :
159 47 : SfxPoolItem* SvxPaperBinItem::Clone( SfxItemPool* ) const
160 : {
161 47 : return new SvxPaperBinItem( *this );
162 : }
163 :
164 :
165 :
166 0 : SvStream& SvxPaperBinItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
167 : {
168 0 : rStrm.WriteUChar( GetValue() );
169 0 : return rStrm;
170 : }
171 :
172 :
173 :
174 0 : SfxPoolItem* SvxPaperBinItem::Create( SvStream& rStrm, sal_uInt16 ) const
175 : {
176 : sal_Int8 nBin;
177 0 : rStrm.ReadSChar( nBin );
178 0 : return new SvxPaperBinItem( Which(), nBin );
179 : }
180 :
181 :
182 :
183 0 : bool SvxPaperBinItem::GetPresentation
184 : (
185 : SfxItemPresentation ePres,
186 : SfxMapUnit /*eCoreUnit*/,
187 : SfxMapUnit /*ePresUnit*/,
188 : OUString& rText, const IntlWrapper *
189 : ) const
190 : {
191 0 : switch ( ePres )
192 : {
193 : case SFX_ITEM_PRESENTATION_NAMELESS:
194 0 : rText = OUString::number( GetValue() );
195 0 : return true;
196 :
197 : case SFX_ITEM_PRESENTATION_COMPLETE:
198 : {
199 0 : sal_uInt8 nValue = GetValue();
200 :
201 0 : if ( PAPERBIN_PRINTER_SETTINGS == nValue )
202 0 : rText = EE_RESSTR(RID_SVXSTR_PAPERBIN_SETTINGS);
203 : else
204 : {
205 0 : rText = EE_RESSTR(RID_SVXSTR_PAPERBIN) + " " + OUString::number( nValue );
206 : }
207 0 : return true;
208 : }
209 : //no break necessary
210 : default: ;//prevent warning
211 : }
212 :
213 0 : return false;
214 : }
215 :
216 : // class SvxSizeItem -----------------------------------------------------
217 :
218 53286 : SvxSizeItem::SvxSizeItem( const sal_uInt16 nId, const Size& rSize ) :
219 :
220 : SfxPoolItem( nId ),
221 :
222 53286 : aSize( rSize )
223 : {
224 53286 : }
225 :
226 :
227 814 : bool SvxSizeItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
228 : {
229 814 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
230 814 : nMemberId &= ~CONVERT_TWIPS;
231 :
232 814 : awt::Size aTmp(aSize.Width(), aSize.Height());
233 814 : if( bConvert )
234 : {
235 707 : aTmp.Height = convertTwipToMm100(aTmp.Height);
236 707 : aTmp.Width = convertTwipToMm100(aTmp.Width);
237 : }
238 :
239 814 : switch( nMemberId )
240 : {
241 457 : case MID_SIZE_SIZE: rVal <<= aTmp; break;
242 105 : case MID_SIZE_WIDTH: rVal <<= aTmp.Width; break;
243 252 : case MID_SIZE_HEIGHT: rVal <<= aTmp.Height; break;
244 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
245 : }
246 :
247 814 : return true;
248 : }
249 :
250 8381 : bool SvxSizeItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
251 : {
252 8381 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
253 8381 : nMemberId &= ~CONVERT_TWIPS;
254 :
255 8381 : switch( nMemberId )
256 : {
257 : case MID_SIZE_SIZE:
258 : {
259 230 : awt::Size aTmp;
260 230 : if( rVal >>= aTmp )
261 : {
262 230 : if(bConvert)
263 : {
264 123 : aTmp.Height = convertMm100ToTwip(aTmp.Height);
265 123 : aTmp.Width = convertMm100ToTwip(aTmp.Width);
266 : }
267 230 : aSize = Size( aTmp.Width, aTmp.Height );
268 : }
269 : else
270 : {
271 0 : return false;
272 : }
273 : }
274 230 : break;
275 : case MID_SIZE_WIDTH:
276 : {
277 2954 : sal_Int32 nVal = 0;
278 2954 : if(!(rVal >>= nVal ))
279 0 : return false;
280 :
281 2954 : aSize.Width() = bConvert ? convertMm100ToTwip(nVal) : nVal;
282 : }
283 2954 : break;
284 : case MID_SIZE_HEIGHT:
285 : {
286 5197 : sal_Int32 nVal = 0;
287 5197 : if(!(rVal >>= nVal))
288 0 : return true;
289 :
290 5197 : aSize.Height() = bConvert ? convertMm100ToTwip(nVal) : nVal;
291 : }
292 5197 : break;
293 : default: OSL_FAIL("Wrong MemberId!");
294 0 : return false;
295 : }
296 8381 : return true;
297 : }
298 :
299 :
300 :
301 3200 : SvxSizeItem::SvxSizeItem( const sal_uInt16 nId ) :
302 :
303 3200 : SfxPoolItem( nId )
304 : {
305 3200 : }
306 :
307 :
308 :
309 15644 : bool SvxSizeItem::operator==( const SfxPoolItem& rAttr ) const
310 : {
311 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
312 :
313 15644 : return ( aSize == static_cast<const SvxSizeItem&>( rAttr ).GetSize() );
314 : }
315 :
316 :
317 :
318 155344 : SfxPoolItem* SvxSizeItem::Clone( SfxItemPool* ) const
319 : {
320 155344 : return new SvxSizeItem( *this );
321 : }
322 :
323 :
324 :
325 0 : bool SvxSizeItem::GetPresentation
326 : (
327 : SfxItemPresentation ePres,
328 : SfxMapUnit eCoreUnit,
329 : SfxMapUnit ePresUnit,
330 : OUString& rText, const IntlWrapper *pIntl
331 : ) const
332 : {
333 0 : OUString cpDelimTmp(cpDelim);
334 0 : switch ( ePres )
335 : {
336 : case SFX_ITEM_PRESENTATION_NAMELESS:
337 0 : rText = GetMetricText( aSize.Width(), eCoreUnit, ePresUnit, pIntl ) +
338 0 : cpDelimTmp +
339 0 : GetMetricText( aSize.Height(), eCoreUnit, ePresUnit, pIntl );
340 0 : return true;
341 :
342 : case SFX_ITEM_PRESENTATION_COMPLETE:
343 0 : rText = EE_RESSTR(RID_SVXITEMS_SIZE_WIDTH) +
344 0 : GetMetricText( aSize.Width(), eCoreUnit, ePresUnit, pIntl ) +
345 0 : " " + EE_RESSTR(GetMetricId(ePresUnit)) +
346 0 : cpDelimTmp +
347 0 : EE_RESSTR(RID_SVXITEMS_SIZE_HEIGHT) +
348 0 : GetMetricText( aSize.Height(), eCoreUnit, ePresUnit, pIntl ) +
349 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
350 0 : return true;
351 : //no break necessary
352 : default: ;//prevent warning
353 :
354 : }
355 0 : return false;
356 : }
357 :
358 :
359 :
360 0 : SvStream& SvxSizeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
361 : {
362 0 : rStrm.WriteInt32( aSize.Width() );
363 0 : rStrm.WriteInt32( aSize.Height() );
364 0 : return rStrm;
365 : }
366 :
367 :
368 :
369 0 : bool SvxSizeItem::ScaleMetrics( long nMult, long nDiv )
370 : {
371 0 : aSize.Width() = Scale( aSize.Width(), nMult, nDiv );
372 0 : aSize.Height() = Scale( aSize.Height(), nMult, nDiv );
373 0 : return true;
374 : }
375 :
376 :
377 :
378 0 : bool SvxSizeItem::HasMetrics() const
379 : {
380 0 : return true;
381 : }
382 :
383 :
384 :
385 0 : SfxPoolItem* SvxSizeItem::Create( SvStream& rStrm, sal_uInt16 ) const
386 : {
387 0 : sal_Int32 nWidth(0), nHeight(0);
388 0 : rStrm.ReadInt32( nWidth ).ReadInt32( nHeight );
389 :
390 0 : SvxSizeItem* pAttr = new SvxSizeItem( Which() );
391 0 : pAttr->SetSize(Size(nWidth, nHeight));
392 :
393 0 : return pAttr;
394 : }
395 :
396 : // class SvxLRSpaceItem --------------------------------------------------
397 :
398 89922 : SvxLRSpaceItem::SvxLRSpaceItem( const sal_uInt16 nId ) :
399 :
400 : SfxPoolItem( nId ),
401 :
402 : nFirstLineOfst ( 0 ),
403 : nTxtLeft ( 0 ),
404 : nLeftMargin ( 0 ),
405 : nRightMargin ( 0 ),
406 : nPropFirstLineOfst( 100 ),
407 : nPropLeftMargin( 100 ),
408 : nPropRightMargin( 100 ),
409 : bAutoFirst ( false ),
410 : bExplicitZeroMarginValRight(false),
411 89922 : bExplicitZeroMarginValLeft(false)
412 : {
413 89922 : }
414 :
415 :
416 :
417 5330 : SvxLRSpaceItem::SvxLRSpaceItem( const long nLeft, const long nRight,
418 : const long nTLeft, const short nOfset,
419 : const sal_uInt16 nId ) :
420 :
421 : SfxPoolItem( nId ),
422 :
423 : nFirstLineOfst ( nOfset ),
424 : nTxtLeft ( nTLeft ),
425 : nLeftMargin ( nLeft ),
426 : nRightMargin ( nRight ),
427 : nPropFirstLineOfst( 100 ),
428 : nPropLeftMargin( 100 ),
429 : nPropRightMargin( 100 ),
430 : bAutoFirst ( false ),
431 : bExplicitZeroMarginValRight(false),
432 5330 : bExplicitZeroMarginValLeft(false)
433 : {
434 5330 : }
435 :
436 :
437 6383 : bool SvxLRSpaceItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
438 : {
439 6383 : bool bRet = true;
440 6383 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
441 6383 : nMemberId &= ~CONVERT_TWIPS;
442 6383 : switch( nMemberId )
443 : {
444 : // now all signed
445 : case MID_L_MARGIN:
446 367 : rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nLeftMargin) : nLeftMargin);
447 367 : break;
448 :
449 : case MID_TXT_LMARGIN :
450 2186 : rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nTxtLeft) : nTxtLeft);
451 2186 : break;
452 : case MID_R_MARGIN:
453 654 : rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nRightMargin) : nRightMargin);
454 654 : break;
455 : case MID_L_REL_MARGIN:
456 91 : rVal <<= (sal_Int16)nPropLeftMargin;
457 91 : break;
458 : case MID_R_REL_MARGIN:
459 91 : rVal <<= (sal_Int16)nPropRightMargin;
460 91 : break;
461 :
462 : case MID_FIRST_LINE_INDENT:
463 2188 : rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nFirstLineOfst) : nFirstLineOfst);
464 2188 : break;
465 :
466 : case MID_FIRST_LINE_REL_INDENT:
467 87 : rVal <<= (sal_Int16)(nPropFirstLineOfst);
468 87 : break;
469 :
470 : case MID_FIRST_AUTO:
471 110 : rVal = css::uno::makeAny<bool>(IsAutoFirst());
472 110 : break;
473 :
474 : default:
475 609 : bRet = false;
476 : OSL_FAIL("unknown MemberId");
477 : }
478 6383 : return bRet;
479 : }
480 :
481 :
482 40563 : bool SvxLRSpaceItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
483 : {
484 40563 : bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
485 40563 : nMemberId &= ~CONVERT_TWIPS;
486 40563 : sal_Int32 nVal = 0;
487 40563 : if( nMemberId != MID_FIRST_AUTO &&
488 39787 : nMemberId != MID_L_REL_MARGIN && nMemberId != MID_R_REL_MARGIN)
489 39785 : if(!(rVal >>= nVal))
490 0 : return false;
491 :
492 40563 : switch( nMemberId )
493 : {
494 : case MID_L_MARGIN:
495 6888 : SetLeft( bConvert ? convertMm100ToTwip(nVal) : nVal );
496 6888 : break;
497 :
498 : case MID_TXT_LMARGIN :
499 11036 : SetTextLeft( bConvert ? convertMm100ToTwip(nVal) : nVal );
500 11036 : break;
501 :
502 : case MID_R_MARGIN:
503 13340 : SetRight(bConvert ? convertMm100ToTwip(nVal) : nVal);
504 13340 : break;
505 : case MID_L_REL_MARGIN:
506 : case MID_R_REL_MARGIN:
507 : {
508 4 : sal_Int32 nRel = 0;
509 4 : if((rVal >>= nRel) && nRel >= 0 && nRel < USHRT_MAX)
510 : {
511 4 : if(MID_L_REL_MARGIN== nMemberId)
512 2 : nPropLeftMargin = (sal_uInt16)nRel;
513 : else
514 2 : nPropRightMargin = (sal_uInt16)nRel;
515 : }
516 : else
517 0 : return false;
518 : }
519 4 : break;
520 : case MID_FIRST_LINE_INDENT :
521 8521 : SetTextFirstLineOfst((short)(bConvert ? convertMm100ToTwip(nVal) : nVal));
522 8521 : break;
523 :
524 : case MID_FIRST_LINE_REL_INDENT:
525 0 : SetPropTextFirstLineOfst ( (sal_uInt16)nVal );
526 0 : break;
527 :
528 : case MID_FIRST_AUTO:
529 774 : SetAutoFirst( Any2Bool(rVal) );
530 774 : break;
531 :
532 : default:
533 : OSL_FAIL("unknown MemberId");
534 0 : return false;
535 : }
536 40563 : return true;
537 : }
538 :
539 :
540 :
541 : // Adapt nLeftMargin and nTxtLeft.
542 :
543 23696 : void SvxLRSpaceItem::AdjustLeft()
544 : {
545 23696 : if ( 0 > nFirstLineOfst )
546 7377 : nLeftMargin = nTxtLeft + nFirstLineOfst;
547 : else
548 16319 : nLeftMargin = nTxtLeft;
549 23696 : }
550 :
551 :
552 :
553 762596 : bool SvxLRSpaceItem::operator==( const SfxPoolItem& rAttr ) const
554 : {
555 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
556 :
557 762596 : const SvxLRSpaceItem& rOther = static_cast<const SvxLRSpaceItem&>(rAttr);
558 :
559 : return (
560 1363347 : nFirstLineOfst == rOther.GetTextFirstLineOfst() &&
561 975500 : nTxtLeft == rOther.GetTextLeft() &&
562 744493 : nLeftMargin == rOther.GetLeft() &&
563 714948 : nRightMargin == rOther.GetRight() &&
564 690408 : nPropFirstLineOfst == rOther.GetPropTextFirstLineOfst() &&
565 690404 : nPropLeftMargin == rOther.GetPropLeft() &&
566 690394 : nPropRightMargin == rOther.GetPropRight() &&
567 690388 : bAutoFirst == rOther.IsAutoFirst() &&
568 1438997 : bExplicitZeroMarginValRight == rOther.IsExplicitZeroMarginValRight() &&
569 1093803 : bExplicitZeroMarginValLeft == rOther.IsExplicitZeroMarginValLeft() );
570 : }
571 :
572 :
573 :
574 80307 : SfxPoolItem* SvxLRSpaceItem::Clone( SfxItemPool* ) const
575 : {
576 80307 : return new SvxLRSpaceItem( *this );
577 : }
578 :
579 :
580 :
581 0 : bool SvxLRSpaceItem::GetPresentation
582 : (
583 : SfxItemPresentation ePres,
584 : SfxMapUnit eCoreUnit,
585 : SfxMapUnit ePresUnit,
586 : OUString& rText, const IntlWrapper* pIntl
587 : ) const
588 : {
589 0 : switch ( ePres )
590 : {
591 : case SFX_ITEM_PRESENTATION_NAMELESS:
592 : {
593 0 : if ( 100 != nPropLeftMargin )
594 : {
595 0 : rText = unicode::formatPercent(nPropLeftMargin,
596 0 : Application::GetSettings().GetUILanguageTag());
597 : }
598 : else
599 0 : rText = GetMetricText( (long)nLeftMargin,
600 0 : eCoreUnit, ePresUnit, pIntl );
601 0 : rText += OUString(cpDelim);
602 0 : if ( 100 != nPropFirstLineOfst )
603 : {
604 0 : rText += unicode::formatPercent(nPropFirstLineOfst,
605 0 : Application::GetSettings().GetUILanguageTag());
606 : }
607 : else
608 0 : rText += GetMetricText( (long)nFirstLineOfst,
609 0 : eCoreUnit, ePresUnit, pIntl );
610 0 : rText += OUString(cpDelim);
611 0 : if ( 100 != nRightMargin )
612 : {
613 0 : rText += unicode::formatPercent(nRightMargin,
614 0 : Application::GetSettings().GetUILanguageTag());
615 : }
616 : else
617 0 : rText += GetMetricText( (long)nRightMargin,
618 0 : eCoreUnit, ePresUnit, pIntl );
619 0 : return true;
620 : }
621 : case SFX_ITEM_PRESENTATION_COMPLETE:
622 : {
623 0 : rText = EE_RESSTR(RID_SVXITEMS_LRSPACE_LEFT);
624 0 : if ( 100 != nPropLeftMargin )
625 0 : rText += unicode::formatPercent(nPropLeftMargin,
626 0 : Application::GetSettings().GetUILanguageTag());
627 : else
628 : {
629 0 : rText = rText +
630 0 : GetMetricText( (long)nLeftMargin, eCoreUnit, ePresUnit, pIntl ) +
631 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
632 : }
633 0 : rText += OUString(cpDelim);
634 0 : if ( 100 != nPropFirstLineOfst || nFirstLineOfst )
635 : {
636 0 : rText += EE_RESSTR(RID_SVXITEMS_LRSPACE_FLINE);
637 0 : if ( 100 != nPropFirstLineOfst )
638 0 : rText = rText + unicode::formatPercent(nPropFirstLineOfst,
639 0 : Application::GetSettings().GetUILanguageTag());
640 : else
641 : {
642 0 : rText = rText +
643 : GetMetricText( (long)nFirstLineOfst,
644 0 : eCoreUnit, ePresUnit, pIntl ) +
645 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
646 : }
647 0 : rText += OUString(cpDelim);
648 : }
649 0 : rText += EE_RESSTR(RID_SVXITEMS_LRSPACE_RIGHT);
650 0 : if ( 100 != nPropRightMargin )
651 0 : rText = rText + unicode::formatPercent(nPropRightMargin,
652 0 : Application::GetSettings().GetUILanguageTag());
653 : else
654 : {
655 0 : rText = rText +
656 : GetMetricText( (long)nRightMargin,
657 0 : eCoreUnit, ePresUnit, pIntl ) +
658 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
659 : }
660 0 : return true;
661 : }
662 : default: ;//prevent warning
663 : }
664 0 : return false;
665 : }
666 :
667 :
668 :
669 : // BulletFI: Before 501 in the Outliner the bullet was not on the position of
670 : // the FI, so in older documents one must set FI to 0.
671 : #define BULLETLR_MARKER 0x599401FE
672 :
673 4 : SvStream& SvxLRSpaceItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
674 : {
675 4 : short nSaveFI = nFirstLineOfst;
676 4 : const_cast<SvxLRSpaceItem*>(this)->SetTextFirstLineOfst( 0 ); // nLeftMargin is manipulated together with this, see Create()
677 :
678 4 : sal_uInt16 nMargin = 0;
679 4 : if( nLeftMargin > 0 )
680 0 : nMargin = sal_uInt16( nLeftMargin );
681 4 : rStrm.WriteUInt16( nMargin );
682 4 : rStrm.WriteUInt16( nPropLeftMargin );
683 4 : if( nRightMargin > 0 )
684 0 : nMargin = sal_uInt16( nRightMargin );
685 : else
686 4 : nMargin = 0;
687 4 : rStrm.WriteUInt16( nMargin );
688 4 : rStrm.WriteUInt16( nPropRightMargin );
689 4 : rStrm.WriteInt16( nFirstLineOfst );
690 4 : rStrm.WriteUInt16( nPropFirstLineOfst );
691 4 : if( nTxtLeft > 0 )
692 0 : nMargin = sal_uInt16( nTxtLeft );
693 : else
694 4 : nMargin = 0;
695 4 : rStrm.WriteUInt16( nMargin );
696 4 : if( nItemVersion >= LRSPACE_AUTOFIRST_VERSION )
697 : {
698 4 : sal_Int8 nAutoFirst = bAutoFirst ? 1 : 0;
699 8 : if( nItemVersion >= LRSPACE_NEGATIVE_VERSION &&
700 8 : ( nLeftMargin < 0 || nRightMargin < 0 || nTxtLeft < 0 ) )
701 0 : nAutoFirst |= 0x80;
702 4 : rStrm.WriteSChar( nAutoFirst );
703 :
704 : // From 6.0 onwards, do not write Magic numbers...
705 : DBG_ASSERT( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_50, "Change File format SvxLRSpaceItem!" );
706 4 : rStrm.WriteUInt32( BULLETLR_MARKER );
707 4 : rStrm.WriteInt16( nSaveFI );
708 :
709 4 : if( 0x80 & nAutoFirst )
710 : {
711 0 : rStrm.WriteInt32( nLeftMargin );
712 0 : rStrm.WriteInt32( nRightMargin );
713 : }
714 : }
715 :
716 4 : const_cast<SvxLRSpaceItem*>(this)->SetTextFirstLineOfst( nSaveFI );
717 :
718 4 : return rStrm;
719 : }
720 :
721 :
722 :
723 0 : SfxPoolItem* SvxLRSpaceItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const
724 : {
725 : sal_uInt16 left, prpleft, right, prpright, prpfirstline, txtleft;
726 : short firstline;
727 0 : sal_Int8 autofirst = 0;
728 :
729 0 : if ( nVersion >= LRSPACE_AUTOFIRST_VERSION )
730 : {
731 0 : rStrm.ReadUInt16( left ).ReadUInt16( prpleft ).ReadUInt16( right ).ReadUInt16( prpright ).ReadInt16( firstline ). ReadUInt16( prpfirstline ).ReadUInt16( txtleft ).ReadSChar( autofirst );
732 :
733 0 : sal_Size nPos = rStrm.Tell();
734 : sal_uInt32 nMarker;
735 0 : rStrm.ReadUInt32( nMarker );
736 0 : if ( nMarker == BULLETLR_MARKER )
737 : {
738 0 : rStrm.ReadInt16( firstline );
739 0 : if ( firstline < 0 )
740 0 : left = left + static_cast<sal_uInt16>(firstline); // see below: txtleft = ...
741 : }
742 : else
743 0 : rStrm.Seek( nPos );
744 : }
745 0 : else if ( nVersion == LRSPACE_TXTLEFT_VERSION )
746 : {
747 0 : rStrm.ReadUInt16( left ).ReadUInt16( prpleft ).ReadUInt16( right ).ReadUInt16( prpright ).ReadInt16( firstline ). ReadUInt16( prpfirstline ).ReadUInt16( txtleft );
748 : }
749 0 : else if ( nVersion == LRSPACE_16_VERSION )
750 : {
751 0 : rStrm.ReadUInt16( left ).ReadUInt16( prpleft ).ReadUInt16( right ).ReadUInt16( prpright ).ReadInt16( firstline ). ReadUInt16( prpfirstline );
752 : }
753 : else
754 : {
755 : sal_Int8 nL, nR, nFL;
756 0 : rStrm.ReadUInt16( left ).ReadSChar( nL ).ReadUInt16( right ).ReadSChar( nR ).ReadInt16( firstline ).ReadSChar( nFL );
757 0 : prpleft = (sal_uInt16)nL;
758 0 : prpright = (sal_uInt16)nR;
759 0 : prpfirstline = (sal_uInt16)nFL;
760 : }
761 :
762 0 : txtleft = firstline >= 0 ? left : left - firstline;
763 0 : SvxLRSpaceItem* pAttr = new SvxLRSpaceItem( Which() );
764 :
765 0 : pAttr->nLeftMargin = left;
766 0 : pAttr->nPropLeftMargin = prpleft;
767 0 : pAttr->nRightMargin = right;
768 0 : pAttr->nPropRightMargin = prpright;
769 0 : pAttr->nFirstLineOfst = firstline;
770 0 : pAttr->nPropFirstLineOfst = prpfirstline;
771 0 : pAttr->nTxtLeft = txtleft;
772 0 : pAttr->bAutoFirst = autofirst & 0x01;
773 0 : if( nVersion >= LRSPACE_NEGATIVE_VERSION && ( autofirst & 0x80 ) )
774 : {
775 : sal_Int32 nMargin;
776 0 : rStrm.ReadInt32( nMargin );
777 0 : pAttr->nLeftMargin = nMargin;
778 0 : pAttr->nTxtLeft = firstline >= 0 ? nMargin : nMargin - firstline;
779 0 : rStrm.ReadInt32( nMargin );
780 0 : pAttr->nRightMargin = nMargin;
781 : }
782 0 : return pAttr;
783 : }
784 :
785 :
786 :
787 25468 : sal_uInt16 SvxLRSpaceItem::GetVersion( sal_uInt16 nFileVersion ) const
788 : {
789 : return (nFileVersion == SOFFICE_FILEFORMAT_31)
790 : ? LRSPACE_TXTLEFT_VERSION
791 25468 : : LRSPACE_NEGATIVE_VERSION;
792 : }
793 :
794 :
795 :
796 0 : bool SvxLRSpaceItem::ScaleMetrics( long nMult, long nDiv )
797 : {
798 0 : nFirstLineOfst = (short)Scale( nFirstLineOfst, nMult, nDiv );
799 0 : nTxtLeft = Scale( nTxtLeft, nMult, nDiv );
800 0 : nLeftMargin = Scale( nLeftMargin, nMult, nDiv );
801 0 : nRightMargin = Scale( nRightMargin, nMult, nDiv );
802 0 : return true;
803 : }
804 :
805 :
806 :
807 0 : bool SvxLRSpaceItem::HasMetrics() const
808 : {
809 0 : return true;
810 : }
811 :
812 0 : void SvxLRSpaceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
813 : {
814 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("svxLRSpaceItem"));
815 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
816 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nFirstLineOfst"), BAD_CAST(OString::number(nFirstLineOfst).getStr()));
817 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTxtLeft"), BAD_CAST(OString::number(nTxtLeft).getStr()));
818 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeftMargin"), BAD_CAST(OString::number(nLeftMargin).getStr()));
819 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRightMargin"), BAD_CAST(OString::number(nRightMargin).getStr()));
820 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropFirstLineOfst"), BAD_CAST(OString::number(nPropFirstLineOfst).getStr()));
821 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLeftMargin"), BAD_CAST(OString::number(nPropLeftMargin).getStr()));
822 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropRightMargin"), BAD_CAST(OString::number(nPropRightMargin).getStr()));
823 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAutoFirst"), BAD_CAST(OString::number(int(bAutoFirst)).getStr()));
824 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValRight"), BAD_CAST(OString::number(int(bExplicitZeroMarginValRight)).getStr()));
825 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValLeft"), BAD_CAST(OString::number(int(bExplicitZeroMarginValLeft)).getStr()));
826 0 : xmlTextWriterEndElement(pWriter);
827 0 : }
828 :
829 : // class SvxULSpaceItem --------------------------------------------------
830 :
831 85537 : SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nId )
832 : : SfxPoolItem(nId)
833 : , nUpper(0)
834 : , nLower(0)
835 : , bContext(false)
836 : , nPropUpper(100)
837 85537 : , nPropLower(100)
838 : {
839 85537 : }
840 :
841 :
842 :
843 13357 : SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nUp, const sal_uInt16 nLow,
844 : const sal_uInt16 nId )
845 : : SfxPoolItem(nId)
846 : , nUpper(nUp)
847 : , nLower(nLow)
848 : , bContext(false)
849 : , nPropUpper(100)
850 13357 : , nPropLower(100)
851 : {
852 13357 : }
853 :
854 :
855 4909 : bool SvxULSpaceItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
856 : {
857 4909 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
858 4909 : nMemberId &= ~CONVERT_TWIPS;
859 4909 : switch( nMemberId )
860 : {
861 : // now all signed
862 : case 0:
863 : {
864 264 : ::com::sun::star::frame::status::UpperLowerMarginScale aUpperLowerMarginScale;
865 264 : aUpperLowerMarginScale.Upper = (sal_Int32)(bConvert ? convertTwipToMm100(nUpper) : nUpper);
866 264 : aUpperLowerMarginScale.Lower = (sal_Int32)(bConvert ? convertTwipToMm100(nLower) : nPropUpper);
867 264 : aUpperLowerMarginScale.ScaleUpper = (sal_Int16)nPropUpper;
868 264 : aUpperLowerMarginScale.ScaleLower = (sal_Int16)nPropLower;
869 264 : rVal <<= aUpperLowerMarginScale;
870 264 : break;
871 : }
872 1758 : case MID_UP_MARGIN: rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nUpper) : nUpper); break;
873 1775 : case MID_LO_MARGIN: rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nLower) : nLower); break;
874 402 : case MID_CTX_MARGIN: rVal <<= bContext; break;
875 355 : case MID_UP_REL_MARGIN: rVal <<= (sal_Int16) nPropUpper; break;
876 355 : case MID_LO_REL_MARGIN: rVal <<= (sal_Int16) nPropLower; break;
877 : }
878 4909 : return true;
879 : }
880 :
881 :
882 57506 : bool SvxULSpaceItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
883 : {
884 57506 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
885 57506 : nMemberId &= ~CONVERT_TWIPS;
886 57506 : sal_Int32 nVal = 0;
887 57506 : bool bVal = false;
888 57506 : switch( nMemberId )
889 : {
890 : case 0:
891 : {
892 0 : ::com::sun::star::frame::status::UpperLowerMarginScale aUpperLowerMarginScale;
893 0 : if ( !(rVal >>= aUpperLowerMarginScale ))
894 0 : return false;
895 : {
896 0 : SetUpper((sal_uInt16)(bConvert ? convertMm100ToTwip( aUpperLowerMarginScale.Upper ) : aUpperLowerMarginScale.Upper));
897 0 : SetLower((sal_uInt16)(bConvert ? convertMm100ToTwip( aUpperLowerMarginScale.Lower ) : aUpperLowerMarginScale.Lower));
898 0 : if( aUpperLowerMarginScale.ScaleUpper > 1 )
899 0 : nPropUpper = aUpperLowerMarginScale.ScaleUpper;
900 0 : if( aUpperLowerMarginScale.ScaleLower > 1 )
901 0 : nPropUpper = aUpperLowerMarginScale.ScaleLower;
902 : }
903 : }
904 0 : break;
905 : case MID_UP_MARGIN :
906 23299 : if(!(rVal >>= nVal) || nVal < 0)
907 0 : return false;
908 23299 : SetUpper((sal_uInt16)(bConvert ? convertMm100ToTwip(nVal) : nVal));
909 23299 : break;
910 : case MID_LO_MARGIN :
911 31562 : if(!(rVal >>= nVal) || nVal < 0)
912 0 : return false;
913 31562 : SetLower((sal_uInt16)(bConvert ? convertMm100ToTwip(nVal) : nVal));
914 31562 : break;
915 : case MID_CTX_MARGIN :
916 2641 : if (!(rVal >>= bVal))
917 0 : return false;
918 2641 : SetContextValue(bVal);
919 2641 : break;
920 : case MID_UP_REL_MARGIN:
921 : case MID_LO_REL_MARGIN:
922 : {
923 4 : sal_Int32 nRel = 0;
924 4 : if((rVal >>= nRel) && nRel > 1 )
925 : {
926 4 : if(MID_UP_REL_MARGIN == nMemberId)
927 2 : nPropUpper = (sal_uInt16)nRel;
928 : else
929 2 : nPropLower = (sal_uInt16)nRel;
930 : }
931 : else
932 0 : return false;
933 : }
934 4 : break;
935 :
936 : default:
937 : OSL_FAIL("unknown MemberId");
938 0 : return false;
939 : }
940 57506 : return true;
941 : }
942 :
943 :
944 :
945 1955033 : bool SvxULSpaceItem::operator==( const SfxPoolItem& rAttr ) const
946 : {
947 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
948 :
949 1955033 : const SvxULSpaceItem& rSpaceItem = static_cast<const SvxULSpaceItem&>( rAttr );
950 2412700 : return ( nUpper == rSpaceItem.nUpper &&
951 807007 : nLower == rSpaceItem.nLower &&
952 694721 : bContext == rSpaceItem.bContext &&
953 2645793 : nPropUpper == rSpaceItem.nPropUpper &&
954 2300412 : nPropLower == rSpaceItem.nPropLower );
955 : }
956 :
957 :
958 :
959 113957 : SfxPoolItem* SvxULSpaceItem::Clone( SfxItemPool* ) const
960 : {
961 113957 : return new SvxULSpaceItem( *this );
962 : }
963 :
964 :
965 :
966 0 : bool SvxULSpaceItem::GetPresentation
967 : (
968 : SfxItemPresentation ePres,
969 : SfxMapUnit eCoreUnit,
970 : SfxMapUnit ePresUnit,
971 : OUString& rText,
972 : const IntlWrapper *pIntl
973 : ) const
974 : {
975 0 : switch ( ePres )
976 : {
977 : case SFX_ITEM_PRESENTATION_NAMELESS:
978 : {
979 0 : if ( 100 != nPropUpper )
980 : {
981 0 : rText = unicode::formatPercent(nPropUpper,
982 0 : Application::GetSettings().GetUILanguageTag());
983 : }
984 : else
985 0 : rText = GetMetricText( (long)nUpper, eCoreUnit, ePresUnit, pIntl );
986 0 : rText += OUString(cpDelim);
987 0 : if ( 100 != nPropLower )
988 : {
989 0 : rText += unicode::formatPercent(nPropLower,
990 0 : Application::GetSettings().GetUILanguageTag());
991 : }
992 : else
993 0 : rText += GetMetricText( (long)nLower, eCoreUnit, ePresUnit, pIntl );
994 0 : return true;
995 : }
996 : case SFX_ITEM_PRESENTATION_COMPLETE:
997 : {
998 0 : rText = EE_RESSTR(RID_SVXITEMS_ULSPACE_UPPER);
999 0 : if ( 100 != nPropUpper )
1000 : {
1001 0 : rText += unicode::formatPercent(nPropUpper,
1002 0 : Application::GetSettings().GetUILanguageTag());
1003 : }
1004 : else
1005 : {
1006 0 : rText = rText +
1007 0 : GetMetricText( (long)nUpper, eCoreUnit, ePresUnit, pIntl ) +
1008 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
1009 : }
1010 0 : rText = rText + OUString(cpDelim) + EE_RESSTR(RID_SVXITEMS_ULSPACE_LOWER);
1011 0 : if ( 100 != nPropLower )
1012 : {
1013 0 : rText += unicode::formatPercent(nPropLower,
1014 0 : Application::GetSettings().GetUILanguageTag());
1015 : }
1016 : else
1017 : {
1018 0 : rText = rText +
1019 0 : GetMetricText( (long)nLower, eCoreUnit, ePresUnit, pIntl ) +
1020 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
1021 : }
1022 0 : return true;
1023 : }
1024 : default: ;//prevent warning
1025 : }
1026 0 : return false;
1027 : }
1028 :
1029 :
1030 :
1031 4 : SvStream& SvxULSpaceItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1032 : {
1033 4 : rStrm.WriteUInt16( GetUpper() )
1034 8 : .WriteUInt16( GetPropUpper() )
1035 8 : .WriteUInt16( GetLower() )
1036 8 : .WriteUInt16( GetPropLower() );
1037 4 : return rStrm;
1038 : }
1039 :
1040 :
1041 :
1042 0 : SfxPoolItem* SvxULSpaceItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const
1043 : {
1044 0 : sal_uInt16 upper, lower, nPL = 0, nPU = 0;
1045 :
1046 0 : if ( nVersion == ULSPACE_16_VERSION )
1047 0 : rStrm.ReadUInt16( upper ).ReadUInt16( nPU ).ReadUInt16( lower ).ReadUInt16( nPL );
1048 : else
1049 : {
1050 : sal_Int8 nU, nL;
1051 0 : rStrm.ReadUInt16( upper ).ReadSChar( nU ).ReadUInt16( lower ).ReadSChar( nL );
1052 0 : nPL = (sal_uInt16)nL;
1053 0 : nPU = (sal_uInt16)nU;
1054 : }
1055 :
1056 0 : SvxULSpaceItem* pAttr = new SvxULSpaceItem( Which() );
1057 0 : pAttr->SetUpperValue( upper );
1058 0 : pAttr->SetLowerValue( lower );
1059 0 : pAttr->SetPropUpper( nPU );
1060 0 : pAttr->SetPropLower( nPL );
1061 0 : return pAttr;
1062 : }
1063 :
1064 :
1065 :
1066 12736 : sal_uInt16 SvxULSpaceItem::GetVersion( sal_uInt16 /*nFileVersion*/ ) const
1067 : {
1068 12736 : return ULSPACE_16_VERSION;
1069 : }
1070 :
1071 :
1072 :
1073 0 : bool SvxULSpaceItem::ScaleMetrics( long nMult, long nDiv )
1074 : {
1075 0 : nUpper = (sal_uInt16)Scale( nUpper, nMult, nDiv );
1076 0 : nLower = (sal_uInt16)Scale( nLower, nMult, nDiv );
1077 0 : return true;
1078 : }
1079 :
1080 :
1081 :
1082 0 : bool SvxULSpaceItem::HasMetrics() const
1083 : {
1084 0 : return true;
1085 : }
1086 :
1087 0 : void SvxULSpaceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
1088 : {
1089 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("svxULSpaceItem"));
1090 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1091 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(nUpper).getStr()));
1092 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(nLower).getStr()));
1093 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContext"), BAD_CAST(OString::boolean(bContext).getStr()));
1094 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropUpper"), BAD_CAST(OString::number(nPropUpper).getStr()));
1095 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLower"), BAD_CAST(OString::number(nPropLower).getStr()));
1096 0 : xmlTextWriterEndElement(pWriter);
1097 0 : }
1098 :
1099 : // class SvxPrintItem ----------------------------------------------------
1100 :
1101 0 : SfxPoolItem* SvxPrintItem::Clone( SfxItemPool* ) const
1102 : {
1103 0 : return new SvxPrintItem( *this );
1104 : }
1105 :
1106 :
1107 :
1108 0 : SvStream& SvxPrintItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1109 : {
1110 0 : rStrm.WriteSChar( (sal_Int8)GetValue() );
1111 0 : return rStrm;
1112 : }
1113 :
1114 :
1115 :
1116 0 : SfxPoolItem* SvxPrintItem::Create( SvStream& rStrm, sal_uInt16 ) const
1117 : {
1118 : sal_Int8 bIsPrint;
1119 0 : rStrm.ReadSChar( bIsPrint );
1120 0 : return new SvxPrintItem( Which(), bIsPrint != 0 );
1121 : }
1122 :
1123 :
1124 :
1125 0 : bool SvxPrintItem::GetPresentation
1126 : (
1127 : SfxItemPresentation /*ePres*/,
1128 : SfxMapUnit /*eCoreUnit*/,
1129 : SfxMapUnit /*ePresUnit*/,
1130 : OUString& rText, const IntlWrapper *
1131 : ) const
1132 : {
1133 0 : sal_uInt16 nId = RID_SVXITEMS_PRINT_FALSE;
1134 :
1135 0 : if ( GetValue() )
1136 0 : nId = RID_SVXITEMS_PRINT_TRUE;
1137 0 : rText = EE_RESSTR(nId);
1138 0 : return true;
1139 : }
1140 :
1141 : // class SvxOpaqueItem ---------------------------------------------------
1142 :
1143 195 : SfxPoolItem* SvxOpaqueItem::Clone( SfxItemPool* ) const
1144 : {
1145 195 : return new SvxOpaqueItem( *this );
1146 : }
1147 :
1148 :
1149 :
1150 0 : SvStream& SvxOpaqueItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1151 : {
1152 0 : rStrm.WriteSChar( (sal_Int8)GetValue() );
1153 0 : return rStrm;
1154 : }
1155 :
1156 :
1157 :
1158 0 : SfxPoolItem* SvxOpaqueItem::Create( SvStream& rStrm, sal_uInt16 ) const
1159 : {
1160 : sal_Int8 bIsOpaque;
1161 0 : rStrm.ReadSChar( bIsOpaque );
1162 0 : return new SvxOpaqueItem( Which(), bIsOpaque != 0 );
1163 : }
1164 :
1165 :
1166 :
1167 0 : bool SvxOpaqueItem::GetPresentation
1168 : (
1169 : SfxItemPresentation /*ePres*/,
1170 : SfxMapUnit /*eCoreUnit*/,
1171 : SfxMapUnit /*ePresUnit*/,
1172 : OUString& rText, const IntlWrapper *
1173 : ) const
1174 : {
1175 0 : sal_uInt16 nId = RID_SVXITEMS_OPAQUE_FALSE;
1176 :
1177 0 : if ( GetValue() )
1178 0 : nId = RID_SVXITEMS_OPAQUE_TRUE;
1179 0 : rText = EE_RESSTR(nId);
1180 0 : return true;
1181 : }
1182 :
1183 : // class SvxProtectItem --------------------------------------------------
1184 :
1185 1092 : bool SvxProtectItem::operator==( const SfxPoolItem& rAttr ) const
1186 : {
1187 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
1188 :
1189 1092 : const SvxProtectItem& rItem = static_cast<const SvxProtectItem&>(rAttr);
1190 1790 : return ( bCntnt == rItem.bCntnt &&
1191 1738 : bSize == rItem.bSize &&
1192 1738 : bPos == rItem.bPos );
1193 : }
1194 :
1195 667 : bool SvxProtectItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1196 : {
1197 667 : nMemberId &= ~CONVERT_TWIPS;
1198 : bool bValue;
1199 667 : switch(nMemberId)
1200 : {
1201 535 : case MID_PROTECT_CONTENT : bValue = bCntnt; break;
1202 66 : case MID_PROTECT_SIZE : bValue = bSize; break;
1203 66 : case MID_PROTECT_POSITION: bValue = bPos; break;
1204 : default:
1205 : OSL_FAIL("Wrong MemberId");
1206 0 : return false;
1207 : }
1208 :
1209 667 : rVal = css::uno::makeAny<bool>( bValue );
1210 667 : return true;
1211 : }
1212 :
1213 107 : bool SvxProtectItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1214 : {
1215 107 : nMemberId &= ~CONVERT_TWIPS;
1216 107 : bool bVal( Any2Bool(rVal) );
1217 107 : switch(nMemberId)
1218 : {
1219 37 : case MID_PROTECT_CONTENT : bCntnt = bVal; break;
1220 35 : case MID_PROTECT_SIZE : bSize = bVal; break;
1221 35 : case MID_PROTECT_POSITION: bPos = bVal; break;
1222 : default:
1223 : OSL_FAIL("Wrong MemberId");
1224 0 : return false;
1225 : }
1226 107 : return true;
1227 : }
1228 :
1229 :
1230 :
1231 1508 : SfxPoolItem* SvxProtectItem::Clone( SfxItemPool* ) const
1232 : {
1233 1508 : return new SvxProtectItem( *this );
1234 : }
1235 :
1236 :
1237 :
1238 0 : bool SvxProtectItem::GetPresentation
1239 : (
1240 : SfxItemPresentation /*ePres*/,
1241 : SfxMapUnit /*eCoreUnit*/,
1242 : SfxMapUnit /*ePresUnit*/,
1243 : OUString& rText, const IntlWrapper *
1244 : ) const
1245 : {
1246 0 : sal_uInt16 nId = RID_SVXITEMS_PROT_CONTENT_FALSE;
1247 :
1248 0 : if ( bCntnt )
1249 0 : nId = RID_SVXITEMS_PROT_CONTENT_TRUE;
1250 0 : rText = EE_RESSTR(nId) + OUString(cpDelim);
1251 0 : nId = RID_SVXITEMS_PROT_SIZE_FALSE;
1252 :
1253 0 : if ( bSize )
1254 0 : nId = RID_SVXITEMS_PROT_SIZE_TRUE;
1255 0 : rText = rText + EE_RESSTR(nId) + OUString(cpDelim);
1256 0 : nId = RID_SVXITEMS_PROT_POS_FALSE;
1257 :
1258 0 : if ( bPos )
1259 0 : nId = RID_SVXITEMS_PROT_POS_TRUE;
1260 0 : rText += EE_RESSTR(nId);
1261 0 : return true;
1262 : }
1263 :
1264 :
1265 :
1266 0 : SvStream& SvxProtectItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1267 : {
1268 0 : sal_Int8 cProt = 0;
1269 0 : if( IsPosProtected() ) cProt |= 0x01;
1270 0 : if( IsSizeProtected() ) cProt |= 0x02;
1271 0 : if( IsContentProtected() ) cProt |= 0x04;
1272 0 : rStrm.WriteSChar( cProt );
1273 0 : return rStrm;
1274 : }
1275 :
1276 :
1277 :
1278 0 : SfxPoolItem* SvxProtectItem::Create( SvStream& rStrm, sal_uInt16 ) const
1279 : {
1280 : sal_Int8 cFlags;
1281 0 : rStrm.ReadSChar( cFlags );
1282 0 : SvxProtectItem* pAttr = new SvxProtectItem( Which() );
1283 0 : pAttr->SetPosProtect( ( cFlags & 0x01 ) != 0 );
1284 0 : pAttr->SetSizeProtect( ( cFlags & 0x02 ) != 0 );
1285 0 : pAttr->SetContentProtect( ( cFlags & 0x04 ) != 0 );
1286 0 : return pAttr;
1287 : }
1288 :
1289 0 : void SvxProtectItem::dumpAsXml(xmlTextWriterPtr pWriter) const
1290 : {
1291 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("svxProtectItem"));
1292 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1293 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("content"), BAD_CAST(OString::boolean(bCntnt).getStr()));
1294 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::boolean(bSize).getStr()));
1295 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("position"), BAD_CAST(OString::boolean(bPos).getStr()));
1296 0 : xmlTextWriterEndElement(pWriter);
1297 0 : }
1298 :
1299 : // class SvxShadowItem ---------------------------------------------------
1300 :
1301 22364 : SvxShadowItem::SvxShadowItem( const sal_uInt16 nId,
1302 : const Color *pColor, const sal_uInt16 nW,
1303 : const SvxShadowLocation eLoc ) :
1304 : SfxEnumItemInterface( nId ),
1305 : aShadowColor(COL_GRAY),
1306 : nWidth ( nW ),
1307 22364 : eLocation ( eLoc )
1308 : {
1309 22364 : if ( pColor )
1310 20770 : aShadowColor = *pColor;
1311 22364 : }
1312 :
1313 :
1314 668 : bool SvxShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1315 : {
1316 668 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1317 668 : nMemberId &= ~CONVERT_TWIPS;
1318 :
1319 668 : table::ShadowFormat aShadow;
1320 668 : table::ShadowLocation eSet = table::ShadowLocation_NONE;
1321 668 : switch( eLocation )
1322 : {
1323 0 : case SVX_SHADOW_TOPLEFT : eSet = table::ShadowLocation_TOP_LEFT ; break;
1324 4 : case SVX_SHADOW_TOPRIGHT : eSet = table::ShadowLocation_TOP_RIGHT ; break;
1325 3 : case SVX_SHADOW_BOTTOMLEFT : eSet = table::ShadowLocation_BOTTOM_LEFT ; break;
1326 35 : case SVX_SHADOW_BOTTOMRIGHT: eSet = table::ShadowLocation_BOTTOM_RIGHT; break;
1327 : default: ;//prevent warning
1328 : }
1329 668 : aShadow.Location = eSet;
1330 668 : aShadow.ShadowWidth = bConvert ? convertTwipToMm100(nWidth) : nWidth;
1331 668 : aShadow.IsTransparent = aShadowColor.GetTransparency() > 0;
1332 668 : aShadow.Color = aShadowColor.GetColor();
1333 :
1334 668 : sal_Int8 nTransparence = rtl::math::round(float(aShadowColor.GetTransparency() * 100) / 255);
1335 :
1336 668 : switch ( nMemberId )
1337 : {
1338 0 : case MID_LOCATION: rVal <<= aShadow.Location; break;
1339 0 : case MID_WIDTH: rVal <<= aShadow.ShadowWidth; break;
1340 0 : case MID_TRANSPARENT: rVal <<= aShadow.IsTransparent; break;
1341 0 : case MID_BG_COLOR: rVal <<= aShadow.Color; break;
1342 564 : case 0: rVal <<= aShadow; break;
1343 104 : case MID_SHADOW_TRANSPARENCE: rVal <<= nTransparence; break;
1344 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
1345 : }
1346 :
1347 668 : return true;
1348 : }
1349 :
1350 349 : bool SvxShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1351 : {
1352 349 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1353 349 : nMemberId &= ~CONVERT_TWIPS;
1354 :
1355 349 : table::ShadowFormat aShadow;
1356 349 : uno::Any aAny;
1357 349 : bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aShadow );
1358 349 : switch ( nMemberId )
1359 : {
1360 : case MID_LOCATION:
1361 : {
1362 0 : bRet = (rVal >>= aShadow.Location);
1363 0 : if ( !bRet )
1364 : {
1365 0 : sal_Int16 nVal = 0;
1366 0 : bRet = (rVal >>= nVal);
1367 0 : aShadow.Location = (table::ShadowLocation) nVal;
1368 : }
1369 :
1370 0 : break;
1371 : }
1372 :
1373 0 : case MID_WIDTH: rVal >>= aShadow.ShadowWidth; break;
1374 0 : case MID_TRANSPARENT: rVal >>= aShadow.IsTransparent; break;
1375 0 : case MID_BG_COLOR: rVal >>= aShadow.Color; break;
1376 292 : case 0: rVal >>= aShadow; break;
1377 : case MID_SHADOW_TRANSPARENCE:
1378 : {
1379 57 : sal_Int32 nTransparence = 0;
1380 57 : if (rVal >>= nTransparence)
1381 : {
1382 57 : Color aColor(aShadow.Color);
1383 57 : aColor.SetTransparency(rtl::math::round(float(nTransparence * 255) / 100));
1384 57 : aShadow.Color = aColor.GetColor();
1385 : }
1386 57 : break;
1387 : }
1388 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
1389 : }
1390 :
1391 349 : if ( bRet )
1392 : {
1393 : // SvxShadowLocation eSet = SVX_SHADOW_NONE;
1394 349 : switch( aShadow.Location )
1395 : {
1396 3 : case table::ShadowLocation_TOP_LEFT : eLocation = SVX_SHADOW_TOPLEFT; break;
1397 10 : case table::ShadowLocation_TOP_RIGHT : eLocation = SVX_SHADOW_TOPRIGHT; break;
1398 5 : case table::ShadowLocation_BOTTOM_LEFT : eLocation = SVX_SHADOW_BOTTOMLEFT ; break;
1399 73 : case table::ShadowLocation_BOTTOM_RIGHT: eLocation = SVX_SHADOW_BOTTOMRIGHT; break;
1400 : default: ;//prevent warning
1401 : }
1402 :
1403 349 : nWidth = bConvert ? convertMm100ToTwip(aShadow.ShadowWidth) : aShadow.ShadowWidth;
1404 349 : Color aSet(aShadow.Color);
1405 349 : aShadowColor = aSet;
1406 : }
1407 :
1408 349 : return bRet;
1409 : }
1410 :
1411 :
1412 :
1413 95842 : bool SvxShadowItem::operator==( const SfxPoolItem& rAttr ) const
1414 : {
1415 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
1416 :
1417 95842 : const SvxShadowItem& rItem = static_cast<const SvxShadowItem&>(rAttr);
1418 191549 : return ( ( aShadowColor == rItem.aShadowColor ) &&
1419 191531 : ( nWidth == rItem.GetWidth() ) &&
1420 191531 : ( eLocation == rItem.GetLocation() ) );
1421 : }
1422 :
1423 :
1424 :
1425 485 : SfxPoolItem* SvxShadowItem::Clone( SfxItemPool* ) const
1426 : {
1427 485 : return new SvxShadowItem( *this );
1428 : }
1429 :
1430 :
1431 :
1432 116809 : sal_uInt16 SvxShadowItem::CalcShadowSpace( SvxShadowItemSide nShadow ) const
1433 : {
1434 116809 : sal_uInt16 nSpace = 0;
1435 :
1436 116809 : switch ( nShadow )
1437 : {
1438 : case SvxShadowItemSide::TOP:
1439 82076 : if ( eLocation == SVX_SHADOW_TOPLEFT ||
1440 41038 : eLocation == SVX_SHADOW_TOPRIGHT )
1441 0 : nSpace = nWidth;
1442 41038 : break;
1443 :
1444 : case SvxShadowItemSide::BOTTOM:
1445 82010 : if ( eLocation == SVX_SHADOW_BOTTOMLEFT ||
1446 41005 : eLocation == SVX_SHADOW_BOTTOMRIGHT )
1447 53 : nSpace = nWidth;
1448 41005 : break;
1449 :
1450 : case SvxShadowItemSide::LEFT:
1451 34766 : if ( eLocation == SVX_SHADOW_TOPLEFT ||
1452 17383 : eLocation == SVX_SHADOW_BOTTOMLEFT )
1453 0 : nSpace = nWidth;
1454 17383 : break;
1455 :
1456 : case SvxShadowItemSide::RIGHT:
1457 34766 : if ( eLocation == SVX_SHADOW_TOPRIGHT ||
1458 17383 : eLocation == SVX_SHADOW_BOTTOMRIGHT )
1459 50 : nSpace = nWidth;
1460 17383 : break;
1461 :
1462 : default:
1463 : OSL_FAIL( "wrong shadow" );
1464 : }
1465 116809 : return nSpace;
1466 : }
1467 :
1468 :
1469 :
1470 0 : bool SvxShadowItem::GetPresentation
1471 : (
1472 : SfxItemPresentation ePres,
1473 : SfxMapUnit eCoreUnit,
1474 : SfxMapUnit ePresUnit,
1475 : OUString& rText, const IntlWrapper *pIntl
1476 : ) const
1477 : {
1478 0 : switch ( ePres )
1479 : {
1480 : case SFX_ITEM_PRESENTATION_NAMELESS:
1481 : {
1482 0 : rText = ::GetColorString( aShadowColor ) + OUString(cpDelim);
1483 0 : sal_uInt16 nId = RID_SVXITEMS_TRANSPARENT_FALSE;
1484 :
1485 0 : if ( aShadowColor.GetTransparency() )
1486 0 : nId = RID_SVXITEMS_TRANSPARENT_TRUE;
1487 0 : rText = rText +
1488 0 : EE_RESSTR(nId) +
1489 0 : OUString(cpDelim) +
1490 0 : GetMetricText( (long)nWidth, eCoreUnit, ePresUnit, pIntl ) +
1491 0 : OUString(cpDelim) +
1492 0 : EE_RESSTR(RID_SVXITEMS_SHADOW_BEGIN + eLocation);
1493 0 : return true;
1494 : }
1495 : case SFX_ITEM_PRESENTATION_COMPLETE:
1496 : {
1497 0 : rText = EE_RESSTR(RID_SVXITEMS_SHADOW_COMPLETE) +
1498 0 : ::GetColorString( aShadowColor ) +
1499 0 : OUString(cpDelim);
1500 :
1501 0 : sal_uInt16 nId = RID_SVXITEMS_TRANSPARENT_FALSE;
1502 0 : if ( aShadowColor.GetTransparency() )
1503 0 : nId = RID_SVXITEMS_TRANSPARENT_TRUE;
1504 0 : rText = rText +
1505 0 : EE_RESSTR(nId) +
1506 0 : OUString(cpDelim) +
1507 0 : GetMetricText( (long)nWidth, eCoreUnit, ePresUnit, pIntl ) +
1508 0 : " " + EE_RESSTR(GetMetricId(ePresUnit)) +
1509 0 : OUString(cpDelim) +
1510 0 : EE_RESSTR(RID_SVXITEMS_SHADOW_BEGIN + eLocation);
1511 0 : return true;
1512 : }
1513 : default: ;//prevent warning
1514 : }
1515 0 : return false;
1516 : }
1517 :
1518 :
1519 :
1520 0 : SvStream& SvxShadowItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1521 : {
1522 0 : rStrm.WriteSChar( GetLocation() )
1523 0 : .WriteUInt16( GetWidth() )
1524 0 : .WriteBool( aShadowColor.GetTransparency() > 0 );
1525 0 : WriteColor( rStrm, GetColor() );
1526 0 : WriteColor( rStrm, GetColor() );
1527 0 : rStrm.WriteSChar( aShadowColor.GetTransparency() > 0 ? 0 : 1 ); //BRUSH_NULL : BRUSH_SOLID
1528 0 : return rStrm;
1529 : }
1530 :
1531 :
1532 :
1533 0 : bool SvxShadowItem::ScaleMetrics( long nMult, long nDiv )
1534 : {
1535 0 : nWidth = (sal_uInt16)Scale( nWidth, nMult, nDiv );
1536 0 : return true;
1537 : }
1538 :
1539 :
1540 :
1541 0 : bool SvxShadowItem::HasMetrics() const
1542 : {
1543 0 : return true;
1544 : }
1545 :
1546 :
1547 :
1548 0 : SfxPoolItem* SvxShadowItem::Create( SvStream& rStrm, sal_uInt16 ) const
1549 : {
1550 : sal_Int8 cLoc;
1551 : sal_uInt16 _nWidth;
1552 : bool bTrans;
1553 0 : Color aColor;
1554 0 : Color aFillColor;
1555 : sal_Int8 nStyle;
1556 0 : rStrm.ReadSChar( cLoc ).ReadUInt16( _nWidth )
1557 0 : .ReadCharAsBool( bTrans );
1558 0 : ReadColor( rStrm, aColor );
1559 0 : ReadColor( rStrm, aFillColor ).ReadSChar( nStyle );
1560 0 : aColor.SetTransparency(bTrans ? 0xff : 0);
1561 0 : return new SvxShadowItem( Which(), &aColor, _nWidth, (SvxShadowLocation)cLoc );
1562 : }
1563 :
1564 :
1565 :
1566 0 : sal_uInt16 SvxShadowItem::GetValueCount() const
1567 : {
1568 0 : return SVX_SHADOW_END; // SVX_SHADOW_BOTTOMRIGHT + 1
1569 : }
1570 :
1571 :
1572 :
1573 0 : OUString SvxShadowItem::GetValueTextByPos( sal_uInt16 nPos ) const
1574 : {
1575 : DBG_ASSERT( nPos < SVX_SHADOW_END, "enum overflow!" );
1576 0 : return EE_RESSTR(RID_SVXITEMS_SHADOW_BEGIN + nPos );
1577 : }
1578 :
1579 :
1580 :
1581 0 : sal_uInt16 SvxShadowItem::GetEnumValue() const
1582 : {
1583 0 : return (sal_uInt16)GetLocation();
1584 : }
1585 :
1586 :
1587 :
1588 0 : void SvxShadowItem::SetEnumValue( sal_uInt16 nVal )
1589 : {
1590 0 : SetLocation( (const SvxShadowLocation)nVal );
1591 0 : }
1592 :
1593 0 : void SvxShadowItem::dumpAsXml(xmlTextWriterPtr pWriter) const
1594 : {
1595 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("svxShadowItem"));
1596 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1597 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aShadowColor"), BAD_CAST(aShadowColor.AsRGBHexString().toUtf8().getStr()));
1598 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(nWidth).getStr()));
1599 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLocation"), BAD_CAST(OString::number(eLocation).getStr()));
1600 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(EE_RESSTR(RID_SVXITEMS_SHADOW_BEGIN + eLocation).toUtf8().getStr()));
1601 0 : xmlTextWriterEndElement(pWriter);
1602 0 : }
1603 :
1604 : // class SvxBoxItem ------------------------------------------------------
1605 :
1606 128433 : SvxBoxItem::SvxBoxItem( const SvxBoxItem& rCpy ) :
1607 :
1608 : SfxPoolItem ( rCpy ),
1609 : nTopDist ( rCpy.nTopDist ),
1610 : nBottomDist ( rCpy.nBottomDist ),
1611 : nLeftDist ( rCpy.nLeftDist ),
1612 128433 : nRightDist ( rCpy.nRightDist )
1613 :
1614 : {
1615 128433 : pTop = rCpy.GetTop() ? new SvxBorderLine( *rCpy.GetTop() ) : 0;
1616 128433 : pBottom = rCpy.GetBottom() ? new SvxBorderLine( *rCpy.GetBottom() ) : 0;
1617 128433 : pLeft = rCpy.GetLeft() ? new SvxBorderLine( *rCpy.GetLeft() ) : 0;
1618 128433 : pRight = rCpy.GetRight() ? new SvxBorderLine( *rCpy.GetRight() ) : 0;
1619 128433 : }
1620 :
1621 :
1622 :
1623 14139 : SvxBoxItem::SvxBoxItem( const sal_uInt16 nId ) :
1624 : SfxPoolItem( nId ),
1625 :
1626 : pTop ( 0 ),
1627 : pBottom ( 0 ),
1628 : pLeft ( 0 ),
1629 : pRight ( 0 ),
1630 : nTopDist ( 0 ),
1631 : nBottomDist ( 0 ),
1632 : nLeftDist ( 0 ),
1633 14139 : nRightDist ( 0 )
1634 :
1635 : {
1636 14139 : }
1637 :
1638 :
1639 :
1640 405413 : SvxBoxItem::~SvxBoxItem()
1641 : {
1642 142318 : delete pTop;
1643 142318 : delete pBottom;
1644 142318 : delete pLeft;
1645 142318 : delete pRight;
1646 263095 : }
1647 :
1648 :
1649 :
1650 1296 : SvxBoxItem& SvxBoxItem::operator=( const SvxBoxItem& rBox )
1651 : {
1652 1296 : nTopDist = rBox.nTopDist;
1653 1296 : nBottomDist = rBox.nBottomDist;
1654 1296 : nLeftDist = rBox.nLeftDist;
1655 1296 : nRightDist = rBox.nRightDist;
1656 1296 : SetLine( rBox.GetTop(), SvxBoxItemLine::TOP );
1657 1296 : SetLine( rBox.GetBottom(), SvxBoxItemLine::BOTTOM );
1658 1296 : SetLine( rBox.GetLeft(), SvxBoxItemLine::LEFT );
1659 1296 : SetLine( rBox.GetRight(), SvxBoxItemLine::RIGHT );
1660 1296 : return *this;
1661 : }
1662 :
1663 :
1664 :
1665 2005499 : inline bool CmpBrdLn( const SvxBorderLine* pBrd1, const SvxBorderLine* pBrd2 )
1666 : {
1667 : bool bRet;
1668 2005499 : if( 0 != pBrd1 ? 0 == pBrd2 : 0 != pBrd2 )
1669 228320 : bRet = false;
1670 : else
1671 1777179 : if( !pBrd1 )
1672 1521864 : bRet = true;
1673 : else
1674 255315 : bRet = (*pBrd1 == *pBrd2);
1675 2005499 : return bRet;
1676 : }
1677 :
1678 :
1679 :
1680 834606 : bool SvxBoxItem::operator==( const SfxPoolItem& rAttr ) const
1681 : {
1682 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
1683 :
1684 834606 : const SvxBoxItem& rBoxItem = static_cast<const SvxBoxItem&>(rAttr);
1685 : return (
1686 1571344 : ( nTopDist == rBoxItem.nTopDist ) &&
1687 1464095 : ( nBottomDist == rBoxItem.nBottomDist ) &&
1688 1276626 : ( nLeftDist == rBoxItem.nLeftDist ) &&
1689 1096119 : ( nRightDist == rBoxItem.nRightDist ) &&
1690 926352 : CmpBrdLn( pTop, rBoxItem.GetTop() ) &&
1691 699903 : CmpBrdLn( pBottom, rBoxItem.GetBottom() ) &&
1692 1442183 : CmpBrdLn( pLeft, rBoxItem.GetLeft() ) &&
1693 1121782 : CmpBrdLn( pRight, rBoxItem.GetRight() ) );
1694 : }
1695 :
1696 :
1697 3912 : table::BorderLine2 SvxBoxItem::SvxLineToLine(const SvxBorderLine* pLine, bool bConvert)
1698 : {
1699 3912 : table::BorderLine2 aLine;
1700 3912 : if(pLine)
1701 : {
1702 1514 : aLine.Color = pLine->GetColor().GetColor() ;
1703 1514 : aLine.InnerLineWidth = sal_uInt16( bConvert ? convertTwipToMm100(pLine->GetInWidth() ): pLine->GetInWidth() );
1704 1514 : aLine.OuterLineWidth = sal_uInt16( bConvert ? convertTwipToMm100(pLine->GetOutWidth()): pLine->GetOutWidth() );
1705 1514 : aLine.LineDistance = sal_uInt16( bConvert ? convertTwipToMm100(pLine->GetDistance()): pLine->GetDistance() );
1706 1514 : aLine.LineStyle = pLine->GetBorderLineStyle();
1707 1514 : aLine.LineWidth = sal_uInt32( bConvert ? convertTwipToMm100( pLine->GetWidth( ) ) : pLine->GetWidth( ) );
1708 : }
1709 : else
1710 2398 : aLine.Color = aLine.InnerLineWidth = aLine.OuterLineWidth = aLine.LineDistance = 0;
1711 3912 : return aLine;
1712 : }
1713 :
1714 3744 : bool SvxBoxItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1715 : {
1716 3744 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1717 3744 : table::BorderLine2 aRetLine;
1718 3744 : sal_uInt16 nDist = 0;
1719 3744 : bool bDistMember = false;
1720 3744 : nMemberId &= ~CONVERT_TWIPS;
1721 3744 : switch(nMemberId)
1722 : {
1723 : case 0:
1724 : {
1725 : // 4 Borders and 5 distances
1726 31 : uno::Sequence< uno::Any > aSeq( 9 );
1727 31 : aSeq[0] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetLeft(), bConvert) );
1728 31 : aSeq[1] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetRight(), bConvert) );
1729 31 : aSeq[2] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetBottom(), bConvert) );
1730 31 : aSeq[3] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetTop(), bConvert) );
1731 31 : aSeq[4] <<= uno::makeAny( (sal_Int32)(bConvert ? convertTwipToMm100( GetDistance()) : GetDistance()));
1732 31 : aSeq[5] <<= uno::makeAny( (sal_Int32)(bConvert ? convertTwipToMm100( nTopDist ) : nTopDist ));
1733 31 : aSeq[6] <<= uno::makeAny( (sal_Int32)(bConvert ? convertTwipToMm100( nBottomDist ) : nBottomDist ));
1734 31 : aSeq[7] <<= uno::makeAny( (sal_Int32)(bConvert ? convertTwipToMm100( nLeftDist ) : nLeftDist ));
1735 31 : aSeq[8] <<= uno::makeAny( (sal_Int32)(bConvert ? convertTwipToMm100( nRightDist ) : nRightDist ));
1736 31 : rVal = uno::makeAny( aSeq );
1737 31 : return true;
1738 : }
1739 : case MID_LEFT_BORDER:
1740 : case LEFT_BORDER:
1741 528 : aRetLine = SvxBoxItem::SvxLineToLine(GetLeft(), bConvert);
1742 528 : break;
1743 : case MID_RIGHT_BORDER:
1744 : case RIGHT_BORDER:
1745 516 : aRetLine = SvxBoxItem::SvxLineToLine(GetRight(), bConvert);
1746 516 : break;
1747 : case MID_BOTTOM_BORDER:
1748 : case BOTTOM_BORDER:
1749 520 : aRetLine = SvxBoxItem::SvxLineToLine(GetBottom(), bConvert);
1750 520 : break;
1751 : case MID_TOP_BORDER:
1752 : case TOP_BORDER:
1753 707 : aRetLine = SvxBoxItem::SvxLineToLine(GetTop(), bConvert);
1754 707 : break;
1755 : case BORDER_DISTANCE:
1756 49 : nDist = GetDistance();
1757 49 : bDistMember = true;
1758 49 : break;
1759 : case TOP_BORDER_DISTANCE:
1760 346 : nDist = nTopDist;
1761 346 : bDistMember = true;
1762 346 : break;
1763 : case BOTTOM_BORDER_DISTANCE:
1764 345 : nDist = nBottomDist;
1765 345 : bDistMember = true;
1766 345 : break;
1767 : case LEFT_BORDER_DISTANCE:
1768 354 : nDist = nLeftDist;
1769 354 : bDistMember = true;
1770 354 : break;
1771 : case RIGHT_BORDER_DISTANCE:
1772 348 : nDist = nRightDist;
1773 348 : bDistMember = true;
1774 348 : break;
1775 : case LINE_STYLE:
1776 : case LINE_WIDTH:
1777 : // it doesn't make sense to return a value for these since it's
1778 : // probably ambiguous
1779 0 : return true;
1780 : break;
1781 : }
1782 :
1783 3713 : if( bDistMember )
1784 1442 : rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(nDist) : nDist);
1785 : else
1786 2271 : rVal <<= aRetLine;
1787 :
1788 3713 : return true;
1789 : }
1790 :
1791 : namespace
1792 : {
1793 :
1794 : bool
1795 43496 : lcl_lineToSvxLine(const table::BorderLine& rLine, SvxBorderLine& rSvxLine, bool bConvert, bool bGuessWidth)
1796 : {
1797 43496 : rSvxLine.SetColor( Color(rLine.Color));
1798 43496 : if ( bGuessWidth )
1799 : {
1800 14062 : rSvxLine.GuessLinesWidths( rSvxLine.GetBorderLineStyle(),
1801 11369 : sal_uInt16( bConvert ? convertMm100ToTwip(rLine.OuterLineWidth) : rLine.OuterLineWidth ),
1802 11369 : sal_uInt16( bConvert ? convertMm100ToTwip(rLine.InnerLineWidth) : rLine.InnerLineWidth ),
1803 50862 : sal_uInt16( bConvert ? convertMm100ToTwip(rLine.LineDistance ) : rLine.LineDistance ));
1804 : }
1805 :
1806 43496 : bool bRet = !rSvxLine.isEmpty();
1807 43496 : return bRet;
1808 : }
1809 :
1810 : }
1811 :
1812 :
1813 36 : bool SvxBoxItem::LineToSvxLine(const ::com::sun::star::table::BorderLine& rLine, SvxBorderLine& rSvxLine, bool bConvert)
1814 : {
1815 36 : return lcl_lineToSvxLine(rLine, rSvxLine, bConvert, true);
1816 : }
1817 :
1818 : bool
1819 43460 : SvxBoxItem::LineToSvxLine(const ::com::sun::star::table::BorderLine2& rLine, SvxBorderLine& rSvxLine, bool bConvert)
1820 : {
1821 : SvxBorderStyle const nStyle =
1822 86920 : (rLine.LineStyle < 0 || BORDER_LINE_STYLE_MAX < rLine.LineStyle)
1823 : ? SOLID // default
1824 80546 : : rLine.LineStyle;
1825 :
1826 43460 : rSvxLine.SetBorderLineStyle( nStyle );
1827 :
1828 43460 : bool bGuessWidth = true;
1829 43460 : if ( rLine.LineWidth )
1830 : {
1831 29485 : rSvxLine.SetWidth( bConvert? convertMm100ToTwip( rLine.LineWidth ) : rLine.LineWidth );
1832 : // fdo#46112: double does not necessarily mean symmetric
1833 : // for backwards compatibility
1834 29485 : bGuessWidth = ((DOUBLE == nStyle || DOUBLE_THIN == nStyle)) &&
1835 29695 : (rLine.InnerLineWidth > 0) && (rLine.OuterLineWidth > 0);
1836 : }
1837 :
1838 43460 : return lcl_lineToSvxLine(rLine, rSvxLine, bConvert, bGuessWidth);
1839 : }
1840 :
1841 :
1842 :
1843 : namespace
1844 : {
1845 :
1846 : bool
1847 42020 : lcl_extractBorderLine(const uno::Any& rAny, table::BorderLine2& rLine)
1848 : {
1849 42020 : if (rAny >>= rLine)
1850 42020 : return true;
1851 :
1852 0 : table::BorderLine aBorderLine;
1853 0 : if (rAny >>= aBorderLine)
1854 : {
1855 0 : rLine.Color = aBorderLine.Color;
1856 0 : rLine.InnerLineWidth = aBorderLine.InnerLineWidth;
1857 0 : rLine.OuterLineWidth = aBorderLine.OuterLineWidth;
1858 0 : rLine.LineDistance = aBorderLine.LineDistance;
1859 0 : rLine.LineStyle = table::BorderLineStyle::SOLID;
1860 0 : return true;
1861 : }
1862 :
1863 0 : return false;
1864 : }
1865 :
1866 : template<typename Item, typename Line>
1867 : bool
1868 0 : lcl_setLine(const uno::Any& rAny, Item& rItem, Line nLine, const bool bConvert)
1869 : {
1870 0 : bool bDone = false;
1871 0 : table::BorderLine2 aBorderLine;
1872 0 : if (lcl_extractBorderLine(rAny, aBorderLine))
1873 : {
1874 0 : SvxBorderLine aLine;
1875 0 : bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert);
1876 0 : rItem.SetLine( bSet ? &aLine : NULL, nLine);
1877 0 : bDone = true;
1878 : }
1879 0 : return bDone;
1880 : }
1881 :
1882 : }
1883 :
1884 79005 : bool SvxBoxItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1885 : {
1886 79005 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1887 79005 : SvxBoxItemLine nLine = SvxBoxItemLine::TOP;
1888 79005 : bool bDistMember = false;
1889 79005 : nMemberId &= ~CONVERT_TWIPS;
1890 79005 : switch(nMemberId)
1891 : {
1892 : case 0:
1893 : {
1894 0 : uno::Sequence< uno::Any > aSeq;
1895 0 : if (( rVal >>= aSeq ) && ( aSeq.getLength() == 9 ))
1896 : {
1897 : // 4 Borders and 5 distances
1898 0 : const SvxBoxItemLine aBorders[] = { SvxBoxItemLine::LEFT, SvxBoxItemLine::RIGHT, SvxBoxItemLine::BOTTOM, SvxBoxItemLine::TOP };
1899 0 : for (int n(0); n != SAL_N_ELEMENTS(aBorders); ++n)
1900 : {
1901 0 : if (!lcl_setLine(aSeq[n], *this, aBorders[n], bConvert))
1902 0 : return false;
1903 : }
1904 :
1905 : // WTH are the borders and the distances saved in different order?
1906 0 : SvxBoxItemLine nLines[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::BOTTOM, SvxBoxItemLine::LEFT, SvxBoxItemLine::RIGHT };
1907 0 : for ( sal_Int32 n = 4; n < 9; n++ )
1908 : {
1909 0 : sal_Int32 nDist = 0;
1910 0 : if ( aSeq[n] >>= nDist )
1911 : {
1912 0 : if( bConvert )
1913 0 : nDist = convertMm100ToTwip(nDist);
1914 0 : if ( n == 4 )
1915 0 : SetDistance( sal_uInt16( nDist ));
1916 : else
1917 0 : SetDistance( sal_uInt16( nDist ), nLines[n-5] );
1918 : }
1919 : else
1920 0 : return false;
1921 : }
1922 :
1923 0 : return true;
1924 : }
1925 : else
1926 0 : return false;
1927 : }
1928 : case LEFT_BORDER_DISTANCE:
1929 9517 : bDistMember = true;
1930 : //fall-through
1931 : case LEFT_BORDER:
1932 : case MID_LEFT_BORDER:
1933 19623 : nLine = SvxBoxItemLine::LEFT;
1934 19623 : break;
1935 : case RIGHT_BORDER_DISTANCE:
1936 9487 : bDistMember = true;
1937 : //fall-through
1938 : case RIGHT_BORDER:
1939 : case MID_RIGHT_BORDER:
1940 19470 : nLine = SvxBoxItemLine::RIGHT;
1941 19470 : break;
1942 : case BOTTOM_BORDER_DISTANCE:
1943 9736 : bDistMember = true;
1944 : //fall-through
1945 : case BOTTOM_BORDER:
1946 : case MID_BOTTOM_BORDER:
1947 20247 : nLine = SvxBoxItemLine::BOTTOM;
1948 20247 : break;
1949 : case TOP_BORDER_DISTANCE:
1950 9371 : bDistMember = true;
1951 : //fall-through
1952 : case TOP_BORDER:
1953 : case MID_TOP_BORDER:
1954 19552 : nLine = SvxBoxItemLine::TOP;
1955 19552 : break;
1956 : case LINE_STYLE:
1957 : {
1958 : drawing::LineStyle eDrawingStyle;
1959 94 : rVal >>= eDrawingStyle;
1960 94 : editeng::SvxBorderStyle eBorderStyle = css::table::BorderLineStyle::NONE;
1961 94 : switch ( eDrawingStyle )
1962 : {
1963 : default:
1964 : case drawing::LineStyle_NONE:
1965 65 : break;
1966 : case drawing::LineStyle_SOLID:
1967 29 : eBorderStyle = SOLID;
1968 29 : break;
1969 : case drawing::LineStyle_DASH:
1970 0 : eBorderStyle = DASHED;
1971 0 : break;
1972 : }
1973 :
1974 : // Set the line style on all borders
1975 470 : for( SvxBoxItemLine n : o3tl::enumrange<SvxBoxItemLine>() )
1976 : {
1977 376 : editeng::SvxBorderLine* pLine = const_cast< editeng::SvxBorderLine* >( GetLine( n ) );
1978 376 : if( pLine )
1979 376 : pLine->SetBorderLineStyle( eBorderStyle );
1980 : }
1981 94 : return true;
1982 : }
1983 : break;
1984 : case LINE_WIDTH:
1985 : {
1986 : // Set the line width on all borders
1987 0 : long nWidth(0);
1988 0 : rVal >>= nWidth;
1989 0 : if( bConvert )
1990 0 : nWidth = convertMm100ToTwip( nWidth );
1991 :
1992 : // Set the line Width on all borders
1993 0 : for( SvxBoxItemLine n : o3tl::enumrange<SvxBoxItemLine>() )
1994 : {
1995 0 : editeng::SvxBorderLine* pLine = const_cast< editeng::SvxBorderLine* >( GetLine( n ) );
1996 0 : if( pLine )
1997 0 : pLine->SetWidth( nWidth );
1998 : }
1999 : }
2000 0 : return true;
2001 : }
2002 :
2003 78911 : if( bDistMember || nMemberId == BORDER_DISTANCE )
2004 : {
2005 38130 : sal_Int32 nDist = 0;
2006 38130 : if(!(rVal >>= nDist))
2007 0 : return false;
2008 :
2009 38130 : if(nDist >= 0)
2010 : {
2011 38126 : if( bConvert )
2012 38126 : nDist = convertMm100ToTwip(nDist);
2013 38126 : if( nMemberId == BORDER_DISTANCE )
2014 19 : SetDistance( sal_uInt16( nDist ));
2015 : else
2016 38107 : SetDistance( sal_uInt16( nDist ), nLine );
2017 38130 : }
2018 : }
2019 : else
2020 : {
2021 40781 : SvxBorderLine aLine;
2022 40781 : if( !rVal.hasValue() )
2023 0 : return false;
2024 :
2025 40781 : table::BorderLine2 aBorderLine;
2026 40781 : if( lcl_extractBorderLine(rVal, aBorderLine) )
2027 : {
2028 : // usual struct
2029 : }
2030 0 : else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE )
2031 : {
2032 : // serialization for basic macro recording
2033 : uno::Reference < script::XTypeConverter > xConverter
2034 0 : ( script::Converter::create(::comphelper::getProcessComponentContext()) );
2035 0 : uno::Sequence < uno::Any > aSeq;
2036 0 : uno::Any aNew;
2037 0 : try { aNew = xConverter->convertTo( rVal, cppu::UnoType<uno::Sequence < uno::Any >>::get() ); }
2038 0 : catch (const uno::Exception&) {}
2039 :
2040 0 : aNew >>= aSeq;
2041 0 : if (aSeq.getLength() >= 4 && aSeq.getLength() <= 6)
2042 : {
2043 0 : sal_Int32 nVal = 0;
2044 0 : if ( aSeq[0] >>= nVal )
2045 0 : aBorderLine.Color = nVal;
2046 0 : if ( aSeq[1] >>= nVal )
2047 0 : aBorderLine.InnerLineWidth = (sal_Int16) nVal;
2048 0 : if ( aSeq[2] >>= nVal )
2049 0 : aBorderLine.OuterLineWidth = (sal_Int16) nVal;
2050 0 : if ( aSeq[3] >>= nVal )
2051 0 : aBorderLine.LineDistance = (sal_Int16) nVal;
2052 0 : if (aSeq.getLength() >= 5) // fdo#40874 added fields
2053 : {
2054 0 : if (aSeq[4] >>= nVal)
2055 : {
2056 0 : aBorderLine.LineStyle = nVal;
2057 : }
2058 0 : if (aSeq.getLength() >= 6)
2059 : {
2060 0 : if (aSeq[5] >>= nVal)
2061 : {
2062 0 : aBorderLine.LineWidth = nVal;
2063 : }
2064 : }
2065 : }
2066 : }
2067 : else
2068 0 : return false;
2069 : }
2070 : else
2071 0 : return false;
2072 :
2073 40781 : bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert);
2074 40781 : SetLine(bSet ? &aLine : 0, nLine);
2075 : }
2076 :
2077 78911 : return true;
2078 : }
2079 :
2080 :
2081 :
2082 114205 : SfxPoolItem* SvxBoxItem::Clone( SfxItemPool* ) const
2083 : {
2084 114205 : return new SvxBoxItem( *this );
2085 : }
2086 :
2087 :
2088 :
2089 0 : bool SvxBoxItem::GetPresentation
2090 : (
2091 : SfxItemPresentation ePres,
2092 : SfxMapUnit eCoreUnit,
2093 : SfxMapUnit ePresUnit,
2094 : OUString& rText, const IntlWrapper *pIntl
2095 : ) const
2096 : {
2097 0 : OUString cpDelimTmp = OUString(cpDelim);
2098 0 : switch ( ePres )
2099 : {
2100 : case SFX_ITEM_PRESENTATION_NAMELESS:
2101 : {
2102 0 : rText.clear();
2103 :
2104 0 : if ( pTop )
2105 : {
2106 0 : rText = pTop->GetValueString( eCoreUnit, ePresUnit, pIntl ) + cpDelimTmp;
2107 : }
2108 0 : if( !(pTop && pBottom && pLeft && pRight &&
2109 0 : *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight) )
2110 : {
2111 0 : if ( pBottom )
2112 : {
2113 0 : rText = rText + pBottom->GetValueString( eCoreUnit, ePresUnit, pIntl ) + cpDelimTmp;
2114 : }
2115 0 : if ( pLeft )
2116 : {
2117 0 : rText = rText + pLeft->GetValueString( eCoreUnit, ePresUnit, pIntl ) + cpDelimTmp;
2118 : }
2119 0 : if ( pRight )
2120 : {
2121 0 : rText = rText + pRight->GetValueString( eCoreUnit, ePresUnit, pIntl ) + cpDelimTmp;
2122 : }
2123 : }
2124 0 : rText += GetMetricText( (long)nTopDist, eCoreUnit, ePresUnit, pIntl );
2125 0 : if( nTopDist != nBottomDist || nTopDist != nLeftDist ||
2126 0 : nTopDist != nRightDist )
2127 : {
2128 0 : rText = rText +
2129 0 : cpDelimTmp +
2130 : GetMetricText( (long)nBottomDist, eCoreUnit,
2131 0 : ePresUnit, pIntl ) +
2132 0 : cpDelimTmp +
2133 0 : GetMetricText( (long)nLeftDist, eCoreUnit, ePresUnit, pIntl ) +
2134 0 : cpDelimTmp +
2135 : GetMetricText( (long)nRightDist, eCoreUnit,
2136 0 : ePresUnit, pIntl );
2137 : }
2138 0 : return true;
2139 : }
2140 : case SFX_ITEM_PRESENTATION_COMPLETE:
2141 : {
2142 0 : if( !(pTop || pBottom || pLeft || pRight) )
2143 : {
2144 0 : rText = EE_RESSTR(RID_SVXITEMS_BORDER_NONE) + cpDelimTmp;
2145 : }
2146 : else
2147 : {
2148 0 : rText = EE_RESSTR(RID_SVXITEMS_BORDER_COMPLETE);
2149 0 : if( pTop && pBottom && pLeft && pRight &&
2150 0 : *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight )
2151 : {
2152 0 : rText += pTop->GetValueString( eCoreUnit, ePresUnit, pIntl, true ) + cpDelimTmp;
2153 : }
2154 : else
2155 : {
2156 0 : if ( pTop )
2157 : {
2158 0 : rText = rText +
2159 0 : EE_RESSTR(RID_SVXITEMS_BORDER_TOP) +
2160 0 : pTop->GetValueString( eCoreUnit, ePresUnit, pIntl, true ) +
2161 0 : cpDelimTmp;
2162 : }
2163 0 : if ( pBottom )
2164 : {
2165 0 : rText = rText +
2166 0 : EE_RESSTR(RID_SVXITEMS_BORDER_BOTTOM) +
2167 0 : pBottom->GetValueString( eCoreUnit, ePresUnit, pIntl, true ) +
2168 0 : cpDelimTmp;
2169 : }
2170 0 : if ( pLeft )
2171 : {
2172 0 : rText = rText +
2173 0 : EE_RESSTR(RID_SVXITEMS_BORDER_LEFT) +
2174 0 : pLeft->GetValueString( eCoreUnit, ePresUnit, pIntl, true ) +
2175 0 : cpDelimTmp;
2176 : }
2177 0 : if ( pRight )
2178 : {
2179 0 : rText = rText +
2180 0 : EE_RESSTR(RID_SVXITEMS_BORDER_RIGHT) +
2181 0 : pRight->GetValueString( eCoreUnit, ePresUnit, pIntl, true ) +
2182 0 : cpDelimTmp;
2183 : }
2184 : }
2185 : }
2186 :
2187 0 : rText += EE_RESSTR(RID_SVXITEMS_BORDER_DISTANCE);
2188 0 : if( nTopDist == nBottomDist && nTopDist == nLeftDist &&
2189 0 : nTopDist == nRightDist )
2190 : {
2191 0 : rText = rText +
2192 : GetMetricText( (long)nTopDist, eCoreUnit,
2193 0 : ePresUnit, pIntl ) +
2194 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
2195 : }
2196 : else
2197 : {
2198 0 : rText = rText +
2199 0 : EE_RESSTR(RID_SVXITEMS_BORDER_TOP) +
2200 : GetMetricText( (long)nTopDist, eCoreUnit,
2201 0 : ePresUnit, pIntl ) +
2202 0 : " " + EE_RESSTR(GetMetricId(ePresUnit)) +
2203 0 : cpDelimTmp +
2204 0 : EE_RESSTR(RID_SVXITEMS_BORDER_BOTTOM) +
2205 : GetMetricText( (long)nBottomDist, eCoreUnit,
2206 0 : ePresUnit, pIntl ) +
2207 0 : " " + EE_RESSTR(GetMetricId(ePresUnit)) +
2208 0 : cpDelimTmp +
2209 0 : EE_RESSTR(RID_SVXITEMS_BORDER_LEFT) +
2210 : GetMetricText( (long)nLeftDist, eCoreUnit,
2211 0 : ePresUnit, pIntl ) +
2212 0 : " " + EE_RESSTR(GetMetricId(ePresUnit)) +
2213 0 : cpDelimTmp +
2214 0 : EE_RESSTR(RID_SVXITEMS_BORDER_RIGHT) +
2215 : GetMetricText( (long)nRightDist, eCoreUnit,
2216 0 : ePresUnit, pIntl ) +
2217 0 : " " + EE_RESSTR(GetMetricId(ePresUnit));
2218 : }
2219 0 : return true;
2220 : }
2221 : default: ;//prevent warning
2222 : }
2223 0 : return false;
2224 : }
2225 :
2226 :
2227 :
2228 528 : SvStream& SvxBoxItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
2229 : {
2230 528 : rStrm.WriteUInt16( GetDistance() );
2231 : const SvxBorderLine* pLine[ 4 ]; // top, left, right, bottom
2232 528 : pLine[ 0 ] = GetTop();
2233 528 : pLine[ 1 ] = GetLeft();
2234 528 : pLine[ 2 ] = GetRight();
2235 528 : pLine[ 3 ] = GetBottom();
2236 :
2237 2640 : for( int i = 0; i < 4; i++ )
2238 : {
2239 2112 : const SvxBorderLine* l = pLine[ i ];
2240 2112 : if( l )
2241 : {
2242 716 : rStrm.WriteSChar(i);
2243 716 : StoreBorderLine(rStrm, *l, BorderLineVersionFromBoxVersion(nItemVersion));
2244 : }
2245 : }
2246 528 : sal_Int8 cLine = 4;
2247 1056 : if( nItemVersion >= BOX_4DISTS_VERSION &&
2248 1056 : !(nTopDist == nLeftDist &&
2249 528 : nTopDist == nRightDist &&
2250 528 : nTopDist == nBottomDist) )
2251 : {
2252 0 : cLine |= 0x10;
2253 : }
2254 :
2255 528 : rStrm.WriteSChar( cLine );
2256 :
2257 528 : if( nItemVersion >= BOX_4DISTS_VERSION && (cLine & 0x10) != 0 )
2258 : {
2259 0 : rStrm.WriteUInt16( nTopDist )
2260 0 : .WriteUInt16( nLeftDist )
2261 0 : .WriteUInt16( nRightDist )
2262 0 : .WriteUInt16( nBottomDist );
2263 : }
2264 :
2265 528 : return rStrm;
2266 : }
2267 :
2268 :
2269 :
2270 530 : sal_uInt16 SvxBoxItem::GetVersion( sal_uInt16 nFFVer ) const
2271 : {
2272 : DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
2273 : SOFFICE_FILEFORMAT_40==nFFVer ||
2274 : SOFFICE_FILEFORMAT_50==nFFVer,
2275 : "SvxBoxItem: Gibt es ein neues Fileformat?" );
2276 530 : return SOFFICE_FILEFORMAT_31==nFFVer ||
2277 530 : SOFFICE_FILEFORMAT_40==nFFVer ? 0 : BOX_BORDER_STYLE_VERSION;
2278 : }
2279 :
2280 :
2281 :
2282 0 : bool SvxBoxItem::ScaleMetrics( long nMult, long nDiv )
2283 : {
2284 0 : if ( pTop ) pTop->ScaleMetrics( nMult, nDiv );
2285 0 : if ( pBottom ) pBottom->ScaleMetrics( nMult, nDiv );
2286 0 : if ( pLeft ) pLeft->ScaleMetrics( nMult, nDiv );
2287 0 : if ( pRight ) pRight->ScaleMetrics( nMult, nDiv );
2288 0 : nTopDist = (sal_uInt16)Scale( nTopDist, nMult, nDiv );
2289 0 : nBottomDist = (sal_uInt16)Scale( nBottomDist, nMult, nDiv );
2290 0 : nLeftDist = (sal_uInt16)Scale( nLeftDist, nMult, nDiv );
2291 0 : nRightDist = (sal_uInt16)Scale( nRightDist, nMult, nDiv );
2292 0 : return true;
2293 : }
2294 :
2295 :
2296 :
2297 0 : bool SvxBoxItem::HasMetrics() const
2298 : {
2299 0 : return true;
2300 : }
2301 :
2302 :
2303 :
2304 512 : SfxPoolItem* SvxBoxItem::Create( SvStream& rStrm, sal_uInt16 nIVersion ) const
2305 : {
2306 : sal_uInt16 nDistance;
2307 512 : rStrm.ReadUInt16( nDistance );
2308 512 : SvxBoxItem* pAttr = new SvxBoxItem( Which() );
2309 :
2310 : SvxBoxItemLine aLineMap[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
2311 512 : SvxBoxItemLine::RIGHT, SvxBoxItemLine::BOTTOM };
2312 :
2313 : sal_Int8 cLine;
2314 : while( true )
2315 : {
2316 1128 : rStrm.ReadSChar( cLine );
2317 :
2318 1128 : if( cLine > 3 )
2319 512 : break;
2320 :
2321 616 : SvxBorderLine aBorder = CreateBorderLine(rStrm, BorderLineVersionFromBoxVersion(nIVersion));
2322 616 : pAttr->SetLine( &aBorder, aLineMap[cLine] );
2323 : }
2324 :
2325 512 : if( nIVersion >= BOX_4DISTS_VERSION && (cLine&0x10) != 0 )
2326 : {
2327 0 : for( sal_uInt16 i=0; i < 4; i++ )
2328 : {
2329 : sal_uInt16 nDist;
2330 0 : rStrm.ReadUInt16( nDist );
2331 0 : pAttr->SetDistance( nDist, aLineMap[i] );
2332 0 : }
2333 : }
2334 : else
2335 : {
2336 512 : pAttr->SetDistance( nDistance );
2337 : }
2338 :
2339 1128 : return pAttr;
2340 : }
2341 :
2342 :
2343 :
2344 22554 : const SvxBorderLine *SvxBoxItem::GetLine( SvxBoxItemLine nLine ) const
2345 : {
2346 22554 : const SvxBorderLine *pRet = 0;
2347 :
2348 22554 : switch ( nLine )
2349 : {
2350 : case SvxBoxItemLine::TOP:
2351 3443 : pRet = pTop;
2352 3443 : break;
2353 : case SvxBoxItemLine::BOTTOM:
2354 5564 : pRet = pBottom;
2355 5564 : break;
2356 : case SvxBoxItemLine::LEFT:
2357 6590 : pRet = pLeft;
2358 6590 : break;
2359 : case SvxBoxItemLine::RIGHT:
2360 6957 : pRet = pRight;
2361 6957 : break;
2362 : default:
2363 : OSL_FAIL( "wrong line" );
2364 0 : break;
2365 : }
2366 :
2367 22554 : return pRet;
2368 : }
2369 :
2370 :
2371 :
2372 83132 : void SvxBoxItem::SetLine( const SvxBorderLine* pNew, SvxBoxItemLine nLine )
2373 : {
2374 83132 : SvxBorderLine* pTmp = pNew ? new SvxBorderLine( *pNew ) : 0;
2375 :
2376 83132 : switch ( nLine )
2377 : {
2378 : case SvxBoxItemLine::TOP:
2379 20622 : delete pTop;
2380 20622 : pTop = pTmp;
2381 20622 : break;
2382 : case SvxBoxItemLine::BOTTOM:
2383 21122 : delete pBottom;
2384 21122 : pBottom = pTmp;
2385 21122 : break;
2386 : case SvxBoxItemLine::LEFT:
2387 20076 : delete pLeft;
2388 20076 : pLeft = pTmp;
2389 20076 : break;
2390 : case SvxBoxItemLine::RIGHT:
2391 21312 : delete pRight;
2392 21312 : pRight = pTmp;
2393 21312 : break;
2394 : default:
2395 0 : delete pTmp;
2396 : OSL_FAIL( "wrong line" );
2397 : }
2398 83132 : }
2399 :
2400 :
2401 :
2402 1195 : sal_uInt16 SvxBoxItem::GetDistance() const
2403 : {
2404 : // The smallest distance that is not 0 will be returned.
2405 1195 : sal_uInt16 nDist = nTopDist;
2406 1195 : if( nBottomDist && (!nDist || nBottomDist < nDist) )
2407 1 : nDist = nBottomDist;
2408 1195 : if( nLeftDist && (!nDist || nLeftDist < nDist) )
2409 9 : nDist = nLeftDist;
2410 1195 : if( nRightDist && (!nDist || nRightDist < nDist) )
2411 1 : nDist = nRightDist;
2412 :
2413 1195 : return nDist;
2414 : }
2415 :
2416 :
2417 :
2418 326226 : sal_uInt16 SvxBoxItem::GetDistance( SvxBoxItemLine nLine ) const
2419 : {
2420 326226 : sal_uInt16 nDist = 0;
2421 326226 : switch ( nLine )
2422 : {
2423 : case SvxBoxItemLine::TOP:
2424 77820 : nDist = nTopDist;
2425 77820 : break;
2426 : case SvxBoxItemLine::BOTTOM:
2427 116006 : nDist = nBottomDist;
2428 116006 : break;
2429 : case SvxBoxItemLine::LEFT:
2430 70176 : nDist = nLeftDist;
2431 70176 : break;
2432 : case SvxBoxItemLine::RIGHT:
2433 62224 : nDist = nRightDist;
2434 62224 : break;
2435 : default:
2436 : OSL_FAIL( "wrong line" );
2437 : }
2438 :
2439 326226 : return nDist;
2440 : }
2441 :
2442 :
2443 :
2444 79797 : void SvxBoxItem::SetDistance( sal_uInt16 nNew, SvxBoxItemLine nLine )
2445 : {
2446 79797 : switch ( nLine )
2447 : {
2448 : case SvxBoxItemLine::TOP:
2449 19803 : nTopDist = nNew;
2450 19803 : break;
2451 : case SvxBoxItemLine::BOTTOM:
2452 20255 : nBottomDist = nNew;
2453 20255 : break;
2454 : case SvxBoxItemLine::LEFT:
2455 19935 : nLeftDist = nNew;
2456 19935 : break;
2457 : case SvxBoxItemLine::RIGHT:
2458 19804 : nRightDist = nNew;
2459 19804 : break;
2460 : default:
2461 : OSL_FAIL( "wrong line" );
2462 : }
2463 79797 : }
2464 :
2465 :
2466 :
2467 196503 : sal_uInt16 SvxBoxItem::CalcLineSpace( SvxBoxItemLine nLine, bool bIgnoreLine ) const
2468 : {
2469 196503 : SvxBorderLine* pTmp = 0;
2470 196503 : sal_uInt16 nDist = 0;
2471 196503 : switch ( nLine )
2472 : {
2473 : case SvxBoxItemLine::TOP:
2474 80506 : pTmp = pTop;
2475 80506 : nDist = nTopDist;
2476 80506 : break;
2477 : case SvxBoxItemLine::BOTTOM:
2478 80515 : pTmp = pBottom;
2479 80515 : nDist = nBottomDist;
2480 80515 : break;
2481 : case SvxBoxItemLine::LEFT:
2482 17741 : pTmp = pLeft;
2483 17741 : nDist = nLeftDist;
2484 17741 : break;
2485 : case SvxBoxItemLine::RIGHT:
2486 17741 : pTmp = pRight;
2487 17741 : nDist = nRightDist;
2488 17741 : break;
2489 : default:
2490 : OSL_FAIL( "wrong line" );
2491 : }
2492 :
2493 196503 : if( pTmp )
2494 : {
2495 61285 : nDist = nDist + pTmp->GetScaledWidth();
2496 : }
2497 135218 : else if( !bIgnoreLine )
2498 116971 : nDist = 0;
2499 196503 : return nDist;
2500 : }
2501 :
2502 : // class SvxBoxInfoItem --------------------------------------------------
2503 :
2504 300270 : SvxBoxInfoItem::SvxBoxInfoItem( const sal_uInt16 nId ) :
2505 : SfxPoolItem( nId ),
2506 : pHori ( 0 ),
2507 : pVert ( 0 ),
2508 : mbEnableHor( false ),
2509 : mbEnableVer( false ),
2510 300270 : nDefDist( 0 )
2511 : {
2512 300270 : bDist = bMinDist = false;
2513 300270 : ResetFlags();
2514 300270 : }
2515 :
2516 :
2517 :
2518 838641 : SvxBoxInfoItem::SvxBoxInfoItem( const SvxBoxInfoItem& rCpy ) :
2519 : SfxPoolItem( rCpy ),
2520 : mbEnableHor( rCpy.mbEnableHor ),
2521 838641 : mbEnableVer( rCpy.mbEnableVer )
2522 : {
2523 838641 : pHori = rCpy.GetHori() ? new SvxBorderLine( *rCpy.GetHori() ) : 0;
2524 838641 : pVert = rCpy.GetVert() ? new SvxBorderLine( *rCpy.GetVert() ) : 0;
2525 838641 : bDist = rCpy.IsDist();
2526 838641 : bMinDist = rCpy.IsMinDist();
2527 838641 : nValidFlags = rCpy.nValidFlags;
2528 838641 : nDefDist = rCpy.GetDefDist();
2529 838641 : }
2530 :
2531 :
2532 :
2533 3122002 : SvxBoxInfoItem::~SvxBoxInfoItem()
2534 : {
2535 1138702 : delete pHori;
2536 1138702 : delete pVert;
2537 1983300 : }
2538 :
2539 :
2540 :
2541 1207 : SvxBoxInfoItem &SvxBoxInfoItem::operator=( const SvxBoxInfoItem& rCpy )
2542 : {
2543 1207 : delete pHori;
2544 1207 : delete pVert;
2545 1207 : pHori = rCpy.GetHori() ? new SvxBorderLine( *rCpy.GetHori() ) : 0;
2546 1207 : pVert = rCpy.GetVert() ? new SvxBorderLine( *rCpy.GetVert() ) : 0;
2547 1207 : mbEnableHor = rCpy.mbEnableHor;
2548 1207 : mbEnableVer = rCpy.mbEnableVer;
2549 1207 : bDist = rCpy.IsDist();
2550 1207 : bMinDist = rCpy.IsMinDist();
2551 1207 : nValidFlags = rCpy.nValidFlags;
2552 1207 : nDefDist = rCpy.GetDefDist();
2553 1207 : return *this;
2554 : }
2555 :
2556 :
2557 :
2558 37784 : bool SvxBoxInfoItem::operator==( const SfxPoolItem& rAttr ) const
2559 : {
2560 37784 : const SvxBoxInfoItem& rBoxInfo = static_cast<const SvxBoxInfoItem&>(rAttr);
2561 :
2562 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
2563 :
2564 37784 : return ( mbEnableHor == rBoxInfo.mbEnableHor
2565 37784 : && mbEnableVer == rBoxInfo.mbEnableVer
2566 37784 : && bDist == rBoxInfo.IsDist()
2567 37784 : && bMinDist == rBoxInfo.IsMinDist()
2568 37784 : && nValidFlags == rBoxInfo.nValidFlags
2569 37782 : && nDefDist == rBoxInfo.GetDefDist()
2570 37782 : && CmpBrdLn( pHori, rBoxInfo.GetHori() )
2571 75546 : && CmpBrdLn( pVert, rBoxInfo.GetVert() )
2572 37784 : );
2573 : }
2574 :
2575 :
2576 :
2577 3073 : void SvxBoxInfoItem::SetLine( const SvxBorderLine* pNew, SvxBoxInfoItemLine nLine )
2578 : {
2579 3073 : SvxBorderLine* pTmp = pNew ? new SvxBorderLine( *pNew ) : 0;
2580 :
2581 3073 : if ( SvxBoxInfoItemLine::HORI == nLine )
2582 : {
2583 1556 : delete pHori;
2584 1556 : pHori = pTmp;
2585 : }
2586 1517 : else if ( SvxBoxInfoItemLine::VERT == nLine )
2587 : {
2588 1517 : delete pVert;
2589 1517 : pVert = pTmp;
2590 : }
2591 : else
2592 : {
2593 0 : delete pTmp;
2594 : OSL_FAIL( "wrong line" );
2595 : }
2596 3073 : }
2597 :
2598 :
2599 :
2600 838611 : SfxPoolItem* SvxBoxInfoItem::Clone( SfxItemPool* ) const
2601 : {
2602 838611 : return new SvxBoxInfoItem( *this );
2603 : }
2604 :
2605 :
2606 :
2607 0 : bool SvxBoxInfoItem::GetPresentation
2608 : (
2609 : SfxItemPresentation /*ePres*/,
2610 : SfxMapUnit /*eCoreUnit*/,
2611 : SfxMapUnit /*ePresUnit*/,
2612 : OUString& rText, const IntlWrapper *
2613 : ) const
2614 : {
2615 0 : rText.clear();
2616 0 : return false;
2617 : }
2618 :
2619 :
2620 :
2621 0 : SvStream& SvxBoxInfoItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2622 : {
2623 0 : sal_Int8 cFlags = 0;
2624 :
2625 0 : if ( IsTable() )
2626 0 : cFlags |= 0x01;
2627 0 : if ( IsDist() )
2628 0 : cFlags |= 0x02;
2629 0 : if ( IsMinDist() )
2630 0 : cFlags |= 0x04;
2631 0 : rStrm.WriteSChar( cFlags )
2632 0 : .WriteUInt16( GetDefDist() );
2633 : const SvxBorderLine* pLine[ 2 ];
2634 0 : pLine[ 0 ] = GetHori();
2635 0 : pLine[ 1 ] = GetVert();
2636 :
2637 0 : for( int i = 0; i < 2; i++ )
2638 : {
2639 0 : const SvxBorderLine* l = pLine[ i ];
2640 0 : if( l )
2641 : {
2642 0 : rStrm.WriteChar( (char) i );
2643 0 : WriteColor( rStrm, l->GetColor() );
2644 0 : rStrm.WriteInt16( l->GetOutWidth() )
2645 0 : .WriteInt16( l->GetInWidth() )
2646 0 : .WriteInt16( l->GetDistance() );
2647 : }
2648 : }
2649 0 : rStrm.WriteChar( (char) 2 );
2650 0 : return rStrm;
2651 : }
2652 :
2653 :
2654 :
2655 0 : bool SvxBoxInfoItem::ScaleMetrics( long nMult, long nDiv )
2656 : {
2657 0 : if ( pHori ) pHori->ScaleMetrics( nMult, nDiv );
2658 0 : if ( pVert ) pVert->ScaleMetrics( nMult, nDiv );
2659 0 : nDefDist = (sal_uInt16)Scale( nDefDist, nMult, nDiv );
2660 0 : return true;
2661 : }
2662 :
2663 :
2664 :
2665 0 : bool SvxBoxInfoItem::HasMetrics() const
2666 : {
2667 0 : return true;
2668 : }
2669 :
2670 :
2671 :
2672 0 : SfxPoolItem* SvxBoxInfoItem::Create( SvStream& rStrm, sal_uInt16 ) const
2673 : {
2674 : sal_Int8 cFlags;
2675 : sal_uInt16 _nDefDist;
2676 0 : rStrm.ReadSChar( cFlags ).ReadUInt16( _nDefDist );
2677 :
2678 0 : SvxBoxInfoItem* pAttr = new SvxBoxInfoItem( Which() );
2679 :
2680 0 : pAttr->SetTable ( ( cFlags & 0x01 ) != 0 );
2681 0 : pAttr->SetDist ( ( cFlags & 0x02 ) != 0 );
2682 0 : pAttr->SetMinDist( ( cFlags & 0x04 ) != 0 );
2683 0 : pAttr->SetDefDist( _nDefDist );
2684 :
2685 : while( true )
2686 : {
2687 : sal_Int8 cLine;
2688 0 : rStrm.ReadSChar( cLine );
2689 :
2690 0 : if( cLine > 1 )
2691 0 : break;
2692 : short nOutline, nInline, nDistance;
2693 0 : Color aColor;
2694 0 : ReadColor( rStrm, aColor ).ReadInt16( nOutline ).ReadInt16( nInline ).ReadInt16( nDistance );
2695 0 : SvxBorderLine aBorder( &aColor );
2696 0 : aBorder.GuessLinesWidths(css::table::BorderLineStyle::NONE, nOutline, nInline, nDistance);
2697 :
2698 0 : switch( cLine )
2699 : {
2700 0 : case 0: pAttr->SetLine( &aBorder, SvxBoxInfoItemLine::HORI ); break;
2701 0 : case 1: pAttr->SetLine( &aBorder, SvxBoxInfoItemLine::VERT ); break;
2702 : }
2703 : }
2704 0 : return pAttr;
2705 : }
2706 :
2707 :
2708 :
2709 300296 : void SvxBoxInfoItem::ResetFlags()
2710 : {
2711 300296 : nValidFlags = static_cast<SvxBoxInfoItemValidFlags>(0x7F); // all valid except Disable
2712 300296 : }
2713 :
2714 31 : bool SvxBoxInfoItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2715 : {
2716 31 : bool bConvert = 0 != (nMemberId & CONVERT_TWIPS);
2717 31 : table::BorderLine2 aRetLine;
2718 31 : sal_Int16 nVal=0;
2719 31 : bool bIntMember = false;
2720 31 : nMemberId &= ~CONVERT_TWIPS;
2721 31 : switch(nMemberId)
2722 : {
2723 : case 0:
2724 : {
2725 : // 2 BorderLines, flags, valid flags and distance
2726 31 : ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > aSeq( 5 );
2727 31 : aSeq[0] = ::com::sun::star::uno::makeAny( SvxBoxItem::SvxLineToLine( pHori, bConvert) );
2728 31 : aSeq[1] = ::com::sun::star::uno::makeAny( SvxBoxItem::SvxLineToLine( pVert, bConvert) );
2729 31 : if ( IsTable() )
2730 0 : nVal |= 0x01;
2731 31 : if ( IsDist() )
2732 31 : nVal |= 0x02;
2733 31 : if ( IsMinDist() )
2734 0 : nVal |= 0x04;
2735 31 : aSeq[2] = ::com::sun::star::uno::makeAny( nVal );
2736 31 : aSeq[3] = ::com::sun::star::uno::makeAny( static_cast<sal_Int16>(nValidFlags) );
2737 31 : aSeq[4] = ::com::sun::star::uno::makeAny( (sal_Int32)(bConvert ? convertTwipToMm100(GetDefDist()) : GetDefDist()) );
2738 31 : rVal = ::com::sun::star::uno::makeAny( aSeq );
2739 31 : return true;
2740 : }
2741 :
2742 : case MID_HORIZONTAL:
2743 0 : aRetLine = SvxBoxItem::SvxLineToLine( pHori, bConvert);
2744 0 : break;
2745 : case MID_VERTICAL:
2746 0 : aRetLine = SvxBoxItem::SvxLineToLine( pVert, bConvert);
2747 0 : break;
2748 : case MID_FLAGS:
2749 0 : bIntMember = true;
2750 0 : if ( IsTable() )
2751 0 : nVal |= 0x01;
2752 0 : if ( IsDist() )
2753 0 : nVal |= 0x02;
2754 0 : if ( IsMinDist() )
2755 0 : nVal |= 0x04;
2756 0 : rVal <<= nVal;
2757 0 : break;
2758 : case MID_VALIDFLAGS:
2759 0 : bIntMember = true;
2760 0 : rVal <<= static_cast<sal_Int16>(nValidFlags);
2761 0 : break;
2762 : case MID_DISTANCE:
2763 0 : bIntMember = true;
2764 0 : rVal <<= (sal_Int32)(bConvert ? convertTwipToMm100(GetDefDist()) : GetDefDist());
2765 0 : break;
2766 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
2767 : }
2768 :
2769 0 : if( !bIntMember )
2770 0 : rVal <<= aRetLine;
2771 :
2772 0 : return true;
2773 : }
2774 :
2775 :
2776 :
2777 0 : bool SvxBoxInfoItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2778 : {
2779 0 : bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2780 0 : nMemberId &= ~CONVERT_TWIPS;
2781 : bool bRet;
2782 0 : switch(nMemberId)
2783 : {
2784 : case 0:
2785 : {
2786 0 : ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > aSeq;
2787 0 : if (( rVal >>= aSeq ) && ( aSeq.getLength() == 5 ))
2788 : {
2789 : // 2 BorderLines, flags, valid flags and distance
2790 0 : if (!lcl_setLine(aSeq[0], *this, SvxBoxInfoItemLine::HORI, bConvert))
2791 0 : return false;
2792 0 : if (!lcl_setLine(aSeq[1], *this, SvxBoxInfoItemLine::VERT, bConvert))
2793 0 : return false;
2794 :
2795 0 : sal_Int16 nFlags( 0 );
2796 0 : sal_Int32 nVal( 0 );
2797 0 : if ( aSeq[2] >>= nFlags )
2798 : {
2799 0 : SetTable ( ( nFlags & 0x01 ) != 0 );
2800 0 : SetDist ( ( nFlags & 0x02 ) != 0 );
2801 0 : SetMinDist( ( nFlags & 0x04 ) != 0 );
2802 : }
2803 : else
2804 0 : return false;
2805 0 : if ( aSeq[3] >>= nFlags )
2806 0 : nValidFlags = static_cast<SvxBoxInfoItemValidFlags>(nFlags);
2807 : else
2808 0 : return false;
2809 0 : if (( aSeq[4] >>= nVal ) && ( nVal >= 0 ))
2810 : {
2811 0 : if( bConvert )
2812 0 : nVal = convertMm100ToTwip(nVal);
2813 0 : SetDefDist( (sal_uInt16)nVal );
2814 : }
2815 : }
2816 0 : return true;
2817 : }
2818 :
2819 : case MID_HORIZONTAL:
2820 : case MID_VERTICAL:
2821 : {
2822 0 : if( !rVal.hasValue() )
2823 0 : return false;
2824 :
2825 0 : table::BorderLine2 aBorderLine;
2826 0 : if( lcl_extractBorderLine(rVal, aBorderLine) )
2827 : {
2828 : // usual struct
2829 : }
2830 0 : else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE )
2831 : {
2832 : // serialization for basic macro recording
2833 0 : uno::Reference < script::XTypeConverter > xConverter( script::Converter::create(::comphelper::getProcessComponentContext()) );
2834 0 : uno::Any aNew;
2835 0 : uno::Sequence < uno::Any > aSeq;
2836 0 : try { aNew = xConverter->convertTo( rVal, cppu::UnoType<uno::Sequence < uno::Any >>::get() ); }
2837 0 : catch (const uno::Exception&) {}
2838 :
2839 0 : if ((aNew >>= aSeq) &&
2840 0 : aSeq.getLength() >= 4 && aSeq.getLength() <= 6)
2841 : {
2842 0 : sal_Int32 nVal = 0;
2843 0 : if ( aSeq[0] >>= nVal )
2844 0 : aBorderLine.Color = nVal;
2845 0 : if ( aSeq[1] >>= nVal )
2846 0 : aBorderLine.InnerLineWidth = (sal_Int16) nVal;
2847 0 : if ( aSeq[2] >>= nVal )
2848 0 : aBorderLine.OuterLineWidth = (sal_Int16) nVal;
2849 0 : if ( aSeq[3] >>= nVal )
2850 0 : aBorderLine.LineDistance = (sal_Int16) nVal;
2851 0 : if (aSeq.getLength() >= 5) // fdo#40874 added fields
2852 : {
2853 0 : if (aSeq[4] >>= nVal)
2854 : {
2855 0 : aBorderLine.LineStyle = nVal;
2856 : }
2857 0 : if (aSeq.getLength() >= 6)
2858 : {
2859 0 : if (aSeq[5] >>= nVal)
2860 : {
2861 0 : aBorderLine.LineWidth = nVal;
2862 : }
2863 : }
2864 : }
2865 : }
2866 : else
2867 0 : return false;
2868 : }
2869 0 : else if (rVal.getValueType() == cppu::UnoType<css::uno::Sequence < sal_Int16 >>::get() )
2870 : {
2871 : // serialization for basic macro recording
2872 0 : ::com::sun::star::uno::Sequence < sal_Int16 > aSeq;
2873 0 : rVal >>= aSeq;
2874 0 : if (aSeq.getLength() >= 4 && aSeq.getLength() <= 6)
2875 : {
2876 0 : aBorderLine.Color = aSeq[0];
2877 0 : aBorderLine.InnerLineWidth = aSeq[1];
2878 0 : aBorderLine.OuterLineWidth = aSeq[2];
2879 0 : aBorderLine.LineDistance = aSeq[3];
2880 0 : if (aSeq.getLength() >= 5) // fdo#40874 added fields
2881 : {
2882 0 : aBorderLine.LineStyle = aSeq[4];
2883 0 : if (aSeq.getLength() >= 6)
2884 : {
2885 0 : aBorderLine.LineWidth = aSeq[5];
2886 : }
2887 : }
2888 : }
2889 : else
2890 0 : return false;
2891 : }
2892 : else
2893 0 : return false;
2894 :
2895 0 : SvxBorderLine aLine;
2896 0 : bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert);
2897 0 : if ( bSet )
2898 0 : SetLine( &aLine, nMemberId == MID_HORIZONTAL ? SvxBoxInfoItemLine::HORI : SvxBoxInfoItemLine::VERT );
2899 0 : break;
2900 : }
2901 : case MID_FLAGS:
2902 : {
2903 0 : sal_Int16 nFlags = sal_Int16();
2904 0 : bRet = (rVal >>= nFlags);
2905 0 : if ( bRet )
2906 : {
2907 0 : SetTable ( ( nFlags & 0x01 ) != 0 );
2908 0 : SetDist ( ( nFlags & 0x02 ) != 0 );
2909 0 : SetMinDist( ( nFlags & 0x04 ) != 0 );
2910 : }
2911 :
2912 0 : break;
2913 : }
2914 : case MID_VALIDFLAGS:
2915 : {
2916 0 : sal_Int16 nFlags = sal_Int16();
2917 0 : bRet = (rVal >>= nFlags);
2918 0 : if ( bRet )
2919 0 : nValidFlags = static_cast<SvxBoxInfoItemValidFlags>(nFlags);
2920 0 : break;
2921 : }
2922 : case MID_DISTANCE:
2923 : {
2924 0 : sal_Int32 nVal = 0;
2925 0 : bRet = (rVal >>= nVal);
2926 0 : if ( bRet && nVal>=0 )
2927 : {
2928 0 : if( bConvert )
2929 0 : nVal = convertMm100ToTwip(nVal);
2930 0 : SetDefDist( (sal_uInt16)nVal );
2931 : }
2932 0 : break;
2933 : }
2934 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
2935 : }
2936 :
2937 0 : return true;
2938 : }
2939 :
2940 : // class SvxFormatBreakItem -------------------------------------------------
2941 :
2942 2989 : bool SvxFormatBreakItem::operator==( const SfxPoolItem& rAttr ) const
2943 : {
2944 : DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "unequal types" );
2945 :
2946 2989 : return GetValue() == static_cast<const SvxFormatBreakItem&>( rAttr ).GetValue();
2947 : }
2948 :
2949 :
2950 :
2951 0 : bool SvxFormatBreakItem::GetPresentation
2952 : (
2953 : SfxItemPresentation /*ePres*/,
2954 : SfxMapUnit /*eCoreUnit*/,
2955 : SfxMapUnit /*ePresUnit*/,
2956 : OUString& rText, const IntlWrapper *
2957 : ) const
2958 : {
2959 0 : rText = GetValueTextByPos( GetValue() );
2960 0 : return true;
2961 : }
2962 :
2963 :
2964 :
2965 0 : OUString SvxFormatBreakItem::GetValueTextByPos( sal_uInt16 nPos ) const
2966 : {
2967 : DBG_ASSERT( nPos < SVX_BREAK_END, "enum overflow!" );
2968 0 : return EE_RESSTR(RID_SVXITEMS_BREAK_BEGIN + nPos);
2969 : }
2970 :
2971 :
2972 54 : bool SvxFormatBreakItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
2973 : {
2974 54 : style::BreakType eBreak = style::BreakType_NONE;
2975 54 : switch ( (SvxBreak)GetValue() )
2976 : {
2977 4 : case SVX_BREAK_COLUMN_BEFORE: eBreak = style::BreakType_COLUMN_BEFORE; break;
2978 1 : case SVX_BREAK_COLUMN_AFTER: eBreak = style::BreakType_COLUMN_AFTER ; break;
2979 0 : case SVX_BREAK_COLUMN_BOTH: eBreak = style::BreakType_COLUMN_BOTH ; break;
2980 35 : case SVX_BREAK_PAGE_BEFORE: eBreak = style::BreakType_PAGE_BEFORE ; break;
2981 1 : case SVX_BREAK_PAGE_AFTER: eBreak = style::BreakType_PAGE_AFTER ; break;
2982 0 : case SVX_BREAK_PAGE_BOTH: eBreak = style::BreakType_PAGE_BOTH ; break;
2983 : default: ;//prevent warning
2984 : }
2985 54 : rVal <<= eBreak;
2986 54 : return true;
2987 : }
2988 :
2989 696 : bool SvxFormatBreakItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
2990 : {
2991 : style::BreakType nBreak;
2992 :
2993 696 : if(!(rVal >>= nBreak))
2994 : {
2995 0 : sal_Int32 nValue = 0;
2996 0 : if(!(rVal >>= nValue))
2997 0 : return false;
2998 :
2999 0 : nBreak = (style::BreakType) nValue;
3000 : }
3001 :
3002 696 : SvxBreak eBreak = SVX_BREAK_NONE;
3003 696 : switch( nBreak )
3004 : {
3005 153 : case style::BreakType_COLUMN_BEFORE: eBreak = SVX_BREAK_COLUMN_BEFORE; break;
3006 1 : case style::BreakType_COLUMN_AFTER: eBreak = SVX_BREAK_COLUMN_AFTER; break;
3007 0 : case style::BreakType_COLUMN_BOTH: eBreak = SVX_BREAK_COLUMN_BOTH; break;
3008 454 : case style::BreakType_PAGE_BEFORE: eBreak = SVX_BREAK_PAGE_BEFORE; break;
3009 3 : case style::BreakType_PAGE_AFTER: eBreak = SVX_BREAK_PAGE_AFTER; break;
3010 0 : case style::BreakType_PAGE_BOTH: eBreak = SVX_BREAK_PAGE_BOTH; break;
3011 : default: ;//prevent warning
3012 : }
3013 696 : SetValue((sal_uInt16) eBreak);
3014 :
3015 696 : return true;
3016 : }
3017 :
3018 :
3019 :
3020 1400 : SfxPoolItem* SvxFormatBreakItem::Clone( SfxItemPool* ) const
3021 : {
3022 1400 : return new SvxFormatBreakItem( *this );
3023 : }
3024 :
3025 :
3026 :
3027 0 : SvStream& SvxFormatBreakItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
3028 : {
3029 0 : rStrm.WriteSChar( GetValue() );
3030 0 : if( FMTBREAK_NOAUTO > nItemVersion )
3031 0 : rStrm.WriteSChar( 0x01 );
3032 0 : return rStrm;
3033 : }
3034 :
3035 :
3036 :
3037 0 : sal_uInt16 SvxFormatBreakItem::GetVersion( sal_uInt16 nFFVer ) const
3038 : {
3039 : DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
3040 : SOFFICE_FILEFORMAT_40==nFFVer ||
3041 : SOFFICE_FILEFORMAT_50==nFFVer,
3042 : "SvxFormatBreakItem: Is there a new file format? ");
3043 : return SOFFICE_FILEFORMAT_31==nFFVer ||
3044 0 : SOFFICE_FILEFORMAT_40==nFFVer ? 0 : FMTBREAK_NOAUTO;
3045 : }
3046 :
3047 :
3048 :
3049 0 : SfxPoolItem* SvxFormatBreakItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const
3050 : {
3051 : sal_Int8 eBreak, bDummy;
3052 0 : rStrm.ReadSChar( eBreak );
3053 0 : if( FMTBREAK_NOAUTO > nVersion )
3054 0 : rStrm.ReadSChar( bDummy );
3055 0 : return new SvxFormatBreakItem( (const SvxBreak)eBreak, Which() );
3056 : }
3057 :
3058 :
3059 :
3060 0 : sal_uInt16 SvxFormatBreakItem::GetValueCount() const
3061 : {
3062 0 : return SVX_BREAK_END; // SVX_BREAK_PAGE_BOTH + 1
3063 : }
3064 :
3065 : // class SvxFormatKeepItem -------------------------------------------------
3066 :
3067 6809 : SfxPoolItem* SvxFormatKeepItem::Clone( SfxItemPool* ) const
3068 : {
3069 6809 : return new SvxFormatKeepItem( *this );
3070 : }
3071 :
3072 :
3073 :
3074 0 : SvStream& SvxFormatKeepItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
3075 : {
3076 0 : rStrm.WriteSChar( (sal_Int8)GetValue() );
3077 0 : return rStrm;
3078 : }
3079 :
3080 :
3081 :
3082 0 : SfxPoolItem* SvxFormatKeepItem::Create( SvStream& rStrm, sal_uInt16 ) const
3083 : {
3084 : sal_Int8 bIsKeep;
3085 0 : rStrm.ReadSChar( bIsKeep );
3086 0 : return new SvxFormatKeepItem( bIsKeep != 0, Which() );
3087 : }
3088 :
3089 :
3090 :
3091 0 : bool SvxFormatKeepItem::GetPresentation
3092 : (
3093 : SfxItemPresentation /*ePres*/,
3094 : SfxMapUnit /*eCoreUnit*/,
3095 : SfxMapUnit /*ePresUnit*/,
3096 : OUString& rText, const IntlWrapper *
3097 : ) const
3098 : {
3099 0 : sal_uInt16 nId = RID_SVXITEMS_FMTKEEP_FALSE;
3100 :
3101 0 : if ( GetValue() )
3102 0 : nId = RID_SVXITEMS_FMTKEEP_TRUE;
3103 0 : rText = EE_RESSTR(nId);
3104 0 : return true;
3105 : }
3106 :
3107 : // class SvxLineItem ------------------------------------------------------
3108 :
3109 18983 : SvxLineItem::SvxLineItem( const sal_uInt16 nId ) :
3110 :
3111 : SfxPoolItem ( nId ),
3112 :
3113 18983 : pLine( NULL )
3114 : {
3115 18983 : }
3116 :
3117 :
3118 :
3119 1738 : SvxLineItem::SvxLineItem( const SvxLineItem& rCpy ) :
3120 :
3121 1738 : SfxPoolItem ( rCpy )
3122 : {
3123 1738 : pLine = rCpy.GetLine() ? new SvxBorderLine( *rCpy.GetLine() ) : 0;
3124 1738 : }
3125 :
3126 :
3127 :
3128 56509 : SvxLineItem::~SvxLineItem()
3129 : {
3130 20319 : delete pLine;
3131 36190 : }
3132 :
3133 :
3134 :
3135 1024 : SvxLineItem& SvxLineItem::operator=( const SvxLineItem& rLine )
3136 : {
3137 1024 : SetLine( rLine.GetLine() );
3138 :
3139 1024 : return *this;
3140 : }
3141 :
3142 :
3143 :
3144 396026 : bool SvxLineItem::operator==( const SfxPoolItem& rAttr ) const
3145 : {
3146 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
3147 :
3148 396026 : return CmpBrdLn( pLine, static_cast<const SvxLineItem&>(rAttr).GetLine() );
3149 : }
3150 :
3151 :
3152 :
3153 1674 : SfxPoolItem* SvxLineItem::Clone( SfxItemPool* ) const
3154 : {
3155 1674 : return new SvxLineItem( *this );
3156 : }
3157 :
3158 1095 : bool SvxLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemId ) const
3159 : {
3160 1095 : bool bConvert = 0!=(nMemId&CONVERT_TWIPS);
3161 1095 : nMemId &= ~CONVERT_TWIPS;
3162 1095 : if ( nMemId == 0 )
3163 : {
3164 1095 : rVal <<= uno::makeAny( SvxBoxItem::SvxLineToLine(pLine, bConvert) );
3165 1095 : return true;
3166 : }
3167 0 : else if ( pLine )
3168 : {
3169 0 : switch ( nMemId )
3170 : {
3171 0 : case MID_FG_COLOR: rVal <<= sal_Int32(pLine->GetColor().GetColor()); break;
3172 0 : case MID_OUTER_WIDTH: rVal <<= sal_Int32(pLine->GetOutWidth()); break;
3173 0 : case MID_INNER_WIDTH: rVal <<= sal_Int32(pLine->GetInWidth( )); break;
3174 0 : case MID_DISTANCE: rVal <<= sal_Int32(pLine->GetDistance()); break;
3175 : default:
3176 : OSL_FAIL( "Wrong MemberId" );
3177 0 : return false;
3178 : }
3179 : }
3180 :
3181 0 : return true;
3182 : }
3183 :
3184 :
3185 :
3186 1239 : bool SvxLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemId )
3187 : {
3188 1239 : bool bConvert = 0!=(nMemId&CONVERT_TWIPS);
3189 1239 : nMemId &= ~CONVERT_TWIPS;
3190 1239 : sal_Int32 nVal = 0;
3191 1239 : if ( nMemId == 0 )
3192 : {
3193 1239 : table::BorderLine2 aLine;
3194 1239 : if ( lcl_extractBorderLine(rVal, aLine) )
3195 : {
3196 1239 : if ( !pLine )
3197 1239 : pLine = new SvxBorderLine;
3198 1239 : if( !SvxBoxItem::LineToSvxLine(aLine, *pLine, bConvert) )
3199 1237 : DELETEZ( pLine );
3200 1239 : return true;
3201 : }
3202 0 : return false;
3203 : }
3204 0 : else if ( rVal >>= nVal )
3205 : {
3206 0 : if ( !pLine )
3207 0 : pLine = new SvxBorderLine;
3208 :
3209 0 : switch ( nMemId )
3210 : {
3211 0 : case MID_FG_COLOR: pLine->SetColor( Color(nVal) ); break;
3212 : case MID_LINE_STYLE:
3213 0 : pLine->SetBorderLineStyle(static_cast<SvxBorderStyle>(nVal));
3214 0 : break;
3215 : default:
3216 : OSL_FAIL( "Wrong MemberId" );
3217 0 : return false;
3218 : }
3219 :
3220 0 : return true;
3221 : }
3222 :
3223 0 : return false;
3224 : }
3225 :
3226 :
3227 :
3228 0 : bool SvxLineItem::GetPresentation
3229 : (
3230 : SfxItemPresentation ePres,
3231 : SfxMapUnit eCoreUnit,
3232 : SfxMapUnit ePresUnit,
3233 : OUString& rText, const IntlWrapper *pIntl
3234 : ) const
3235 : {
3236 0 : rText.clear();
3237 :
3238 0 : if ( pLine )
3239 0 : rText = pLine->GetValueString( eCoreUnit, ePresUnit, pIntl,
3240 0 : (SFX_ITEM_PRESENTATION_COMPLETE == ePres) );
3241 0 : return true;
3242 : }
3243 :
3244 :
3245 :
3246 1056 : SvStream& SvxLineItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
3247 : {
3248 1056 : if( pLine )
3249 : {
3250 0 : WriteColor( rStrm, pLine->GetColor() );
3251 0 : rStrm.WriteInt16( pLine->GetOutWidth() )
3252 0 : .WriteInt16( pLine->GetInWidth() )
3253 0 : .WriteInt16( pLine->GetDistance() );
3254 : }
3255 : else
3256 : {
3257 1056 : WriteColor( rStrm, Color() );
3258 1056 : rStrm.WriteInt16( 0 ).WriteInt16( 0 ).WriteInt16( 0 );
3259 : }
3260 1056 : return rStrm;
3261 : }
3262 :
3263 :
3264 :
3265 0 : bool SvxLineItem::ScaleMetrics( long nMult, long nDiv )
3266 : {
3267 0 : if ( pLine ) pLine->ScaleMetrics( nMult, nDiv );
3268 0 : return true;
3269 : }
3270 :
3271 :
3272 :
3273 0 : bool SvxLineItem::HasMetrics() const
3274 : {
3275 0 : return true;
3276 : }
3277 :
3278 :
3279 :
3280 1024 : SfxPoolItem* SvxLineItem::Create( SvStream& rStrm, sal_uInt16 ) const
3281 : {
3282 1024 : SvxLineItem* _pLine = new SvxLineItem( Which() );
3283 : short nOutline, nInline, nDistance;
3284 1024 : Color aColor;
3285 :
3286 1024 : ReadColor( rStrm, aColor ).ReadInt16( nOutline ).ReadInt16( nInline ).ReadInt16( nDistance );
3287 1024 : if( nOutline )
3288 : {
3289 0 : SvxBorderLine aLine( &aColor );
3290 0 : aLine.GuessLinesWidths(css::table::BorderLineStyle::NONE, nOutline, nInline, nDistance);
3291 0 : _pLine->SetLine( &aLine );
3292 : }
3293 1024 : return _pLine;
3294 : }
3295 :
3296 :
3297 :
3298 1278 : void SvxLineItem::SetLine( const SvxBorderLine* pNew )
3299 : {
3300 1278 : delete pLine;
3301 1278 : pLine = pNew ? new SvxBorderLine( *pNew ) : 0;
3302 1278 : }
3303 :
3304 : // class SvxBrushItem ----------------------------------------------------
3305 :
3306 : #define LOAD_GRAPHIC ((sal_uInt16)0x0001)
3307 : #define LOAD_LINK ((sal_uInt16)0x0002)
3308 : #define LOAD_FILTER ((sal_uInt16)0x0004)
3309 :
3310 : // class SvxBrushItem_Impl -----------------------------------------------
3311 :
3312 : class SvxBrushItem_Impl
3313 : {
3314 : public:
3315 : GraphicObject* pGraphicObject;
3316 : sal_Int8 nGraphicTransparency; //contains a percentage value which is
3317 : //copied to the GraphicObject when necessary
3318 : Link<> aDoneLink;
3319 : SvStream* pStream;
3320 :
3321 58714 : SvxBrushItem_Impl( GraphicObject* p ) : pGraphicObject( p ), nGraphicTransparency(0), pStream(0) {}
3322 : };
3323 :
3324 :
3325 :
3326 2324 : void SvxBrushItem::SetDoneLink( const Link<>& rLink )
3327 : {
3328 2324 : pImpl->aDoneLink = rLink;
3329 2324 : }
3330 :
3331 :
3332 :
3333 5939 : SvxBrushItem::SvxBrushItem( sal_uInt16 _nWhich ) :
3334 :
3335 : SfxPoolItem( _nWhich ),
3336 :
3337 : aColor ( COL_TRANSPARENT ),
3338 : nShadingValue ( ShadingPattern::CLEAR ),
3339 5939 : pImpl ( new SvxBrushItem_Impl( 0 ) ),
3340 : maStrLink (),
3341 : maStrFilter (),
3342 : eGraphicPos ( GPOS_NONE ),
3343 11878 : bLoadAgain ( true )
3344 :
3345 : {
3346 5939 : }
3347 :
3348 :
3349 :
3350 8413 : SvxBrushItem::SvxBrushItem( const Color& rColor, sal_uInt16 _nWhich) :
3351 :
3352 : SfxPoolItem( _nWhich ),
3353 :
3354 : aColor ( rColor ),
3355 : nShadingValue ( ShadingPattern::CLEAR ),
3356 8413 : pImpl ( new SvxBrushItem_Impl( 0 ) ),
3357 : maStrLink (),
3358 : maStrFilter (),
3359 : eGraphicPos ( GPOS_NONE ),
3360 16826 : bLoadAgain ( true )
3361 :
3362 : {
3363 8413 : }
3364 :
3365 :
3366 :
3367 40 : SvxBrushItem::SvxBrushItem( const Graphic& rGraphic, SvxGraphicPosition ePos,
3368 : sal_uInt16 _nWhich ) :
3369 :
3370 : SfxPoolItem( _nWhich ),
3371 :
3372 : aColor ( COL_TRANSPARENT ),
3373 : nShadingValue ( ShadingPattern::CLEAR ),
3374 80 : pImpl ( new SvxBrushItem_Impl( new GraphicObject( rGraphic ) ) ),
3375 : maStrLink (),
3376 : maStrFilter (),
3377 : eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ),
3378 120 : bLoadAgain ( true )
3379 :
3380 : {
3381 : DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" );
3382 40 : }
3383 :
3384 :
3385 :
3386 0 : SvxBrushItem::SvxBrushItem( const GraphicObject& rGraphicObj,
3387 : SvxGraphicPosition ePos, sal_uInt16 _nWhich ) :
3388 :
3389 : SfxPoolItem( _nWhich ),
3390 :
3391 : aColor ( COL_TRANSPARENT ),
3392 : nShadingValue ( ShadingPattern::CLEAR ),
3393 0 : pImpl ( new SvxBrushItem_Impl( new GraphicObject( rGraphicObj ) ) ),
3394 : maStrLink (),
3395 : maStrFilter (),
3396 : eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ),
3397 0 : bLoadAgain ( true )
3398 :
3399 : {
3400 : DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" );
3401 0 : }
3402 :
3403 :
3404 :
3405 40 : SvxBrushItem::SvxBrushItem(
3406 : const OUString& rLink, const OUString& rFilter,
3407 : SvxGraphicPosition ePos, sal_uInt16 _nWhich ) :
3408 :
3409 : SfxPoolItem( _nWhich ),
3410 :
3411 : aColor ( COL_TRANSPARENT ),
3412 : nShadingValue ( ShadingPattern::CLEAR ),
3413 40 : pImpl ( new SvxBrushItem_Impl( NULL ) ),
3414 : maStrLink ( rLink ),
3415 : maStrFilter ( rFilter ),
3416 : eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ),
3417 80 : bLoadAgain ( true )
3418 :
3419 : {
3420 : DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" );
3421 40 : }
3422 :
3423 :
3424 :
3425 512 : SvxBrushItem::SvxBrushItem( SvStream& rStream, sal_uInt16 nVersion,
3426 : sal_uInt16 _nWhich )
3427 : : SfxPoolItem( _nWhich )
3428 : , aColor ( COL_TRANSPARENT )
3429 : , nShadingValue ( ShadingPattern::CLEAR )
3430 512 : , pImpl ( new SvxBrushItem_Impl( NULL ) )
3431 : , maStrLink ()
3432 : , maStrFilter ()
3433 : , eGraphicPos ( GPOS_NONE )
3434 1024 : , bLoadAgain (false)
3435 : {
3436 : bool bTrans;
3437 512 : Color aTempColor;
3438 512 : Color aTempFillColor;
3439 : sal_Int8 nStyle;
3440 :
3441 512 : rStream.ReadCharAsBool( bTrans );
3442 512 : ReadColor( rStream, aTempColor );
3443 512 : ReadColor( rStream, aTempFillColor );
3444 512 : rStream.ReadSChar( nStyle );
3445 :
3446 512 : switch ( nStyle )
3447 : {
3448 : case 8://BRUSH_25:
3449 : {
3450 0 : sal_uInt32 nRed = aTempColor.GetRed();
3451 0 : sal_uInt32 nGreen = aTempColor.GetGreen();
3452 0 : sal_uInt32 nBlue = aTempColor.GetBlue();
3453 0 : nRed += (sal_uInt32)(aTempFillColor.GetRed())*2;
3454 0 : nGreen += (sal_uInt32)(aTempFillColor.GetGreen())*2;
3455 0 : nBlue += (sal_uInt32)(aTempFillColor.GetBlue())*2;
3456 0 : aColor = Color( (sal_Int8)(nRed/3), (sal_Int8)(nGreen/3), (sal_Int8)(nBlue/3) );
3457 : }
3458 0 : break;
3459 :
3460 : case 9://BRUSH_50:
3461 : {
3462 0 : sal_uInt32 nRed = aTempColor.GetRed();
3463 0 : sal_uInt32 nGreen = aTempColor.GetGreen();
3464 0 : sal_uInt32 nBlue = aTempColor.GetBlue();
3465 0 : nRed += (sal_uInt32)(aTempFillColor.GetRed());
3466 0 : nGreen += (sal_uInt32)(aTempFillColor.GetGreen());
3467 0 : nBlue += (sal_uInt32)(aTempFillColor.GetBlue());
3468 0 : aColor = Color( (sal_Int8)(nRed/2), (sal_Int8)(nGreen/2), (sal_Int8)(nBlue/2) );
3469 : }
3470 0 : break;
3471 :
3472 : case 10://BRUSH_75:
3473 : {
3474 0 : sal_uInt32 nRed = aTempColor.GetRed()*2;
3475 0 : sal_uInt32 nGreen = aTempColor.GetGreen()*2;
3476 0 : sal_uInt32 nBlue = aTempColor.GetBlue()*2;
3477 0 : nRed += (sal_uInt32)(aTempFillColor.GetRed());
3478 0 : nGreen += (sal_uInt32)(aTempFillColor.GetGreen());
3479 0 : nBlue += (sal_uInt32)(aTempFillColor.GetBlue());
3480 0 : aColor = Color( (sal_Int8)(nRed/3), (sal_Int8)(nGreen/3), (sal_Int8)(nBlue/3) );
3481 : }
3482 0 : break;
3483 :
3484 : case 0://BRUSH_NULL:
3485 8 : aColor = Color( COL_TRANSPARENT );
3486 8 : break;
3487 :
3488 : default:
3489 504 : aColor = aTempColor;
3490 : }
3491 :
3492 512 : if ( nVersion >= BRUSH_GRAPHIC_VERSION )
3493 : {
3494 512 : sal_uInt16 nDoLoad = 0;
3495 : sal_Int8 nPos;
3496 :
3497 512 : rStream.ReadUInt16( nDoLoad );
3498 :
3499 512 : if ( nDoLoad & LOAD_GRAPHIC )
3500 : {
3501 0 : Graphic aGraphic;
3502 :
3503 0 : ReadGraphic( rStream, aGraphic );
3504 0 : pImpl->pGraphicObject = new GraphicObject( aGraphic );
3505 :
3506 0 : if( SVSTREAM_FILEFORMAT_ERROR == rStream.GetError() )
3507 : {
3508 0 : rStream.ResetError();
3509 : rStream.SetError( ERRCODE_SVX_GRAPHIC_WRONG_FILEFORMAT|
3510 0 : ERRCODE_WARNING_MASK );
3511 0 : }
3512 : }
3513 :
3514 512 : if ( nDoLoad & LOAD_LINK )
3515 : {
3516 : // UNICODE: rStream >> aRel;
3517 0 : OUString aRel = rStream.ReadUniOrByteString(rStream.GetStreamCharSet());
3518 :
3519 : // TODO/MBA: how can we get a BaseURL here?!
3520 : OSL_FAIL("No BaseURL!");
3521 0 : OUString aAbs = INetURLObject::GetAbsURL( "", aRel );
3522 : DBG_ASSERT( !aAbs.isEmpty(), "Invalid URL!" );
3523 0 : maStrLink = aAbs;
3524 : }
3525 :
3526 512 : if ( nDoLoad & LOAD_FILTER )
3527 : {
3528 : // UNICODE: rStream >> maStrFilter;
3529 0 : maStrFilter = rStream.ReadUniOrByteString(rStream.GetStreamCharSet());
3530 : }
3531 :
3532 512 : rStream.ReadSChar( nPos );
3533 :
3534 512 : eGraphicPos = (SvxGraphicPosition)nPos;
3535 : }
3536 512 : }
3537 :
3538 :
3539 :
3540 43770 : SvxBrushItem::SvxBrushItem( const SvxBrushItem& rItem ) :
3541 :
3542 43770 : SfxPoolItem( rItem.Which() ),
3543 : nShadingValue ( ShadingPattern::CLEAR ),
3544 43770 : pImpl ( new SvxBrushItem_Impl( NULL ) ),
3545 : maStrLink (),
3546 : maStrFilter (),
3547 : eGraphicPos ( GPOS_NONE ),
3548 87540 : bLoadAgain ( true )
3549 :
3550 : {
3551 43770 : *this = rItem;
3552 43770 : }
3553 :
3554 :
3555 :
3556 133148 : SvxBrushItem::~SvxBrushItem()
3557 : {
3558 58463 : delete pImpl->pGraphicObject;
3559 58463 : delete pImpl;
3560 74685 : }
3561 :
3562 :
3563 :
3564 530 : sal_uInt16 SvxBrushItem::GetVersion( sal_uInt16 /*nFileVersion*/ ) const
3565 : {
3566 530 : return BRUSH_GRAPHIC_VERSION;
3567 : }
3568 :
3569 :
3570 178 : static inline sal_Int8 lcl_PercentToTransparency(long nPercent)
3571 : {
3572 : //0xff must not be returned!
3573 178 : return sal_Int8(nPercent ? (50 + 0xfe * nPercent) / 100 : 0);
3574 : }
3575 127 : sal_Int8 SvxBrushItem::TransparencyToPercent(sal_Int32 nTrans)
3576 : {
3577 127 : return (sal_Int8)((nTrans * 100 + 127) / 254);
3578 : }
3579 :
3580 1857 : bool SvxBrushItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
3581 : {
3582 1857 : nMemberId &= ~CONVERT_TWIPS;
3583 1857 : switch( nMemberId)
3584 : {
3585 : case MID_BACK_COLOR:
3586 832 : rVal <<= (sal_Int32)( aColor.GetColor() );
3587 832 : break;
3588 : case MID_BACK_COLOR_R_G_B:
3589 39 : rVal <<= (sal_Int32)( aColor.GetRGBColor() );
3590 39 : break;
3591 : case MID_BACK_COLOR_TRANSPARENCY:
3592 105 : rVal <<= SvxBrushItem::TransparencyToPercent(aColor.GetTransparency());
3593 105 : break;
3594 : case MID_GRAPHIC_POSITION:
3595 102 : rVal <<= (style::GraphicLocation)(sal_Int16)eGraphicPos;
3596 102 : break;
3597 :
3598 : case MID_GRAPHIC:
3599 : SAL_WARN( "editeng.items", "not implemented" );
3600 0 : break;
3601 :
3602 : case MID_GRAPHIC_TRANSPARENT:
3603 262 : rVal = css::uno::makeAny<bool>( aColor.GetTransparency() == 0xff );
3604 262 : break;
3605 :
3606 : case MID_GRAPHIC_URL:
3607 : {
3608 311 : OUString sLink;
3609 311 : if ( !maStrLink.isEmpty() )
3610 3 : sLink = maStrLink;
3611 308 : else if( pImpl->pGraphicObject )
3612 : {
3613 : OUString sPrefix(
3614 220 : UNO_NAME_GRAPHOBJ_URLPREFIX);
3615 : OUString sId(OStringToOUString(
3616 : pImpl->pGraphicObject->GetUniqueID(),
3617 440 : RTL_TEXTENCODING_ASCII_US));
3618 440 : sLink = sPrefix + sId;
3619 : }
3620 311 : rVal <<= sLink;
3621 : }
3622 311 : break;
3623 :
3624 : case MID_GRAPHIC_FILTER:
3625 : {
3626 101 : rVal <<= maStrFilter;
3627 : }
3628 101 : break;
3629 :
3630 : case MID_GRAPHIC_TRANSPARENCY:
3631 4 : rVal <<= pImpl->nGraphicTransparency;
3632 4 : break;
3633 :
3634 : case MID_SHADING_VALUE:
3635 : {
3636 101 : rVal <<= nShadingValue;
3637 : }
3638 101 : break;
3639 : }
3640 :
3641 1857 : return true;
3642 : }
3643 :
3644 :
3645 :
3646 9639 : bool SvxBrushItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
3647 : {
3648 9639 : nMemberId &= ~CONVERT_TWIPS;
3649 9639 : switch( nMemberId)
3650 : {
3651 : case MID_BACK_COLOR:
3652 : case MID_BACK_COLOR_R_G_B:
3653 : {
3654 6887 : sal_Int32 nCol = 0;
3655 6887 : if ( !( rVal >>= nCol ) )
3656 0 : return false;
3657 6887 : if(MID_BACK_COLOR_R_G_B == nMemberId)
3658 : {
3659 15 : nCol = COLORDATA_RGB( nCol );
3660 15 : nCol += aColor.GetColor() & 0xff000000;
3661 : }
3662 6887 : aColor = Color( nCol );
3663 : }
3664 6887 : break;
3665 : case MID_BACK_COLOR_TRANSPARENCY:
3666 : {
3667 101 : sal_Int32 nTrans = 0;
3668 101 : if ( !( rVal >>= nTrans ) || nTrans < 0 || nTrans > 100 )
3669 0 : return false;
3670 101 : aColor.SetTransparency(lcl_PercentToTransparency(nTrans));
3671 : }
3672 101 : break;
3673 :
3674 : case MID_GRAPHIC_POSITION:
3675 : {
3676 : style::GraphicLocation eLocation;
3677 392 : if ( !( rVal>>=eLocation ) )
3678 : {
3679 0 : sal_Int32 nValue = 0;
3680 0 : if ( !( rVal >>= nValue ) )
3681 0 : return false;
3682 0 : eLocation = (style::GraphicLocation)nValue;
3683 : }
3684 392 : SetGraphicPos( (SvxGraphicPosition)(sal_uInt16)eLocation );
3685 : }
3686 392 : break;
3687 :
3688 : case MID_GRAPHIC:
3689 : SAL_WARN( "editeng.items", "not implemented" );
3690 0 : break;
3691 :
3692 : case MID_GRAPHIC_TRANSPARENT:
3693 872 : aColor.SetTransparency( Any2Bool( rVal ) ? 0xff : 0 );
3694 872 : break;
3695 :
3696 : case MID_GRAPHIC_URL:
3697 : {
3698 408 : if ( rVal.getValueType() == ::cppu::UnoType<OUString>::get() )
3699 : {
3700 42 : OUString sLink;
3701 42 : rVal >>= sLink;
3702 42 : if( sLink.startsWith( UNO_NAME_GRAPHOBJ_URLPKGPREFIX ) )
3703 : {
3704 : OSL_FAIL( "package urls aren't implemented" );
3705 : }
3706 42 : else if( sLink.startsWith( UNO_NAME_GRAPHOBJ_URLPREFIX ) )
3707 : {
3708 26 : maStrLink.clear();
3709 : OString sId(OUStringToOString(sLink.copy( sizeof(UNO_NAME_GRAPHOBJ_URLPREFIX)-1 ),
3710 26 : RTL_TEXTENCODING_ASCII_US));
3711 26 : GraphicObject *pOldGrfObj = pImpl->pGraphicObject;
3712 26 : pImpl->pGraphicObject = new GraphicObject( sId );
3713 26 : ApplyGraphicTransparency_Impl();
3714 26 : delete pOldGrfObj;
3715 : }
3716 : else
3717 : {
3718 16 : SetGraphicLink(sLink);
3719 : }
3720 42 : if ( !sLink.isEmpty() && eGraphicPos == GPOS_NONE )
3721 3 : eGraphicPos = GPOS_MM;
3722 39 : else if( sLink.isEmpty() )
3723 13 : eGraphicPos = GPOS_NONE;
3724 : }
3725 : }
3726 408 : break;
3727 :
3728 : case MID_GRAPHIC_FILTER:
3729 : {
3730 392 : if( rVal.getValueType() == ::cppu::UnoType<OUString>::get() )
3731 : {
3732 392 : OUString sLink;
3733 392 : rVal >>= sLink;
3734 392 : SetGraphicFilter( sLink );
3735 : }
3736 : }
3737 392 : break;
3738 : case MID_GRAPHIC_TRANSPARENCY :
3739 : {
3740 23 : sal_Int32 nTmp = 0;
3741 23 : rVal >>= nTmp;
3742 23 : if(nTmp >= 0 && nTmp <= 100)
3743 : {
3744 23 : pImpl->nGraphicTransparency = sal_Int8(nTmp);
3745 23 : if(pImpl->pGraphicObject)
3746 0 : ApplyGraphicTransparency_Impl();
3747 : }
3748 : }
3749 23 : break;
3750 :
3751 : case MID_SHADING_VALUE:
3752 : {
3753 564 : sal_Int32 nVal = 0;
3754 564 : if (!(rVal >>= nVal))
3755 0 : return false;
3756 :
3757 564 : SetShadingValue( nVal );
3758 : }
3759 564 : break;
3760 : }
3761 :
3762 9639 : return true;
3763 : }
3764 :
3765 :
3766 :
3767 0 : bool SvxBrushItem::GetPresentation
3768 : (
3769 : SfxItemPresentation /*ePres*/,
3770 : SfxMapUnit /*eCoreUnit*/,
3771 : SfxMapUnit /*ePresUnit*/,
3772 : OUString& rText, const IntlWrapper *
3773 : ) const
3774 : {
3775 0 : if ( GPOS_NONE == eGraphicPos )
3776 : {
3777 0 : rText = ::GetColorString( aColor ) + OUString(cpDelim);
3778 0 : sal_uInt16 nId = RID_SVXITEMS_TRANSPARENT_FALSE;
3779 :
3780 0 : if ( aColor.GetTransparency() )
3781 0 : nId = RID_SVXITEMS_TRANSPARENT_TRUE;
3782 0 : rText += EE_RESSTR(nId);
3783 : }
3784 : else
3785 : {
3786 0 : rText = EE_RESSTR(RID_SVXITEMS_GRAPHIC);
3787 : }
3788 :
3789 0 : return true;
3790 : }
3791 :
3792 :
3793 :
3794 45951 : SvxBrushItem& SvxBrushItem::operator=( const SvxBrushItem& rItem )
3795 : {
3796 45951 : aColor = rItem.aColor;
3797 45951 : eGraphicPos = rItem.eGraphicPos;
3798 :
3799 45951 : DELETEZ( pImpl->pGraphicObject );
3800 45951 : maStrLink.clear();
3801 45951 : maStrFilter.clear();
3802 :
3803 45951 : if ( GPOS_NONE != eGraphicPos )
3804 : {
3805 905 : maStrLink = rItem.maStrLink;
3806 905 : maStrFilter = rItem.maStrFilter;
3807 905 : if ( rItem.pImpl->pGraphicObject )
3808 : {
3809 866 : pImpl->pGraphicObject = new GraphicObject( *rItem.pImpl->pGraphicObject );
3810 : }
3811 : }
3812 :
3813 45951 : nShadingValue = rItem.nShadingValue;
3814 :
3815 45951 : pImpl->nGraphicTransparency = rItem.pImpl->nGraphicTransparency;
3816 45951 : return *this;
3817 : }
3818 :
3819 :
3820 :
3821 246401 : bool SvxBrushItem::operator==( const SfxPoolItem& rAttr ) const
3822 : {
3823 : DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
3824 :
3825 246401 : const SvxBrushItem& rCmp = static_cast<const SvxBrushItem&>(rAttr);
3826 458759 : bool bEqual = ( aColor == rCmp.aColor && eGraphicPos == rCmp.eGraphicPos &&
3827 458759 : pImpl->nGraphicTransparency == rCmp.pImpl->nGraphicTransparency);
3828 :
3829 246401 : if ( bEqual )
3830 : {
3831 212358 : if ( GPOS_NONE != eGraphicPos )
3832 : {
3833 580 : bEqual = maStrLink == rCmp.maStrLink;
3834 :
3835 580 : if ( bEqual )
3836 : {
3837 579 : bEqual = maStrFilter == rCmp.maStrFilter;
3838 : }
3839 :
3840 580 : if ( bEqual )
3841 : {
3842 551 : if ( !rCmp.pImpl->pGraphicObject )
3843 0 : bEqual = !pImpl->pGraphicObject;
3844 : else
3845 1102 : bEqual = pImpl->pGraphicObject &&
3846 1102 : ( *pImpl->pGraphicObject == *rCmp.pImpl->pGraphicObject );
3847 : }
3848 : }
3849 :
3850 212358 : if (bEqual)
3851 : {
3852 212323 : bEqual = nShadingValue == rCmp.nShadingValue;
3853 : }
3854 : }
3855 :
3856 246401 : return bEqual;
3857 : }
3858 :
3859 :
3860 :
3861 12327 : SfxPoolItem* SvxBrushItem::Clone( SfxItemPool* ) const
3862 : {
3863 12327 : return new SvxBrushItem( *this );
3864 : }
3865 :
3866 :
3867 :
3868 512 : SfxPoolItem* SvxBrushItem::Create( SvStream& rStream, sal_uInt16 nVersion ) const
3869 : {
3870 512 : return new SvxBrushItem( rStream, nVersion, Which() );
3871 : }
3872 :
3873 :
3874 :
3875 528 : SvStream& SvxBrushItem::Store( SvStream& rStream , sal_uInt16 /*nItemVersion*/ ) const
3876 : {
3877 528 : rStream.WriteBool( false );
3878 528 : WriteColor( rStream, aColor );
3879 528 : WriteColor( rStream, aColor );
3880 528 : rStream.WriteSChar( aColor.GetTransparency() > 0 ? 0 : 1 ); //BRUSH_NULL : BRUSH_SOLID
3881 :
3882 528 : sal_uInt16 nDoLoad = 0;
3883 :
3884 528 : if ( pImpl->pGraphicObject && maStrLink.isEmpty() )
3885 0 : nDoLoad |= LOAD_GRAPHIC;
3886 528 : if ( !maStrLink.isEmpty() )
3887 0 : nDoLoad |= LOAD_LINK;
3888 528 : if ( !maStrFilter.isEmpty() )
3889 0 : nDoLoad |= LOAD_FILTER;
3890 528 : rStream.WriteUInt16( nDoLoad );
3891 :
3892 528 : if ( pImpl->pGraphicObject && maStrLink.isEmpty() )
3893 0 : WriteGraphic( rStream, pImpl->pGraphicObject->GetGraphic() );
3894 528 : if ( !maStrLink.isEmpty() )
3895 : {
3896 : OSL_FAIL("No BaseURL!");
3897 : // TODO/MBA: how to get a BaseURL?!
3898 0 : OUString aRel = INetURLObject::GetRelURL( "", maStrLink );
3899 : // UNICODE: rStream << aRel;
3900 0 : rStream.WriteUniOrByteString(aRel, rStream.GetStreamCharSet());
3901 : }
3902 528 : if ( !maStrFilter.isEmpty() )
3903 : {
3904 : // UNICODE: rStream << maStrFilter;
3905 0 : rStream.WriteUniOrByteString(maStrFilter, rStream.GetStreamCharSet());
3906 : }
3907 528 : rStream.WriteSChar( eGraphicPos );
3908 528 : return rStream;
3909 : }
3910 :
3911 :
3912 :
3913 0 : void SvxBrushItem::PurgeMedium() const
3914 : {
3915 0 : DELETEZ( pImpl->pStream );
3916 0 : }
3917 :
3918 :
3919 4572 : const GraphicObject* SvxBrushItem::GetGraphicObject(OUString const & referer) const
3920 : {
3921 4572 : if ( bLoadAgain && !maStrLink.isEmpty() && !pImpl->pGraphicObject )
3922 : // when graphics already loaded, use as a cache
3923 : {
3924 16 : if (SvtSecurityOptions().isUntrustedReferer(referer)) {
3925 0 : return 0;
3926 : }
3927 16 : pImpl->pStream = utl::UcbStreamHelper::CreateStream( maStrLink, STREAM_STD_READ );
3928 16 : if( pImpl->pStream && !pImpl->pStream->GetError() )
3929 : {
3930 0 : Graphic aGraphic;
3931 : int nRes;
3932 0 : pImpl->pStream->Seek( STREAM_SEEK_TO_BEGIN );
3933 0 : nRes = GraphicFilter::GetGraphicFilter().
3934 : ImportGraphic( aGraphic, maStrLink, *pImpl->pStream,
3935 0 : GRFILTER_FORMAT_DONTKNOW, NULL, GraphicFilterImportFlags::DontSetLogsizeForJpeg );
3936 :
3937 0 : if( nRes != GRFILTER_OK )
3938 : {
3939 0 : bLoadAgain = false;
3940 : }
3941 : else
3942 : {
3943 0 : pImpl->pGraphicObject = new GraphicObject;
3944 0 : pImpl->pGraphicObject->SetGraphic( aGraphic );
3945 0 : const_cast < SvxBrushItem*> (this)->ApplyGraphicTransparency_Impl();
3946 0 : }
3947 : }
3948 : else
3949 : {
3950 16 : bLoadAgain = false;
3951 : }
3952 : }
3953 :
3954 4572 : return pImpl->pGraphicObject;
3955 : }
3956 :
3957 : //UUUU
3958 18 : sal_Int8 SvxBrushItem::getGraphicTransparency() const
3959 : {
3960 18 : return pImpl->nGraphicTransparency;
3961 : }
3962 :
3963 : // -----------------------------------------------------------------------
3964 : //UUUU
3965 12 : void SvxBrushItem::setGraphicTransparency(sal_Int8 nNew)
3966 : {
3967 12 : if(nNew != pImpl->nGraphicTransparency)
3968 : {
3969 12 : pImpl->nGraphicTransparency = nNew;
3970 12 : ApplyGraphicTransparency_Impl();
3971 : }
3972 12 : }
3973 :
3974 : // -----------------------------------------------------------------------
3975 :
3976 :
3977 3573 : const Graphic* SvxBrushItem::GetGraphic(OUString const & referer) const
3978 : {
3979 3573 : const GraphicObject* pGrafObj = GetGraphicObject(referer);
3980 3573 : return( pGrafObj ? &( pGrafObj->GetGraphic() ) : NULL );
3981 : }
3982 :
3983 :
3984 :
3985 760 : void SvxBrushItem::SetGraphicPos( SvxGraphicPosition eNew )
3986 : {
3987 760 : eGraphicPos = eNew;
3988 :
3989 760 : if ( GPOS_NONE == eGraphicPos )
3990 : {
3991 747 : DELETEZ( pImpl->pGraphicObject );
3992 747 : maStrLink.clear();
3993 747 : maStrFilter.clear();
3994 : }
3995 : else
3996 : {
3997 13 : if ( !pImpl->pGraphicObject && maStrLink.isEmpty() )
3998 : {
3999 7 : pImpl->pGraphicObject = new GraphicObject; // Creating a dummy
4000 : }
4001 : }
4002 760 : }
4003 :
4004 :
4005 :
4006 39 : void SvxBrushItem::SetGraphic( const Graphic& rNew )
4007 : {
4008 39 : if ( maStrLink.isEmpty() )
4009 : {
4010 39 : if ( pImpl->pGraphicObject )
4011 19 : pImpl->pGraphicObject->SetGraphic( rNew );
4012 : else
4013 20 : pImpl->pGraphicObject = new GraphicObject( rNew );
4014 :
4015 39 : ApplyGraphicTransparency_Impl();
4016 :
4017 39 : if ( GPOS_NONE == eGraphicPos )
4018 0 : eGraphicPos = GPOS_MM; // None would be brush, then Default: middle
4019 : }
4020 : else
4021 : {
4022 : OSL_FAIL( "SetGraphic() on linked graphic! :-/" );
4023 : }
4024 39 : }
4025 :
4026 :
4027 :
4028 0 : void SvxBrushItem::SetGraphicObject( const GraphicObject& rNewObj )
4029 : {
4030 0 : if ( maStrLink.isEmpty() )
4031 : {
4032 0 : if ( pImpl->pGraphicObject )
4033 0 : *pImpl->pGraphicObject = rNewObj;
4034 : else
4035 0 : pImpl->pGraphicObject = new GraphicObject( rNewObj );
4036 :
4037 0 : ApplyGraphicTransparency_Impl();
4038 :
4039 0 : if ( GPOS_NONE == eGraphicPos )
4040 0 : eGraphicPos = GPOS_MM; // None would be brush, then Default: middle
4041 : }
4042 : else
4043 : {
4044 : OSL_FAIL( "SetGraphic() on linked graphic! :-/" );
4045 : }
4046 0 : }
4047 :
4048 :
4049 :
4050 16 : void SvxBrushItem::SetGraphicLink( const OUString& rNew )
4051 : {
4052 16 : if ( rNew.isEmpty() )
4053 13 : maStrLink.clear();
4054 : else
4055 : {
4056 3 : maStrLink = rNew;
4057 3 : DELETEZ( pImpl->pGraphicObject );
4058 : }
4059 16 : }
4060 :
4061 :
4062 :
4063 392 : void SvxBrushItem::SetGraphicFilter( const OUString& rNew )
4064 : {
4065 392 : maStrFilter = rNew;
4066 392 : }
4067 :
4068 564 : void SvxBrushItem::SetShadingValue( const sal_Int32 nNew )
4069 : {
4070 564 : nShadingValue = nNew;
4071 564 : }
4072 :
4073 : //static
4074 0 : SvxGraphicPosition SvxBrushItem::WallpaperStyle2GraphicPos( WallpaperStyle eStyle )
4075 : {
4076 : SvxGraphicPosition eResult;
4077 : // The switch is not the fastest, but the safest
4078 0 : switch( eStyle )
4079 : {
4080 0 : case WALLPAPER_NULL: eResult = GPOS_NONE; break;
4081 0 : case WALLPAPER_TILE: eResult = GPOS_TILED; break;
4082 0 : case WALLPAPER_CENTER: eResult = GPOS_MM; break;
4083 0 : case WALLPAPER_SCALE: eResult = GPOS_AREA; break;
4084 0 : case WALLPAPER_TOPLEFT: eResult = GPOS_LT; break;
4085 0 : case WALLPAPER_TOP: eResult = GPOS_MT; break;
4086 0 : case WALLPAPER_TOPRIGHT: eResult = GPOS_RT; break;
4087 0 : case WALLPAPER_LEFT: eResult = GPOS_LM; break;
4088 0 : case WALLPAPER_RIGHT: eResult = GPOS_RM; break;
4089 0 : case WALLPAPER_BOTTOMLEFT: eResult = GPOS_LB; break;
4090 0 : case WALLPAPER_BOTTOM: eResult = GPOS_MB; break;
4091 0 : case WALLPAPER_BOTTOMRIGHT: eResult = GPOS_RB; break;
4092 0 : default: eResult = GPOS_NONE;
4093 : }
4094 0 : return eResult;
4095 : };
4096 :
4097 : //static
4098 0 : WallpaperStyle SvxBrushItem::GraphicPos2WallpaperStyle( SvxGraphicPosition ePos )
4099 : {
4100 : WallpaperStyle eResult;
4101 0 : switch( ePos )
4102 : {
4103 0 : case GPOS_NONE: eResult = WALLPAPER_NULL; break;
4104 0 : case GPOS_TILED: eResult = WALLPAPER_TILE; break;
4105 0 : case GPOS_MM: eResult = WALLPAPER_CENTER; break;
4106 0 : case GPOS_AREA: eResult = WALLPAPER_SCALE; break;
4107 0 : case GPOS_LT: eResult = WALLPAPER_TOPLEFT; break;
4108 0 : case GPOS_MT: eResult = WALLPAPER_TOP; break;
4109 0 : case GPOS_RT: eResult = WALLPAPER_TOPRIGHT; break;
4110 0 : case GPOS_LM: eResult = WALLPAPER_LEFT; break;
4111 0 : case GPOS_RM: eResult = WALLPAPER_RIGHT; break;
4112 0 : case GPOS_LB: eResult = WALLPAPER_BOTTOMLEFT; break;
4113 0 : case GPOS_MB: eResult = WALLPAPER_BOTTOM; break;
4114 0 : case GPOS_RB: eResult = WALLPAPER_BOTTOMRIGHT; break;
4115 0 : default: eResult = WALLPAPER_NULL;
4116 : }
4117 0 : return eResult;
4118 : }
4119 :
4120 0 : SvxBrushItem::SvxBrushItem( const CntWallpaperItem& rItem, sal_uInt16 _nWhich ) :
4121 : SfxPoolItem ( _nWhich ),
4122 : nShadingValue ( ShadingPattern::CLEAR ),
4123 0 : pImpl ( new SvxBrushItem_Impl( 0 ) ),
4124 : maStrLink (),
4125 : maStrFilter (),
4126 0 : bLoadAgain ( true )
4127 : {
4128 0 : aColor = rItem.GetColor();
4129 :
4130 0 : if (!rItem.GetBitmapURL().isEmpty())
4131 : {
4132 0 : maStrLink = rItem.GetBitmapURL();
4133 0 : SetGraphicPos( WallpaperStyle2GraphicPos((WallpaperStyle)rItem.GetStyle() ) );
4134 : }
4135 : else
4136 : {
4137 0 : SetGraphicPos( GPOS_NONE );
4138 : }
4139 0 : }
4140 :
4141 77 : void SvxBrushItem::ApplyGraphicTransparency_Impl()
4142 : {
4143 : DBG_ASSERT(pImpl->pGraphicObject, "no GraphicObject available" );
4144 77 : if(pImpl->pGraphicObject)
4145 : {
4146 77 : GraphicAttr aAttr(pImpl->pGraphicObject->GetAttr());
4147 : aAttr.SetTransparency(lcl_PercentToTransparency(
4148 77 : pImpl->nGraphicTransparency));
4149 77 : pImpl->pGraphicObject->SetAttr(aAttr);
4150 : }
4151 77 : }
4152 :
4153 0 : void SvxBrushItem::dumpAsXml(xmlTextWriterPtr pWriter) const
4154 : {
4155 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("svxBrushItem"));
4156 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
4157 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("color"), BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr()));
4158 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("shadingValue"), BAD_CAST(OString::number(nShadingValue).getStr()));
4159 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("link"), BAD_CAST(maStrLink.toUtf8().getStr()));
4160 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("filter"), BAD_CAST(maStrFilter.toUtf8().getStr()));
4161 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("graphicPos"), BAD_CAST(OString::number(eGraphicPos).getStr()));
4162 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("loadAgain"), BAD_CAST(OString::boolean(bLoadAgain).getStr()));
4163 0 : xmlTextWriterEndElement(pWriter);
4164 0 : }
4165 :
4166 : // class SvxFrameDirectionItem ----------------------------------------------
4167 :
4168 292808 : SvxFrameDirectionItem::SvxFrameDirectionItem( SvxFrameDirection nValue ,
4169 : sal_uInt16 _nWhich )
4170 292808 : : SfxUInt16Item( _nWhich, (sal_uInt16)nValue )
4171 : {
4172 292808 : }
4173 :
4174 443590 : SvxFrameDirectionItem::~SvxFrameDirectionItem()
4175 : {
4176 443590 : }
4177 :
4178 393390 : bool SvxFrameDirectionItem::operator==( const SfxPoolItem& rCmp ) const
4179 : {
4180 : DBG_ASSERT( SfxPoolItem::operator==(rCmp), "unequal types" );
4181 :
4182 393390 : return GetValue() == static_cast<const SvxFrameDirectionItem&>(rCmp).GetValue();
4183 : }
4184 :
4185 78069 : SfxPoolItem* SvxFrameDirectionItem::Clone( SfxItemPool * ) const
4186 : {
4187 78069 : return new SvxFrameDirectionItem( *this );
4188 : }
4189 :
4190 0 : SfxPoolItem* SvxFrameDirectionItem::Create( SvStream & rStrm, sal_uInt16 /*nVer*/ ) const
4191 : {
4192 : sal_uInt16 nValue;
4193 0 : rStrm.ReadUInt16( nValue );
4194 0 : return new SvxFrameDirectionItem( (SvxFrameDirection)nValue, Which() );
4195 : }
4196 :
4197 356 : SvStream& SvxFrameDirectionItem::Store( SvStream & rStrm, sal_uInt16 /*nIVer*/ ) const
4198 : {
4199 356 : sal_uInt16 nValue = GetValue();
4200 356 : rStrm.WriteUInt16( nValue );
4201 356 : return rStrm;
4202 : }
4203 :
4204 13100 : sal_uInt16 SvxFrameDirectionItem::GetVersion( sal_uInt16 nFVer ) const
4205 : {
4206 13100 : return SOFFICE_FILEFORMAT_50 > nFVer ? USHRT_MAX : 0;
4207 : }
4208 :
4209 0 : bool SvxFrameDirectionItem::GetPresentation(
4210 : SfxItemPresentation /*ePres*/,
4211 : SfxMapUnit /*eCoreUnit*/,
4212 : SfxMapUnit /*ePresUnit*/,
4213 : OUString& rText, const IntlWrapper *) const
4214 : {
4215 0 : rText = EE_RESSTR( RID_SVXITEMS_FRMDIR_BEGIN + GetValue() );
4216 0 : return true;
4217 : }
4218 :
4219 30284 : bool SvxFrameDirectionItem::PutValue( const com::sun::star::uno::Any& rVal,
4220 : sal_uInt8 )
4221 : {
4222 30284 : sal_Int16 nVal = sal_Int16();
4223 30284 : bool bRet = ( rVal >>= nVal );
4224 30284 : if( bRet )
4225 : {
4226 : // translate WritingDirection2 constants into SvxFrameDirection
4227 30284 : switch( nVal )
4228 : {
4229 : case text::WritingMode2::LR_TB:
4230 8173 : SetValue( FRMDIR_HORI_LEFT_TOP );
4231 8173 : break;
4232 : case text::WritingMode2::RL_TB:
4233 96 : SetValue( FRMDIR_HORI_RIGHT_TOP );
4234 96 : break;
4235 : case text::WritingMode2::TB_RL:
4236 7 : SetValue( FRMDIR_VERT_TOP_RIGHT );
4237 7 : break;
4238 : case text::WritingMode2::TB_LR:
4239 0 : SetValue( FRMDIR_VERT_TOP_LEFT );
4240 0 : break;
4241 : case text::WritingMode2::PAGE:
4242 21714 : SetValue( FRMDIR_ENVIRONMENT );
4243 21714 : break;
4244 : default:
4245 294 : bRet = false;
4246 294 : break;
4247 : }
4248 : }
4249 :
4250 30284 : return bRet;
4251 : }
4252 :
4253 2699 : bool SvxFrameDirectionItem::QueryValue( com::sun::star::uno::Any& rVal,
4254 : sal_uInt8 ) const
4255 : {
4256 : // translate SvxFrameDirection into WritingDirection2
4257 : sal_Int16 nVal;
4258 2699 : bool bRet = true;
4259 2699 : switch( GetValue() )
4260 : {
4261 : case FRMDIR_HORI_LEFT_TOP:
4262 2470 : nVal = text::WritingMode2::LR_TB;
4263 2470 : break;
4264 : case FRMDIR_HORI_RIGHT_TOP:
4265 18 : nVal = text::WritingMode2::RL_TB;
4266 18 : break;
4267 : case FRMDIR_VERT_TOP_RIGHT:
4268 4 : nVal = text::WritingMode2::TB_RL;
4269 4 : break;
4270 : case FRMDIR_VERT_TOP_LEFT:
4271 0 : nVal = text::WritingMode2::TB_LR;
4272 0 : break;
4273 : case FRMDIR_ENVIRONMENT:
4274 207 : nVal = text::WritingMode2::PAGE;
4275 207 : break;
4276 : default:
4277 : OSL_FAIL("Unknown SvxFrameDirection value!");
4278 0 : bRet = false;
4279 0 : break;
4280 : }
4281 :
4282 : // return value + error state
4283 2699 : if( bRet )
4284 : {
4285 2699 : rVal <<= nVal;
4286 : }
4287 2699 : return bRet;
4288 444 : }
4289 :
4290 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
