Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <com/sun/star/text/HoriOrientation.hpp>
21 : #include <com/sun/star/awt/XBitmap.hpp>
22 : #include <cppuhelper/supportsservice.hxx>
23 : #include <vcl/svapp.hxx>
24 : #include <osl/mutex.hxx>
25 : #include <vcl/graph.hxx>
26 : #include <svtools/grfmgr.hxx>
27 : #include <toolkit/helper/vclunohelper.hxx>
28 :
29 : #include <editeng/brushitem.hxx>
30 : #include <editeng/unoprnms.hxx>
31 : #include <editeng/numitem.hxx>
32 : #include <editeng/eeitem.hxx>
33 : #include <editeng/unotext.hxx>
34 : #include <editeng/unofdesc.hxx>
35 : #include <editeng/unonrule.hxx>
36 : #include <editeng/editids.hrc>
37 : #include <editeng/numdef.hxx>
38 : #include <boost/scoped_array.hpp>
39 :
40 : using ::com::sun::star::util::XCloneable;
41 : using ::com::sun::star::ucb::XAnyCompare;
42 :
43 :
44 : using namespace ::std;
45 : using namespace ::com::sun::star;
46 : using namespace ::com::sun::star::uno;
47 : using namespace ::com::sun::star::lang;
48 : using namespace ::com::sun::star::container;
49 :
50 : const SvxAdjust aUnoToSvxAdjust[] =
51 : {
52 : SVX_ADJUST_LEFT,
53 : SVX_ADJUST_RIGHT,
54 : SVX_ADJUST_CENTER,
55 : SVX_ADJUST_LEFT,
56 : SVX_ADJUST_LEFT,
57 : SVX_ADJUST_LEFT,
58 : SVX_ADJUST_BLOCK
59 : };
60 :
61 : const unsigned short aSvxToUnoAdjust[] =
62 : {
63 : text::HoriOrientation::LEFT,
64 : text::HoriOrientation::RIGHT,
65 : text::HoriOrientation::FULL,
66 : text::HoriOrientation::CENTER,
67 : text::HoriOrientation::FULL,
68 : text::HoriOrientation::LEFT
69 : };
70 :
71 4136 : SvxAdjust ConvertUnoAdjust( unsigned short nAdjust )
72 : {
73 : DBG_ASSERT( nAdjust <= 7, "Enum hat sich geaendert! [CL]" );
74 4136 : return aUnoToSvxAdjust[nAdjust];
75 : }
76 :
77 1746 : unsigned short ConvertUnoAdjust( SvxAdjust eAdjust )
78 : {
79 : DBG_ASSERT( eAdjust <= 6, "Enum hat sich geaendert! [CL]" );
80 1746 : return aSvxToUnoAdjust[eAdjust];
81 : }
82 :
83 11688 : UNO3_GETIMPLEMENTATION_IMPL( SvxUnoNumberingRules );
84 :
85 7276 : SvxUnoNumberingRules::SvxUnoNumberingRules( const SvxNumRule& rRule ) throw()
86 7276 : : maRule( rRule )
87 : {
88 7276 : }
89 :
90 14552 : SvxUnoNumberingRules::~SvxUnoNumberingRules() throw()
91 : {
92 14552 : }
93 :
94 : //XIndexReplace
95 4140 : void SAL_CALL SvxUnoNumberingRules::replaceByIndex( sal_Int32 Index, const uno::Any& Element )
96 : throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
97 : {
98 4140 : SolarMutexGuard aGuard;
99 :
100 4140 : if( Index < 0 || Index >= maRule.GetLevelCount() )
101 2 : throw IndexOutOfBoundsException();
102 :
103 8276 : Sequence< beans::PropertyValue > aSeq;
104 :
105 4138 : if( !( Element >>= aSeq) )
106 2 : throw IllegalArgumentException();
107 8276 : setNumberingRuleByIndex( aSeq, Index );
108 4136 : }
109 :
110 : // XIndexAccess
111 712 : sal_Int32 SAL_CALL SvxUnoNumberingRules::getCount() throw( RuntimeException, std::exception )
112 : {
113 712 : SolarMutexGuard aGuard;
114 :
115 712 : return maRule.GetLevelCount();
116 : }
117 :
118 1748 : Any SAL_CALL SvxUnoNumberingRules::getByIndex( sal_Int32 Index )
119 : throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
120 : {
121 1748 : SolarMutexGuard aGuard;
122 :
123 1748 : if( Index < 0 || Index >= maRule.GetLevelCount() )
124 2 : throw IndexOutOfBoundsException();
125 :
126 1746 : return Any( getNumberingRuleByIndex(Index) );
127 : }
128 :
129 : //XElementAccess
130 2 : Type SAL_CALL SvxUnoNumberingRules::getElementType()
131 : throw( RuntimeException, std::exception )
132 : {
133 2 : return ::getCppuType(( const Sequence< beans::PropertyValue >*)0);
134 : }
135 :
136 2 : sal_Bool SAL_CALL SvxUnoNumberingRules::hasElements() throw( RuntimeException, std::exception )
137 : {
138 2 : return sal_True;
139 : }
140 :
141 : // XAnyCompare
142 76 : sal_Int16 SAL_CALL SvxUnoNumberingRules::compare( const Any& rAny1, const Any& rAny2 ) throw(RuntimeException, std::exception)
143 : {
144 76 : return SvxUnoNumberingRules::Compare( rAny1, rAny2 );
145 : }
146 :
147 : // XCloneable
148 0 : Reference< XCloneable > SAL_CALL SvxUnoNumberingRules::createClone( ) throw (RuntimeException, std::exception)
149 : {
150 0 : return new SvxUnoNumberingRules(maRule);
151 : }
152 :
153 : // XServiceInfo
154 : const char pSvxUnoNumberingRulesService[] = "com.sun.star.text.NumberingRules";
155 :
156 2 : OUString SAL_CALL SvxUnoNumberingRules::getImplementationName( ) throw(RuntimeException, std::exception)
157 : {
158 2 : return OUString( "SvxUnoNumberingRules" );
159 : }
160 :
161 0 : sal_Bool SAL_CALL SvxUnoNumberingRules::supportsService( const OUString& ServiceName ) throw(RuntimeException, std::exception)
162 : {
163 0 : return cppu::supportsService(this, ServiceName);
164 : }
165 :
166 0 : Sequence< OUString > SAL_CALL SvxUnoNumberingRules::getSupportedServiceNames( ) throw(RuntimeException, std::exception)
167 : {
168 0 : OUString aService( pSvxUnoNumberingRulesService );
169 0 : Sequence< OUString > aSeq( &aService, 1 );
170 0 : return aSeq;
171 : }
172 :
173 1746 : Sequence<beans::PropertyValue> SvxUnoNumberingRules::getNumberingRuleByIndex(sal_Int32 nIndex) const
174 : throw (RuntimeException)
175 : {
176 : // NumberingRule aRule;
177 1746 : const SvxNumberFormat& rFmt = maRule.GetLevel((sal_uInt16) nIndex);
178 1746 : sal_uInt16 nIdx = 0;
179 :
180 1746 : const int nProps = 15;
181 1746 : boost::scoped_array<beans::PropertyValue> pArray(new beans::PropertyValue[nProps]);
182 :
183 3492 : Any aVal;
184 : {
185 1746 : aVal <<= rFmt.GetNumberingType();
186 1746 : beans::PropertyValue aAlignProp( OUString(UNO_NAME_NRULE_NUMBERINGTYPE), -1, aVal, beans::PropertyState_DIRECT_VALUE);
187 1746 : pArray[nIdx++] = aAlignProp;
188 : }
189 :
190 : {
191 1746 : SvxAdjust eAdj = rFmt.GetNumAdjust();
192 1746 : aVal <<= ConvertUnoAdjust(eAdj);
193 1746 : pArray[nIdx++] = beans::PropertyValue( OUString(UNO_NAME_NRULE_ADJUST), -1, aVal, beans::PropertyState_DIRECT_VALUE);
194 : }
195 :
196 : {
197 1746 : aVal <<= OUString(rFmt.GetPrefix());
198 1746 : beans::PropertyValue aPrefixProp( OUString(UNO_NAME_NRULE_PREFIX), -1, aVal, beans::PropertyState_DIRECT_VALUE);
199 1746 : pArray[nIdx++] = aPrefixProp;
200 : }
201 :
202 : {
203 1746 : aVal <<= OUString(rFmt.GetSuffix());
204 1746 : beans::PropertyValue aSuffixProp( OUString(UNO_NAME_NRULE_SUFFIX), -1, aVal, beans::PropertyState_DIRECT_VALUE);
205 1746 : pArray[nIdx++] = aSuffixProp;
206 : }
207 :
208 1746 : if(SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType())
209 : {
210 704 : sal_Unicode nCode = rFmt.GetBulletChar();
211 704 : OUString aStr( &nCode, 1 );
212 704 : aVal <<= aStr;
213 1408 : beans::PropertyValue aBulletProp( OUString("BulletChar"), -1, aVal, beans::PropertyState_DIRECT_VALUE);
214 1408 : pArray[nIdx++] = aBulletProp;
215 : }
216 :
217 1746 : if( rFmt.GetBulletFont() )
218 : {
219 726 : awt::FontDescriptor aDesc;
220 726 : SvxUnoFontDescriptor::ConvertFromFont( *rFmt.GetBulletFont(), aDesc );
221 726 : aVal.setValue(&aDesc, ::cppu::UnoType<awt::FontDescriptor>::get());
222 726 : pArray[nIdx++] = beans::PropertyValue( OUString(UNO_NAME_NRULE_BULLET_FONT), -1, aVal, beans::PropertyState_DIRECT_VALUE);
223 : }
224 :
225 : {
226 1746 : const SvxBrushItem* pBrush = rFmt.GetBrush();
227 1746 : if(pBrush && pBrush->GetGraphicObject())
228 : {
229 0 : const GraphicObject* pGrafObj = pBrush->GetGraphicObject();
230 0 : OUString aURL( UNO_NAME_GRAPHOBJ_URLPREFIX);
231 0 : aURL += OStringToOUString(pGrafObj->GetUniqueID(),
232 0 : RTL_TEXTENCODING_ASCII_US);
233 :
234 0 : aVal <<= aURL;
235 0 : const beans::PropertyValue aGraphicProp( OUString("GraphicURL"), -1, aVal, beans::PropertyState_DIRECT_VALUE);
236 0 : pArray[nIdx++] = aGraphicProp;
237 : }
238 : }
239 :
240 : {
241 1746 : const Size aSize( rFmt.GetGraphicSize() );
242 1746 : const awt::Size aUnoSize( aSize.Width(), aSize.Height() );
243 1746 : aVal <<= aUnoSize;
244 1746 : const beans::PropertyValue aGraphicSizeProp(OUString("GraphicSize"), -1, aVal, beans::PropertyState_DIRECT_VALUE );
245 1746 : pArray[nIdx++] = aGraphicSizeProp;
246 : }
247 :
248 1746 : aVal <<= (sal_Int16)rFmt.GetStart();
249 1746 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_START_WITH), -1, aVal, beans::PropertyState_DIRECT_VALUE);
250 :
251 1746 : aVal <<= (sal_Int32)rFmt.GetAbsLSpace();
252 1746 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_LEFT_MARGIN), -1, aVal, beans::PropertyState_DIRECT_VALUE);
253 :
254 1746 : aVal <<= (sal_Int32)rFmt.GetFirstLineOffset();
255 1746 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_FIRST_LINE_OFFSET), -1, aVal, beans::PropertyState_DIRECT_VALUE);
256 :
257 1746 : pArray[nIdx++] = beans::PropertyValue(OUString("SymbolTextDistance"), -1, aVal, beans::PropertyState_DIRECT_VALUE);
258 :
259 1746 : aVal <<= (sal_Int32)rFmt.GetBulletColor().GetColor();
260 1746 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_BULLET_COLOR), -1, aVal, beans::PropertyState_DIRECT_VALUE);
261 :
262 1746 : aVal <<= (sal_Int16)rFmt.GetBulletRelSize();
263 1746 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_BULLET_RELSIZE), -1, aVal, beans::PropertyState_DIRECT_VALUE);
264 :
265 : DBG_ASSERT( nIdx <= nProps, "FixMe: overflow in Array!!! [CL]" );
266 1746 : Sequence< beans::PropertyValue> aSeq(pArray.get(), nIdx);
267 :
268 3492 : return aSeq;
269 : }
270 :
271 4136 : void SvxUnoNumberingRules::setNumberingRuleByIndex(const Sequence<beans::PropertyValue >& rProperties, sal_Int32 nIndex)
272 : throw (RuntimeException, IllegalArgumentException, std::exception)
273 : {
274 4136 : SvxNumberFormat aFmt(maRule.GetLevel( (sal_uInt16)nIndex ));
275 4136 : const beans::PropertyValue* pPropArray = rProperties.getConstArray();
276 47292 : for(int i = 0; i < rProperties.getLength(); i++)
277 : {
278 43156 : const beans::PropertyValue& rProp = pPropArray[i];
279 43156 : const OUString& rPropName = rProp.Name;
280 43156 : const Any& aVal = rProp.Value;
281 :
282 43156 : if ( rPropName == UNO_NAME_NRULE_NUMBERINGTYPE )
283 : {
284 2756 : sal_Int16 nSet = sal_Int16();
285 2756 : aVal >>= nSet;
286 :
287 : // There is no reason to limit numbering types.
288 2756 : if ( nSet>=0 )
289 : {
290 2756 : aFmt.SetNumberingType(nSet);
291 2756 : continue;
292 : }
293 : }
294 40400 : else if ( rPropName == UNO_NAME_NRULE_PREFIX )
295 : {
296 1808 : OUString aPrefix;
297 1808 : if( aVal >>= aPrefix )
298 : {
299 1808 : aFmt.SetPrefix(aPrefix);
300 1808 : continue;
301 0 : }
302 : }
303 38592 : else if ( rPropName == UNO_NAME_NRULE_SUFFIX )
304 : {
305 1808 : OUString aSuffix;
306 1808 : if( aVal >>= aSuffix )
307 : {
308 1808 : aFmt.SetSuffix(aSuffix);
309 1808 : continue;
310 0 : }
311 : }
312 36784 : else if ( rPropName == UNO_NAME_NRULE_BULLETID )
313 : {
314 0 : sal_Int16 nSet = sal_Int16();
315 0 : if( aVal >>= nSet )
316 : {
317 0 : if(nSet < 0x100)
318 : {
319 0 : aFmt.SetBulletChar(nSet);
320 0 : continue;
321 : }
322 : }
323 : }
324 36784 : else if ( rPropName == "BulletChar" )
325 : {
326 2518 : OUString aStr;
327 2518 : if( aVal >>= aStr )
328 : {
329 2518 : if(!aStr.isEmpty())
330 : {
331 2518 : aFmt.SetBulletChar(aStr[0]);
332 : }
333 : else
334 : {
335 0 : aFmt.SetBulletChar(0);
336 : }
337 2518 : continue;
338 0 : }
339 : }
340 34266 : else if ( rPropName == UNO_NAME_NRULE_ADJUST )
341 : {
342 4136 : sal_Int16 nAdjust = sal_Int16();
343 4136 : if( aVal >>= nAdjust )
344 : {
345 4136 : aFmt.SetNumAdjust(ConvertUnoAdjust( (unsigned short)nAdjust ));
346 4136 : continue;
347 : }
348 : }
349 30130 : else if ( rPropName == UNO_NAME_NRULE_BULLET_FONT )
350 : {
351 2514 : awt::FontDescriptor aDesc;
352 2514 : if( aVal >>= aDesc )
353 : {
354 2514 : vcl::Font aFont;
355 2514 : SvxUnoFontDescriptor::ConvertToFont( aDesc, aFont );
356 2514 : aFmt.SetBulletFont(&aFont);
357 2514 : continue;
358 0 : }
359 : }
360 27616 : else if ( rPropName == "Graphic" )
361 : {
362 0 : Reference< awt::XBitmap > xBmp;
363 0 : if( aVal >>= xBmp )
364 : {
365 0 : Graphic aGraf( VCLUnoHelper::GetBitmap( xBmp ) );
366 0 : SvxBrushItem aBrushItem(aGraf, GPOS_AREA, SID_ATTR_BRUSH);
367 0 : aFmt.SetGraphicBrush( &aBrushItem );
368 0 : continue;
369 0 : }
370 : }
371 27616 : else if ( rPropName == "GraphicURL" )
372 : {
373 0 : OUString aURL;
374 0 : if( aVal >>= aURL )
375 : {
376 0 : GraphicObject aGrafObj( GraphicObject::CreateGraphicObjectFromURL( aURL ) );
377 0 : SvxBrushItem aBrushItem( aGrafObj, GPOS_AREA, SID_ATTR_BRUSH );
378 0 : aFmt.SetGraphicBrush( &aBrushItem );
379 0 : continue;
380 0 : }
381 : }
382 27616 : else if ( rPropName == "GraphicSize" )
383 : {
384 4 : awt::Size aUnoSize;
385 4 : if( aVal >>= aUnoSize )
386 : {
387 4 : aFmt.SetGraphicSize( Size( aUnoSize.Width, aUnoSize.Height ) );
388 4 : continue;
389 : }
390 : }
391 27612 : else if ( rPropName == UNO_NAME_NRULE_START_WITH )
392 : {
393 74 : sal_Int16 nStart = sal_Int16();
394 74 : if( aVal >>= nStart )
395 : {
396 74 : aFmt.SetStart( nStart );
397 74 : continue;
398 : }
399 : }
400 27538 : else if ( rPropName == UNO_NAME_NRULE_LEFT_MARGIN )
401 : {
402 1926 : sal_Int32 nMargin = 0;
403 1926 : if( aVal >>= nMargin )
404 : {
405 1926 : aFmt.SetAbsLSpace((sal_uInt16)nMargin);
406 1926 : continue;
407 : }
408 : }
409 25612 : else if ( rPropName == UNO_NAME_NRULE_FIRST_LINE_OFFSET )
410 : {
411 1926 : sal_Int32 nMargin = 0;
412 1926 : if( aVal >>= nMargin )
413 : {
414 1926 : aFmt.SetFirstLineOffset((sal_uInt16)nMargin);
415 1926 : continue;
416 : }
417 : }
418 23686 : else if ( rPropName == "SymbolTextDistance" )
419 : {
420 1808 : sal_Int32 nTextDistance = 0;
421 1808 : if( aVal >>= nTextDistance )
422 : {
423 1808 : aFmt.SetCharTextDistance((sal_uInt16)nTextDistance);
424 1808 : continue;
425 : }
426 : }
427 21878 : else if ( rPropName == UNO_NAME_NRULE_BULLET_COLOR )
428 : {
429 3906 : sal_Int32 nColor = 0;
430 3906 : if( aVal >>= nColor )
431 : {
432 3906 : aFmt.SetBulletColor( static_cast<Color>(nColor) );
433 3906 : continue;
434 : }
435 : }
436 17972 : else if ( rPropName == UNO_NAME_NRULE_BULLET_RELSIZE )
437 : {
438 4136 : sal_Int16 nSize = sal_Int16();
439 4136 : if( aVal >>= nSize )
440 : {
441 : // [Bug 120650] the slide content corrupt when open in Aoo
442 4136 : if ((nSize>250)||(nSize<=0))
443 : {
444 0 : nSize = 100;
445 : }
446 :
447 4136 : aFmt.SetBulletRelSize( (short)nSize );
448 4136 : continue;
449 : }
450 : }
451 : else
452 : {
453 13836 : continue;
454 : }
455 :
456 0 : throw IllegalArgumentException();
457 : }
458 :
459 : // check that we always have a brush item for bitmap numbering
460 4136 : if( aFmt.GetNumberingType() == SVX_NUM_BITMAP )
461 : {
462 0 : if( NULL == aFmt.GetBrush() )
463 : {
464 0 : GraphicObject aGrafObj;
465 0 : SvxBrushItem aBrushItem( aGrafObj, GPOS_AREA, SID_ATTR_BRUSH );
466 0 : aFmt.SetGraphicBrush( &aBrushItem );
467 : }
468 : }
469 4136 : maRule.SetLevel( (sal_uInt16)nIndex, aFmt );
470 4136 : }
471 :
472 2528 : const SvxNumRule& SvxGetNumRule( Reference< XIndexReplace > xRule ) throw( IllegalArgumentException )
473 : {
474 2528 : SvxUnoNumberingRules* pRule = SvxUnoNumberingRules::getImplementation( xRule );
475 2528 : if( pRule == NULL )
476 10 : throw IllegalArgumentException();
477 :
478 2518 : return pRule->getNumRule();
479 : }
480 :
481 7276 : com::sun::star::uno::Reference< com::sun::star::container::XIndexReplace > SvxCreateNumRule( const SvxNumRule* pRule ) throw()
482 : {
483 : DBG_ASSERT( pRule, "No default SvxNumRule!" );
484 7276 : if( pRule )
485 : {
486 7276 : return new SvxUnoNumberingRules( *pRule );
487 : }
488 : else
489 : {
490 0 : SvxNumRule aDefaultRule( NUM_BULLET_REL_SIZE|NUM_BULLET_COLOR|NUM_CHAR_TEXT_DISTANCE, SVX_MAX_NUM, false);
491 0 : return new SvxUnoNumberingRules( aDefaultRule );
492 : }
493 : }
494 :
495 2008 : class SvxUnoNumberingRulesCompare : public ::cppu::WeakAggImplHelper1< XAnyCompare >
496 : {
497 : public:
498 : virtual sal_Int16 SAL_CALL compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
499 : };
500 :
501 126 : sal_Int16 SAL_CALL SvxUnoNumberingRulesCompare::compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException, std::exception)
502 : {
503 126 : return SvxUnoNumberingRules::Compare( Any1, Any2 );
504 : }
505 :
506 202 : sal_Int16 SvxUnoNumberingRules::Compare( const Any& Any1, const Any& Any2 )
507 : {
508 404 : Reference< XIndexReplace > x1( Any1, UNO_QUERY ), x2( Any2, UNO_QUERY );
509 202 : if( x1.is() && x2.is() )
510 : {
511 202 : if( x1.get() == x2.get() )
512 0 : return 0;
513 :
514 202 : SvxUnoNumberingRules* pRule1 = SvxUnoNumberingRules::getImplementation( x1 );
515 202 : if( pRule1 )
516 : {
517 202 : SvxUnoNumberingRules* pRule2 = SvxUnoNumberingRules::getImplementation( x2 );
518 202 : if( pRule2 )
519 : {
520 192 : const SvxNumRule& rRule1 = pRule1->getNumRule();
521 192 : const SvxNumRule& rRule2 = pRule2->getNumRule();
522 :
523 192 : const sal_uInt16 nLevelCount1 = rRule1.GetLevelCount();
524 192 : const sal_uInt16 nLevelCount2 = rRule2.GetLevelCount();
525 :
526 192 : if( nLevelCount1 == 0 || nLevelCount2 == 0 )
527 0 : return -1;
528 :
529 1112 : for( sal_uInt16 i = 0; (i < nLevelCount1) && (i < nLevelCount2); i++ )
530 : {
531 1020 : if( rRule1.GetLevel(i) != rRule2.GetLevel(i) )
532 100 : return -1;
533 : }
534 92 : return 0;
535 : }
536 : }
537 : }
538 :
539 212 : return -1;
540 : }
541 :
542 676 : Reference< XAnyCompare > SvxCreateNumRuleCompare() throw()
543 : {
544 676 : return new SvxUnoNumberingRulesCompare();
545 : }
546 :
547 0 : ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexReplace > SvxCreateNumRule() throw()
548 : {
549 0 : SvxNumRule aTempRule( 0, 10, false );
550 0 : return SvxCreateNumRule( &aTempRule );
551 669 : }
552 :
553 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
