xref: /aoo41x/main/editeng/source/items/numitem.cxx (revision 190118d0)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_editeng.hxx"
26 
27 #include <editeng/numitem.hxx>
28 
29 #include <com/sun/star/text/HoriOrientation.hpp>
30 #include <com/sun/star/text/VertOrientation.hpp>
31 #include <com/sun/star/text/RelOrientation.hpp>
32 #include <editeng/brshitem.hxx>
33 #include <vcl/font.hxx>
34 #include <editeng/editids.hrc>
35 #include <editeng/editrids.hrc>
36 #include <editeng/numdef.hxx>
37 #include <vcl/graph.hxx>
38 #include <vcl/window.hxx>
39 #include <vcl/svapp.hxx>
40 #include <editeng/unolingu.hxx>
41 #include <com/sun/star/text/XNumberingFormatter.hpp>
42 #include <com/sun/star/text/XDefaultNumberingProvider.hpp>
43 #include <com/sun/star/style/NumberingType.hpp>
44 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
45 #include <com/sun/star/beans/PropertyValue.hpp>
46 #include <comphelper/processfactory.hxx>
47 
48 #include <editeng/unonrule.hxx>
49 
50 #define MM100_TO_TWIP(MM100)	((MM100*72L+63L)/127L)
51 
52 #define DEF_WRITER_LSPACE 	500		//Standardeinrueckung
53 #define DEF_DRAW_LSPACE 	800		//Standardeinrueckung
54 
55 #define NUMITEM_VERSION_01        0x01
56 #define NUMITEM_VERSION_02        0x02
57 #define NUMITEM_VERSION_03        0x03
58 #define NUMITEM_VERSION_04        0x04
59 
60 using namespace ::com::sun::star;
61 using namespace ::com::sun::star::lang;
62 using namespace ::com::sun::star::uno;
63 using namespace ::com::sun::star::text;
64 using namespace ::com::sun::star::beans;
65 using namespace ::com::sun::star::style;
66 
67 sal_Int32 SvxNumberType::nRefCount = 0;
68 com::sun::star::uno::Reference<com::sun::star::text::XNumberingFormatter> SvxNumberType::xFormatter = 0;
lcl_getFormatter(com::sun::star::uno::Reference<com::sun::star::text::XNumberingFormatter> & _xFormatter)69 void lcl_getFormatter(com::sun::star::uno::Reference<com::sun::star::text::XNumberingFormatter>& _xFormatter)
70 {
71     if(!_xFormatter.is())
72    	{
73 		try
74 		{
75 			Reference< XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
76 			Reference < XInterface > xI = xMSF->createInstance(
77 				::rtl::OUString::createFromAscii( "com.sun.star.text.DefaultNumberingProvider" ) );
78 			Reference<XDefaultNumberingProvider> xRet(xI, UNO_QUERY);
79 			DBG_ASSERT(xRet.is(), "service missing: \"com.sun.star.text.DefaultNumberingProvider\"");
80 			_xFormatter = Reference<XNumberingFormatter> (xRet, UNO_QUERY);
81 		}
82 		catch(Exception& )
83 		{
84 		}
85 	}
86 }
87 /* -----------------------------22.02.01 14:24--------------------------------
88 
89  ---------------------------------------------------------------------------*/
SvxNumberType(sal_Int16 nType)90 SvxNumberType::SvxNumberType(sal_Int16 nType) :
91 	nNumType(nType),
92 	bShowSymbol(sal_True)
93 {
94 	nRefCount++;
95 }
96 /* -----------------------------22.02.01 14:31--------------------------------
97 
98  ---------------------------------------------------------------------------*/
SvxNumberType(const SvxNumberType & rType)99 SvxNumberType::SvxNumberType(const SvxNumberType& rType) :
100 	nNumType(rType.nNumType),
101 	bShowSymbol(rType.bShowSymbol)
102 {
103 	nRefCount++;
104 }
105 /* -----------------------------22.02.01 14:24--------------------------------
106 
107  ---------------------------------------------------------------------------*/
~SvxNumberType()108 SvxNumberType::~SvxNumberType()
109 {
110 	if(!--nRefCount)
111 		xFormatter = 0;
112 }
113 /* -----------------------------22.02.01 11:09--------------------------------
114 
115  ---------------------------------------------------------------------------*/
GetNumStr(sal_uLong nNo) const116 String SvxNumberType::GetNumStr( sal_uLong nNo ) const
117 {
118     LanguageType eLang = Application::GetSettings().GetLanguage();
119 	Locale aLocale = SvxCreateLocale(eLang);
120 	return GetNumStr( nNo, aLocale );
121 }
122 /* -----------------28.10.98 15:56-------------------
123  *
124  * --------------------------------------------------*/
GetNumStr(sal_uLong nNo,const Locale & rLocale) const125 String 	SvxNumberType::GetNumStr( sal_uLong nNo, const Locale& rLocale ) const
126 {
127     lcl_getFormatter(xFormatter);
128 	String aTmpStr;
129 	if(!xFormatter.is())
130 		return aTmpStr;
131 
132 	if(bShowSymbol)
133 	{
134 		switch(nNumType)
135 		{
136             case NumberingType::CHAR_SPECIAL:
137             case NumberingType::BITMAP:
138 			break;
139 			default:
140 				{
141 					//#95525# '0' allowed for ARABIC numberings
142 					if(NumberingType::ARABIC == nNumType && 0 == nNo )
143 						aTmpStr = '0';
144 					else
145 					{
146 						Sequence< PropertyValue > aProperties(2);
147 						PropertyValue* pValues = aProperties.getArray();
148 						pValues[0].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NumberingType"));
149 						pValues[0].Value <<= nNumType;
150 						pValues[1].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Value"));
151 						pValues[1].Value <<= (sal_Int32)nNo;
152 
153 						try
154 						{
155 							aTmpStr = xFormatter->makeNumberingString( aProperties, rLocale );
156 						}
157 						catch(Exception&)
158 						{
159 						}
160 					}
161 				}
162 		}
163 	}
164 	return aTmpStr;
165 }
166 /* -----------------27.10.98 10:33-------------------
167  *
168  * --------------------------------------------------*/
169 // --> OD 2008-01-09 #newlistlevelattrs#
SvxNumberFormat(sal_Int16 eType,SvxNumPositionAndSpaceMode ePositionAndSpaceMode)170 SvxNumberFormat::SvxNumberFormat( sal_Int16 eType,
171                                   SvxNumPositionAndSpaceMode ePositionAndSpaceMode )
172 // <--
173     : SvxNumberType(eType),
174       eNumAdjust(SVX_ADJUST_LEFT),
175       nInclUpperLevels(0),
176       nStart(1),
177       cBullet(SVX_DEF_BULLET),
178       nBulletRelSize(100),
179       nBulletColor(COL_BLACK),
180       // --> OD 2008-01-09 #newlistlevelattrs#
181       mePositionAndSpaceMode( ePositionAndSpaceMode ),
182       // <--
183       nFirstLineOffset(0),
184       nAbsLSpace(0),
185       nLSpace(0),
186       nCharTextDistance(0),
187       // --> OD 2008-01-09 #newlistlevelattrs#
188       meLabelFollowedBy( LISTTAB ),
189       mnListtabPos( 0 ),
190       mnFirstLineIndent( 0 ),
191       mnIndentAt( 0 ),
192       // <--
193       pGraphicBrush(0),
194       eVertOrient(text::VertOrientation::NONE),
195       pBulletFont(0)
196 {
197 }
198 /* -----------------27.10.98 10:56-------------------
199  *
200  * --------------------------------------------------*/
SvxNumberFormat(const SvxNumberFormat & rFormat)201 SvxNumberFormat::SvxNumberFormat(const SvxNumberFormat& rFormat) :
202     SvxNumberType(rFormat),
203     // --> OD 2008-01-09 #newlistlevelattrs#
204     mePositionAndSpaceMode( rFormat.mePositionAndSpaceMode ),
205     // <--
206     pGraphicBrush(0),
207     pBulletFont(0)
208 {
209     *this = rFormat;
210 }
211 /* -----------------27.10.98 10:56-------------------
212  *
213  * --------------------------------------------------*/
~SvxNumberFormat()214 SvxNumberFormat::~SvxNumberFormat()
215 {
216 	delete pGraphicBrush;
217 	delete pBulletFont;
218 }
219 /* -----------------08.12.98 11:14-------------------
220  *
221  * --------------------------------------------------*/
SvxNumberFormat(SvStream & rStream)222 SvxNumberFormat::SvxNumberFormat(SvStream &rStream)
223 : mePositionAndSpaceMode( LABEL_WIDTH_AND_POSITION ),
224   meLabelFollowedBy( LISTTAB ),
225   mnListtabPos( 0 ),
226   mnFirstLineIndent( 0 ),
227   mnIndentAt( 0 )
228 {
229 
230     sal_uInt16 nVersion;
231   rStream >> nVersion;
232 
233   sal_uInt16 nUSHORT;
234   rStream >> nUSHORT;
235   SetNumberingType((sal_Int16)nUSHORT);
236   rStream >> nUSHORT;
237   eNumAdjust      = (SvxAdjust)nUSHORT;
238   rStream >> nUSHORT;
239   nInclUpperLevels = (sal_uInt8)nUSHORT;
240   rStream >> nUSHORT;
241   nStart          = nUSHORT;
242   rStream >> nUSHORT;
243   cBullet = nUSHORT;
244 
245   short nShort;
246   rStream >> nShort;
247   nFirstLineOffset        = nShort;
248   rStream >> nShort;
249   nAbsLSpace              = nShort;
250   rStream >> nShort;
251   nLSpace                 = nShort;
252 
253   rStream >> nShort;
254   nCharTextDistance       = nShort;
255   rtl_TextEncoding eEnc = gsl_getSystemTextEncoding();
256   rStream.ReadByteString(sPrefix, eEnc);
257   rStream.ReadByteString(sSuffix, eEnc);
258   rStream.ReadByteString(sCharStyleName, eEnc);
259   rStream >> nUSHORT;
260   if(nUSHORT)
261   {
262         SvxBrushItem aHelper(0);
263       pGraphicBrush = (SvxBrushItem*) aHelper.Create( rStream, BRUSH_GRAPHIC_VERSION );
264   }
265   else
266       pGraphicBrush = 0;
267 
268   rStream >> nUSHORT;
269     eVertOrient          = (sal_Int16)nUSHORT;
270 
271   rStream >> nUSHORT;
272   if(nUSHORT)
273   {
274       pBulletFont = new Font;
275       rStream >> *pBulletFont;
276         if(!pBulletFont->GetCharSet())
277             pBulletFont->SetCharSet(rStream.GetStreamCharSet());
278     }
279   else
280       pBulletFont = 0;
281   rStream >> aGraphicSize;
282 
283   rStream >> nBulletColor;
284   rStream >> nUSHORT;
285   nBulletRelSize = nUSHORT;
286   rStream >> nUSHORT;
287   SetShowSymbol((sal_Bool)nUSHORT);
288 
289   if( nVersion < NUMITEM_VERSION_03 )
290       cBullet = ByteString::ConvertToUnicode( (sal_Char)cBullet,
291                           (pBulletFont&&pBulletFont->GetCharSet()) ?  pBulletFont->GetCharSet()
292                                       : RTL_TEXTENCODING_SYMBOL );
293     if(pBulletFont)
294     {
295         sal_Bool bConvertBulletFont = rStream.GetVersion() <= SOFFICE_FILEFORMAT_50;
296         if(bConvertBulletFont)
297         {
298 
299             FontToSubsFontConverter pConverter =
300                         CreateFontToSubsFontConverter(pBulletFont->GetName(),
301                             FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS);
302             if(pConverter)
303             {
304                 cBullet = ConvertFontToSubsFontChar(pConverter, cBullet);
305                 String sFontName = GetFontToSubsFontName(pConverter);
306                 pBulletFont->SetName(sFontName);
307                 DestroyFontToSubsFontConverter(pConverter);
308             }
309         }
310     }
311 
312     if( NUMITEM_VERSION_04 <= nVersion )
313     {
314         rStream >> nUSHORT;
315         mePositionAndSpaceMode = (SvxNumPositionAndSpaceMode) nUSHORT;
316         rStream >> nUSHORT;
317         meLabelFollowedBy = ( SvxNumLabelFollowedBy ) nUSHORT;
318         long nLong;
319         rStream >> nLong;
320         mnListtabPos = nLong;
321         rStream >> nLong;
322         mnFirstLineIndent = nLong;
323         rStream >> nLong;
324         mnIndentAt = nLong;
325     }
326 }
327 /* -----------------08.12.98 11:14-------------------
328  *
329  * --------------------------------------------------*/
Store(SvStream & rStream,FontToSubsFontConverter pConverter)330 SvStream&   SvxNumberFormat::Store(SvStream &rStream, FontToSubsFontConverter pConverter)
331 {
332     if(pConverter && pBulletFont)
333     {
334         cBullet = ConvertFontToSubsFontChar(pConverter, cBullet);
335         String sFontName = GetFontToSubsFontName(pConverter);
336         pBulletFont->SetName(sFontName);
337     }
338 
339     rStream << (sal_uInt16)NUMITEM_VERSION_04;
340 
341     rStream << (sal_uInt16)GetNumberingType();
342     rStream << (sal_uInt16)eNumAdjust;
343     rStream << (sal_uInt16)nInclUpperLevels;
344     rStream << nStart;
345     rStream << (sal_uInt16)cBullet;
346 
347     rStream << nFirstLineOffset;
348     rStream << nAbsLSpace;
349     rStream << nLSpace;
350 
351     rStream << nCharTextDistance;
352     rtl_TextEncoding eEnc = gsl_getSystemTextEncoding();
353     rStream.WriteByteString(sPrefix, eEnc);
354     rStream.WriteByteString(sSuffix, eEnc);
355     rStream.WriteByteString(sCharStyleName, eEnc);
356     if(pGraphicBrush)
357     {
358         rStream << (sal_uInt16)1;
359 
360         // #75113# in SD or SI force bullet itself to be stored,
361         // for that purpose throw away link when link and graphic
362         // are present, so Brush save is forced
363         if(pGraphicBrush->GetGraphicLink() && pGraphicBrush->GetGraphic())
364         {
365             String aEmpty;
366             pGraphicBrush->SetGraphicLink(aEmpty);
367         }
368 
369         pGraphicBrush->Store(rStream, BRUSH_GRAPHIC_VERSION);
370     }
371     else
372         rStream << (sal_uInt16)0;
373 
374     rStream << (sal_uInt16)eVertOrient;
375     if(pBulletFont)
376     {
377         rStream << (sal_uInt16)1;
378         rStream << *pBulletFont;
379     }
380     else
381         rStream << (sal_uInt16)0;
382     rStream << aGraphicSize;
383 
384     Color nTempColor = nBulletColor;
385     if(COL_AUTO == nBulletColor.GetColor())
386         nTempColor = COL_BLACK;
387     rStream << nTempColor;
388     rStream << nBulletRelSize;
389     rStream << (sal_uInt16)IsShowSymbol();
390 
391     rStream << ( sal_uInt16 ) mePositionAndSpaceMode;
392     rStream << ( sal_uInt16 ) meLabelFollowedBy;
393     rStream << ( long ) mnListtabPos;
394     rStream << ( long ) mnFirstLineIndent;
395     rStream << ( long ) mnIndentAt;
396 
397     return rStream;
398 }
399 
400 /* -----------------------------23.02.01 11:10--------------------------------
401 
402  ---------------------------------------------------------------------------*/
operator =(const SvxNumberFormat & rFormat)403 SvxNumberFormat& SvxNumberFormat::operator=( const SvxNumberFormat& rFormat )
404 {
405     if (& rFormat == this) { return *this; }
406 
407 	SetNumberingType(rFormat.GetNumberingType());
408 		eNumAdjust			= rFormat.eNumAdjust ;
409 		nInclUpperLevels 	= rFormat.nInclUpperLevels ;
410 		nStart				= rFormat.nStart ;
411 		cBullet				= rFormat.cBullet ;
412         // --> OD 2008-01-09 #newlistlevelattrs#
413         mePositionAndSpaceMode = rFormat.mePositionAndSpaceMode;
414         // <--
415 		nFirstLineOffset	= rFormat.nFirstLineOffset;
416 		nAbsLSpace			= rFormat.nAbsLSpace ;
417 		nLSpace             = rFormat.nLSpace ;
418 		nCharTextDistance	= rFormat.nCharTextDistance ;
419         // --> OD 2008-01-09 #newlistlevelattrs#
420         meLabelFollowedBy = rFormat.meLabelFollowedBy;
421         mnListtabPos = rFormat.mnListtabPos;
422         mnFirstLineIndent = rFormat.mnFirstLineIndent;
423         mnIndentAt = rFormat.mnIndentAt;
424         // <--
425         eVertOrient         = rFormat.eVertOrient ;
426 		sPrefix  			= rFormat.sPrefix     ;
427 		sSuffix             = rFormat.sSuffix     ;
428 		aGraphicSize		= rFormat.aGraphicSize  ;
429 		nBulletColor 		= rFormat.nBulletColor   ;
430 		nBulletRelSize      = rFormat.nBulletRelSize;
431 		SetShowSymbol(rFormat.IsShowSymbol());
432 		sCharStyleName      = rFormat.sCharStyleName;
433 	DELETEZ(pGraphicBrush);
434 	if(rFormat.pGraphicBrush)
435     {
436 		pGraphicBrush = new SvxBrushItem(*rFormat.pGraphicBrush);
437         pGraphicBrush->SetDoneLink( STATIC_LINK( this, SvxNumberFormat, GraphicArrived) );
438     }
439 	DELETEZ(pBulletFont);
440 	if(rFormat.pBulletFont)
441 			pBulletFont = new Font(*rFormat.pBulletFont);
442 	return *this;
443 }
444 /* -----------------27.10.98 10:56-------------------
445  *
446  * --------------------------------------------------*/
operator ==(const SvxNumberFormat & rFormat) const447 sal_Bool  SvxNumberFormat::operator==( const SvxNumberFormat& rFormat) const
448 {
449 	if( GetNumberingType()  != rFormat.GetNumberingType() ||
450 		eNumAdjust			!= rFormat.eNumAdjust ||
451 		nInclUpperLevels 	!= rFormat.nInclUpperLevels ||
452 		nStart				!= rFormat.nStart ||
453 		cBullet				!= rFormat.cBullet ||
454         // --> OD 2008-01-09 #newlistlevelattrs#
455         mePositionAndSpaceMode != rFormat.mePositionAndSpaceMode ||
456         // <--
457 		nFirstLineOffset	!= rFormat.nFirstLineOffset ||
458 		nAbsLSpace			!= rFormat.nAbsLSpace ||
459 		nLSpace             != rFormat.nLSpace ||
460 		nCharTextDistance	!= rFormat.nCharTextDistance ||
461         // --> OD 2008-01-09 #newlistlevelattrs#
462         meLabelFollowedBy != rFormat.meLabelFollowedBy ||
463         mnListtabPos != rFormat.mnListtabPos ||
464         mnFirstLineIndent != rFormat.mnFirstLineIndent ||
465         mnIndentAt != rFormat.mnIndentAt ||
466         // <--
467 		eVertOrient			!= rFormat.eVertOrient ||
468 		sPrefix  			!= rFormat.sPrefix     ||
469 		sSuffix             != rFormat.sSuffix     ||
470 		aGraphicSize		!= rFormat.aGraphicSize  ||
471 		nBulletColor 		!= rFormat.nBulletColor   ||
472 		nBulletRelSize      != rFormat.nBulletRelSize ||
473 		IsShowSymbol()		!= rFormat.IsShowSymbol() ||
474 		sCharStyleName      != rFormat.sCharStyleName
475 		)
476 		return sal_False;
477 	if (
478         (pGraphicBrush && !rFormat.pGraphicBrush) ||
479         (!pGraphicBrush && rFormat.pGraphicBrush) ||
480         (pGraphicBrush && *pGraphicBrush != *rFormat.pGraphicBrush)
481        )
482     {
483 		return sal_False;
484     }
485 	if (
486         (pBulletFont && !rFormat.pBulletFont) ||
487         (!pBulletFont && rFormat.pBulletFont) ||
488         (pBulletFont && *pBulletFont != *rFormat.pBulletFont)
489        )
490     {
491 		return sal_False;
492     }
493 	return sal_True;
494 }
495 /* -----------------28.10.98 09:53-------------------
496  *
497  * --------------------------------------------------*/
SetGraphicBrush(const SvxBrushItem * pBrushItem,const Size * pSize,const sal_Int16 * pOrient)498 void SvxNumberFormat::SetGraphicBrush( const SvxBrushItem* pBrushItem,
499                     const Size* pSize, const sal_Int16* pOrient)
500 {
501 	if(!pBrushItem)
502 	{
503 		delete pGraphicBrush;
504 		pGraphicBrush = 0;
505 	}
506 	else if ( !pGraphicBrush || (pGraphicBrush && !(*pBrushItem == *pGraphicBrush)) )
507 	{
508 		delete pGraphicBrush;
509 		pGraphicBrush =  (SvxBrushItem*)pBrushItem->Clone();
510         pGraphicBrush->SetDoneLink( STATIC_LINK( this, SvxNumberFormat, GraphicArrived) );
511    }
512 
513 	if(pOrient)
514 		eVertOrient = *pOrient;
515 	else
516         eVertOrient = text::VertOrientation::NONE;
517 	if(pSize)
518 		aGraphicSize = *pSize;
519 	else
520 		aGraphicSize.Width() = aGraphicSize.Height() = 0;
521 }
522 /* -----------------28.10.98 09:59-------------------
523  *
524  * --------------------------------------------------*/
SetGraphic(const String & rName)525 void SvxNumberFormat::SetGraphic( const String& rName )
526 {
527 	const String* pName;
528 	if( pGraphicBrush &&
529 			0 != (pName = pGraphicBrush->GetGraphicLink())
530 				&& *pName == rName )
531 		return ;
532 
533 	delete pGraphicBrush;
534 	String sTmp;
535     pGraphicBrush = new SvxBrushItem( rName, sTmp, GPOS_AREA, 0 );
536 	pGraphicBrush->SetDoneLink( STATIC_LINK( this, SvxNumberFormat, GraphicArrived) );
537     if( eVertOrient == text::VertOrientation::NONE )
538         eVertOrient = text::VertOrientation::TOP;
539 
540 	aGraphicSize.Width() = aGraphicSize.Height() = 0;
541 }
542 /* -----------------------------22.02.01 15:55--------------------------------
543 
544  ---------------------------------------------------------------------------*/
SetVertOrient(sal_Int16 eSet)545 void SvxNumberFormat::SetVertOrient(sal_Int16 eSet)
546 {
547 	eVertOrient = eSet;
548 }
549 /* -----------------------------22.02.01 15:55--------------------------------
550 
551  ---------------------------------------------------------------------------*/
GetVertOrient() const552 sal_Int16    SvxNumberFormat::GetVertOrient() const
553 {
554 	return eVertOrient;
555 }
556 /* -----------------28.10.98 09:59-------------------
557  *
558  * --------------------------------------------------*/
SetBulletFont(const Font * pFont)559 void SvxNumberFormat::SetBulletFont(const Font* pFont)
560 {
561 	delete pBulletFont;
562 	pBulletFont = pFont ? new Font(*pFont): 0;
563 }
564 
565 // --> OD 2008-01-09 #newlistlevelattrs#
GetPositionAndSpaceMode() const566 SvxNumberFormat::SvxNumPositionAndSpaceMode SvxNumberFormat::GetPositionAndSpaceMode() const
567 {
568     return mePositionAndSpaceMode;
569 }
SetPositionAndSpaceMode(SvxNumPositionAndSpaceMode ePositionAndSpaceMode)570 void SvxNumberFormat::SetPositionAndSpaceMode( SvxNumPositionAndSpaceMode ePositionAndSpaceMode )
571 {
572     mePositionAndSpaceMode = ePositionAndSpaceMode;
573 }
574 
GetLSpace() const575 short SvxNumberFormat::GetLSpace() const
576 {
577 //#if OSL_DEBUG_LEVEL > 1
578 //    DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION,
579 //                "<SvxNumberFormat::GetLSpace()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION");
580 //#endif
581     return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION ? nLSpace : 0;
582 }
GetAbsLSpace() const583 short SvxNumberFormat::GetAbsLSpace() const
584 {
585 //#if OSL_DEBUG_LEVEL > 1
586 //    DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION,
587 //                "<SvxNumberFormat::GetAbsLSpace()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION");
588 //#endif
589     return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION
590            ? nAbsLSpace
591            : static_cast<short>( GetFirstLineIndent() + GetIndentAt() );
592 }
GetFirstLineOffset() const593 short SvxNumberFormat::GetFirstLineOffset() const
594 {
595 //#if OSL_DEBUG_LEVEL > 1
596 //    DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION,
597 //                "<SvxNumberFormat::GetFirstLineOffset()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION");
598 //#endif
599     return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION
600            ? nFirstLineOffset
601            : static_cast<short>( GetFirstLineIndent() );
602 }
GetCharTextDistance() const603 short SvxNumberFormat::GetCharTextDistance() const
604 {
605 //#if OSL_DEBUG_LEVEL > 1
606 //    DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION,
607 //                "<SvxNumberFormat::GetCharTextDistance()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION");
608 //#endif
609     return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION ? nCharTextDistance : 0;
610 }
611 
SetLabelFollowedBy(const SvxNumLabelFollowedBy eLabelFollowedBy)612 void SvxNumberFormat::SetLabelFollowedBy( const SvxNumLabelFollowedBy eLabelFollowedBy )
613 {
614     meLabelFollowedBy = eLabelFollowedBy;
615 }
GetLabelFollowedBy() const616 SvxNumberFormat::SvxNumLabelFollowedBy SvxNumberFormat::GetLabelFollowedBy() const
617 {
618     return meLabelFollowedBy;
619 }
SetListtabPos(const long nListtabPos)620 void SvxNumberFormat::SetListtabPos( const long nListtabPos )
621 {
622     mnListtabPos = nListtabPos;
623 }
GetListtabPos() const624 long SvxNumberFormat::GetListtabPos() const
625 {
626     return mnListtabPos;
627 }
SetFirstLineIndent(const long nFirstLineIndent)628 void SvxNumberFormat::SetFirstLineIndent( const long nFirstLineIndent )
629 {
630     mnFirstLineIndent = nFirstLineIndent;
631 }
GetFirstLineIndent() const632 long SvxNumberFormat::GetFirstLineIndent() const
633 {
634     return mnFirstLineIndent;
635 }
SetIndentAt(const long nIndentAt)636 void SvxNumberFormat::SetIndentAt( const long nIndentAt )
637 {
638     mnIndentAt = nIndentAt;
639 }
GetIndentAt() const640 long SvxNumberFormat::GetIndentAt() const
641 {
642     return mnIndentAt;
643 }
644 // <--
645 
646 /* -----------------28.10.98 10:03-------------------
647  *
648  * --------------------------------------------------*/
IMPL_STATIC_LINK(SvxNumberFormat,GraphicArrived,void *,EMPTYARG)649 IMPL_STATIC_LINK( SvxNumberFormat, GraphicArrived, void *, EMPTYARG )
650 {
651 	// ggfs. die GrfSize setzen:
652 	if( !pThis->aGraphicSize.Width() || !pThis->aGraphicSize.Height() )
653 	{
654 		const Graphic* pGrf = pThis->pGraphicBrush->GetGraphic();
655 		if( pGrf )
656 			pThis->aGraphicSize = SvxNumberFormat::GetGraphicSizeMM100( pGrf );
657 	}
658     pThis->NotifyGraphicArrived();
659 	return 0;
660 }
661 /* -----------------------------02.07.01 15:36--------------------------------
662 
663  ---------------------------------------------------------------------------*/
NotifyGraphicArrived()664 void SvxNumberFormat::NotifyGraphicArrived()
665 {
666 }
667 
668 /* -----------------28.10.98 10:38-------------------
669  *
670  * --------------------------------------------------*/
GetGraphicSizeMM100(const Graphic * pGraphic)671 Size SvxNumberFormat::GetGraphicSizeMM100(const Graphic* pGraphic)
672 {
673 	const MapMode aMapMM100( MAP_100TH_MM );
674 	const Size& rSize = pGraphic->GetPrefSize();
675 	Size aRetSize;
676 	if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
677 	{
678 		OutputDevice* pOutDev = Application::GetDefaultDevice();
679 		MapMode aOldMap( pOutDev->GetMapMode() );
680 		pOutDev->SetMapMode( aMapMM100 );
681 		aRetSize = pOutDev->PixelToLogic( rSize );
682 		pOutDev->SetMapMode( aOldMap );
683 	}
684 	else
685 		aRetSize = OutputDevice::LogicToLogic( rSize, pGraphic->GetPrefMapMode(), aMapMM100 );
686 	return aRetSize;
687 }
688 /* -----------------28.10.98 15:57-------------------
689  *
690  * --------------------------------------------------*/
CreateRomanString(sal_uLong nNo,sal_Bool bUpper)691 String SvxNumberFormat::CreateRomanString( sal_uLong nNo, sal_Bool bUpper )
692 {
693 	nNo %= 4000;			// mehr kann nicht dargestellt werden
694 //		i, ii, iii, iv, v, vi, vii, vii, viii, ix
695 //							(Dummy),1000,500,100,50,10,5,1
696 	const char *cRomanArr = bUpper
697 						? "MDCLXVI--"	// +2 Dummy-Eintraege !!
698 						: "mdclxvi--";	// +2 Dummy-Eintraege !!
699 
700 	String sRet;
701 	sal_uInt16 nMask = 1000;
702 	while( nMask )
703 	{
704 		sal_uInt8 nZahl = sal_uInt8(nNo / nMask);
705 		sal_uInt8 nDiff = 1;
706 		nNo %= nMask;
707 
708 		if( 5 < nZahl )
709 		{
710 			if( nZahl < 9 )
711 				sRet += sal_Unicode(*(cRomanArr-1));
712 			++nDiff;
713 			nZahl -= 5;
714 		}
715 		switch( nZahl )
716 		{
717 		case 3:		{ sRet += sal_Unicode(*cRomanArr); }
718 		case 2:		{ sRet += sal_Unicode(*cRomanArr); }
719 		case 1:		{ sRet += sal_Unicode(*cRomanArr); }
720 					break;
721 
722 		case 4:		{
723 						sRet += sal_Unicode(*cRomanArr);
724 						sRet += sal_Unicode(*(cRomanArr-nDiff));
725 					}
726 					break;
727 		case 5:		{ sRet += sal_Unicode(*(cRomanArr-nDiff)); }
728 					break;
729 		}
730 
731 		nMask /= 10;			// zur naechsten Dekade
732 		cRomanArr += 2;
733 	}
734 	return sRet;
735 }
736 #ifdef OLD_NUMBER_FORMATTING
GetCharStr(sal_uLong nNo,String & rStr) const737 void SvxNumberFormat::GetCharStr( sal_uLong nNo, String& rStr ) const
738 {
739 	DBG_ASSERT( nNo, "0 ist eine ungueltige Nummer !!" );
740 
741 	const sal_uLong coDiff = 'Z' - 'A' +1;
742 	char cAdd = (SVX_NUM_CHARS_UPPER_LETTER == eNumType ? 'A' : 'a') - 1;
743 	sal_uLong nCalc;
744 
745 	do {
746 		nCalc = nNo % coDiff;
747 		if( !nCalc )
748 			nCalc = coDiff;
749 		rStr.Insert( sal_Unicode(cAdd + nCalc ), 0 );
750 		nNo -= nCalc;
751 		if( nNo )
752 			nNo /= coDiff;
753 	} while( nNo );
754 }
755 
GetCharStrN(sal_uLong nNo,String & rStr) const756 void SvxNumberFormat::GetCharStrN( sal_uLong nNo, String& rStr ) const
757 {
758 	DBG_ASSERT( nNo, "0 ist eine ungueltige Nummer !!" );
759 
760 	const sal_uLong coDiff = 'Z' - 'A' +1;
761 	char cChar = (char)(--nNo % coDiff);
762 	if( SVX_NUM_CHARS_UPPER_LETTER_N == eNumType )
763 		cChar += 'A';
764 	else
765 		cChar += 'a';
766 
767 	rStr.Fill( (sal_uInt16)(nNo / coDiff) + 1, sal_Unicode(cChar) );
768 }
769 #endif //OLD_NUMBER_FORMATTING
770 /* -----------------------------22.02.01 13:31--------------------------------
771 
772  ---------------------------------------------------------------------------*/
GetCharFmtName() const773 const String&	SvxNumberFormat::GetCharFmtName()const
774 {
775 	return sCharStyleName;
776 }
777 /* -----------------27.10.98 10:38-------------------
778  *
779  * --------------------------------------------------*/
780 sal_Int32 SvxNumRule::nRefCount = 0;
781 static SvxNumberFormat*	pStdNumFmt = 0;
782 static SvxNumberFormat*	pStdOutlineNumFmt = 0;
783 // --> OD 2008-02-11 #newlistlevelattrs#
SvxNumRule(sal_uLong nFeatures,sal_uInt16 nLevels,sal_Bool bCont,SvxNumRuleType eType,SvxNumberFormat::SvxNumPositionAndSpaceMode eDefaultNumberFormatPositionAndSpaceMode)784 SvxNumRule::SvxNumRule( sal_uLong nFeatures,
785                         sal_uInt16 nLevels,
786                         sal_Bool bCont,
787                         SvxNumRuleType eType,
788                         SvxNumberFormat::SvxNumPositionAndSpaceMode
789                                     eDefaultNumberFormatPositionAndSpaceMode )
790     : nLevelCount(nLevels),
791       nFeatureFlags(nFeatures),
792       eNumberingType(eType),
793       bContinuousNumbering(bCont)
794 {
795 	++nRefCount;
796     LanguageType eLang = Application::GetSettings().GetLanguage();
797 	aLocale = SvxCreateLocale(eLang);
798 	for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
799 	{
800 		if(i < nLevels)
801 		{
802 			aFmts[i] = new SvxNumberFormat(SVX_NUM_CHARS_UPPER_LETTER);
803 			//daran wird zwischen writer und draw unterschieden
804 			if(nFeatures & NUM_CONTINUOUS)
805 			{
806                 // --> OD 2008-02-11 #newlistlevelattrs#
807                 if ( eDefaultNumberFormatPositionAndSpaceMode ==
808                                     SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
809                 {
810                     aFmts[i]->SetLSpace( MM100_TO_TWIP(DEF_WRITER_LSPACE) );
811                     aFmts[i]->SetAbsLSpace( MM100_TO_TWIP(DEF_WRITER_LSPACE * (i+1)) );
812                     aFmts[i]->SetFirstLineOffset(MM100_TO_TWIP(-DEF_WRITER_LSPACE));
813                 }
814                 else if ( eDefaultNumberFormatPositionAndSpaceMode ==
815                                             SvxNumberFormat::LABEL_ALIGNMENT )
816                 {
817                     // first line indent of general numbering in inch: -0,25 inch
818                     const long cFirstLineIndent = -1440/4;
819                     // indent values of general numbering in inch:
820                     //  0,5         0,75        1,0         1,25        1,5
821                     //  1,75        2,0         2,25        2,5         2,75
822                     const long cIndentAt = 1440/4;
823                     aFmts[i]->SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT );
824                     aFmts[i]->SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
825                     aFmts[i]->SetListtabPos( cIndentAt * (i+2) );
826                     aFmts[i]->SetFirstLineIndent( cFirstLineIndent );
827                     aFmts[i]->SetIndentAt( cIndentAt * (i+2) );
828                 }
829                 // <--
830 			}
831 			else
832 			{
833 				aFmts[i]->SetLSpace( DEF_DRAW_LSPACE );
834 				aFmts[i]->SetAbsLSpace( DEF_DRAW_LSPACE * (i) );
835 			}
836 		}
837 		else
838 			aFmts[i] = 0;
839 		aFmtsSet[i] = sal_False;
840 	}
841 }
842 /* -----------------27.10.98 10:41-------------------
843  *
844  * --------------------------------------------------*/
SvxNumRule(const SvxNumRule & rCopy)845 SvxNumRule::SvxNumRule(const SvxNumRule& rCopy)
846 {
847 	++nRefCount;
848 	aLocale				= rCopy.aLocale;
849 	nLevelCount          = rCopy.nLevelCount         ;
850 	nFeatureFlags        = rCopy.nFeatureFlags       ;
851 	bContinuousNumbering = rCopy.bContinuousNumbering;
852 	eNumberingType		 = rCopy.eNumberingType;
853 	memset( aFmts, 0, sizeof( aFmts ));
854 	for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
855 	{
856 		if(rCopy.aFmts[i])
857 			aFmts[i] = new SvxNumberFormat(*rCopy.aFmts[i]);
858 		else
859 			aFmts[i] = 0;
860 		aFmtsSet[i] = rCopy.aFmtsSet[i];
861 	}
862 }
863 /* -----------------08.12.98 11:07-------------------
864  *
865  * --------------------------------------------------*/
SvxNumRule(SvStream & rStream)866 SvxNumRule::SvxNumRule(SvStream &rStream)
867 {
868     ++nRefCount;
869     LanguageType eLang = Application::GetSettings().GetLanguage();
870     aLocale = SvxCreateLocale(eLang);
871     sal_uInt16 nVersion;
872     sal_uInt16 nTemp;
873     rStream >> nVersion;
874     rStream >> nLevelCount;
875     rStream >> nTemp;
876     nFeatureFlags = nTemp;
877     rStream >> nTemp;
878     bContinuousNumbering = (sal_Bool)nTemp;
879     rStream >> nTemp;
880     eNumberingType       = (SvxNumRuleType)nTemp;
881     memset( aFmts, 0, sizeof( aFmts ));
882 
883     for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
884     {
885         sal_uInt16 nSet;
886         rStream >> nSet;
887         if(nSet)
888             aFmts[i] = new SvxNumberFormat(rStream);
889         else
890             aFmts[i] = 0;
891         aFmtsSet[i] = aFmts[i] ? sal_True : sal_False;
892     }
893     if(NUMITEM_VERSION_02 <= nVersion)
894     {
895         sal_uInt16 nShort;
896         rStream >> nShort;
897         nFeatureFlags = nShort;
898     }
899 }
900 
901 /* -----------------08.12.98 11:07-------------------
902  *
903  * --------------------------------------------------*/
Store(SvStream & rStream)904 SvStream&   SvxNumRule::Store(SvStream &rStream)
905 {
906     rStream<<(sal_uInt16)NUMITEM_VERSION_03;
907     rStream<<nLevelCount;
908     //first save of nFeatureFlags for old versions
909     rStream<<(sal_uInt16)nFeatureFlags;
910     rStream<<(sal_uInt16)bContinuousNumbering;
911     rStream<<(sal_uInt16)eNumberingType;
912 
913     FontToSubsFontConverter pConverter = 0;
914     sal_Bool bConvertBulletFont = rStream.GetVersion() <= SOFFICE_FILEFORMAT_50;
915     for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
916     {
917         if(aFmts[i])
918         {
919             rStream << sal_uInt16(1);
920             if(bConvertBulletFont && aFmts[i]->GetBulletFont())
921             {
922                 if(!pConverter)
923                     pConverter =
924                         CreateFontToSubsFontConverter(aFmts[i]->GetBulletFont()->GetName(),
925                                     FONTTOSUBSFONT_EXPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS);
926             }
927             aFmts[i]->Store(rStream, pConverter);
928         }
929         else
930             rStream << sal_uInt16(0);
931     }
932     //second save of nFeatureFlags for new versions
933     rStream<<(sal_uInt16)nFeatureFlags;
934     if(pConverter)
935         DestroyFontToSubsFontConverter(pConverter);
936 
937     return rStream;
938 }
939 
940 /* -----------------27.10.98 10:41-------------------
941  *
942  * --------------------------------------------------*/
~SvxNumRule()943 SvxNumRule::~SvxNumRule()
944 {
945 	for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
946 		delete aFmts[i];
947 	if(!--nRefCount)
948 	{
949 		DELETEZ(pStdNumFmt);
950 		DELETEZ(pStdOutlineNumFmt);
951 	}
952 }
953 /* -----------------29.10.98 16:07-------------------
954  *
955  * --------------------------------------------------*/
operator =(const SvxNumRule & rCopy)956 SvxNumRule& SvxNumRule::operator=( const SvxNumRule& rCopy )
957 {
958 	nLevelCount          = rCopy.nLevelCount;
959 	nFeatureFlags        = rCopy.nFeatureFlags;
960 	bContinuousNumbering = rCopy.bContinuousNumbering;
961 	eNumberingType       = rCopy.eNumberingType;
962 	for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
963 	{
964 		delete aFmts[i];
965 		if(rCopy.aFmts[i])
966 			aFmts[i] = new SvxNumberFormat(*rCopy.aFmts[i]);
967 		else
968 			aFmts[i] = 0;
969 		aFmtsSet[i] = rCopy.aFmtsSet[i];
970 	}
971 	return *this;
972 }
973 /* -----------------27.10.98 10:41-------------------
974  *
975  * --------------------------------------------------*/
operator ==(const SvxNumRule & rCopy) const976 int   SvxNumRule::operator==( const SvxNumRule& rCopy) const
977 {
978 	if(nLevelCount != rCopy.nLevelCount ||
979 		nFeatureFlags != rCopy.nFeatureFlags ||
980 			bContinuousNumbering != rCopy.bContinuousNumbering ||
981 				eNumberingType != rCopy.eNumberingType)
982 			return sal_False;
983 	for(sal_uInt16 i = 0; i < nLevelCount; i++)
984 	{
985 		if (
986             (aFmtsSet[i] != rCopy.aFmtsSet[i]) ||
987 		    (!aFmts[i] && rCopy.aFmts[i]) ||
988 		    (aFmts[i] && !rCopy.aFmts[i]) ||
989 		    (aFmts[i] && *aFmts[i] !=  *rCopy.aFmts[i])
990            )
991         {
992 			return sal_False;
993         }
994 	}
995 	return sal_True;
996 }
997 /* -----------------27.10.98 10:41-------------------
998  *
999  * --------------------------------------------------*/
Get(sal_uInt16 nLevel) const1000 const SvxNumberFormat* 	SvxNumRule::Get(sal_uInt16 nLevel)const
1001 {
1002 	DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" );
1003 	if( nLevel < SVX_MAX_NUM )
1004 		return aFmtsSet[nLevel] ? aFmts[nLevel] : 0;
1005 	else
1006 		return 0;
1007 }
1008 /* -----------------02.11.98 09:10-------------------
1009  *
1010  * --------------------------------------------------*/
GetLevel(sal_uInt16 nLevel) const1011 const SvxNumberFormat& 	SvxNumRule::GetLevel(sal_uInt16 nLevel)const
1012 {
1013 	if(!pStdNumFmt)
1014 	{
1015 		pStdNumFmt = new SvxNumberFormat(SVX_NUM_ARABIC);
1016 	 	pStdOutlineNumFmt = new SvxNumberFormat(SVX_NUM_NUMBER_NONE);
1017 	}
1018 
1019 	DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" );
1020 
1021 	return ( ( nLevel < SVX_MAX_NUM ) && aFmts[nLevel] ) ?
1022 			*aFmts[nLevel] :  eNumberingType == SVX_RULETYPE_NUMBERING ?
1023 														*pStdNumFmt : *pStdOutlineNumFmt;
1024 }
1025 
1026 /* -----------------29.10.98 09:08-------------------
1027  *
1028  * --------------------------------------------------*/
SetLevel(sal_uInt16 i,const SvxNumberFormat & rNumFmt,sal_Bool bIsValid)1029 void SvxNumRule::SetLevel( sal_uInt16 i, const SvxNumberFormat& rNumFmt, sal_Bool bIsValid )
1030 {
1031 	DBG_ASSERT(i < SVX_MAX_NUM, "falsches Level" );
1032 
1033 	if( (i < SVX_MAX_NUM) && (!aFmtsSet[i] || !(rNumFmt == *Get( i ))) )
1034 	{
1035 		delete aFmts[ i ];
1036 		aFmts[ i ] = new SvxNumberFormat( rNumFmt );
1037 		aFmtsSet[i] = bIsValid;
1038 //		bInvalidRuleFlag = sal_True;
1039 	}
1040 }
1041 /* -----------------30.10.98 12:44-------------------
1042  *
1043  * --------------------------------------------------*/
SetLevel(sal_uInt16 nLevel,const SvxNumberFormat * pFmt)1044 void SvxNumRule::SetLevel(sal_uInt16 nLevel, const SvxNumberFormat* pFmt)
1045 {
1046 	DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" );
1047 
1048 	if( nLevel < SVX_MAX_NUM )
1049 	{
1050 		aFmtsSet[nLevel] = 0 != pFmt;
1051 		if(pFmt)
1052 			SetLevel(nLevel, *pFmt);
1053 		else
1054 		{
1055 			delete aFmts[nLevel];
1056 			aFmts[nLevel] = 0;
1057 		}
1058 	}
1059 }
1060 /* -----------------28.10.98 15:38-------------------
1061  *
1062  * --------------------------------------------------*/
MakeNumString(const SvxNodeNum & rNum,sal_Bool bInclStrings) const1063 String 	SvxNumRule::MakeNumString( const SvxNodeNum& rNum, sal_Bool bInclStrings ) const
1064 {
1065 	String aStr;
1066 	if( SVX_NO_NUM > rNum.GetLevel() && !( SVX_NO_NUMLEVEL & rNum.GetLevel() ) )
1067 	{
1068 		const SvxNumberFormat& rMyNFmt = GetLevel( rNum.GetLevel() );
1069 		if( SVX_NUM_NUMBER_NONE != rMyNFmt.GetNumberingType() )
1070 		{
1071 			sal_uInt8 i = rNum.GetLevel();
1072 
1073 			if( !IsContinuousNumbering() &&
1074 				1 < rMyNFmt.GetIncludeUpperLevels() )		// nur der eigene Level ?
1075 			{
1076 				sal_uInt8 n = rMyNFmt.GetIncludeUpperLevels();
1077 				if( 1 < n )
1078 				{
1079 					if( i+1 >= n )
1080 						i -= n - 1;
1081 					else
1082 						i = 0;
1083 				}
1084 			}
1085 
1086 			for( ; i <= rNum.GetLevel(); ++i )
1087 			{
1088 				const SvxNumberFormat& rNFmt = GetLevel( i );
1089 				if( SVX_NUM_NUMBER_NONE == rNFmt.GetNumberingType() )
1090 				{
1091 	// Soll aus 1.1.1 --> 2. NoNum --> 1..1 oder 1.1 ??
1092 	//                 if( i != rNum.nMyLevel )
1093 	//                    aStr += aDotStr;
1094 					continue;
1095 				}
1096 
1097 				sal_Bool bDot = sal_True;
1098 				if( rNum.GetLevelVal()[ i ] )
1099 				{
1100 					if(SVX_NUM_BITMAP != rNFmt.GetNumberingType())
1101 						aStr += rNFmt.GetNumStr( rNum.GetLevelVal()[ i ], aLocale );
1102 					else
1103 						bDot = sal_False;
1104 				}
1105 				else
1106 					aStr += sal_Unicode('0');		// alle 0-Level sind eine 0
1107 				if( i != rNum.GetLevel() && bDot)
1108 					aStr += sal_Unicode('.');
1109 			}
1110 		}
1111 
1112 		if( bInclStrings )
1113 		{
1114 			aStr.Insert( rMyNFmt.GetPrefix(), 0 );
1115 			aStr += rMyNFmt.GetSuffix();
1116 		}
1117 	}
1118 	return aStr;
1119 }
1120 /* -----------------18.08.99 10:18-------------------
1121 	Description: changes linked to embedded bitmaps
1122  --------------------------------------------------*/
UnLinkGraphics()1123 sal_Bool SvxNumRule::UnLinkGraphics()
1124 {
1125 	sal_Bool bRet = sal_False;
1126 	for(sal_uInt16 i = 0; i < GetLevelCount(); i++)
1127 	{
1128 		SvxNumberFormat aFmt(GetLevel(i));
1129 		const SvxBrushItem* pBrush = aFmt.GetBrush();
1130 		const String* pLinkStr;
1131 		const Graphic* pGraphic;
1132 		if(SVX_NUM_BITMAP == aFmt.GetNumberingType())
1133 		{
1134 			if(pBrush &&
1135 				0 != (pLinkStr = pBrush->GetGraphicLink()) &&
1136 					pLinkStr->Len() &&
1137 					0 !=(pGraphic = pBrush->GetGraphic()))
1138 			{
1139 				SvxBrushItem aTempItem(*pBrush);
1140 				aTempItem.SetGraphicLink( String());
1141 				aTempItem.SetGraphic(*pGraphic);
1142                 sal_Int16    eOrient = aFmt.GetVertOrient();
1143 				aFmt.SetGraphicBrush( &aTempItem, &aFmt.GetGraphicSize(), &eOrient );
1144 				bRet = sal_True;
1145 			}
1146 		}
1147 		else if((SVX_NUM_BITMAP|LINK_TOKEN) == aFmt.GetNumberingType())
1148 			aFmt.SetNumberingType(SVX_NUM_BITMAP);
1149 		SetLevel(i, aFmt);
1150 	}
1151 	return bRet;
1152 }
1153 
1154 /* -----------------27.10.98 10:41-------------------
1155  *
1156  * --------------------------------------------------*/
SvxNumBulletItem(SvxNumRule & rRule)1157 SvxNumBulletItem::SvxNumBulletItem(SvxNumRule& rRule) :
1158 	SfxPoolItem(SID_ATTR_NUMBERING_RULE),
1159 	pNumRule(new SvxNumRule(rRule))
1160 {
1161 }
1162 
1163 /*-----------------23.11.98 10:36-------------------
1164  MT: Das sind ja sehr sinnige Kommentare...
1165 --------------------------------------------------*/
SvxNumBulletItem(SvxNumRule & rRule,sal_uInt16 _nWhich)1166 SvxNumBulletItem::SvxNumBulletItem(SvxNumRule& rRule, sal_uInt16 _nWhich ) :
1167     SfxPoolItem(_nWhich),
1168 	pNumRule(new SvxNumRule(rRule))
1169 {
1170 }
1171 
Create(SvStream & s,sal_uInt16 n) const1172 SfxPoolItem* SvxNumBulletItem::Create(SvStream &s, sal_uInt16 n) const
1173 {
1174     return SfxPoolItem::Create(s, n );
1175 }
1176 
1177 /* -----------------27.10.98 10:41-------------------
1178  *
1179  * --------------------------------------------------*/
SvxNumBulletItem(const SvxNumBulletItem & rCopy)1180 SvxNumBulletItem::SvxNumBulletItem(const SvxNumBulletItem& rCopy) :
1181 	SfxPoolItem(rCopy.Which())
1182 {
1183 	pNumRule = new SvxNumRule(*rCopy.pNumRule);
1184 }
1185 /* -----------------27.10.98 10:41-------------------
1186  *
1187  * --------------------------------------------------*/
~SvxNumBulletItem()1188 SvxNumBulletItem::~SvxNumBulletItem()
1189 {
1190 	delete pNumRule;
1191 }
1192 
1193 /* -----------------27.10.98 10:41-------------------
1194  *
1195  * --------------------------------------------------*/
operator ==(const SfxPoolItem & rCopy) const1196 int  SvxNumBulletItem::operator==( const SfxPoolItem& rCopy) const
1197 {
1198 	return *pNumRule == *((SvxNumBulletItem&)rCopy).pNumRule;
1199 }
1200 /* -----------------27.10.98 10:41-------------------
1201  *
1202  * --------------------------------------------------*/
Clone(SfxItemPool *) const1203 SfxPoolItem*  SvxNumBulletItem::Clone( SfxItemPool * ) const
1204 {
1205 	return new SvxNumBulletItem(*this);
1206 }
1207 /* -----------------08.12.98 10:43-------------------
1208  *
1209  * --------------------------------------------------*/
GetVersion(sal_uInt16) const1210 sal_uInt16  SvxNumBulletItem::GetVersion( sal_uInt16 /*nFileVersion*/ ) const
1211 {
1212     return NUMITEM_VERSION_03;
1213 }
1214 /* -----------------08.12.98 10:43-------------------
1215  *
1216  * --------------------------------------------------*/
Store(SvStream & rStream,sal_uInt16) const1217 SvStream&   SvxNumBulletItem::Store(SvStream &rStream, sal_uInt16 /*nItemVersion*/ )const
1218 {
1219     pNumRule->Store(rStream);
1220     return rStream;
1221 }
1222 
1223 /* -----------------08.12.98 10:43-------------------
1224  *
1225  * --------------------------------------------------*/
1226 
QueryValue(com::sun::star::uno::Any & rVal,sal_uInt8) const1227 sal_Bool SvxNumBulletItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
1228 {
1229 	rVal <<= SvxCreateNumRule( pNumRule );
1230 	return sal_True;
1231 }
1232 
PutValue(const com::sun::star::uno::Any & rVal,sal_uInt8)1233 sal_Bool SvxNumBulletItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
1234 {
1235 	uno::Reference< container::XIndexReplace > xRule;
1236 	if( rVal >>= xRule )
1237 	{
1238 		try
1239 		{
1240 			SvxNumRule* pNewRule = new SvxNumRule( SvxGetNumRule( xRule ) );
1241 			if( pNewRule->GetLevelCount() != pNumRule->GetLevelCount() ||
1242 				pNewRule->GetNumRuleType() != pNumRule->GetNumRuleType() )
1243 			{
1244 				SvxNumRule* pConverted = SvxConvertNumRule( pNewRule, pNumRule->GetLevelCount(), pNumRule->GetNumRuleType() );
1245 				delete pNewRule;
1246 				pNewRule = pConverted;
1247 			}
1248 			delete pNumRule;
1249 			pNumRule = pNewRule;
1250 			return sal_True;
1251 		}
1252 		catch(lang::IllegalArgumentException&)
1253 		{
1254 		}
1255 	}
1256 	return sal_False;
1257 }
1258 
1259 /* -----------------08.12.98 10:43-------------------
1260  *
1261  * --------------------------------------------------*/
SvxConvertNumRule(const SvxNumRule * pRule,sal_uInt16 nLevels,SvxNumRuleType eType)1262 SvxNumRule* SvxConvertNumRule( const SvxNumRule* pRule, sal_uInt16 nLevels, SvxNumRuleType eType )
1263 {
1264 	const sal_uInt16 nSrcLevels = pRule->GetLevelCount();
1265 	SvxNumRule* pNewRule = new SvxNumRule( pRule->GetFeatureFlags(), nLevels, pRule->IsContinuousNumbering(), eType );
1266 
1267 	for( sal_uInt16 nLevel = 0; (nLevel < nLevels) && (nLevel < nSrcLevels); nLevel++ )
1268 		pNewRule->SetLevel( nLevel, pRule->GetLevel( nLevel ) );
1269 
1270 	return pNewRule;
1271 }
1272