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