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