rsc/source/res/rscrange.cxx

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