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 3384 : SvxAdjust ConvertUnoAdjust( unsigned short nAdjust )
72 : {
73 : DBG_ASSERT( nAdjust <= 7, "Enum hat sich geaendert! [CL]" );
74 3384 : return aUnoToSvxAdjust[nAdjust];
75 : }
76 :
77 2403 : unsigned short ConvertUnoAdjust( SvxAdjust eAdjust )
78 : {
79 : DBG_ASSERT( eAdjust <= 6, "Enum hat sich geaendert! [CL]" );
80 2403 : return aSvxToUnoAdjust[eAdjust];
81 : }
82 :
83 7616 : UNO3_GETIMPLEMENTATION_IMPL( SvxUnoNumberingRules );
84 :
85 5159 : SvxUnoNumberingRules::SvxUnoNumberingRules( const SvxNumRule& rRule ) throw()
86 5159 : : maRule( rRule )
87 : {
88 5159 : }
89 :
90 10318 : SvxUnoNumberingRules::~SvxUnoNumberingRules() throw()
91 : {
92 10318 : }
93 :
94 : //XIndexReplace
95 3386 : void SAL_CALL SvxUnoNumberingRules::replaceByIndex( sal_Int32 Index, const uno::Any& Element )
96 : throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
97 : {
98 3386 : SolarMutexGuard aGuard;
99 :
100 3386 : if( Index < 0 || Index >= maRule.GetLevelCount() )
101 1 : throw IndexOutOfBoundsException();
102 :
103 6770 : Sequence< beans::PropertyValue > aSeq;
104 :
105 3385 : if( !( Element >>= aSeq) )
106 1 : throw IllegalArgumentException();
107 6770 : setNumberingRuleByIndex( aSeq, Index );
108 3384 : }
109 :
110 : // XIndexAccess
111 1081 : sal_Int32 SAL_CALL SvxUnoNumberingRules::getCount() throw( RuntimeException, std::exception )
112 : {
113 1081 : SolarMutexGuard aGuard;
114 :
115 1081 : return maRule.GetLevelCount();
116 : }
117 :
118 2404 : Any SAL_CALL SvxUnoNumberingRules::getByIndex( sal_Int32 Index )
119 : throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
120 : {
121 2404 : SolarMutexGuard aGuard;
122 :
123 2404 : if( Index < 0 || Index >= maRule.GetLevelCount() )
124 1 : throw IndexOutOfBoundsException();
125 :
126 2403 : return Any( getNumberingRuleByIndex(Index) );
127 : }
128 :
129 : //XElementAccess
130 1 : Type SAL_CALL SvxUnoNumberingRules::getElementType()
131 : throw( RuntimeException, std::exception )
132 : {
133 1 : return cppu::UnoType<Sequence< beans::PropertyValue >>::get();
134 : }
135 :
136 1 : sal_Bool SAL_CALL SvxUnoNumberingRules::hasElements() throw( RuntimeException, std::exception )
137 : {
138 1 : return sal_True;
139 : }
140 :
141 : // XAnyCompare
142 51 : sal_Int16 SAL_CALL SvxUnoNumberingRules::compare( const Any& rAny1, const Any& rAny2 ) throw(RuntimeException, std::exception)
143 : {
144 51 : 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 1 : OUString SAL_CALL SvxUnoNumberingRules::getImplementationName( ) throw(RuntimeException, std::exception)
157 : {
158 1 : 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 2403 : Sequence<beans::PropertyValue> SvxUnoNumberingRules::getNumberingRuleByIndex(sal_Int32 nIndex) const
174 : throw (RuntimeException)
175 : {
176 : // NumberingRule aRule;
177 2403 : const SvxNumberFormat& rFmt = maRule.GetLevel((sal_uInt16) nIndex);
178 2403 : sal_uInt16 nIdx = 0;
179 :
180 2403 : const int nProps = 15;
181 2403 : boost::scoped_array<beans::PropertyValue> pArray(new beans::PropertyValue[nProps]);
182 :
183 4806 : Any aVal;
184 : {
185 2403 : aVal <<= rFmt.GetNumberingType();
186 2403 : beans::PropertyValue aAlignProp( OUString(UNO_NAME_NRULE_NUMBERINGTYPE), -1, aVal, beans::PropertyState_DIRECT_VALUE);
187 2403 : pArray[nIdx++] = aAlignProp;
188 : }
189 :
190 : {
191 2403 : SvxAdjust eAdj = rFmt.GetNumAdjust();
192 2403 : aVal <<= ConvertUnoAdjust(eAdj);
193 2403 : pArray[nIdx++] = beans::PropertyValue( OUString(UNO_NAME_NRULE_ADJUST), -1, aVal, beans::PropertyState_DIRECT_VALUE);
194 : }
195 :
196 : {
197 2403 : aVal <<= OUString(rFmt.GetPrefix());
198 2403 : beans::PropertyValue aPrefixProp( OUString(UNO_NAME_NRULE_PREFIX), -1, aVal, beans::PropertyState_DIRECT_VALUE);
199 2403 : pArray[nIdx++] = aPrefixProp;
200 : }
201 :
202 : {
203 2403 : aVal <<= OUString(rFmt.GetSuffix());
204 2403 : beans::PropertyValue aSuffixProp( OUString(UNO_NAME_NRULE_SUFFIX), -1, aVal, beans::PropertyState_DIRECT_VALUE);
205 2403 : pArray[nIdx++] = aSuffixProp;
206 : }
207 :
208 2403 : if(SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType())
209 : {
210 885 : sal_Unicode nCode = rFmt.GetBulletChar();
211 885 : OUString aStr( &nCode, 1 );
212 885 : aVal <<= aStr;
213 1770 : beans::PropertyValue aBulletProp( OUString("BulletChar"), -1, aVal, beans::PropertyState_DIRECT_VALUE);
214 1770 : pArray[nIdx++] = aBulletProp;
215 : }
216 :
217 2403 : if( rFmt.GetBulletFont() )
218 : {
219 953 : awt::FontDescriptor aDesc;
220 953 : SvxUnoFontDescriptor::ConvertFromFont( *rFmt.GetBulletFont(), aDesc );
221 953 : aVal.setValue(&aDesc, ::cppu::UnoType<awt::FontDescriptor>::get());
222 953 : pArray[nIdx++] = beans::PropertyValue( OUString(UNO_NAME_NRULE_BULLET_FONT), -1, aVal, beans::PropertyState_DIRECT_VALUE);
223 : }
224 :
225 : {
226 2403 : const SvxBrushItem* pBrush = rFmt.GetBrush();
227 2403 : if(pBrush && pBrush->GetGraphicObject())
228 : {
229 9 : const GraphicObject* pGrafObj = pBrush->GetGraphicObject();
230 9 : OUString aURL( UNO_NAME_GRAPHOBJ_URLPREFIX);
231 18 : aURL += OStringToOUString(pGrafObj->GetUniqueID(),
232 9 : RTL_TEXTENCODING_ASCII_US);
233 :
234 9 : aVal <<= aURL;
235 18 : const beans::PropertyValue aGraphicProp( OUString("GraphicURL"), -1, aVal, beans::PropertyState_DIRECT_VALUE);
236 18 : pArray[nIdx++] = aGraphicProp;
237 : }
238 : }
239 :
240 : {
241 2403 : const Size aSize( rFmt.GetGraphicSize() );
242 2403 : const awt::Size aUnoSize( aSize.Width(), aSize.Height() );
243 2403 : aVal <<= aUnoSize;
244 2403 : const beans::PropertyValue aGraphicSizeProp(OUString("GraphicSize"), -1, aVal, beans::PropertyState_DIRECT_VALUE );
245 2403 : pArray[nIdx++] = aGraphicSizeProp;
246 : }
247 :
248 2403 : aVal <<= (sal_Int16)rFmt.GetStart();
249 2403 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_START_WITH), -1, aVal, beans::PropertyState_DIRECT_VALUE);
250 :
251 2403 : aVal <<= (sal_Int32)rFmt.GetAbsLSpace();
252 2403 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_LEFT_MARGIN), -1, aVal, beans::PropertyState_DIRECT_VALUE);
253 :
254 2403 : aVal <<= (sal_Int32)rFmt.GetFirstLineOffset();
255 2403 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_FIRST_LINE_OFFSET), -1, aVal, beans::PropertyState_DIRECT_VALUE);
256 :
257 2403 : pArray[nIdx++] = beans::PropertyValue(OUString("SymbolTextDistance"), -1, aVal, beans::PropertyState_DIRECT_VALUE);
258 :
259 2403 : aVal <<= (sal_Int32)rFmt.GetBulletColor().GetColor();
260 2403 : pArray[nIdx++] = beans::PropertyValue(OUString(UNO_NAME_NRULE_BULLET_COLOR), -1, aVal, beans::PropertyState_DIRECT_VALUE);
261 :
262 2403 : aVal <<= (sal_Int16)rFmt.GetBulletRelSize();
263 2403 : 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 2403 : Sequence< beans::PropertyValue> aSeq(pArray.get(), nIdx);
267 :
268 4806 : return aSeq;
269 : }
270 :
271 3384 : void SvxUnoNumberingRules::setNumberingRuleByIndex(const Sequence<beans::PropertyValue >& rProperties, sal_Int32 nIndex)
272 : throw (RuntimeException, IllegalArgumentException, std::exception)
273 : {
274 3384 : SvxNumberFormat aFmt(maRule.GetLevel( (sal_uInt16)nIndex ));
275 3384 : const beans::PropertyValue* pPropArray = rProperties.getConstArray();
276 45677 : for(int i = 0; i < rProperties.getLength(); i++)
277 : {
278 42293 : const beans::PropertyValue& rProp = pPropArray[i];
279 42293 : const OUString& rPropName = rProp.Name;
280 42293 : const Any& aVal = rProp.Value;
281 :
282 42293 : if ( rPropName == UNO_NAME_NRULE_NUMBERINGTYPE )
283 : {
284 2559 : sal_Int16 nSet = sal_Int16();
285 2559 : aVal >>= nSet;
286 :
287 : // There is no reason to limit numbering types.
288 2559 : if ( nSet>=0 )
289 : {
290 2559 : aFmt.SetNumberingType(nSet);
291 2559 : continue;
292 : }
293 : }
294 39734 : else if ( rPropName == UNO_NAME_NRULE_PREFIX )
295 : {
296 2445 : OUString aPrefix;
297 2445 : if( aVal >>= aPrefix )
298 : {
299 2445 : aFmt.SetPrefix(aPrefix);
300 2445 : continue;
301 0 : }
302 : }
303 37289 : else if ( rPropName == UNO_NAME_NRULE_SUFFIX )
304 : {
305 2445 : OUString aSuffix;
306 2445 : if( aVal >>= aSuffix )
307 : {
308 2445 : aFmt.SetSuffix(aSuffix);
309 2445 : continue;
310 0 : }
311 : }
312 34844 : 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 34844 : else if ( rPropName == "BulletChar" )
325 : {
326 2389 : OUString aStr;
327 2389 : if( aVal >>= aStr )
328 : {
329 2389 : if(!aStr.isEmpty())
330 : {
331 2389 : aFmt.SetBulletChar(aStr[0]);
332 : }
333 : else
334 : {
335 0 : aFmt.SetBulletChar(0);
336 : }
337 2389 : continue;
338 0 : }
339 : }
340 32455 : else if ( rPropName == UNO_NAME_NRULE_ADJUST )
341 : {
342 3384 : sal_Int16 nAdjust = sal_Int16();
343 3384 : if( aVal >>= nAdjust )
344 : {
345 3384 : aFmt.SetNumAdjust(ConvertUnoAdjust( (unsigned short)nAdjust ));
346 3384 : continue;
347 : }
348 : }
349 29071 : else if ( rPropName == UNO_NAME_NRULE_BULLET_FONT )
350 : {
351 2441 : awt::FontDescriptor aDesc;
352 2441 : if( aVal >>= aDesc )
353 : {
354 2441 : vcl::Font aFont;
355 2441 : SvxUnoFontDescriptor::ConvertToFont( aDesc, aFont );
356 2441 : aFmt.SetBulletFont(&aFont);
357 2441 : continue;
358 0 : }
359 : }
360 26630 : else if ( rPropName == "Graphic" )
361 : {
362 6 : Reference< awt::XBitmap > xBmp;
363 6 : if( aVal >>= xBmp )
364 : {
365 6 : Graphic aGraf( VCLUnoHelper::GetBitmap( xBmp ) );
366 12 : SvxBrushItem aBrushItem(aGraf, GPOS_AREA, SID_ATTR_BRUSH);
367 6 : aFmt.SetGraphicBrush( &aBrushItem );
368 12 : continue;
369 0 : }
370 : }
371 26624 : 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 26624 : else if ( rPropName == "GraphicSize" )
383 : {
384 8 : awt::Size aUnoSize;
385 8 : if( aVal >>= aUnoSize )
386 : {
387 8 : aFmt.SetGraphicSize( Size( aUnoSize.Width, aUnoSize.Height ) );
388 8 : continue;
389 : }
390 : }
391 26616 : else if ( rPropName == UNO_NAME_NRULE_START_WITH )
392 : {
393 58 : sal_Int16 nStart = sal_Int16();
394 58 : if( aVal >>= nStart )
395 : {
396 58 : aFmt.SetStart( nStart );
397 58 : continue;
398 : }
399 : }
400 26558 : else if ( rPropName == UNO_NAME_NRULE_LEFT_MARGIN )
401 : {
402 2108 : sal_Int32 nMargin = 0;
403 2108 : if( aVal >>= nMargin )
404 : {
405 2108 : aFmt.SetAbsLSpace((sal_uInt16)nMargin);
406 2108 : continue;
407 : }
408 : }
409 24450 : else if ( rPropName == UNO_NAME_NRULE_FIRST_LINE_OFFSET )
410 : {
411 2105 : sal_Int32 nMargin = 0;
412 2105 : if( aVal >>= nMargin )
413 : {
414 2105 : aFmt.SetFirstLineOffset((sal_uInt16)nMargin);
415 2105 : continue;
416 : }
417 : }
418 22345 : else if ( rPropName == "SymbolTextDistance" )
419 : {
420 1994 : sal_Int32 nTextDistance = 0;
421 1994 : if( aVal >>= nTextDistance )
422 : {
423 1994 : aFmt.SetCharTextDistance((sal_uInt16)nTextDistance);
424 1994 : continue;
425 : }
426 : }
427 20351 : else if ( rPropName == UNO_NAME_NRULE_BULLET_COLOR )
428 : {
429 3216 : sal_Int32 nColor = 0;
430 3216 : if( aVal >>= nColor )
431 : {
432 3216 : aFmt.SetBulletColor( static_cast<Color>(nColor) );
433 3216 : continue;
434 : }
435 : }
436 17135 : else if ( rPropName == UNO_NAME_NRULE_BULLET_RELSIZE )
437 : {
438 3384 : sal_Int16 nSize = sal_Int16();
439 3384 : if( aVal >>= nSize )
440 : {
441 : // [Bug 120650] the slide content corrupt when open in Aoo
442 3384 : if ((nSize>250)||(nSize<=0))
443 : {
444 0 : nSize = 100;
445 : }
446 :
447 3384 : aFmt.SetBulletRelSize( (short)nSize );
448 3384 : continue;
449 : }
450 : }
451 : else
452 : {
453 13751 : continue;
454 : }
455 :
456 0 : throw IllegalArgumentException();
457 : }
458 :
459 : // check that we always have a brush item for bitmap numbering
460 3384 : if( aFmt.GetNumberingType() == SVX_NUM_BITMAP )
461 : {
462 6 : 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 3384 : maRule.SetLevel( (sal_uInt16)nIndex, aFmt );
470 3384 : }
471 :
472 1600 : const SvxNumRule& SvxGetNumRule( Reference< XIndexReplace > xRule ) throw( IllegalArgumentException )
473 : {
474 1600 : SvxUnoNumberingRules* pRule = SvxUnoNumberingRules::getImplementation( xRule );
475 1600 : if( pRule == NULL )
476 12 : throw IllegalArgumentException();
477 :
478 1588 : return pRule->getNumRule();
479 : }
480 :
481 5159 : com::sun::star::uno::Reference< com::sun::star::container::XIndexReplace > SvxCreateNumRule( const SvxNumRule* pRule ) throw()
482 : {
483 : DBG_ASSERT( pRule, "No default SvxNumRule!" );
484 5159 : if( pRule )
485 : {
486 5159 : return new SvxUnoNumberingRules( *pRule );
487 : }
488 : else
489 : {
490 0 : SvxNumRule aDefaultRule( SvxNumRuleFlags::BULLET_REL_SIZE | SvxNumRuleFlags::BULLET_COLOR | SvxNumRuleFlags::CHAR_TEXT_DISTANCE, SVX_MAX_NUM, false);
491 0 : return new SvxUnoNumberingRules( aDefaultRule );
492 : }
493 : }
494 :
495 1583 : 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 107 : sal_Int16 SAL_CALL SvxUnoNumberingRulesCompare::compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException, std::exception)
502 : {
503 107 : return SvxUnoNumberingRules::Compare( Any1, Any2 );
504 : }
505 :
506 158 : sal_Int16 SvxUnoNumberingRules::Compare( const Any& Any1, const Any& Any2 )
507 : {
508 316 : Reference< XIndexReplace > x1( Any1, UNO_QUERY ), x2( Any2, UNO_QUERY );
509 158 : if( x1.is() && x2.is() )
510 : {
511 158 : if( x1.get() == x2.get() )
512 0 : return 0;
513 :
514 158 : SvxUnoNumberingRules* pRule1 = SvxUnoNumberingRules::getImplementation( x1 );
515 158 : if( pRule1 )
516 : {
517 158 : SvxUnoNumberingRules* pRule2 = SvxUnoNumberingRules::getImplementation( x2 );
518 158 : if( pRule2 )
519 : {
520 146 : const SvxNumRule& rRule1 = pRule1->getNumRule();
521 146 : const SvxNumRule& rRule2 = pRule2->getNumRule();
522 :
523 146 : const sal_uInt16 nLevelCount1 = rRule1.GetLevelCount();
524 146 : const sal_uInt16 nLevelCount2 = rRule2.GetLevelCount();
525 :
526 146 : if( nLevelCount1 == 0 || nLevelCount2 == 0 )
527 0 : return -1;
528 :
529 1006 : for( sal_uInt16 i = 0; (i < nLevelCount1) && (i < nLevelCount2); i++ )
530 : {
531 920 : if( rRule1.GetLevel(i) != rRule2.GetLevel(i) )
532 60 : return -1;
533 : }
534 86 : return 0;
535 : }
536 : }
537 : }
538 :
539 170 : return -1;
540 : }
541 :
542 531 : Reference< XAnyCompare > SvxCreateNumRuleCompare() throw()
543 : {
544 531 : return new SvxUnoNumberingRulesCompare();
545 : }
546 :
547 0 : ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexReplace > SvxCreateNumRule() throw()
548 : {
549 0 : SvxNumRule aTempRule( SvxNumRuleFlags::NONE, 10, false );
550 0 : return SvxCreateNumRule( &aTempRule );
551 : }
552 :
553 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
