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