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 *************************************************************************/ 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 *************************************************************************/ 67 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 //======================================================================= 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 *************************************************************************/ 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 *************************************************************************/ 277 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 //======================================================================= 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 *************************************************************************/ 459 RscLongEnumRange::RscLongEnumRange( Atom nId, sal_uInt32 nTypeId ) 460 : RscLongRange( nId, nTypeId ) 461 { 462 } 463 464 /************************************************************************* 465 |* RscLongEnumRange::SetConst() 466 |* 467 |* Beschreibung 468 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 501 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 //======================================================================= 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 752 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 *************************************************************************/ 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 //======================================================================= 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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