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