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 : /****************** I N C L U D E S **************************************/
21 :
22 : // C and C++ Includes.
23 : #include <stdlib.h>
24 : #include <stdio.h>
25 : #include <string.h>
26 :
27 : // Solar Definitionen
28 : #include <tools/solar.h>
29 :
30 : // Programmabh�ngige Includes.
31 : #include <rscrange.hxx>
32 :
33 : /****************** D E F I N E S ****************************************/
34 : /****************** C O D E **********************************************/
35 : /****************** R s c R a n g e **************************************/
36 : /*************************************************************************
37 : |*
38 : |* RscRange::RscRange()
39 : |*
40 : *************************************************************************/
41 6910 : RscRange::RscRange( Atom nId, sal_uInt32 nTypeId )
42 6910 : : RscTop( nId, nTypeId )
43 : {
44 6910 : nMin = nMax = 0;
45 6910 : nSize = ALIGNED_SIZE( sizeof( RscRangeInst ) );
46 6910 : }
47 :
48 : /*************************************************************************
49 : |*
50 : |* RscRange::GetClassType()
51 : |*
52 : *************************************************************************/
53 0 : RSCCLASS_TYPE RscRange::GetClassType() const
54 : {
55 0 : return RSCCLASS_NUMBER;
56 : }
57 :
58 : /*************************************************************************
59 : |*
60 : |* RscRange::SetRange()
61 : |*
62 : *************************************************************************/
63 6910 : ERRTYPE RscRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
64 : {
65 6910 : if( nMinimum > nMaximum )
66 : {
67 0 : nMin = nMaximum;
68 0 : nMax = nMinimum;
69 : }
70 : else
71 : {
72 6910 : nMax = nMaximum;
73 6910 : nMin = nMinimum;
74 : };
75 :
76 6910 : return( ERR_OK );
77 : }
78 :
79 : /*************************************************************************
80 : |*
81 : |* RscRange::IsValueDefault()
82 : |*
83 : *************************************************************************/
84 2604 : sal_Bool RscRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
85 : {
86 2604 : if( pDef )
87 : {
88 2604 : if( ((RscRangeInst*)rInst.pData)->nValue ==
89 : ((RscRangeInst*)pDef)->nValue )
90 : {
91 539 : return sal_True;
92 : }
93 : }
94 :
95 2065 : return sal_False;
96 : }
97 :
98 : /*************************************************************************
99 : |*
100 : |* RscRange::SetNumber()
101 : |*
102 : *************************************************************************/
103 10776 : ERRTYPE RscRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
104 : {
105 10776 : if( nMax < nValue || nMin > nValue )
106 0 : return( ERR_RSCRANGE_OUTDEFSET );
107 10776 : ((RscRangeInst *)rInst.pData)->nValue = (sal_uInt16)( nValue - nMin );
108 10776 : ((RscRangeInst *)rInst.pData)->bDflt = sal_False;
109 10776 : return( ERR_OK );
110 : }
111 :
112 : /*************************************************************************
113 : |*
114 : |* RscRange::GetNumber()
115 : |*
116 : *************************************************************************/
117 4294 : ERRTYPE RscRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
118 : {
119 4294 : *pN = ((RscRangeInst *)rInst.pData)->nValue + nMin;
120 4294 : return( ERR_OK );
121 : }
122 :
123 : /*************************************************************************
124 : |*
125 : |* RscRange::Create()
126 : |*
127 : *************************************************************************/
128 84236 : RSCINST RscRange::Create( RSCINST * pInst, const RSCINST & rDflt,
129 : sal_Bool bOwnClass )
130 : {
131 84236 : RSCINST aInst;
132 :
133 84236 : if( !pInst )
134 : {
135 10797 : aInst.pClass = this;
136 : aInst.pData = (CLASS_DATA)
137 10797 : rtl_allocateMemory( sizeof( RscRangeInst ) );
138 : }
139 : else
140 73439 : aInst = *pInst;
141 84236 : if( !bOwnClass && rDflt.IsInst() )
142 166 : bOwnClass = rDflt.pClass->InHierarchy( this );
143 :
144 84236 : if( bOwnClass )
145 166 : memmove( aInst.pData, rDflt.pData, sizeof( RscRangeInst ) );
146 : else
147 : {
148 84070 : if( 0L >= nMin && 0L <= nMax )
149 84050 : ((RscRangeInst *)aInst.pData)->nValue = (sal_uInt16)(0L - nMin);
150 : else
151 20 : ((RscRangeInst *)aInst.pData)->nValue = 0;
152 84070 : ((RscRangeInst *)aInst.pData)->bDflt = sal_True;
153 : }
154 :
155 84236 : return( aInst );
156 : }
157 :
158 : /*************************************************************************
159 : |*
160 : |* RscRange::WriteSrc()
161 : |*
162 : *************************************************************************/
163 3048 : void RscRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
164 : RscTypCont *, sal_uInt32, const char * )
165 : {
166 3048 : fprintf( fOutput, "%ld", long( ((RscRangeInst *)rInst.pData)->nValue + nMin ) );
167 3048 : }
168 :
169 : /*************************************************************************
170 : |*
171 : |* RscRange::WriteRc()
172 : |*
173 : *************************************************************************/
174 144342 : ERRTYPE RscRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
175 : RscTypCont *, sal_uInt32, sal_Bool )
176 : {
177 144342 : if( nMin >= 0 )
178 : {
179 : sal_uInt16 n;
180 5684 : n = (sal_uInt16)(((RscRangeInst *)rInst.pData)->nValue + nMin);
181 5684 : aMem.Put( n );
182 : }
183 : else
184 : {
185 : sal_Int16 n;
186 138658 : n = (sal_Int16)(((RscRangeInst *)rInst.pData)->nValue + nMin);
187 138658 : aMem.Put( n );
188 : }
189 :
190 144342 : return( ERR_OK );
191 : }
192 :
193 : //=======================================================================
194 0 : void RscRange::WriteRcAccess
195 : (
196 : FILE * fOutput,
197 : RscTypCont * /*pTC*/,
198 : const char * pName
199 : )
200 : {
201 0 : fprintf( fOutput, "\t\tSet%s( ", pName );
202 0 : if( nMin >= 0 )
203 0 : fprintf( fOutput, "*(sal_uInt32 *)(pResData+nOffset) );\n" );
204 : else
205 0 : fprintf( fOutput, "*(sal_Int32 *)(pResData+nOffset) );\n" );
206 0 : fprintf( fOutput, "\t\tnOffset += sizeof( sal_uInt32 );\n" );
207 0 : }
208 :
209 : /****************** R s c L o n g R a n g e ******************************/
210 : /*************************************************************************
211 : |*
212 : |* RscLongRange::RscLongRange()
213 : |*
214 : *************************************************************************/
215 1382 : RscLongRange::RscLongRange( Atom nId, sal_uInt32 nTypeId )
216 1382 : : RscTop( nId, nTypeId )
217 : {
218 1382 : nMin = nMax = 0;
219 1382 : nSize = ALIGNED_SIZE( sizeof( RscLongRangeInst ) );
220 1382 : }
221 :
222 : /*************************************************************************
223 : |*
224 : |* RscLongRange::GetClassType()
225 : |*
226 : *************************************************************************/
227 0 : RSCCLASS_TYPE RscLongRange::GetClassType() const
228 : {
229 0 : return RSCCLASS_NUMBER;
230 : }
231 :
232 : /*************************************************************************
233 : |*
234 : |* RscLongRange::SetRange()
235 : |*
236 : *************************************************************************/
237 1382 : ERRTYPE RscLongRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
238 : {
239 1382 : if( nMinimum > nMaximum )
240 : {
241 0 : nMin = nMaximum;
242 0 : nMax = nMinimum;
243 : }
244 : else
245 : {
246 1382 : nMax = nMaximum;
247 1382 : nMin = nMinimum;
248 : };
249 :
250 1382 : return( ERR_OK );
251 : }
252 :
253 : /*************************************************************************
254 : |*
255 : |* RscLongRange::IsValueDefault()
256 : |*
257 : *************************************************************************/
258 1334 : sal_Bool RscLongRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
259 : {
260 1334 : if( pDef )
261 : return 0 == memcmp( &((RscLongRangeInst*)rInst.pData)->nValue,
262 : &((RscLongRangeInst*)pDef)->nValue,
263 1334 : sizeof( sal_Int32 ) );
264 :
265 0 : return sal_False;
266 : }
267 :
268 : /*************************************************************************
269 : |*
270 : |* RscLongRange::SetNumber()
271 : |*
272 : *************************************************************************/
273 70657 : ERRTYPE RscLongRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
274 : {
275 70657 : if( nMax < nValue || nMin > nValue )
276 0 : return( ERR_RSCRANGE_OUTDEFSET );
277 70657 : void * pData = &((RscLongRangeInst*)rInst.pData)->nValue;
278 70657 : memcpy( pData, &nValue, sizeof( sal_Int32 ) );
279 70657 : ((RscLongRangeInst *)rInst.pData)->bDflt = sal_False;
280 70657 : return( ERR_OK );
281 : }
282 :
283 : /*************************************************************************
284 : |*
285 : |* RscLongRange::GetNumber()
286 : |*
287 : *************************************************************************/
288 72408 : ERRTYPE RscLongRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
289 : {
290 : memmove( pN, &((RscLongRangeInst*)rInst.pData)->nValue,
291 72408 : sizeof( sal_Int32 ) );
292 72408 : return( ERR_OK );
293 : }
294 :
295 : /*************************************************************************
296 : |*
297 : |* RscLongRange::Create()
298 : |*
299 : *************************************************************************/
300 96620 : RSCINST RscLongRange::Create( RSCINST * pInst, const RSCINST & rDflt,
301 : sal_Bool bOwnClass )
302 : {
303 96620 : RSCINST aInst;
304 :
305 96620 : if( !pInst )
306 : {
307 59 : aInst.pClass = this;
308 : aInst.pData = (CLASS_DATA)
309 59 : rtl_allocateMemory( sizeof( RscLongRangeInst ) );
310 : }
311 : else
312 96561 : aInst = *pInst;
313 96620 : if( !bOwnClass && rDflt.IsInst() )
314 542 : bOwnClass = rDflt.pClass->InHierarchy( this );
315 :
316 96620 : if( bOwnClass )
317 542 : memmove( aInst.pData, rDflt.pData, sizeof( RscLongRangeInst ) );
318 : else
319 : {
320 : sal_Int32 lDflt;
321 96078 : if( 0L >= nMin && 0L <= nMax )
322 96078 : lDflt = 0;
323 : else
324 0 : lDflt = nMin;
325 96078 : void * pData = &((RscLongRangeInst*)aInst.pData)->nValue;
326 96078 : memcpy( pData, &lDflt, sizeof( sal_Int32 ) );
327 96078 : ((RscLongRangeInst *)aInst.pData)->bDflt = sal_True;
328 : }
329 :
330 96620 : return( aInst );
331 : }
332 :
333 : /*************************************************************************
334 : |*
335 : |* RscLongRange::WriteSrc()
336 : |*
337 : *************************************************************************/
338 35141 : void RscLongRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
339 : RscTypCont *, sal_uInt32, const char * )
340 : {
341 : sal_Int32 lVal;
342 35141 : GetNumber( rInst, &lVal );
343 35141 : fprintf( fOutput, "%d", static_cast<int>(lVal) );
344 35141 : }
345 :
346 : /*************************************************************************
347 : |*
348 : |* RscLongRange::WriteRc()
349 : |*
350 : *************************************************************************/
351 3063 : ERRTYPE RscLongRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
352 : RscTypCont *, sal_uInt32, sal_Bool )
353 : {
354 : sal_Int32 lVal;
355 :
356 3063 : GetNumber( rInst, &lVal );
357 3063 : aMem.Put( (sal_Int32)lVal );
358 :
359 3063 : return( ERR_OK );
360 : }
361 :
362 : //=======================================================================
363 0 : void RscLongRange::WriteRcAccess
364 : (
365 : FILE * fOutput,
366 : RscTypCont * /*pTC*/,
367 : const char * pName
368 : )
369 : {
370 0 : fprintf( fOutput, "\t\tSet%s( ", pName );
371 0 : fprintf( fOutput, "GetLong( pResData+nOffset ) );\n" );
372 0 : fprintf( fOutput, "\t\tnOffset += sizeof( sal_Int32 );\n" );
373 0 : }
374 :
375 : /****************** R s c L o n g E n u m R a n g e *********************/
376 : /*************************************************************************
377 : |* RscLongEnumRange::RscLongEnumRange()
378 : |*
379 : |* Beschreibung
380 : *************************************************************************/
381 691 : RscLongEnumRange::RscLongEnumRange( Atom nId, sal_uInt32 nTypeId )
382 691 : : RscLongRange( nId, nTypeId )
383 : {
384 691 : }
385 :
386 : /*************************************************************************
387 : |* RscLongEnumRange::SetConst()
388 : |*
389 : |* Beschreibung
390 : *************************************************************************/
391 51 : ERRTYPE RscLongEnumRange::SetConst( const RSCINST & rInst, Atom /*nConst*/,
392 : sal_Int32 nValue )
393 : {
394 51 : return SetNumber( rInst, nValue );
395 : }
396 :
397 : /****************** R s c I d R a n g e **********************************/
398 : /*************************************************************************
399 : |*
400 : |* RscIdRange::RscIdRange()
401 : |*
402 : *************************************************************************/
403 2073 : RscIdRange::RscIdRange( Atom nId, sal_uInt32 nTypeId )
404 2073 : : RscTop( nId, nTypeId )
405 : {
406 2073 : nSize = ALIGNED_SIZE( sizeof( RscId ) );
407 2073 : nMin = nMax = 0;
408 2073 : }
409 :
410 : /*************************************************************************
411 : |*
412 : |* RscIdRange::RscIdRange()
413 : |*
414 : *************************************************************************/
415 0 : RSCCLASS_TYPE RscIdRange::GetClassType() const
416 : {
417 0 : return RSCCLASS_NUMBER;
418 : }
419 :
420 : /*************************************************************************
421 : |*
422 : |* RscIdRange::Create()
423 : |*
424 : *************************************************************************/
425 16423 : RSCINST RscIdRange::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
426 16423 : RSCINST aInst;
427 : RscId * pClassData;
428 :
429 16423 : if( !pInst ){
430 952 : aInst.pClass = this;
431 952 : aInst.pData = (CLASS_DATA)rtl_allocateMemory( sizeof( RscId ) );
432 : }
433 : else
434 15471 : aInst = *pInst;
435 :
436 :
437 16423 : if( !bOwnClass && rDflt.IsInst() )
438 16 : bOwnClass = rDflt.pClass->InHierarchy( this );
439 :
440 16423 : pClassData = (RscId *)aInst.pData;
441 :
442 16423 : pClassData->Create();
443 16423 : if( bOwnClass )
444 16 : *pClassData = *(RscId *)rDflt.pData;
445 : else{
446 16407 : *pClassData = RscId();
447 16407 : if( 0 >= nMin && 0 <= nMax )
448 7265 : *pClassData = RscId( (sal_Int32)0 );
449 : else
450 9142 : *pClassData = RscId( nMin );
451 : //cUnused wird fuer Defaultkennung verwendet
452 16407 : ((RscId *)aInst.pData)->aExp.cUnused = sal_True;
453 : }
454 :
455 16423 : return( aInst );
456 : }
457 :
458 : /*************************************************************************
459 : |*
460 : |* RscIdRange::Destroy()
461 : |*
462 : *************************************************************************/
463 16423 : void RscIdRange :: Destroy( const RSCINST & rInst ){
464 16423 : ((RscId *)rInst.pData)->Destroy();
465 16423 : }
466 :
467 : /*************************************************************************
468 : |*
469 : |* RscIdRange::IsValueDefault()
470 : |*
471 : *************************************************************************/
472 5493 : sal_Bool RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
473 5493 : if( pDef ){
474 10986 : if( ((RscId*)rInst.pData)->aExp.IsNumber()
475 5493 : && ((RscId*)pDef)->aExp.IsNumber() )
476 : {
477 10986 : if( ((RscId*)rInst.pData)->GetNumber() ==
478 5493 : ((RscId*)pDef)->GetNumber() )
479 : {
480 203 : return sal_True;
481 : }
482 : }
483 : }
484 :
485 5290 : return sal_False;
486 : }
487 :
488 : /*************************************************************************
489 : |*
490 : |* RscIdRange::SetNumber()
491 : |*
492 : *************************************************************************/
493 11476 : ERRTYPE RscIdRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
494 : {
495 11476 : if( nMax < nValue || nMin > nValue )
496 0 : return( ERR_RSCRANGE_OUTDEFSET );
497 :
498 11476 : *(RscId *)rInst.pData = RscId( nValue );
499 11476 : ((RscId *)rInst.pData)->aExp.cUnused = sal_False;
500 11476 : return( ERR_OK );
501 : }
502 :
503 : /*************************************************************************
504 : |*
505 : |* RscIdRange::GetNumber()
506 : |*
507 : *************************************************************************/
508 0 : ERRTYPE RscIdRange::GetNumber( const RSCINST & rInst, sal_Int32 * plValue ){
509 0 : *plValue = ((RscId *)rInst.pData)->GetNumber();
510 0 : return( ERR_OK );
511 : }
512 :
513 : /*************************************************************************
514 : |*
515 : |* RscIdRange::SetRef()
516 : |*
517 : *************************************************************************/
518 11476 : ERRTYPE RscIdRange::SetRef( const RSCINST & rInst, const RscId & rRscId ){
519 11476 : ERRTYPE aError;
520 11476 : if( rRscId.IsId() ){
521 11476 : aError = SetNumber( rInst, rRscId );
522 11476 : if( aError.IsOk() ){
523 11476 : *(RscId *)rInst.pData = rRscId;
524 11476 : ((RscId *)rInst.pData)->aExp.cUnused = sal_False;
525 : }
526 : }
527 : else
528 0 : aError = ERR_RSCRANGE_OUTDEFSET;
529 :
530 11476 : return( aError );
531 : }
532 :
533 : /*************************************************************************
534 : |*
535 : |* RscIdRange::GetRef()
536 : |*
537 : *************************************************************************/
538 701 : ERRTYPE RscIdRange::GetRef( const RSCINST & rInst, RscId * pRscId ){
539 701 : *pRscId = *(RscId *)rInst.pData;
540 :
541 701 : return( ERR_OK );
542 : }
543 :
544 : /*************************************************************************
545 : |*
546 : |* RscIdRange::WriteSrc()
547 : |*
548 : *************************************************************************/
549 5991 : void RscIdRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
550 : RscTypCont *, sal_uInt32, const char * )
551 : {
552 5991 : fprintf( fOutput, "%s", ((RscId *)rInst.pData)->GetName().getStr() );
553 5991 : }
554 :
555 : /*************************************************************************
556 : |*
557 : |* RscIdRange::WriteRc()
558 : |*
559 : *************************************************************************/
560 5306 : ERRTYPE RscIdRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
561 : RscTypCont *, sal_uInt32, sal_Bool )
562 : {
563 5306 : sal_Int32 lVal = ((RscId*)rInst.pData)->GetNumber();
564 :
565 5306 : aMem.Put( (sal_Int32)lVal );
566 :
567 5306 : return( ERR_OK );
568 : }
569 :
570 : //=======================================================================
571 0 : void RscIdRange::WriteRcAccess
572 : (
573 : FILE * fOutput,
574 : RscTypCont * /*pTC*/,
575 : const char * pName
576 : )
577 : {
578 0 : fprintf( fOutput, "\t\tSet%s( ", pName );
579 0 : fprintf( fOutput, "GetLong( pResData+nOffset ) );\n" );
580 0 : fprintf( fOutput, "\t\tnOffset += sizeof( sal_Int32 );\n" );
581 0 : }
582 :
583 : /*************************************************************************
584 : |*
585 : |* RscIdRange::IsConsistent()
586 : |*
587 : *************************************************************************/
588 0 : sal_Bool RscIdRange::IsConsistent( const RSCINST & rInst )
589 : {
590 0 : long nValue = ((RscId *)rInst.pData)->GetNumber();
591 0 : if( (nMax >= nValue) && (nMin <= nValue) )
592 0 : return sal_True;
593 : else {
594 0 : return sal_False;
595 : }
596 : }
597 :
598 : /****************** R s c B o o l ****************************************/
599 : /*************************************************************************
600 : |*
601 : |* RscBool::RscBool()
602 : |*
603 : *************************************************************************/
604 691 : RscBool::RscBool( Atom nId, sal_uInt32 nTypeId )
605 691 : : RscRange( nId, nTypeId )
606 : {
607 691 : RscRange::SetRange( 0, 1 );
608 691 : }
609 :
610 : /*************************************************************************
611 : |*
612 : |* RscBool::GetClassType()
613 : |*
614 : *************************************************************************/
615 0 : RSCCLASS_TYPE RscBool::GetClassType() const
616 : {
617 0 : return RSCCLASS_BOOL;
618 : }
619 :
620 : /*************************************************************************
621 : |*
622 : |* RscBool::WriteSrc()
623 : |*
624 : *************************************************************************/
625 758 : void RscBool::WriteSrc( const RSCINST & rInst, FILE * fOutput,
626 : RscTypCont *, sal_uInt32, const char * )
627 : {
628 : sal_Int32 l;
629 :
630 758 : GetNumber( rInst, &l );
631 758 : if( l )
632 758 : fprintf( fOutput, "TRUE" );
633 : else
634 0 : fprintf( fOutput, "FALSE" );
635 758 : }
636 :
637 : //=======================================================================
638 0 : void RscBool::WriteRcAccess
639 : (
640 : FILE * fOutput,
641 : RscTypCont * /*pTC*/,
642 : const char * pName
643 : )
644 : {
645 0 : fprintf( fOutput, "\t\tSet%s( ", pName );
646 0 : fprintf( fOutput, "(sal_Bool)*(short *)(pResData+nOffset) );\n" );
647 0 : fprintf( fOutput, "\t\tnOffset += sizeof( short );\n" );
648 0 : }
649 :
650 : /****************** R s c B r e a k R a n g e ****************************/
651 : /*************************************************************************
652 : |*
653 : |* RscBreakRange::SetNumber()
654 : |*
655 : *************************************************************************/
656 691 : RscBreakRange :: RscBreakRange( Atom nId, sal_uInt32 nTypeId )
657 691 : : RscRange( nId, nTypeId )
658 : {
659 691 : nOutRange = 0xFFFFFFFF;
660 691 : }
661 :
662 : /*************************************************************************
663 : |*
664 : |* RscBreakRange::SetNumber()
665 : |*
666 : *************************************************************************/
667 0 : ERRTYPE RscBreakRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue ){
668 0 : if( nValue == nOutRange )
669 0 : return( ERR_RSCRANGE_OUTDEFSET );
670 : else
671 0 : return( RscRange::SetNumber( rInst, nValue ) );
672 : }
673 :
674 : /*************************************************************************
675 : |*
676 : |* RscBreakRange::Create()
677 : |*
678 : *************************************************************************/
679 0 : RSCINST RscBreakRange::Create( RSCINST * pInst, const RSCINST & rDflt,
680 : sal_Bool bOwnClass )
681 : {
682 0 : RSCINST aInst;
683 : sal_Int32 l;
684 :
685 0 : aInst = RscRange::Create( pInst, rDflt, bOwnClass );
686 :
687 0 : GetNumber( aInst, &l );
688 0 : if( l == nOutRange )
689 0 : ((RscRangeInst *)aInst.pData)->nValue++;
690 :
691 0 : return( aInst );
692 : }
693 :
694 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
