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