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