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_rsc.hxx"
26 /****************** I N C L U D E S **************************************/
27
28 // C and C++ Includes.
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32
33 // Solar Definitionen
34 #include <tools/solar.h>
35
36 // Programmabh�ngige Includes.
37 #include <rscrange.hxx>
38
39 /****************** D E F I N E S ****************************************/
40 /****************** C O D E **********************************************/
41 /****************** R s c R a n g e **************************************/
42 /*************************************************************************
43 |*
44 |* RscRange::RscRange()
45 |*
46 |* Beschreibung
47 |* Ersterstellung MM 03.04.91
48 |* Letzte Aenderung MM 03.04.91
49 |*
50 *************************************************************************/
RscRange(Atom nId,sal_uInt32 nTypeId)51 RscRange::RscRange( Atom nId, sal_uInt32 nTypeId )
52 : RscTop( nId, nTypeId )
53 {
54 nMin = nMax = 0;
55 nSize = ALIGNED_SIZE( sizeof( RscRangeInst ) );
56 }
57
58 /*************************************************************************
59 |*
60 |* RscRange::GetClassType()
61 |*
62 |* Beschreibung
63 |* Ersterstellung MM 03.04.91
64 |* Letzte Aenderung MM 03.04.91
65 |*
66 *************************************************************************/
GetClassType() const67 RSCCLASS_TYPE RscRange::GetClassType() const
68 {
69 return RSCCLASS_NUMBER;
70 }
71
72 /*************************************************************************
73 |*
74 |* RscRange::SetRange()
75 |*
76 |* Beschreibung
77 |* Ersterstellung MM 03.04.91
78 |* Letzte Aenderung MM 03.04.91
79 |*
80 *************************************************************************/
SetRange(sal_Int32 nMinimum,sal_Int32 nMaximum)81 ERRTYPE RscRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
82 {
83 if( nMinimum > nMaximum )
84 {
85 nMin = nMaximum;
86 nMax = nMinimum;
87 }
88 else
89 {
90 nMax = nMaximum;
91 nMin = nMinimum;
92 };
93
94 return( ERR_OK );
95 }
96
97 /*************************************************************************
98 |*
99 |* RscRange::IsValueDefault()
100 |*
101 |* Beschreibung
102 |* Ersterstellung MM 15.02.92
103 |* Letzte Aenderung MM 15.02.92
104 |*
105 *************************************************************************/
IsValueDefault(const RSCINST & rInst,CLASS_DATA pDef)106 sal_Bool RscRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
107 {
108 if( pDef )
109 {
110 if( ((RscRangeInst*)rInst.pData)->nValue ==
111 ((RscRangeInst*)pDef)->nValue )
112 {
113 return sal_True;
114 }
115 }
116
117 return sal_False;
118 }
119
120 /*************************************************************************
121 |*
122 |* RscRange::SetNumber()
123 |*
124 |* Beschreibung
125 |* Ersterstellung MM 03.04.91
126 |* Letzte Aenderung MM 03.04.91
127 |*
128 *************************************************************************/
SetNumber(const RSCINST & rInst,sal_Int32 nValue)129 ERRTYPE RscRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
130 {
131 if( nMax < nValue || nMin > nValue )
132 return( ERR_RSCRANGE_OUTDEFSET );
133 ((RscRangeInst *)rInst.pData)->nValue = (sal_uInt16)( nValue - nMin );
134 ((RscRangeInst *)rInst.pData)->bDflt = sal_False;
135 return( ERR_OK );
136 }
137
138 /*************************************************************************
139 |*
140 |* RscRange::GetNumber()
141 |*
142 |* Beschreibung
143 |* Ersterstellung MM 22.04.91
144 |* Letzte Aenderung MM 22.04.91
145 |*
146 *************************************************************************/
GetNumber(const RSCINST & rInst,sal_Int32 * pN)147 ERRTYPE RscRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
148 {
149 *pN = ((RscRangeInst *)rInst.pData)->nValue + nMin;
150 return( ERR_OK );
151 }
152
153 /*************************************************************************
154 |*
155 |* RscRange::Create()
156 |*
157 |* Beschreibung
158 |* Ersterstellung MM 03.04.91
159 |* Letzte Aenderung MM 03.04.91
160 |*
161 *************************************************************************/
Create(RSCINST * pInst,const RSCINST & rDflt,sal_Bool bOwnClass)162 RSCINST RscRange::Create( RSCINST * pInst, const RSCINST & rDflt,
163 sal_Bool bOwnClass )
164 {
165 RSCINST aInst;
166
167 if( !pInst )
168 {
169 aInst.pClass = this;
170 aInst.pData = (CLASS_DATA)
171 rtl_allocateMemory( sizeof( RscRangeInst ) );
172 }
173 else
174 aInst = *pInst;
175 if( !bOwnClass && rDflt.IsInst() )
176 bOwnClass = rDflt.pClass->InHierarchy( this );
177
178 if( bOwnClass )
179 memmove( aInst.pData, rDflt.pData, sizeof( RscRangeInst ) );
180 else
181 {
182 if( 0L >= nMin && 0L <= nMax )
183 ((RscRangeInst *)aInst.pData)->nValue = (sal_uInt16)(0L - nMin);
184 else
185 ((RscRangeInst *)aInst.pData)->nValue = 0;
186 ((RscRangeInst *)aInst.pData)->bDflt = sal_True;
187 }
188
189 return( aInst );
190 }
191
192 /*************************************************************************
193 |*
194 |* RscRange::WriteSrc()
195 |*
196 |* Beschreibung
197 |* Ersterstellung MM 08.04.91
198 |* Letzte Aenderung MM 08.04.91
199 |*
200 *************************************************************************/
WriteSrc(const RSCINST & rInst,FILE * fOutput,RscTypCont *,sal_uInt32,const char *)201 void RscRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
202 RscTypCont *, sal_uInt32, const char * )
203 {
204 fprintf( fOutput, "%ld", long( ((RscRangeInst *)rInst.pData)->nValue + nMin ) );
205 }
206
207 /*************************************************************************
208 |*
209 |* RscRange::WriteRc()
210 |*
211 |* Beschreibung
212 |* Ersterstellung MM 15.04.91
213 |* Letzte Aenderung MM 15.04.91
214 |*
215 *************************************************************************/
WriteRc(const RSCINST & rInst,RscWriteRc & aMem,RscTypCont *,sal_uInt32,sal_Bool)216 ERRTYPE RscRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
217 RscTypCont *, sal_uInt32, sal_Bool )
218 {
219 if( nMin >= 0 )
220 {
221 sal_uInt16 n;
222 n = (sal_uInt16)(((RscRangeInst *)rInst.pData)->nValue + nMin);
223 aMem.Put( n );
224 }
225 else
226 {
227 sal_Int16 n;
228 n = (sal_Int16)(((RscRangeInst *)rInst.pData)->nValue + nMin);
229 aMem.Put( n );
230 }
231
232 return( ERR_OK );
233 }
234
235 //=======================================================================
WriteRcAccess(FILE * fOutput,RscTypCont *,const char * pName)236 void RscRange::WriteRcAccess
237 (
238 FILE * fOutput,
239 RscTypCont * /*pTC*/,
240 const char * pName
241 )
242 {
243 fprintf( fOutput, "\t\tSet%s( ", pName );
244 if( nMin >= 0 )
245 fprintf( fOutput, "*(sal_uInt32 *)(pResData+nOffset) );\n" );
246 else
247 fprintf( fOutput, "*(sal_Int32 *)(pResData+nOffset) );\n" );
248 fprintf( fOutput, "\t\tnOffset += sizeof( sal_uInt32 );\n" );
249 }
250
251 /****************** R s c L o n g R a n g e ******************************/
252 /*************************************************************************
253 |*
254 |* RscLongRange::RscLongRange()
255 |*
256 |* Beschreibung
257 |* Ersterstellung MM 18.07.94
258 |* Letzte Aenderung MM 18.07.94
259 |*
260 *************************************************************************/
RscLongRange(Atom nId,sal_uInt32 nTypeId)261 RscLongRange::RscLongRange( Atom nId, sal_uInt32 nTypeId )
262 : RscTop( nId, nTypeId )
263 {
264 nMin = nMax = 0;
265 nSize = ALIGNED_SIZE( sizeof( RscLongRangeInst ) );
266 }
267
268 /*************************************************************************
269 |*
270 |* RscLongRange::GetClassType()
271 |*
272 |* Beschreibung
273 |* Ersterstellung MM 18.07.94
274 |* Letzte Aenderung MM 18.07.94
275 |*
276 *************************************************************************/
GetClassType() const277 RSCCLASS_TYPE RscLongRange::GetClassType() const
278 {
279 return RSCCLASS_NUMBER;
280 }
281
282 /*************************************************************************
283 |*
284 |* RscLongRange::SetRange()
285 |*
286 |* Beschreibung
287 |* Ersterstellung MM 18.07.94
288 |* Letzte Aenderung MM 18.07.94
289 |*
290 *************************************************************************/
SetRange(sal_Int32 nMinimum,sal_Int32 nMaximum)291 ERRTYPE RscLongRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
292 {
293 if( nMinimum > nMaximum )
294 {
295 nMin = nMaximum;
296 nMax = nMinimum;
297 }
298 else
299 {
300 nMax = nMaximum;
301 nMin = nMinimum;
302 };
303
304 return( ERR_OK );
305 }
306
307 /*************************************************************************
308 |*
309 |* RscLongRange::IsValueDefault()
310 |*
311 |* Beschreibung
312 |* Ersterstellung MM 15.02.92
313 |* Letzte Aenderung MM 15.02.92
314 |*
315 *************************************************************************/
IsValueDefault(const RSCINST & rInst,CLASS_DATA pDef)316 sal_Bool RscLongRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
317 {
318 if( pDef )
319 return 0 == memcmp( &((RscLongRangeInst*)rInst.pData)->nValue,
320 &((RscLongRangeInst*)pDef)->nValue,
321 sizeof( sal_Int32 ) );
322
323 return sal_False;
324 }
325
326 /*************************************************************************
327 |*
328 |* RscLongRange::SetNumber()
329 |*
330 |* Beschreibung
331 |* Ersterstellung MM 18.07.94
332 |* Letzte Aenderung MM 18.07.94
333 |*
334 *************************************************************************/
SetNumber(const RSCINST & rInst,sal_Int32 nValue)335 ERRTYPE RscLongRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
336 {
337 if( nMax < nValue || nMin > nValue )
338 return( ERR_RSCRANGE_OUTDEFSET );
339 void * pData = &((RscLongRangeInst*)rInst.pData)->nValue;
340 memmove( pData, &nValue, sizeof( sal_Int32 ) );
341 ((RscLongRangeInst *)rInst.pData)->bDflt = sal_False;
342 return( ERR_OK );
343 }
344
345 /*************************************************************************
346 |*
347 |* RscLongRange::GetNumber()
348 |*
349 |* Beschreibung
350 |* Ersterstellung MM 22.04.91
351 |* Letzte Aenderung MM 22.04.91
352 |*
353 *************************************************************************/
GetNumber(const RSCINST & rInst,sal_Int32 * pN)354 ERRTYPE RscLongRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
355 {
356 memmove( pN, &((RscLongRangeInst*)rInst.pData)->nValue,
357 sizeof( sal_Int32 ) );
358 return( ERR_OK );
359 }
360
361 /*************************************************************************
362 |*
363 |* RscLongRange::Create()
364 |*
365 |* Beschreibung
366 |* Ersterstellung MM 18.07.94
367 |* Letzte Aenderung MM 18.07.94
368 |*
369 *************************************************************************/
Create(RSCINST * pInst,const RSCINST & rDflt,sal_Bool bOwnClass)370 RSCINST RscLongRange::Create( RSCINST * pInst, const RSCINST & rDflt,
371 sal_Bool bOwnClass )
372 {
373 RSCINST aInst;
374
375 if( !pInst )
376 {
377 aInst.pClass = this;
378 aInst.pData = (CLASS_DATA)
379 rtl_allocateMemory( sizeof( RscLongRangeInst ) );
380 }
381 else
382 aInst = *pInst;
383 if( !bOwnClass && rDflt.IsInst() )
384 bOwnClass = rDflt.pClass->InHierarchy( this );
385
386 if( bOwnClass )
387 memmove( aInst.pData, rDflt.pData, sizeof( RscLongRangeInst ) );
388 else
389 {
390 sal_Int32 lDflt;
391 if( 0L >= nMin && 0L <= nMax )
392 lDflt = 0;
393 else
394 lDflt = nMin;
395 void * pData = &((RscLongRangeInst*)aInst.pData)->nValue;
396 memmove( pData, &lDflt, sizeof( sal_Int32 ) );
397 ((RscLongRangeInst *)aInst.pData)->bDflt = sal_True;
398 }
399
400 return( aInst );
401 }
402
403 /*************************************************************************
404 |*
405 |* RscLongRange::WriteSrc()
406 |*
407 |* Beschreibung
408 |* Ersterstellung MM 18.07.94
409 |* Letzte Aenderung MM 18.07.94
410 |*
411 *************************************************************************/
WriteSrc(const RSCINST & rInst,FILE * fOutput,RscTypCont *,sal_uInt32,const char *)412 void RscLongRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
413 RscTypCont *, sal_uInt32, const char * )
414 {
415 sal_Int32 lVal;
416 GetNumber( rInst, &lVal );
417 fprintf( fOutput, "%d", static_cast<int>(lVal) );
418 }
419
420 /*************************************************************************
421 |*
422 |* RscLongRange::WriteRc()
423 |*
424 |* Beschreibung
425 |* Ersterstellung MM 18.07.94
426 |* Letzte Aenderung MM 18.04.94
427 |*
428 *************************************************************************/
WriteRc(const RSCINST & rInst,RscWriteRc & aMem,RscTypCont *,sal_uInt32,sal_Bool)429 ERRTYPE RscLongRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
430 RscTypCont *, sal_uInt32, sal_Bool )
431 {
432 sal_Int32 lVal;
433
434 GetNumber( rInst, &lVal );
435 aMem.Put( (sal_Int32)lVal );
436
437 return( ERR_OK );
438 }
439
440 //=======================================================================
WriteRcAccess(FILE * fOutput,RscTypCont *,const char * pName)441 void RscLongRange::WriteRcAccess
442 (
443 FILE * fOutput,
444 RscTypCont * /*pTC*/,
445 const char * pName
446 )
447 {
448 fprintf( fOutput, "\t\tSet%s( ", pName );
449 fprintf( fOutput, "GetLong( pResData+nOffset ) );\n" );
450 fprintf( fOutput, "\t\tnOffset += sizeof( sal_Int32 );\n" );
451 }
452
453 /****************** R s c L o n g E n u m R a n g e *********************/
454 /*************************************************************************
455 |* RscLongEnumRange::RscLongEnumRange()
456 |*
457 |* Beschreibung
458 *************************************************************************/
RscLongEnumRange(Atom nId,sal_uInt32 nTypeId)459 RscLongEnumRange::RscLongEnumRange( Atom nId, sal_uInt32 nTypeId )
460 : RscLongRange( nId, nTypeId )
461 {
462 }
463
464 /*************************************************************************
465 |* RscLongEnumRange::SetConst()
466 |*
467 |* Beschreibung
468 *************************************************************************/
SetConst(const RSCINST & rInst,Atom,sal_Int32 nValue)469 ERRTYPE RscLongEnumRange::SetConst( const RSCINST & rInst, Atom /*nConst*/,
470 sal_Int32 nValue )
471 {
472 return SetNumber( rInst, nValue );
473 }
474
475 /****************** R s c I d R a n g e **********************************/
476 /*************************************************************************
477 |*
478 |* RscIdRange::RscIdRange()
479 |*
480 |* Beschreibung
481 |* Ersterstellung MM 03.04.91
482 |* Letzte Aenderung MM 03.04.91
483 |*
484 *************************************************************************/
RscIdRange(Atom nId,sal_uInt32 nTypeId)485 RscIdRange::RscIdRange( Atom nId, sal_uInt32 nTypeId )
486 : RscTop( nId, nTypeId )
487 {
488 nSize = ALIGNED_SIZE( sizeof( RscId ) );
489 nMin = nMax = 0;
490 }
491
492 /*************************************************************************
493 |*
494 |* RscIdRange::RscIdRange()
495 |*
496 |* Beschreibung
497 |* Ersterstellung MM 03.04.91
498 |* Letzte Aenderung MM 03.04.91
499 |*
500 *************************************************************************/
GetClassType() const501 RSCCLASS_TYPE RscIdRange::GetClassType() const
502 {
503 return RSCCLASS_NUMBER;
504 }
505
506 /*************************************************************************
507 |*
508 |* RscIdRange::Create()
509 |*
510 |* Beschreibung
511 |* Ersterstellung MM 03.04.91
512 |* Letzte Aenderung MM 03.04.91
513 |*
514 *************************************************************************/
Create(RSCINST * pInst,const RSCINST & rDflt,sal_Bool bOwnClass)515 RSCINST RscIdRange::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
516 RSCINST aInst;
517 RscId * pClassData;
518
519 if( !pInst ){
520 aInst.pClass = this;
521 aInst.pData = (CLASS_DATA)rtl_allocateMemory( sizeof( RscId ) );
522 }
523 else
524 aInst = *pInst;
525
526
527 if( !bOwnClass && rDflt.IsInst() )
528 bOwnClass = rDflt.pClass->InHierarchy( this );
529
530 pClassData = (RscId *)aInst.pData;
531
532 pClassData->Create();
533 if( bOwnClass )
534 *pClassData = *(RscId *)rDflt.pData;
535 else{
536 *pClassData = RscId();
537 if( 0 >= nMin && 0 <= nMax )
538 *pClassData = RscId( (sal_Int32)0 );
539 else
540 *pClassData = RscId( nMin );
541 //cUnused wird fuer Defaultkennung verwendet
542 ((RscId *)aInst.pData)->aExp.cUnused = sal_True;
543 }
544
545 return( aInst );
546 }
547
548 /*************************************************************************
549 |*
550 |* RscIdRange::Destroy()
551 |*
552 |* Beschreibung
553 |* Ersterstellung MM 22.11.91
554 |* Letzte Aenderung MM 22.11.91
555 |*
556 *************************************************************************/
Destroy(const RSCINST & rInst)557 void RscIdRange :: Destroy( const RSCINST & rInst ){
558 ((RscId *)rInst.pData)->Destroy();
559 }
560
561 /*************************************************************************
562 |*
563 |* RscIdRange::IsValueDefault()
564 |*
565 |* Beschreibung
566 |* Ersterstellung MM 15.01.92
567 |* Letzte Aenderung MM 15.01.92
568 |*
569 *************************************************************************/
IsValueDefault(const RSCINST & rInst,CLASS_DATA pDef)570 sal_Bool RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
571 if( pDef ){
572 if( ((RscId*)rInst.pData)->aExp.IsNumber()
573 && ((RscId*)pDef)->aExp.IsNumber() )
574 {
575 if( ((RscId*)rInst.pData)->GetNumber() ==
576 ((RscId*)pDef)->GetNumber() )
577 {
578 return sal_True;
579 }
580 }
581 }
582
583 return sal_False;
584 }
585
586 /*************************************************************************
587 |*
588 |* RscIdRange::SetNumber()
589 |*
590 |* Beschreibung
591 |* Ersterstellung MM 25.11.91
592 |* Letzte Aenderung MM 25.11.91
593 |*
594 *************************************************************************/
SetNumber(const RSCINST & rInst,sal_Int32 nValue)595 ERRTYPE RscIdRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
596 {
597 if( nMax < nValue || nMin > nValue )
598 return( ERR_RSCRANGE_OUTDEFSET );
599
600 *(RscId *)rInst.pData = RscId( nValue );
601 ((RscId *)rInst.pData)->aExp.cUnused = sal_False;
602 return( ERR_OK );
603 }
604
605 /*************************************************************************
606 |*
607 |* RscIdRange::GetNumber()
608 |*
609 |* Beschreibung
610 |* Ersterstellung MM 25.11.91
611 |* Letzte Aenderung MM 25.11.91
612 |*
613 *************************************************************************/
GetNumber(const RSCINST & rInst,sal_Int32 * plValue)614 ERRTYPE RscIdRange::GetNumber( const RSCINST & rInst, sal_Int32 * plValue ){
615 *plValue = ((RscId *)rInst.pData)->GetNumber();
616 return( ERR_OK );
617 }
618
619 /*************************************************************************
620 |*
621 |* RscIdRange::SetRef()
622 |*
623 |* Beschreibung
624 |* Ersterstellung MM 22.11.91
625 |* Letzte Aenderung MM 22.11.91
626 |*
627 *************************************************************************/
SetRef(const RSCINST & rInst,const RscId & rRscId)628 ERRTYPE RscIdRange::SetRef( const RSCINST & rInst, const RscId & rRscId ){
629 ERRTYPE aError;
630 if( rRscId.IsId() ){
631 aError = SetNumber( rInst, rRscId );
632 if( aError.IsOk() ){
633 *(RscId *)rInst.pData = rRscId;
634 ((RscId *)rInst.pData)->aExp.cUnused = sal_False;
635 }
636 }
637 else
638 aError = ERR_RSCRANGE_OUTDEFSET;
639
640 return( aError );
641 }
642
643 /*************************************************************************
644 |*
645 |* RscIdRange::GetRef()
646 |*
647 |* Beschreibung
648 |* Ersterstellung MM 22.11.91
649 |* Letzte Aenderung MM 22.11.91
650 |*
651 *************************************************************************/
GetRef(const RSCINST & rInst,RscId * pRscId)652 ERRTYPE RscIdRange::GetRef( const RSCINST & rInst, RscId * pRscId ){
653 *pRscId = *(RscId *)rInst.pData;
654
655 return( ERR_OK );
656 }
657
658 /*************************************************************************
659 |*
660 |* RscIdRange::WriteSrc()
661 |*
662 |* Beschreibung
663 |* Ersterstellung MM 22.11.91
664 |* Letzte Aenderung MM 25.11.91
665 |*
666 *************************************************************************/
WriteSrc(const RSCINST & rInst,FILE * fOutput,RscTypCont *,sal_uInt32,const char *)667 void RscIdRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
668 RscTypCont *, sal_uInt32, const char * )
669 {
670 fprintf( fOutput, "%s", ((RscId *)rInst.pData)->GetName().GetBuffer() );
671 }
672
673 /*************************************************************************
674 |*
675 |* RscIdRange::WriteRc()
676 |*
677 |* Beschreibung
678 |* Ersterstellung MM 25.11.91
679 |* Letzte Aenderung MM 25.11.91
680 |*
681 *************************************************************************/
WriteRc(const RSCINST & rInst,RscWriteRc & aMem,RscTypCont *,sal_uInt32,sal_Bool)682 ERRTYPE RscIdRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
683 RscTypCont *, sal_uInt32, sal_Bool )
684 {
685 sal_Int32 lVal = ((RscId*)rInst.pData)->GetNumber();
686
687 aMem.Put( (sal_Int32)lVal );
688
689 return( ERR_OK );
690 }
691
692 //=======================================================================
WriteRcAccess(FILE * fOutput,RscTypCont *,const char * pName)693 void RscIdRange::WriteRcAccess
694 (
695 FILE * fOutput,
696 RscTypCont * /*pTC*/,
697 const char * pName
698 )
699 {
700 fprintf( fOutput, "\t\tSet%s( ", pName );
701 fprintf( fOutput, "GetLong( pResData+nOffset ) );\n" );
702 fprintf( fOutput, "\t\tnOffset += sizeof( sal_Int32 );\n" );
703 }
704
705 /*************************************************************************
706 |*
707 |* RscIdRange::IsConsistent()
708 |*
709 |* Beschreibung
710 |* Ersterstellung MM 22.11.91
711 |* Letzte Aenderung MM 22.11.91
712 |*
713 *************************************************************************/
IsConsistent(const RSCINST & rInst,RscInconsList * pList)714 sal_Bool RscIdRange::IsConsistent( const RSCINST & rInst, RscInconsList * pList )
715 {
716 long nValue = ((RscId *)rInst.pData)->GetNumber();
717 if( (nMax >= nValue) && (nMin <= nValue) )
718 return sal_True;
719 else {
720 if( pList )
721 pList->Insert( new RscInconsistent(
722 *(RscId *)rInst.pData, *(RscId *)rInst.pData ) );
723 return sal_False;
724 }
725 }
726
727 /****************** R s c B o o l ****************************************/
728 /*************************************************************************
729 |*
730 |* RscBool::RscBool()
731 |*
732 |* Beschreibung
733 |* Ersterstellung MM 29.04.91
734 |* Letzte Aenderung MM 29.04.91
735 |*
736 *************************************************************************/
RscBool(Atom nId,sal_uInt32 nTypeId)737 RscBool::RscBool( Atom nId, sal_uInt32 nTypeId )
738 : RscRange( nId, nTypeId )
739 {
740 RscRange::SetRange( 0, 1 );
741 }
742
743 /*************************************************************************
744 |*
745 |* RscBool::GetClassType()
746 |*
747 |* Beschreibung
748 |* Ersterstellung MM 29.04.91
749 |* Letzte Aenderung MM 29.04.91
750 |*
751 *************************************************************************/
GetClassType() const752 RSCCLASS_TYPE RscBool::GetClassType() const
753 {
754 return RSCCLASS_BOOL;
755 }
756
757 /*************************************************************************
758 |*
759 |* RscBool::WriteSrc()
760 |*
761 |* Beschreibung
762 |* Ersterstellung MM 29.04.91
763 |* Letzte Aenderung MM 29.04.91
764 |*
765 *************************************************************************/
WriteSrc(const RSCINST & rInst,FILE * fOutput,RscTypCont *,sal_uInt32,const char *)766 void RscBool::WriteSrc( const RSCINST & rInst, FILE * fOutput,
767 RscTypCont *, sal_uInt32, const char * )
768 {
769 sal_Int32 l;
770
771 GetNumber( rInst, &l );
772 if( l )
773 fprintf( fOutput, "TRUE" );
774 else
775 fprintf( fOutput, "FALSE" );
776 }
777
778 //=======================================================================
WriteRcAccess(FILE * fOutput,RscTypCont *,const char * pName)779 void RscBool::WriteRcAccess
780 (
781 FILE * fOutput,
782 RscTypCont * /*pTC*/,
783 const char * pName
784 )
785 {
786 fprintf( fOutput, "\t\tSet%s( ", pName );
787 fprintf( fOutput, "(sal_Bool)*(short *)(pResData+nOffset) );\n" );
788 fprintf( fOutput, "\t\tnOffset += sizeof( short );\n" );
789 }
790
791 /****************** R s c B r e a k R a n g e ****************************/
792 /*************************************************************************
793 |*
794 |* RscBreakRange::SetNumber()
795 |*
796 |* Beschreibung
797 |* Ersterstellung MM 24.06.91
798 |* Letzte Aenderung MM 24.06.91
799 |*
800 *************************************************************************/
RscBreakRange(Atom nId,sal_uInt32 nTypeId)801 RscBreakRange :: RscBreakRange( Atom nId, sal_uInt32 nTypeId )
802 : RscRange( nId, nTypeId )
803 {
804 nOutRange = 0xFFFFFFFF;
805 }
806
807 /*************************************************************************
808 |*
809 |* RscBreakRange::SetNumber()
810 |*
811 |* Beschreibung
812 |* Ersterstellung MM 24.06.91
813 |* Letzte Aenderung MM 24.06.91
814 |*
815 *************************************************************************/
SetNumber(const RSCINST & rInst,sal_Int32 nValue)816 ERRTYPE RscBreakRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue ){
817 if( nValue == nOutRange )
818 return( ERR_RSCRANGE_OUTDEFSET );
819 else
820 return( RscRange::SetNumber( rInst, nValue ) );
821 }
822
823 /*************************************************************************
824 |*
825 |* RscBreakRange::Create()
826 |*
827 |* Beschreibung
828 |* Ersterstellung MM 24.06.91
829 |* Letzte Aenderung MM 24.06.91
830 |*
831 *************************************************************************/
Create(RSCINST * pInst,const RSCINST & rDflt,sal_Bool bOwnClass)832 RSCINST RscBreakRange::Create( RSCINST * pInst, const RSCINST & rDflt,
833 sal_Bool bOwnClass )
834 {
835 RSCINST aInst;
836 sal_Int32 l;
837
838 aInst = RscRange::Create( pInst, rDflt, bOwnClass );
839
840 GetNumber( aInst, &l );
841 if( l == nOutRange )
842 ((RscRangeInst *)aInst.pData)->nValue++;
843
844 return( aInst );
845 }
846
847