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