?  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 / paraitem.cxx
blobb03ce0d648f1d8317f9ea4dc9c195d61eaa87d6c
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/style/TabStop.hpp>
32 #include <com/sun/star/style/LineSpacing.hpp>
33 #include <com/sun/star/style/LineSpacingMode.hpp>
34 #include <com/sun/star/uno/Sequence.hxx>
35 #include <comphelper/processfactory.hxx>
36 #include <unotools/syslocale.hxx>
37 #include <comphelper/types.hxx>
38
39 using namespace ::rtl;
40 using namespace ::com::sun::star;
41
42 #include <tools/rtti.hxx>
43
44 #define _SVX_PARAITEM_CXX
45 #include <svl/itempool.hxx>
46
47 #include <svl/memberid.hrc>
48 #include <editeng/editrids.hrc>
49
50 #include <editeng/lspcitem.hxx>
51 #include <editeng/adjitem.hxx>
52 #include <editeng/orphitem.hxx>
53 #include <editeng/widwitem.hxx>
54 #include <editeng/tstpitem.hxx>
55 #include <editeng/pmdlitem.hxx>
56 #include <editeng/spltitem.hxx>
57 #include <editeng/hyznitem.hxx>
58 #include <editeng/scriptspaceitem.hxx>
59 #include <editeng/hngpnctitem.hxx>
60 #include <editeng/forbiddenruleitem.hxx>
61 #include <editeng/paravertalignitem.hxx>
62 #include <editeng/pgrditem.hxx>
63 #include <rtl/ustring.hxx>
64 #include <editeng/memberids.hrc>
65 #include <editeng/editids.hrc>
66 #include <editeng/itemtype.hxx>
67 #include <editeng/eerdll.hxx>
68 #include <editeng/paperinf.hxx>
69 #include <vcl/svapp.hxx>
70 #include <algorithm>
71
72 using namespace ::rtl;
73 using namespace ::com::sun::star;
74
75 // Konvertierung fuer UNO
76 #define TWIP_TO_MM100(TWIP) ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L))
77 #define TWIP_TO_MM100_UNSIGNED(TWIP) ((((TWIP)*127L+36L)/72L))
78 #define MM100_TO_TWIP(MM100) ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L))
79 #define MM100_TO_TWIP_UNSIGNED(MM100) ((((MM100)*72L+63L)/127L))
80
81
82 // STATIC DATA -----------------------------------------------------------
83
84
85 // -----------------------------------------------------------------------
86
87
88 TYPEINIT1_FACTORY(SvxLineSpacingItem, SfxPoolItem , new SvxLineSpacingItem(LINE_SPACE_DEFAULT_HEIGHT, 0));
89 TYPEINIT1_FACTORY(SvxAdjustItem, SfxPoolItem, new SvxAdjustItem(SVX_ADJUST_LEFT, 0));
90 TYPEINIT1_FACTORY(SvxWidowsItem, SfxByteItem, new SvxWidowsItem(0, 0));
91 TYPEINIT1_FACTORY(SvxOrphansItem, SfxByteItem, new SvxOrphansItem(0, 0));
92 TYPEINIT1_FACTORY(SvxHyphenZoneItem, SfxPoolItem, new SvxHyphenZoneItem(sal_False, 0));
93 TYPEINIT1_FACTORY(SvxTabStopItem, SfxPoolItem, new SvxTabStopItem(0));
94 TYPEINIT1_FACTORY(SvxFmtSplitItem, SfxBoolItem, new SvxFmtSplitItem(sal_False, 0));
95 TYPEINIT1_FACTORY(SvxPageModelItem, SfxStringItem, new SvxPageModelItem(0));
96 TYPEINIT1_FACTORY(SvxScriptSpaceItem, SfxBoolItem, new SvxScriptSpaceItem(sal_False, 0));
97 TYPEINIT1_FACTORY(SvxHangingPunctuationItem, SfxBoolItem, new SvxHangingPunctuationItem(sal_False, 0));
98 TYPEINIT1_FACTORY(SvxForbiddenRuleItem, SfxBoolItem, new SvxForbiddenRuleItem(sal_False, 0));
99 TYPEINIT1_FACTORY(SvxParaVertAlignItem, SfxUInt16Item, new SvxParaVertAlignItem(0, 0));
100 TYPEINIT1_FACTORY(SvxParaGridItem, SfxBoolItem, new SvxParaGridItem(sal_True, 0));
101
102 SV_IMPL_VARARR_SORT( SvxTabStopArr, SvxTabStop )
103
104 // -----------------------------------------------------------------------
105
106 SvxLineSpacingItem::SvxLineSpacingItem( sal_uInt16 nHeight, const sal_uInt16 nId )
107 : SfxEnumItemInterface( nId )
108 {
109 nPropLineSpace = 100;
110 nInterLineSpace = 0;
111 nLineHeight = nHeight;
112 eLineSpace = SVX_LINE_SPACE_AUTO;
113 eInterLineSpace = SVX_INTER_LINE_SPACE_OFF;
114 }
115
116 // -----------------------------------------------------------------------
117
118 int SvxLineSpacingItem::operator==( const SfxPoolItem& rAttr ) const
119 {
120 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
121
122 const SvxLineSpacingItem& rLineSpace = (const SvxLineSpacingItem&)rAttr;
123 return (
124 // Same Linespacing Rule?
125 (eLineSpace == rLineSpace.eLineSpace)
126 // For maximum and minimum Linespacing be the size must coincide.
127 && (eLineSpace == SVX_LINE_SPACE_AUTO ||
128 nLineHeight == rLineSpace.nLineHeight)
129 // Same Linespacing Rule?
130 && ( eInterLineSpace == rLineSpace.eInterLineSpace )
131 // Either set proportional or additive.
132 && (( eInterLineSpace == SVX_INTER_LINE_SPACE_OFF)
133 || (eInterLineSpace == SVX_INTER_LINE_SPACE_PROP
134 && nPropLineSpace == rLineSpace.nPropLineSpace)
135 || (eInterLineSpace == SVX_INTER_LINE_SPACE_FIX
136 && (nInterLineSpace == rLineSpace.nInterLineSpace)))) ?
137 1 : 0;
138 }
139
140 /* Who does still know why the LineSpacingItem is so complicated?
141 We can not use it for UNO since there are only two values:
142 - ein sal_uInt16 for the mode
143 - ein sal_uInt32 for all values (distance, height, rel. detail)
144 */
145 bool SvxLineSpacingItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
146 {
147 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
148 nMemberId &= ~CONVERT_TWIPS;
149
150 style::LineSpacing aLSp;
151 switch( eLineSpace )
152 {
153 case SVX_LINE_SPACE_AUTO:
154 if(eInterLineSpace == SVX_INTER_LINE_SPACE_FIX)
155 {
156 aLSp.Mode = style::LineSpacingMode::LEADING;
157 aLSp.Height = ( bConvert ? (short)TWIP_TO_MM100(nInterLineSpace) : nInterLineSpace);
158 }
159 else if(eInterLineSpace == SVX_INTER_LINE_SPACE_OFF)
160 {
161 aLSp.Mode = style::LineSpacingMode::PROP;
162 aLSp.Height = 100;
163 }
164 else
165 {
166 aLSp.Mode = style::LineSpacingMode::PROP;
167 aLSp.Height = nPropLineSpace;
168 }
169 break;
170 case SVX_LINE_SPACE_FIX :
171 case SVX_LINE_SPACE_MIN :
172 aLSp.Mode = eLineSpace == SVX_LINE_SPACE_FIX ? style::LineSpacingMode::FIX : style::LineSpacingMode::MINIMUM;
173 aLSp.Height = ( bConvert ? (short)TWIP_TO_MM100_UNSIGNED(nLineHeight) : nLineHeight );
174 break;
175 default:
176 ;//prevent warning about SVX_LINE_SPACE_END
177 }
178
179 switch ( nMemberId )
180 {
181 case 0 : rVal <<= aLSp; break;
182 case MID_LINESPACE : rVal <<= aLSp.Mode; break;
183 case MID_HEIGHT : rVal <<= aLSp.Height; break;
184 default: OSL_FAIL("Wrong MemberId!"); break;
185 }
186
187 return true;
188 }
189
190 bool SvxLineSpacingItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
191 {
192 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
193 nMemberId &= ~CONVERT_TWIPS;
194
195 // fill with current data
196 style::LineSpacing aLSp;
197 uno::Any aAny;
198 sal_Bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aLSp );
199
200 // get new data
201 switch ( nMemberId )
202 {
203 case 0 : bRet = (rVal >>= aLSp); break;
204 case MID_LINESPACE : bRet = (rVal >>= aLSp.Mode); break;
205 case MID_HEIGHT : bRet = (rVal >>= aLSp.Height); break;
206 default: OSL_FAIL("Wrong MemberId!"); break;
207 }
208
209 if( bRet )
210 {
211 nLineHeight = aLSp.Height;
212 switch( aLSp.Mode )
213 {
214 case style::LineSpacingMode::LEADING:
215 {
216 eInterLineSpace = SVX_INTER_LINE_SPACE_FIX;
217 eLineSpace = SVX_LINE_SPACE_AUTO;
218 nInterLineSpace = aLSp.Height;
219 if(bConvert)
220 nInterLineSpace = (short)MM100_TO_TWIP(nInterLineSpace);
221
222 }
223 break;
224 case style::LineSpacingMode::PROP:
225 {
226 eLineSpace = SVX_LINE_SPACE_AUTO;
227 nPropLineSpace = (sal_Int8)std::min(aLSp.Height, (short)0xFF);
228 if(100 == aLSp.Height)
229 eInterLineSpace = SVX_INTER_LINE_SPACE_OFF;
230 else
231 eInterLineSpace = SVX_INTER_LINE_SPACE_PROP;
232 }
233 break;
234 case style::LineSpacingMode::FIX:
235 case style::LineSpacingMode::MINIMUM:
236 {
237 eInterLineSpace = SVX_INTER_LINE_SPACE_OFF;
238 eLineSpace = aLSp.Mode == style::LineSpacingMode::FIX ? SVX_LINE_SPACE_FIX : SVX_LINE_SPACE_MIN;
239 nLineHeight = aLSp.Height;
240 if(bConvert)
241 nLineHeight = (sal_uInt16)MM100_TO_TWIP_UNSIGNED(nLineHeight);
242 }
243 break;
244 }
245 }
246
247 return bRet;
248 }
249
250 // -----------------------------------------------------------------------
251
252 SfxPoolItem* SvxLineSpacingItem::Clone( SfxItemPool * ) const
253 {
254 return new SvxLineSpacingItem( *this );
255 }
256
257 //------------------------------------------------------------------------
258
259 SfxItemPresentation SvxLineSpacingItem::GetPresentation
260 (
261 SfxItemPresentation /*ePres*/,
262 SfxMapUnit /*eCoreUnit*/,
263 SfxMapUnit /*ePresUnit*/,
264 XubString& rText, const IntlWrapper *
265 ) const
266 {
267 #ifdef DBG_UTIL
268 rText.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "SvxLineSpacingItem" ));
269 #else
270 rText.Erase();
271 #endif
272 return SFX_ITEM_PRESENTATION_NONE;
273 }
274
275 // -----------------------------------------------------------------------
276
277 SfxPoolItem* SvxLineSpacingItem::Create(SvStream& rStrm, sal_uInt16) const
278 {
279 sal_Int8 nPropSpace;
280 short nInterSpace;
281 sal_uInt16 nHeight;
282 sal_Int8 nRule, nInterRule;
283
284 rStrm >> nPropSpace
285 >> nInterSpace
286 >> nHeight
287 >> nRule
288 >> nInterRule;
289
290 SvxLineSpacingItem* pAttr = new SvxLineSpacingItem( nHeight, Which() );
291 pAttr->SetInterLineSpace( nInterSpace );
292 pAttr->SetPropLineSpace( nPropSpace );
293 pAttr->GetLineSpaceRule() = (SvxLineSpace)nRule;
294 pAttr->GetInterLineSpaceRule() = (SvxInterLineSpace)nInterRule;
295 return pAttr;
296 }
297
298 // -----------------------------------------------------------------------
299
300 SvStream& SvxLineSpacingItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
301 {
302 rStrm << (sal_Int8) GetPropLineSpace()
303 << (short) GetInterLineSpace()
304 << (sal_uInt16) GetLineHeight()
305 << (sal_Int8) GetLineSpaceRule()
306 << (sal_Int8) GetInterLineSpaceRule();
307 return rStrm;
308 }
309
310 // -----------------------------------------------------------------------
311
312 sal_uInt16 SvxLineSpacingItem::GetValueCount() const
313 {
314 return SVX_LINESPACE_END; // SVX_LINESPACE_TWO_LINES + 1
315 }
316
317 // -----------------------------------------------------------------------
318
319 rtl::OUString SvxLineSpacingItem::GetValueTextByPos( sal_uInt16 nPos ) const
320 {
321 //! load strings from resource
322 rtl::OUString aText;
323 switch ( nPos )
324 {
325 case SVX_LINESPACE_USER:
326 aText = "User";
327 break;
328 case SVX_LINESPACE_ONE_LINE:
329 aText = "One line";
330 break;
331 case SVX_LINESPACE_ONE_POINT_FIVE_LINES:
332 aText = "1.5 line";
333 break;
334 case SVX_LINESPACE_TWO_LINES:
335 aText = "Two lines";
336 break;
337 }
338 return aText;
339 }
340
341 // -----------------------------------------------------------------------
342
343 sal_uInt16 SvxLineSpacingItem::GetEnumValue() const
344 {
345 sal_uInt16 nVal;
346 switch ( nPropLineSpace )
347 {
348 case 100: nVal = SVX_LINESPACE_ONE_LINE; break;
349 case 150: nVal = SVX_LINESPACE_ONE_POINT_FIVE_LINES; break;
350 case 200: nVal = SVX_LINESPACE_TWO_LINES; break;
351 default: nVal = SVX_LINESPACE_USER; break;
352 }
353 return nVal;
354 }
355
356 // -----------------------------------------------------------------------
357
358 void SvxLineSpacingItem::SetEnumValue( sal_uInt16 nVal )
359 {
360 switch ( nVal )
361 {
362 case SVX_LINESPACE_ONE_LINE: nPropLineSpace = 100; break;
363 case SVX_LINESPACE_ONE_POINT_FIVE_LINES: nPropLineSpace = 150; break;
364 case SVX_LINESPACE_TWO_LINES: nPropLineSpace = 200; break;
365 }
366 }
367
368 // class SvxAdjustItem ---------------------------------------------------
369
370 SvxAdjustItem::SvxAdjustItem(const SvxAdjust eAdjst, const sal_uInt16 nId )
371 : SfxEnumItemInterface( nId ),
372 bOneBlock( sal_False ), bLastCenter( sal_False ), bLastBlock( sal_False )
373 {
374 SetAdjust( eAdjst );
375 }
376
377 // -----------------------------------------------------------------------
378
379 int SvxAdjustItem::operator==( const SfxPoolItem& rAttr ) const
380 {
381 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
382
383 return( ( GetAdjust() == ((SvxAdjustItem&)rAttr).GetAdjust() &&
384 bOneBlock == ((SvxAdjustItem&)rAttr).bOneBlock &&
385 bLastCenter == ((SvxAdjustItem&)rAttr).bLastCenter &&
386 bLastBlock == ((SvxAdjustItem&)rAttr).bLastBlock )
387 ? 1 : 0 );
388 }
389
390 bool SvxAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
391 {
392 nMemberId &= ~CONVERT_TWIPS;
393 switch( nMemberId )
394 {
395 case MID_PARA_ADJUST : rVal <<= (sal_Int16)GetAdjust(); break;
396 case MID_LAST_LINE_ADJUST : rVal <<= (sal_Int16)GetLastBlock(); break;
397 case MID_EXPAND_SINGLE :
398 {
399 sal_Bool bValue = bOneBlock;
400 rVal.setValue( &bValue, ::getCppuBooleanType() );
401 break;
402 }
403 default: ;//prevent warning
404 }
405 return true;
406 }
407
408 bool SvxAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
409 {
410 nMemberId &= ~CONVERT_TWIPS;
411 switch( nMemberId )
412 {
413 case MID_PARA_ADJUST :
414 case MID_LAST_LINE_ADJUST :
415 {
416 sal_Int32 eVal = - 1;
417 try
418 {
419 eVal = ::comphelper::getEnumAsINT32(rVal);
420 }
421 catch(...) {}
422 if(eVal >= 0 && eVal <= 4)
423 {
424 if(MID_LAST_LINE_ADJUST == nMemberId &&
425 eVal != SVX_ADJUST_LEFT &&
426 eVal != SVX_ADJUST_BLOCK &&
427 eVal != SVX_ADJUST_CENTER)
428 return sal_False;
429 if(eVal < (sal_uInt16)SVX_ADJUST_END)
430 nMemberId == MID_PARA_ADJUST ?
431 SetAdjust((SvxAdjust)eVal) :
432 SetLastBlock((SvxAdjust)eVal);
433 }
434 }
435 break;
436 case MID_EXPAND_SINGLE :
437 bOneBlock = Any2Bool(rVal);
438 break;
439 }
440 return true;
441 }
442
443 // -----------------------------------------------------------------------
444
445 SfxPoolItem* SvxAdjustItem::Clone( SfxItemPool * ) const
446 {
447 return new SvxAdjustItem( *this );
448 }
449
450 //------------------------------------------------------------------------
451
452 SfxItemPresentation SvxAdjustItem::GetPresentation
453 (
454 SfxItemPresentation ePres,
455 SfxMapUnit /*eCoreUnit*/,
456 SfxMapUnit /*ePresUnit*/,
457 XubString& rText, const IntlWrapper *
458 ) const
459 {
460 switch ( ePres )
461 {
462 case SFX_ITEM_PRESENTATION_NONE:
463 rText.Erase();
464 return SFX_ITEM_PRESENTATION_NONE;
465 case SFX_ITEM_PRESENTATION_NAMELESS:
466 case SFX_ITEM_PRESENTATION_COMPLETE:
467 rText = GetValueTextByPos( (sal_uInt16)GetAdjust() );
468 return ePres;
469 default: ;//prevent warning
470 }
471 return SFX_ITEM_PRESENTATION_NONE;
472 }
473
474 // -----------------------------------------------------------------------
475
476 sal_uInt16 SvxAdjustItem::GetValueCount() const
477 {
478 return SVX_ADJUST_END; // SVX_ADJUST_BLOCKLINE + 1
479 }
480
481 // -----------------------------------------------------------------------
482
483 rtl::OUString SvxAdjustItem::GetValueTextByPos( sal_uInt16 nPos ) const
484 {
485 DBG_ASSERT( nPos <= (sal_uInt16)SVX_ADJUST_BLOCKLINE, "enum overflow!" );
486 return EE_RESSTR(RID_SVXITEMS_ADJUST_BEGIN + nPos);
487 }
488
489 // -----------------------------------------------------------------------
490
491 sal_uInt16 SvxAdjustItem::GetEnumValue() const
492 {
493 return (sal_uInt16)GetAdjust();
494 }
495
496 // -----------------------------------------------------------------------
497
498 void SvxAdjustItem::SetEnumValue( sal_uInt16 nVal )
499 {
500 SetAdjust( (const SvxAdjust)nVal );
501 }
502
503 // -----------------------------------------------------------------------
504
505 sal_uInt16 SvxAdjustItem::GetVersion( sal_uInt16 nFileVersion ) const
506 {
507 return (nFileVersion == SOFFICE_FILEFORMAT_31)
508 ? 0 : ADJUST_LASTBLOCK_VERSION;
509 }
510
511 // -----------------------------------------------------------------------
512
513 SfxPoolItem* SvxAdjustItem::Create(SvStream& rStrm, sal_uInt16 nVersion) const
514 {
515 char eAdjustment;
516 rStrm >> eAdjustment;
517 SvxAdjustItem *pRet = new SvxAdjustItem( (SvxAdjust)eAdjustment, Which() );
518 if( nVersion >= ADJUST_LASTBLOCK_VERSION )
519 {
520 sal_Int8 nFlags;
521 rStrm >> nFlags;
522 pRet->bOneBlock = 0 != (nFlags & 0x0001);
523 pRet->bLastCenter = 0 != (nFlags & 0x0002);
524 pRet->bLastBlock = 0 != (nFlags & 0x0004);
525 }
526 return pRet;
527 }
528
529 // -----------------------------------------------------------------------
530
531 SvStream& SvxAdjustItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const
532 {
533 rStrm << (char)GetAdjust();
534 if ( nItemVersion >= ADJUST_LASTBLOCK_VERSION )
535 {
536 sal_Int8 nFlags = 0;
537 if ( bOneBlock )
538 nFlags |= 0x0001;
539 if ( bLastCenter )
540 nFlags |= 0x0002;
541 if ( bLastBlock )
542 nFlags |= 0x0004;
543 rStrm << (sal_Int8) nFlags;
544 }
545 return rStrm;
546 }
547
548 // class SvxWidowsItem ---------------------------------------------------
549
550 SvxWidowsItem::SvxWidowsItem(const sal_uInt8 nL, const sal_uInt16 nId ) :
551 SfxByteItem( nId, nL )
552 {
553 }
554
555 // -----------------------------------------------------------------------
556
557 SfxPoolItem* SvxWidowsItem::Clone( SfxItemPool * ) const
558 {
559 return new SvxWidowsItem( *this );
560 }
561
562 // -----------------------------------------------------------------------
563
564 SfxPoolItem* SvxWidowsItem::Create(SvStream& rStrm, sal_uInt16) const
565 {
566 sal_Int8 nLines;
567 rStrm >> nLines;
568 return new SvxWidowsItem( nLines, Which() );
569 }
570
571 // -----------------------------------------------------------------------
572
573 SvStream& SvxWidowsItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
574 {
575 rStrm << (sal_Int8)GetValue();
576 return rStrm;
577 }
578
579 //------------------------------------------------------------------------
580
581 SfxItemPresentation SvxWidowsItem::GetPresentation
582 (
583 SfxItemPresentation ePres,
584 SfxMapUnit /*eCoreUnit*/,
585 SfxMapUnit /*ePresUnit*/,
586 XubString& rText, const IntlWrapper *
587 ) const
588 {
589 switch ( ePres )
590 {
591 case SFX_ITEM_PRESENTATION_NONE:
592 {
593 rText.Erase();
594 break;
595 }
596
597 case SFX_ITEM_PRESENTATION_NAMELESS:
598 {
599 rText = EE_RESSTR(RID_SVXITEMS_LINES);
600 break;
601 }
602
603 case SFX_ITEM_PRESENTATION_COMPLETE:
604 {
605 rText = EE_RESSTR(RID_SVXITEMS_WIDOWS_COMPLETE);
606 rText += ' ';
607 rText += EE_RESSTR(RID_SVXITEMS_LINES);
608 }
609
610 default:
611 {
612 SAL_WARN( "editeng.items", "SvxWidowsItem::GetPresentation(): unknown SfxItemPresentation" );
613 }
614 }
615
616 rText.SearchAndReplace( String::CreateFromAscii( "%1" ), String::CreateFromInt32( GetValue() ) );
617 return ePres;
618 }
619
620 // class SvxOrphansItem --------------------------------------------------
621
622 SvxOrphansItem::SvxOrphansItem(const sal_uInt8 nL, const sal_uInt16 nId ) :
623 SfxByteItem( nId, nL )
624 {
625 }
626
627 // -----------------------------------------------------------------------
628
629 SfxPoolItem* SvxOrphansItem::Clone( SfxItemPool * ) const
630 {
631 return new SvxOrphansItem( *this );
632 }
633
634 // -----------------------------------------------------------------------
635
636 SfxPoolItem* SvxOrphansItem::Create(SvStream& rStrm, sal_uInt16) const
637 {
638 sal_Int8 nLines;
639 rStrm >> nLines;
640 return new SvxOrphansItem( nLines, Which() );
641 }
642
643 // -----------------------------------------------------------------------
644
645 SvStream& SvxOrphansItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
646 {
647 rStrm << (sal_Int8) GetValue();
648 return rStrm;
649 }
650
651 //------------------------------------------------------------------------
652
653 SfxItemPresentation SvxOrphansItem::GetPresentation
654 (
655 SfxItemPresentation ePres,
656 SfxMapUnit /*eCoreUnit*/,
657 SfxMapUnit /*ePresUnit*/,
658 XubString& rText, const IntlWrapper *
659 ) const
660 {
661 switch ( ePres )
662 {
663 case SFX_ITEM_PRESENTATION_NONE:
664 {
665 rText.Erase();
666 break;
667 }
668
669 case SFX_ITEM_PRESENTATION_NAMELESS:
670 {
671 rText = EE_RESSTR(RID_SVXITEMS_LINES);
672 break;
673 }
674
675 case SFX_ITEM_PRESENTATION_COMPLETE:
676 {
677 rText = EE_RESSTR(RID_SVXITEMS_ORPHANS_COMPLETE);
678 rText += ' ';
679 rText += EE_RESSTR(RID_SVXITEMS_LINES);
680 }
681
682 default:
683 {
684 SAL_WARN( "editeng.items", "SvxOrphansItem::GetPresentation(): unknown SfxItemPresentation" );
685 }
686 }
687
688 rText.SearchAndReplace( String::CreateFromAscii( "%1" ), String::CreateFromInt32( GetValue() ) );
689 return ePres;
690 }
691
692 // class SvxHyphenZoneItem -----------------------------------------------
693
694 SvxHyphenZoneItem::SvxHyphenZoneItem( const sal_Bool bHyph, const sal_uInt16 nId ) :
695 SfxPoolItem( nId )
696 {
697 bHyphen = bHyph;
698 bPageEnd = sal_True;
699 nMinLead = nMinTrail = 0;
700 nMaxHyphens = 255;
701 }
702
703 // -----------------------------------------------------------------------
704 bool SvxHyphenZoneItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
705 {
706 nMemberId &= ~CONVERT_TWIPS;
707 switch(nMemberId)
708 {
709 case MID_IS_HYPHEN:
710 rVal = Bool2Any(bHyphen);
711 break;
712 case MID_HYPHEN_MIN_LEAD:
713 rVal <<= (sal_Int16)nMinLead;
714 break;
715 case MID_HYPHEN_MIN_TRAIL:
716 rVal <<= (sal_Int16)nMinTrail;
717 break;
718 case MID_HYPHEN_MAX_HYPHENS:
719 rVal <<= (sal_Int16)nMaxHyphens;
720 break;
721 }
722 return true;
723 }
724 // -----------------------------------------------------------------------
725 bool SvxHyphenZoneItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
726 {
727 nMemberId &= ~CONVERT_TWIPS;
728 sal_Int16 nNewVal = 0;
729
730 if( nMemberId != MID_IS_HYPHEN )
731 if(!(rVal >>= nNewVal))
732 return false;
733
734 switch(nMemberId)
735 {
736 case MID_IS_HYPHEN:
737 bHyphen = Any2Bool(rVal);
738 break;
739 case MID_HYPHEN_MIN_LEAD:
740 nMinLead = (sal_uInt8)nNewVal;
741 break;
742 case MID_HYPHEN_MIN_TRAIL:
743 nMinTrail = (sal_uInt8)nNewVal;
744 break;
745 case MID_HYPHEN_MAX_HYPHENS:
746 nMaxHyphens = (sal_uInt8)nNewVal;
747 break;
748 }
749 return true;
750 }
751
752 // -----------------------------------------------------------------------
753
754 int SvxHyphenZoneItem::operator==( const SfxPoolItem& rAttr ) const
755 {
756 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
757
758 return ( (((SvxHyphenZoneItem&)rAttr).bHyphen == bHyphen)
759 && (((SvxHyphenZoneItem&)rAttr).bPageEnd == bPageEnd)
760 && (((SvxHyphenZoneItem&)rAttr).nMinLead == nMinLead)
761 && (((SvxHyphenZoneItem&)rAttr).nMinTrail == nMinTrail)
762 && (((SvxHyphenZoneItem&)rAttr).nMaxHyphens == nMaxHyphens) );
763 }
764
765 // -----------------------------------------------------------------------
766
767 SfxPoolItem* SvxHyphenZoneItem::Clone( SfxItemPool * ) const
768 {
769 return new SvxHyphenZoneItem( *this );
770 }
771
772 //------------------------------------------------------------------------
773
774 SfxItemPresentation SvxHyphenZoneItem::GetPresentation
775 (
776 SfxItemPresentation ePres,
777 SfxMapUnit /*eCoreUnit*/,
778 SfxMapUnit /*ePresUnit*/,
779 XubString& rText, const IntlWrapper *
780 ) const
781 {
782 switch ( ePres )
783 {
784 case SFX_ITEM_PRESENTATION_NONE:
785 rText.Erase();
786 return SFX_ITEM_PRESENTATION_NONE;
787 case SFX_ITEM_PRESENTATION_NAMELESS:
788 {
789 sal_uInt16 nId = RID_SVXITEMS_HYPHEN_FALSE;
790
791 if ( bHyphen )
792 nId = RID_SVXITEMS_HYPHEN_TRUE;
793 rText = EE_RESSTR(nId);
794 rText += cpDelim;
795 nId = RID_SVXITEMS_PAGE_END_FALSE;
796
797 if ( bPageEnd )
798 nId = RID_SVXITEMS_PAGE_END_TRUE;
799 rText += EE_RESSTR(nId);
800 rText += cpDelim;
801 rText += String::CreateFromInt32( nMinLead );
802 rText += cpDelim;
803 rText += String::CreateFromInt32( nMinTrail );
804 rText += cpDelim;
805 rText += String::CreateFromInt32( nMaxHyphens );
806 return SFX_ITEM_PRESENTATION_COMPLETE;
807 }
808 case SFX_ITEM_PRESENTATION_COMPLETE:
809 {
810 sal_uInt16 nId = RID_SVXITEMS_HYPHEN_FALSE;
811
812 if ( bHyphen )
813 nId = RID_SVXITEMS_HYPHEN_TRUE;
814 rText = EE_RESSTR(nId);
815 rText += cpDelim;
816 nId = RID_SVXITEMS_PAGE_END_FALSE;
817
818 if ( bPageEnd )
819 nId = RID_SVXITEMS_PAGE_END_TRUE;
820 rText += EE_RESSTR(nId);
821 rText += cpDelim;
822 rText += String::CreateFromInt32(nMinLead);
823 rText += EE_RESSTR(RID_SVXITEMS_HYPHEN_MINLEAD);
824 rText += cpDelim;
825 rText += String::CreateFromInt32(nMinTrail);
826 rText += EE_RESSTR(RID_SVXITEMS_HYPHEN_MINTRAIL);
827 rText += cpDelim;
828 rText += String::CreateFromInt32(nMaxHyphens);
829 rText += EE_RESSTR(RID_SVXITEMS_HYPHEN_MAX);
830 return SFX_ITEM_PRESENTATION_COMPLETE;
831 }
832 default: ;//prevent warning
833 }
834 return SFX_ITEM_PRESENTATION_NONE;
835 }
836
837 // -----------------------------------------------------------------------
838
839 SfxPoolItem* SvxHyphenZoneItem::Create(SvStream& rStrm, sal_uInt16) const
840 {
841 sal_Int8 _bHyphen, _bHyphenPageEnd;
842 sal_Int8 _nMinLead, _nMinTrail, _nMaxHyphens;
843 rStrm >> _bHyphen >> _bHyphenPageEnd >> _nMinLead >> _nMinTrail >> _nMaxHyphens;
844 SvxHyphenZoneItem* pAttr = new SvxHyphenZoneItem( sal_False, Which() );
845 pAttr->SetHyphen( sal_Bool( _bHyphen != 0 ) );
846 pAttr->SetPageEnd( sal_Bool( _bHyphenPageEnd != 0 ) );
847 pAttr->GetMinLead() = _nMinLead;
848 pAttr->GetMinTrail() = _nMinTrail;
849 pAttr->GetMaxHyphens() = _nMaxHyphens;
850 return pAttr;
851 }
852
853 // -----------------------------------------------------------------------
854
855 SvStream& SvxHyphenZoneItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
856 {
857 rStrm << (sal_Int8) IsHyphen()
858 << (sal_Int8) IsPageEnd()
859 << (sal_Int8) GetMinLead()
860 << (sal_Int8) GetMinTrail()
861 << (sal_Int8) GetMaxHyphens();
862 return rStrm;
863 }
864
865 // class SvxTabStop ------------------------------------------------------
866
867 SvxTabStop::SvxTabStop()
868 {
869 nTabPos = 0;
870 eAdjustment = SVX_TAB_ADJUST_LEFT;
871 m_cDecimal = cDfltDecimalChar;
872 cFill = cDfltFillChar;
873 }
874
875 // -----------------------------------------------------------------------
876
877 SvxTabStop::SvxTabStop( const sal_Int32 nPos, const SvxTabAdjust eAdjst,
878 const sal_Unicode cDec, const sal_Unicode cFil )
879 {
880 nTabPos = nPos;
881 eAdjustment = eAdjst;
882 m_cDecimal = cDec;
883 cFill = cFil;
884 }
885 // -----------------------------------------------------------------------------
886 void SvxTabStop::fillDecimal() const
887 {
888 if ( cDfltDecimalChar == m_cDecimal )
889 m_cDecimal = SvtSysLocale().GetLocaleData().getNumDecimalSep().GetChar(0);
890 }
891 // -----------------------------------------------------------------------
892
893 XubString SvxTabStop::GetValueString() const
894 {
895 XubString aStr;
896
897 aStr += sal_Unicode( '(' );
898 aStr += rtl::OUString::valueOf(static_cast<sal_Int32>(nTabPos));
899 aStr += cpDelim;
900 aStr += EE_RESSTR(RID_SVXITEMS_TAB_ADJUST_BEGIN + (sal_uInt16)eAdjustment);
901
902 aStr += cpDelim;
903 aStr += sal_Unicode('[');
904 aStr += EE_RESSTR(RID_SVXITEMS_TAB_DECIMAL_CHAR);
905 aStr += GetDecimal();
906 aStr += sal_Unicode(']');
907 aStr += cpDelim;
908 aStr += cpDelim;
909 aStr += sal_Unicode('[');
910 aStr += EE_RESSTR(RID_SVXITEMS_TAB_FILL_CHAR);
911 aStr += cFill;
912 aStr += sal_Unicode(']');
913 aStr += sal_Unicode(')');
914
915 return aStr;
916 }
917
918 // class SvxTabStopItem --------------------------------------------------
919
920 SvxTabStopItem::SvxTabStopItem( sal_uInt16 _nWhich ) :
921 SfxPoolItem( _nWhich ),
922 SvxTabStopArr( sal_Int8(SVX_TAB_DEFCOUNT) )
923 {
924 const sal_uInt16 nTabs = SVX_TAB_DEFCOUNT, nDist = SVX_TAB_DEFDIST;
925 const SvxTabAdjust eAdjst= SVX_TAB_ADJUST_DEFAULT;
926
927 for (sal_uInt16 i = 0; i < nTabs; ++i)
928 {
929 SvxTabStop aTab( (i + 1) * nDist, eAdjst );
930 SvxTabStopArr::Insert( aTab );
931 }
932 }
933
934 // -----------------------------------------------------------------------
935
936 SvxTabStopItem::SvxTabStopItem( const sal_uInt16 nTabs,
937 const sal_uInt16 nDist,
938 const SvxTabAdjust eAdjst,
939 sal_uInt16 _nWhich ) :
940 SfxPoolItem( _nWhich ),
941 SvxTabStopArr( sal_Int8(nTabs) )
942 {
943 for ( sal_uInt16 i = 0; i < nTabs; ++i )
944 {
945 SvxTabStop aTab( (i + 1) * nDist, eAdjst );
946 SvxTabStopArr::Insert( aTab );
947 }
948 }
949
950 // -----------------------------------------------------------------------
951
952 SvxTabStopItem::SvxTabStopItem( const SvxTabStopItem& rTSI ) :
953 SfxPoolItem( rTSI.Which() ),
954 SvxTabStopArr( (sal_Int8)rTSI.Count() )
955 {
956 SvxTabStopArr::Insert( &rTSI );
957 }
958
959 // -----------------------------------------------------------------------
960
961 sal_uInt16 SvxTabStopItem::GetPos( const SvxTabStop& rTab ) const
962 {
963 sal_uInt16 nFound;
964 return Seek_Entry( rTab, &nFound ) ? nFound : SVX_TAB_NOTFOUND;
965 }
966
967 // -----------------------------------------------------------------------
968
969 sal_uInt16 SvxTabStopItem::GetPos( const sal_Int32 nPos ) const
970 {
971 sal_uInt16 nFound;
972 return Seek_Entry( SvxTabStop( nPos ), &nFound ) ? nFound : SVX_TAB_NOTFOUND;
973 }
974
975 // -----------------------------------------------------------------------
976
977 SvxTabStopItem& SvxTabStopItem::operator=( const SvxTabStopItem& rTSI )
978 {
979 Remove( 0, Count() );
980 SvxTabStopArr::Insert( &rTSI );
981 return *this;
982 }
983
984 bool SvxTabStopItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
985 {
986 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
987 nMemberId &= ~CONVERT_TWIPS;
988 switch ( nMemberId )
989 {
990 case MID_TABSTOPS:
991 {
992 sal_uInt16 nCount = Count();
993 uno::Sequence< style::TabStop> aSeq(nCount);
994 style::TabStop* pArr = aSeq.getArray();
995 for(sal_uInt16 i = 0; i < nCount; i++)
996 {
997 const SvxTabStop& rTab = *(GetStart() + i);
998 pArr[i].Position = bConvert ? TWIP_TO_MM100(rTab.GetTabPos()) : rTab.GetTabPos();
999 switch(rTab.GetAdjustment())
1000 {
1001 case SVX_TAB_ADJUST_LEFT : pArr[i].Alignment = style::TabAlign_LEFT; break;
1002 case SVX_TAB_ADJUST_RIGHT : pArr[i].Alignment = style::TabAlign_RIGHT; break;
1003 case SVX_TAB_ADJUST_DECIMAL: pArr[i].Alignment = style::TabAlign_DECIMAL; break;
1004 case SVX_TAB_ADJUST_CENTER : pArr[i].Alignment = style::TabAlign_CENTER; break;
1005 default: //SVX_TAB_ADJUST_DEFAULT
1006 pArr[i].Alignment = style::TabAlign_DEFAULT;
1007
1008 }
1009 pArr[i].DecimalChar = rTab.GetDecimal();
1010 pArr[i].FillChar = rTab.GetFill();
1011 }
1012 rVal <<= aSeq;
1013 break;
1014 }
1015 case MID_STD_TAB:
1016 {
1017 const SvxTabStop &rTab = *(GetStart());
1018 rVal <<= (static_cast<sal_Int32>(bConvert ? TWIP_TO_MM100(rTab.GetTabPos()) : rTab.GetTabPos()));
1019 break;
1020 }
1021 }
1022 return sal_True;
1023 }
1024
1025 bool SvxTabStopItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1026 {
1027 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1028 nMemberId &= ~CONVERT_TWIPS;
1029 switch ( nMemberId )
1030 {
1031 case MID_TABSTOPS:
1032 {
1033 uno::Sequence< style::TabStop> aSeq;
1034 if(!(rVal >>= aSeq))
1035 {
1036 uno::Sequence < uno::Sequence < uno::Any > > aAnySeq;
1037 if (!(rVal >>= aAnySeq))
1038 return sal_False;
1039 sal_Int32 nLength = aAnySeq.getLength();
1040 aSeq.realloc( nLength );
1041 for ( sal_Int32 n=0; n<nLength; n++ )
1042 {
1043 uno::Sequence < uno::Any >& rAnySeq = aAnySeq[n];
1044 if ( rAnySeq.getLength() == 4 )
1045 {
1046 if (!(rAnySeq[0] >>= aSeq[n].Position)) return sal_False;
1047 if (!(rAnySeq[1] >>= aSeq[n].Alignment))
1048 {
1049 sal_Int32 nVal = 0;
1050 if (rAnySeq[1] >>= nVal)
1051 aSeq[n].Alignment = (com::sun::star::style::TabAlign) nVal;
1052 else
1053 return sal_False;
1054 }
1055 if (!(rAnySeq[2] >>= aSeq[n].DecimalChar))
1056 {
1057 ::rtl::OUString aVal;
1058 if ( (rAnySeq[2] >>= aVal) && aVal.getLength() == 1 )
1059 aSeq[n].DecimalChar = aVal.toChar();
1060 else
1061 return sal_False;
1062 }
1063 if (!(rAnySeq[3] >>= aSeq[n].FillChar))
1064 {
1065 ::rtl::OUString aVal;
1066 if ( (rAnySeq[3] >>= aVal) && aVal.getLength() == 1 )
1067 aSeq[n].FillChar = aVal.toChar();
1068 else
1069 return sal_False;
1070 }
1071 }
1072 else
1073 return sal_False;
1074 }
1075 }
1076
1077 SvxTabStopArr::Remove( 0, Count() );
1078 const style::TabStop* pArr = aSeq.getConstArray();
1079 const sal_uInt16 nCount = (sal_uInt16)aSeq.getLength();
1080 for(sal_uInt16 i = 0; i < nCount ; i++)
1081 {
1082 SvxTabAdjust eAdjust = SVX_TAB_ADJUST_DEFAULT;
1083 switch(pArr[i].Alignment)
1084 {
1085 case style::TabAlign_LEFT : eAdjust = SVX_TAB_ADJUST_LEFT; break;
1086 case style::TabAlign_CENTER : eAdjust = SVX_TAB_ADJUST_CENTER; break;
1087 case style::TabAlign_RIGHT : eAdjust = SVX_TAB_ADJUST_RIGHT; break;
1088 case style::TabAlign_DECIMAL: eAdjust = SVX_TAB_ADJUST_DECIMAL; break;
1089 default: ;//prevent warning
1090 }
1091 sal_Unicode cFill = pArr[i].FillChar;
1092 sal_Unicode cDecimal = pArr[i].DecimalChar;
1093 SvxTabStop aTab( bConvert ? MM100_TO_TWIP(pArr[i].Position) : pArr[i].Position,
1094 eAdjust,
1095 cDecimal,
1096 cFill );
1097 Insert(aTab);
1098 }
1099 break;
1100 }
1101 case MID_STD_TAB:
1102 {
1103 sal_Int32 nNewPos = 0;
1104 if (!(rVal >>= nNewPos) )
1105 return sal_False;
1106 if (bConvert)
1107 nNewPos = MM100_TO_TWIP ( nNewPos );
1108 if (nNewPos <= 0)
1109 return sal_False;
1110 const SvxTabStop& rTab = *(GetStart());
1111 SvxTabStop aNewTab ( nNewPos, rTab.GetAdjustment(), rTab.GetDecimal(), rTab.GetFill() );
1112 Remove ( 0 );
1113 Insert( aNewTab );
1114 break;
1115 }
1116 }
1117 return sal_True;
1118 }
1119 // -----------------------------------------------------------------------
1120
1121 int SvxTabStopItem::operator==( const SfxPoolItem& rAttr ) const
1122 {
1123 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
1124
1125 const SvxTabStopItem& rTSI = (SvxTabStopItem&)rAttr;
1126
1127 if ( Count() != rTSI.Count() )
1128 return 0;
1129
1130 for ( sal_uInt16 i = 0; i < Count(); ++i )
1131 if( !(*this)[i].IsEqual( rTSI[i] ) )
1132 return 0;
1133 return 1;
1134 }
1135
1136 // -----------------------------------------------------------------------
1137
1138 SfxPoolItem* SvxTabStopItem::Clone( SfxItemPool * ) const
1139 {
1140 return new SvxTabStopItem( *this );
1141 }
1142
1143 //------------------------------------------------------------------------
1144
1145 SfxItemPresentation SvxTabStopItem::GetPresentation
1146 (
1147 SfxItemPresentation ePres,
1148 SfxMapUnit eCoreUnit,
1149 SfxMapUnit ePresUnit,
1150 XubString& rText, const IntlWrapper *pIntl
1151 ) const
1152 {
1153 rText.Erase();
1154
1155 if ( ePres > SFX_ITEM_PRESENTATION_NONE )
1156 {
1157 sal_Bool bComma = sal_False;
1158
1159 for ( sal_uInt16 i = 0; i < Count(); ++i )
1160 {
1161 if ( SVX_TAB_ADJUST_DEFAULT != ((*this)[i]).GetAdjustment() )
1162 {
1163 if ( bComma )
1164 rText += sal_Unicode(',');
1165 rText += GetMetricText(
1166 ((*this)[i]).GetTabPos(), eCoreUnit, ePresUnit, pIntl );
1167 if ( SFX_ITEM_PRESENTATION_COMPLETE == ePres )
1168 rText += EE_RESSTR(GetMetricId(ePresUnit));
1169 bComma = sal_True;
1170 }
1171 }
1172 }
1173 return ePres;
1174 }
1175
1176 // -----------------------------------------------------------------------
1177
1178 SfxPoolItem* SvxTabStopItem::Create( SvStream& rStrm, sal_uInt16 ) const
1179 {
1180 sal_Int8 nTabs;
1181 rStrm >> nTabs;
1182 SvxTabStopItem* pAttr =
1183 new SvxTabStopItem( 0, 0, SVX_TAB_ADJUST_DEFAULT, Which() );
1184
1185 for ( sal_Int8 i = 0; i < nTabs; i++ )
1186 {
1187 sal_Int32 nPos(0);
1188 sal_Int8 eAdjust;
1189 unsigned char cDecimal, cFill;
1190 rStrm >> nPos >> eAdjust >> cDecimal >> cFill;
1191 if( !i || SVX_TAB_ADJUST_DEFAULT != eAdjust )
1192 pAttr->Insert( SvxTabStop
1193 ( nPos, (SvxTabAdjust)eAdjust, sal_Unicode(cDecimal), sal_Unicode(cFill) ) );
1194 }
1195 return pAttr;
1196 }
1197
1198 // -----------------------------------------------------------------------
1199
1200 SvStream& SvxTabStopItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
1201 {
1202 // Default-Tabs are only expanded for the default Attribute. For complete
1203 // backward compabillity (<=304) all tabs have to be expanded, this makes
1204 // the files grow large in size. All only SWG!
1205
1206 const SfxItemPool *pPool = SfxItemPool::GetStoringPool();
1207 const bool bStoreDefTabs = pPool
1208 && pPool->GetName().equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("SWG"))
1209 && ::IsDefaultItem( this );
1210
1211 const short nTabs = Count();
1212 sal_uInt16 nCount = 0, nDefDist = 0;
1213 sal_Int32 nNew = 0;
1214
1215 if( bStoreDefTabs )
1216 {
1217 const SvxTabStopItem& rDefTab = (const SvxTabStopItem &)
1218 pPool->GetDefaultItem( pPool->GetWhich( SID_ATTR_TABSTOP, sal_False ) );
1219 nDefDist = sal_uInt16( rDefTab.GetStart()->GetTabPos() );
1220 const sal_Int32 nPos = nTabs > 0 ? (*this)[nTabs-1].GetTabPos() : 0;
1221 nCount = (sal_uInt16)(nPos / nDefDist);
1222 nNew = (nCount + 1) * nDefDist;
1223
1224 if( nNew <= nPos + 50 )
1225 nNew += nDefDist;
1226
1227 sal_Int32 lA3Width = SvxPaperInfo::GetPaperSize(PAPER_A3).Width();
1228 nCount = (sal_uInt16)(nNew < lA3Width ? ( lA3Width - nNew ) / nDefDist + 1 : 0);
1229 }
1230
1231 rStrm << (sal_Int8) ( nTabs + nCount );
1232 for ( short i = 0; i < nTabs; i++ )
1233 {
1234 const SvxTabStop& rTab = (*this)[ i ];
1235 rStrm << rTab.GetTabPos()
1236 << (sal_Int8) rTab.GetAdjustment()
1237 << (unsigned char) rTab.GetDecimal()
1238 << (unsigned char) rTab.GetFill();
1239 }
1240
1241 if ( bStoreDefTabs )
1242 for( ; nCount; --nCount )
1243 {
1244 SvxTabStop aSwTabStop(nNew, SVX_TAB_ADJUST_DEFAULT);
1245 rStrm << aSwTabStop.GetTabPos()
1246 << (sal_Int8) aSwTabStop.GetAdjustment()
1247 << (unsigned char) aSwTabStop.GetDecimal()
1248 << (unsigned char) aSwTabStop.GetFill();
1249 nNew += nDefDist;
1250 }
1251
1252 return rStrm;
1253 }
1254
1255 // -----------------------------------------------------------------------
1256 sal_Bool SvxTabStopItem::Insert( const SvxTabStop& rTab )
1257 {
1258 sal_uInt16 nTabPos = GetPos(rTab);
1259 if(SVX_TAB_NOTFOUND != nTabPos )
1260 Remove(nTabPos);
1261 return SvxTabStopArr::Insert( rTab );
1262 }
1263 // -----------------------------------------------------------------------
1264 void SvxTabStopItem::Insert( const SvxTabStopItem* pTabs, sal_uInt16 nStart,
1265 sal_uInt16 nEnd )
1266 {
1267 for( sal_uInt16 i = nStart; i < nEnd && i < pTabs->Count(); i++ )
1268 {
1269 const SvxTabStop& rTab = (*pTabs)[i];
1270 sal_uInt16 nTabPos = GetPos(rTab);
1271 if(SVX_TAB_NOTFOUND != nTabPos)
1272 Remove(nTabPos);
1273 }
1274 SvxTabStopArr::Insert( pTabs, nStart, nEnd );
1275 }
1276
1277
1278
1279 // class SvxFmtSplitItem -------------------------------------------------
1280 SvxFmtSplitItem::~SvxFmtSplitItem()
1281 {
1282 }
1283 // -----------------------------------------------------------------------
1284 SfxPoolItem* SvxFmtSplitItem::Clone( SfxItemPool * ) const
1285 {
1286 return new SvxFmtSplitItem( *this );
1287 }
1288
1289 // -----------------------------------------------------------------------
1290
1291 SvStream& SvxFmtSplitItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
1292 {
1293 rStrm << (sal_Int8)GetValue();
1294 return rStrm;
1295 }
1296
1297 // -----------------------------------------------------------------------
1298
1299 SfxPoolItem* SvxFmtSplitItem::Create( SvStream& rStrm, sal_uInt16 ) const
1300 {
1301 sal_Int8 bIsSplit;
1302 rStrm >> bIsSplit;
1303 return new SvxFmtSplitItem( sal_Bool( bIsSplit != 0 ), Which() );
1304 }
1305
1306 //------------------------------------------------------------------------
1307
1308 SfxItemPresentation SvxFmtSplitItem::GetPresentation
1309 (
1310 SfxItemPresentation ePres,
1311 SfxMapUnit /*eCoreUnit*/,
1312 SfxMapUnit /*ePresUnit*/,
1313 XubString& rText, const IntlWrapper *
1314 ) const
1315 {
1316 switch ( ePres )
1317 {
1318 case SFX_ITEM_PRESENTATION_NONE:
1319 rText.Erase();
1320 return SFX_ITEM_PRESENTATION_NONE;
1321 case SFX_ITEM_PRESENTATION_NAMELESS:
1322 case SFX_ITEM_PRESENTATION_COMPLETE:
1323 {
1324 sal_uInt16 nId = RID_SVXITEMS_FMTSPLIT_FALSE;
1325
1326 if ( GetValue() )
1327 nId = RID_SVXITEMS_FMTSPLIT_TRUE;
1328 rText = EE_RESSTR(nId);
1329 return ePres;
1330 }
1331 default: ;//prevent warning
1332 }
1333 return SFX_ITEM_PRESENTATION_NONE;
1334 }
1335
1336 // --------------------------------------------------------------------
1337
1338 SfxPoolItem* SvxPageModelItem::Clone( SfxItemPool* ) const
1339 {
1340 return new SvxPageModelItem( *this );
1341 }
1342
1343 //------------------------------------------------------------------------
1344
1345 bool SvxPageModelItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1346 {
1347 nMemberId &= ~CONVERT_TWIPS;
1348
1349 switch ( nMemberId )
1350 {
1351 case MID_AUTO: rVal <<= (sal_Bool) bAuto; break;
1352 case MID_NAME: rVal <<= ::rtl::OUString( GetValue() ); break;
1353 default: OSL_FAIL("Wrong MemberId!"); return sal_False;
1354 }
1355
1356 return sal_True;
1357 }
1358
1359 bool SvxPageModelItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1360 {
1361 nMemberId &= ~CONVERT_TWIPS;
1362 sal_Bool bRet;
1363 ::rtl::OUString aStr;
1364 switch ( nMemberId )
1365 {
1366 case MID_AUTO: bRet = ( rVal >>= bAuto ); break;
1367 case MID_NAME: bRet = ( rVal >>= aStr ); if ( bRet ) SetValue(aStr); break;
1368 default: OSL_FAIL("Wrong MemberId!"); return sal_False;
1369 }
1370
1371 return bRet;
1372 }
1373
1374 SfxItemPresentation SvxPageModelItem::GetPresentation
1375 (
1376 SfxItemPresentation ePres,
1377 SfxMapUnit /*eCoreUnit*/,
1378 SfxMapUnit /*ePresUnit*/,
1379 XubString& rText, const IntlWrapper *
1380 ) const
1381 {
1382 rText.Erase();
1383 bool bSet = ( GetValue().Len() > 0 );
1384
1385 switch ( ePres )
1386 {
1387 case SFX_ITEM_PRESENTATION_NONE:
1388 return SFX_ITEM_PRESENTATION_NONE;
1389
1390 case SFX_ITEM_PRESENTATION_NAMELESS:
1391 if ( bSet )
1392 rText = GetValue();
1393 return SFX_ITEM_PRESENTATION_NAMELESS;
1394
1395 case SFX_ITEM_PRESENTATION_COMPLETE:
1396 if ( bSet )
1397 {
1398 rText = EE_RESSTR(RID_SVXITEMS_PAGEMODEL_COMPLETE);
1399 rText += GetValue();
1400 }
1401 return SFX_ITEM_PRESENTATION_COMPLETE;
1402 default: ;//prevent warning
1403 }
1404 return SFX_ITEM_PRESENTATION_NONE;
1405 }
1406
1407 //------------------------------------------------------------------------
1408
1409 SvxScriptSpaceItem::SvxScriptSpaceItem( sal_Bool bOn, const sal_uInt16 nId )
1410 : SfxBoolItem( nId, bOn )
1411 {
1412 }
1413
1414 SfxPoolItem* SvxScriptSpaceItem::Clone( SfxItemPool * ) const
1415 {
1416 return new SvxScriptSpaceItem( GetValue(), Which() );
1417 }
1418
1419 SfxPoolItem* SvxScriptSpaceItem::Create(SvStream & rStrm, sal_uInt16) const
1420 {
1421 sal_Bool bFlag;
1422 rStrm >> bFlag;
1423 return new SvxScriptSpaceItem( bFlag, Which() );
1424 }
1425
1426 sal_uInt16 SvxScriptSpaceItem::GetVersion( sal_uInt16 nFFVer ) const
1427 {
1428 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
1429 SOFFICE_FILEFORMAT_40==nFFVer ||
1430 SOFFICE_FILEFORMAT_50==nFFVer,
1431 "SvxTwoLinesItem: Is there a new file format? ");
1432
1433 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
1434 }
1435
1436 SfxItemPresentation SvxScriptSpaceItem::GetPresentation(
1437 SfxItemPresentation ePres,
1438 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
1439 String &rText, const IntlWrapper* /*pIntl*/ ) const
1440 {
1441 switch( ePres )
1442 {
1443 case SFX_ITEM_PRESENTATION_NONE:
1444 rText.Erase();
1445 break;
1446 case SFX_ITEM_PRESENTATION_NAMELESS:
1447 case SFX_ITEM_PRESENTATION_COMPLETE:
1448 {
1449 rText = EE_RESSTR( !GetValue()
1450 ? RID_SVXITEMS_SCRPTSPC_OFF
1451 : RID_SVXITEMS_SCRPTSPC_ON );
1452 return ePres;
1453 }
1454 default: ;//prevent warning
1455 }
1456 return SFX_ITEM_PRESENTATION_NONE;
1457 }
1458
1459 //------------------------------------------------------------------------
1460
1461 SvxHangingPunctuationItem::SvxHangingPunctuationItem(
1462 sal_Bool bOn, const sal_uInt16 nId )
1463 : SfxBoolItem( nId, bOn )
1464 {
1465 }
1466
1467 SfxPoolItem* SvxHangingPunctuationItem::Clone( SfxItemPool * ) const
1468 {
1469 return new SvxHangingPunctuationItem( GetValue(), Which() );
1470 }
1471
1472 SfxPoolItem* SvxHangingPunctuationItem::Create(SvStream & rStrm, sal_uInt16) const
1473 {
1474 sal_Bool nValue;
1475 rStrm >> nValue;
1476 return new SvxHangingPunctuationItem( nValue, Which() );
1477 }
1478
1479 sal_uInt16 SvxHangingPunctuationItem::GetVersion( sal_uInt16 nFFVer ) const
1480 {
1481 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
1482 SOFFICE_FILEFORMAT_40==nFFVer ||
1483 SOFFICE_FILEFORMAT_50==nFFVer,
1484 "SvxHangingPunctuationItem: Is there a new file format? ");
1485
1486 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
1487 }
1488
1489 SfxItemPresentation SvxHangingPunctuationItem::GetPresentation(
1490 SfxItemPresentation ePres,
1491 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
1492 String &rText, const IntlWrapper* /*pIntl*/ ) const
1493 {
1494 switch( ePres )
1495 {
1496 case SFX_ITEM_PRESENTATION_NONE:
1497 rText.Erase();
1498 break;
1499 case SFX_ITEM_PRESENTATION_NAMELESS:
1500 case SFX_ITEM_PRESENTATION_COMPLETE:
1501 {
1502 rText = EE_RESSTR( !GetValue()
1503 ? RID_SVXITEMS_HNGPNCT_OFF
1504 : RID_SVXITEMS_HNGPNCT_ON );
1505 return ePres;
1506 }
1507 default: ;//prevent warning
1508 break;
1509 }
1510 return SFX_ITEM_PRESENTATION_NONE;
1511 }
1512 //------------------------------------------------------------------------
1513
1514 SvxForbiddenRuleItem::SvxForbiddenRuleItem(
1515 sal_Bool bOn, const sal_uInt16 nId )
1516 : SfxBoolItem( nId, bOn )
1517 {
1518 }
1519
1520 SfxPoolItem* SvxForbiddenRuleItem::Clone( SfxItemPool * ) const
1521 {
1522 return new SvxForbiddenRuleItem( GetValue(), Which() );
1523 }
1524
1525 SfxPoolItem* SvxForbiddenRuleItem::Create(SvStream & rStrm, sal_uInt16) const
1526 {
1527 sal_Bool nValue;
1528 rStrm >> nValue;
1529 return new SvxForbiddenRuleItem( nValue, Which() );
1530 }
1531
1532 sal_uInt16 SvxForbiddenRuleItem::GetVersion( sal_uInt16 nFFVer ) const
1533 {
1534 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
1535 SOFFICE_FILEFORMAT_40==nFFVer ||
1536 SOFFICE_FILEFORMAT_50==nFFVer,
1537 "SvxForbiddenRuleItem: Is there a new file format? ");
1538
1539 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
1540 }
1541
1542 SfxItemPresentation SvxForbiddenRuleItem::GetPresentation(
1543 SfxItemPresentation ePres,
1544 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
1545 String &rText, const IntlWrapper* /*pIntl*/ ) const
1546 {
1547 switch( ePres )
1548 {
1549 case SFX_ITEM_PRESENTATION_NONE:
1550 rText.Erase();
1551 break;
1552 case SFX_ITEM_PRESENTATION_NAMELESS:
1553 case SFX_ITEM_PRESENTATION_COMPLETE:
1554 {
1555 rText = EE_RESSTR( !GetValue()
1556 ? RID_SVXITEMS_FORBIDDEN_RULE_OFF
1557 : RID_SVXITEMS_FORBIDDEN_RULE_ON );
1558 return ePres;
1559 }
1560 default: ;//prevent warning
1561 break;
1562 }
1563 return SFX_ITEM_PRESENTATION_NONE;
1564 }
1565
1566 /*************************************************************************
1567 |* class SvxParaVertAlignItem
1568 *************************************************************************/
1569
1570 SvxParaVertAlignItem::SvxParaVertAlignItem( sal_uInt16 nValue,
1571 const sal_uInt16 nW )
1572 : SfxUInt16Item( nW, nValue )
1573 {
1574 }
1575
1576 SfxPoolItem* SvxParaVertAlignItem::Clone( SfxItemPool* ) const
1577 {
1578 return new SvxParaVertAlignItem( GetValue(), Which() );
1579 }
1580
1581 SfxPoolItem* SvxParaVertAlignItem::Create( SvStream& rStrm, sal_uInt16 ) const
1582 {
1583 sal_uInt16 nVal;
1584 rStrm >> nVal;
1585 return new SvxParaVertAlignItem( nVal, Which() );
1586 }
1587
1588 SvStream& SvxParaVertAlignItem::Store( SvStream & rStrm, sal_uInt16 ) const
1589 {
1590 rStrm << GetValue();
1591 return rStrm;
1592 }
1593
1594 sal_uInt16 SvxParaVertAlignItem::GetVersion( sal_uInt16 nFFVer ) const
1595 {
1596 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
1597 }
1598
1599 SfxItemPresentation SvxParaVertAlignItem::GetPresentation(
1600 SfxItemPresentation ePres,
1601 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
1602 String &rText, const IntlWrapper* ) const
1603 {
1604 switch( ePres )
1605 {
1606 case SFX_ITEM_PRESENTATION_NONE:
1607 rText.Erase();
1608 break;
1609 case SFX_ITEM_PRESENTATION_NAMELESS:
1610 case SFX_ITEM_PRESENTATION_COMPLETE:
1611 {
1612 sal_uInt16 nTmp;
1613 switch( GetValue() )
1614 {
1615 case AUTOMATIC: nTmp = RID_SVXITEMS_PARAVERTALIGN_AUTO; break;
1616 case TOP: nTmp = RID_SVXITEMS_PARAVERTALIGN_TOP; break;
1617 case CENTER: nTmp = RID_SVXITEMS_PARAVERTALIGN_CENTER; break;
1618 case BOTTOM: nTmp = RID_SVXITEMS_PARAVERTALIGN_BOTTOM; break;
1619 default: nTmp = RID_SVXITEMS_PARAVERTALIGN_BASELINE; break;
1620 }
1621 rText = EE_RESSTR( nTmp );
1622 return ePres;
1623 }
1624 default: ;//prevent warning
1625 break;
1626 }
1627 return SFX_ITEM_PRESENTATION_NONE;
1628 }
1629
1630 bool SvxParaVertAlignItem::QueryValue( com::sun::star::uno::Any& rVal,
1631 sal_uInt8 /*nMemberId*/ ) const
1632 {
1633 rVal <<= (sal_Int16)GetValue();
1634 return sal_True;
1635 }
1636
1637 bool SvxParaVertAlignItem::PutValue( const com::sun::star::uno::Any& rVal,
1638 sal_uInt8 /*nMemberId*/ )
1639 {
1640 sal_Int16 nVal = sal_Int16();
1641 if((rVal >>= nVal) && nVal >=0 && nVal <= BOTTOM )
1642 {
1643 SetValue( (sal_uInt16)nVal );
1644 return sal_True;
1645 }
1646 else
1647 return sal_False;
1648 }
1649
1650 int SvxParaVertAlignItem::operator==( const SfxPoolItem& rItem ) const
1651 {
1652 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
1653 return SfxUInt16Item::operator==( rItem );
1654 }
1655
1656
1657 SvxParaGridItem::SvxParaGridItem( sal_Bool bOn, const sal_uInt16 nId )
1658 : SfxBoolItem( nId, bOn )
1659 {
1660 }
1661
1662 SfxPoolItem* SvxParaGridItem::Clone( SfxItemPool * ) const
1663 {
1664 return new SvxParaGridItem( GetValue(), Which() );
1665 }
1666
1667 SfxPoolItem* SvxParaGridItem::Create(SvStream & rStrm, sal_uInt16) const
1668 {
1669 sal_Bool bFlag;
1670 rStrm >> bFlag;
1671 return new SvxParaGridItem( bFlag, Which() );
1672 }
1673
1674 sal_uInt16 SvxParaGridItem::GetVersion( sal_uInt16 nFFVer ) const
1675 {
1676 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
1677 SOFFICE_FILEFORMAT_40==nFFVer ||
1678 SOFFICE_FILEFORMAT_50==nFFVer,
1679 "SvxParaGridItem: Is there a new file format? ");
1680
1681 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
1682 }
1683
1684 SfxItemPresentation SvxParaGridItem::GetPresentation(
1685 SfxItemPresentation ePres,
1686 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
1687 String &rText, const IntlWrapper* /*pIntl*/ ) const
1688 {
1689 switch( ePres )
1690 {
1691 case SFX_ITEM_PRESENTATION_NONE:
1692 rText.Erase();
1693 break;
1694 case SFX_ITEM_PRESENTATION_NAMELESS:
1695 case SFX_ITEM_PRESENTATION_COMPLETE:
1696 {
1697 rText = GetValue() ?
1698 EE_RESSTR( RID_SVXITEMS_PARASNAPTOGRID_ON ) :
1699 EE_RESSTR( RID_SVXITEMS_PARASNAPTOGRID_OFF );
1700
1701 return ePres;
1702 }
1703 default: ;//prevent warning
1704 break;
1705 }
1706 return SFX_ITEM_PRESENTATION_NONE;
1707 }
1708
1709
1710 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE