rsc/source/res/rsccont.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: rsccont.cxx,v $
  10  * $Revision: 1.7 $
  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 // Programmabh�ngige Includes.
  41 #include <rsccont.hxx>
  42
  43 #include <tools/rcid.h>
  44
  45 /****************** C O D E **********************************************/
  46 /****************** E N T R Y S T R U C T ********************************/
  47 /*************************************************************************
  48 |*
  49 |*        ENTRYSTRUCT::Destroy()
  50 |*
  51 |*        Beschreibung
  52 |*        Ersterstellung        MM 06.08.91
  53 |*        Letzte Aenderung      MM 06.08.91
  54 |*
  55 *************************************************************************/
  56 void ENTRY_STRUCT::Destroy()
  57 {
  58     aName.Destroy();
  59     if( aInst.IsInst() ){
  60         aInst.pClass->Destroy( aInst );
  61         rtl_freeMemory( aInst.pData );
  62     };
  63 }
  64
  65 /****************** R s c B a s e C o n t ********************************/
  66 /*************************************************************************
  67 |*
  68 |*        RscBaseCont::RscBaseCont()
  69 |*
  70 |*        Beschreibung
  71 |*        Ersterstellung        MM 25.05.91
  72 |*        Letzte Aenderung      MM 25.05.91
  73 |*
  74 *************************************************************************/
  75 RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
  76                           BOOL bNoIdent )
  77     : RscTop( nId, nTypeId, pSuper ),
  78       nSize( 0 )
  79 {
  80     pTypeClass = NULL;
  81     pTypeClass1 = NULL;
  82     bNoId = bNoIdent;
  83     nOffInstData = RscTop::Size();
  84     nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscBaseContInst ) );
  85 }
  86
  87 /*************************************************************************
  88 |*
  89 |*        RscBaseCont::~RscBaseCont()
  90 |*
  91 |*        Beschreibung
  92 |*        Ersterstellung        MM 25.05.91
  93 |*        Letzte Aenderung      MM 25.05.91
  94 |*
  95 *************************************************************************/
  96 RscBaseCont::~RscBaseCont()
  97 {
  98 }
  99
 100 /*************************************************************************
 101 |*
 102 |*        RscBaseCont::GetClassType()
 103 |*
 104 |*        Beschreibung
 105 |*        Ersterstellung        MM 25.05.91
 106 |*        Letzte Aenderung      MM 25.05.91
 107 |*
 108 *************************************************************************/
 109 RSCCLASS_TYPE RscBaseCont::GetClassType() const
 110 {
 111     return RSCCLASS_COMPLEX;
 112 }
 113
 114 /*************************************************************************
 115 |*
 116 |*        DestroyElements()
 117 |*
 118 |*        Beschreibung
 119 |*        Ersterstellung        MM 26.04.91
 120 |*        Letzte Aenderung      MM 26.04.91
 121 |*
 122 *************************************************************************/
 123 void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
 124 {
 125     sal_uInt32  i = 0;
 126
 127     if( pClassData->nEntries ){
 128         for( i = 0; i < pClassData->nEntries; i++ ){
 129             pClassData->pEntries[ i ].Destroy();
 130         };
 131         rtl_freeMemory( pClassData->pEntries );
 132         pClassData->pEntries = NULL;
 133         pClassData->nEntries = 0;
 134     };
 135 }
 136
 137 /*************************************************************************
 138 |*
 139 |*        RscBaseCont::Create()
 140 |*
 141 |*        Beschreibung
 142 |*        Ersterstellung        MM 26.04.91
 143 |*        Letzte Aenderung      MM 26.04.91
 144 |*
 145 *************************************************************************/
 146 RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
 147                              BOOL bOwnClass )
 148 {
 149     sal_uInt32  i = 0;
 150     RSCINST aInst;
 151     RscBaseContInst * pClassData;
 152
 153     if( !pInst ){
 154         aInst.pClass = this;
 155         aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
 156     }
 157     else
 158         aInst = *pInst;
 159     if( !bOwnClass && rDflt.IsInst() )
 160         bOwnClass = rDflt.pClass->InHierarchy( this );
 161
 162     RscTop::Create( &aInst, rDflt, bOwnClass );
 163
 164     pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
 165     pClassData->nEntries = 0;
 166     pClassData->pEntries = NULL;
 167     pClassData->bDflt = TRUE;
 168
 169     if( bOwnClass ){
 170         RscBaseContInst *       pDfltClassData;
 171         RSCINST                 aDfltI;
 172
 173         pDfltClassData = (RscBaseContInst *)(rDflt.pData + nOffInstData);
 174
 175         if( 0 != pDfltClassData->nEntries ){
 176             *pClassData = *pDfltClassData;
 177             pClassData->pEntries =
 178                 (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
 179                                                 * pClassData->nEntries );
 180             for( i = 0; i < pClassData->nEntries; i++ ){
 181                 pClassData->pEntries[ i ].Create();
 182                 pClassData->pEntries[ i ].aName =
 183                                     pDfltClassData->pEntries[ i ].aName;
 184                 aDfltI = pDfltClassData->pEntries[ i ].aInst;
 185                 pClassData->pEntries[ i ].aInst =
 186                                     aDfltI.pClass->Create( NULL, aDfltI );
 187             };
 188         };
 189     }
 190
 191     return( aInst );
 192 }
 193
 194 /*************************************************************************
 195 |*
 196 |*        RscBaseCont::Destroy()
 197 |*
 198 |*        Beschreibung
 199 |*        Ersterstellung        MM 25.05.91
 200 |*        Letzte Aenderung      MM 25.05.91
 201 |*
 202 *************************************************************************/
 203 void RscBaseCont::Destroy( const RSCINST & rInst ){
 204     RscBaseContInst * pClassData;
 205
 206     RscTop::Destroy( rInst);
 207
 208     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 209     DestroyElements( pClassData );
 210 }
 211
 212 /*************************************************************************
 213 |*
 214 |*        RscBaseCont::SearchEle()
 215 |*
 216 |*        Beschreibung
 217 |*        Ersterstellung        MM 17.05.91
 218 |*        Letzte Aenderung      MM 17.05.91
 219 |*
 220 *************************************************************************/
 221 RSCINST RscBaseCont::SearchElePos( const RSCINST & rInst, const RscId & rEleName,
 222                                    RscTop * pClass, sal_uInt32 nPos )
 223 {
 224     sal_uInt32  i = 0;
 225     RscBaseContInst * pClassData;
 226
 227     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 228     if( !pClass )
 229         pClass = pTypeClass;
 230
 231     if( rEleName.IsId() ){
 232         for( i = nPos; i < pClassData->nEntries; i++ ){
 233             if( pClassData->pEntries[ i ].aName == rEleName
 234               && pClassData->pEntries[ i ].aInst.pClass == pClass )
 235             {
 236                 return( pClassData->pEntries[ i ].aInst );
 237             };
 238         };
 239     };
 240     return RSCINST();
 241 }
 242
 243 /*************************************************************************
 244 |*
 245 |*        RscBaseCont::SearchEle()
 246 |*
 247 |*        Beschreibung
 248 |*        Ersterstellung        MM 17.05.91
 249 |*        Letzte Aenderung      MM 17.05.91
 250 |*
 251 *************************************************************************/
 252 RSCINST RscBaseCont::SearchEle( const RSCINST & rInst, const RscId & rEleName,
 253                                 RscTop * pClass )
 254 {
 255     return SearchElePos( rInst, rEleName, pClass, 0 );
 256 }
 257
 258 /*************************************************************************
 259 |*
 260 |*        RscBaseCont::GetElement()
 261 |*
 262 |*        Beschreibung
 263 |*        Ersterstellung        MM 26.04.91
 264 |*        Letzte Aenderung      MM 26.04.91
 265 |*
 266 *************************************************************************/
 267 ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
 268                                  RscTop * pCreateClass,
 269                                  const RSCINST & rCreateInst, RSCINST * pGetInst )
 270 {
 271     RscBaseContInst * pClassData;
 272     RSCINST               aTmpI;
 273     ERRTYPE               aError;
 274
 275     if( !bNoId && !rEleName.IsId() )
 276         aError = WRN_CONT_NOID;
 277     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 278
 279     if( pCreateClass ){
 280         if( !pCreateClass->InHierarchy( pTypeClass ) ){
 281             if( pTypeClass1 ){
 282                 if( !pCreateClass->InHierarchy( pTypeClass1 ) ){
 283                     // Falscher Typ
 284                     return ERR_CONT_INVALIDTYPE;
 285                 }
 286             }
 287             else{
 288                 // Falscher Typ
 289                 return ERR_CONT_INVALIDTYPE;
 290             };
 291         };
 292     }
 293     else
 294         pCreateClass = pTypeClass;
 295
 296     pClassData->bDflt = FALSE;
 297     if( !bNoId )
 298         aTmpI = SearchEle( rInst, rEleName, pCreateClass );
 299     // Eintrag gefunden
 300     if( aTmpI.IsInst() ){
 301         aError = WRN_CONT_DOUBLEID;
 302         if( rCreateInst.IsInst() ){
 303             aTmpI.pClass->Destroy( aTmpI );
 304             aTmpI.pClass->Create( &aTmpI, rCreateInst );
 305         };
 306     }
 307     else {
 308         if( pClassData->pEntries ){
 309             pClassData->pEntries =
 310                 (ENTRY_STRUCT *)rtl_reallocateMemory( pClassData->pEntries,
 311                          sizeof( ENTRY_STRUCT ) * (pClassData->nEntries +1) );
 312         }
 313         else {
 314             pClassData->pEntries =
 315                 (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
 316                                                 * (pClassData->nEntries +1) );
 317         };
 318
 319         pClassData->pEntries[ pClassData->nEntries ].Create();
 320         pClassData->pEntries[ pClassData->nEntries ].aName = rEleName;
 321
 322         if( rCreateInst.IsInst() ){
 323             // Instanz mit CreateInst-Daten initialisieren
 324             pClassData->pEntries[ pClassData->nEntries ].aInst =
 325                         pCreateClass->Create( NULL, rCreateInst );
 326         }
 327         else {
 328             pClassData->pEntries[ pClassData->nEntries ].aInst =
 329                         pCreateClass->Create( NULL, RSCINST() );
 330         };
 331
 332         pClassData->nEntries++;
 333         aTmpI = pClassData->pEntries[ pClassData->nEntries -1 ].aInst;
 334     }
 335
 336     *pGetInst = aTmpI;
 337     return aError;
 338 }
 339
 340 /*************************************************************************
 341 |*
 342 |*        RscBaseCont::GetCount()
 343 |*
 344 |*        Beschreibung
 345 |*        Ersterstellung        MM 08.05.91
 346 |*        Letzte Aenderung      MM 08.05.91
 347 |*
 348 *************************************************************************/
 349 sal_uInt32 RscBaseCont::GetCount( const RSCINST & rInst ){
 350     RscBaseContInst * pClassData;
 351
 352     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 353     return( pClassData->nEntries );
 354 }
 355
 356 /*************************************************************************
 357 |*
 358 |*        RscBaseCont::GetPosEle()
 359 |*
 360 |*        Beschreibung
 361 |*        Ersterstellung        MM 08.05.91
 362 |*        Letzte Aenderung      MM 08.05.91
 363 |*
 364 *************************************************************************/
 365 RSCINST RscBaseCont::GetPosEle( const RSCINST & rInst, sal_uInt32 nPos ){
 366     RscBaseContInst * pClassData;
 367
 368     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 369
 370     if( nPos < pClassData->nEntries )
 371         return( pClassData->pEntries[ nPos ].aInst );
 372     return RSCINST();
 373 }
 374
 375 /*************************************************************************
 376 |*
 377 |*        RscBaseCont::MovePosEle()
 378 |*
 379 |*        Beschreibung
 380 |*        Ersterstellung        MM 23.10.91
 381 |*        Letzte Aenderung      MM 23.10.91
 382 |*
 383 *************************************************************************/
 384 ERRTYPE RscBaseCont::MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
 385                                  sal_uInt32 nSourcePos )
 386 {
 387     ERRTYPE aError;
 388     RscBaseContInst * pClassData;
 389
 390     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 391
 392     if( (nDestPos < pClassData->nEntries) && (nSourcePos < pClassData->nEntries) ){
 393         ENTRY_STRUCT aEntry;
 394         int                  nInc = 1;
 395         sal_uInt32               i = 0;
 396
 397         // Quelle Merken
 398         aEntry = pClassData->pEntries[ nSourcePos ];
 399         // Richtung der for-Schleife bestimmen
 400         if( nDestPos < nSourcePos )
 401             nInc = -1;
 402
 403         for( i = nSourcePos; i != nDestPos; i += nInc )
 404             pClassData->pEntries[ i ] = pClassData->pEntries[ i + nInc ];
 405
 406         // Zuweisung Quelle auf Ziel
 407         pClassData->pEntries[ nDestPos ] = aEntry;
 408     }
 409     else
 410         aError = ERR_RSCCONT;
 411     return aError;
 412 }
 413
 414 /*************************************************************************
 415 |*
 416 |*        RscBaseCont::SetPosRscId()
 417 |*
 418 |*        Beschreibung
 419 |*        Ersterstellung        MM 30.09.91
 420 |*        Letzte Aenderung      MM 30.09.91
 421 |*
 422 *************************************************************************/
 423 ERRTYPE RscBaseCont::SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
 424                                   const RscId & rId ){
 425     RscBaseContInst * pClassData;
 426     RSCINST               aTmpI;
 427     ERRTYPE               aError;
 428
 429     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 430
 431     if( nPos < pClassData->nEntries ){
 432         if( ! (rId == pClassData->pEntries[ nPos ].aName) )
 433             aTmpI = SearchEle( rInst, rId,
 434                                pClassData->pEntries[ nPos ].aInst.pClass );
 435         if( !aTmpI.IsInst() )
 436             pClassData->pEntries[ nPos ].aName = rId;
 437         else
 438             aError = ERR_RSCCONT;
 439     }
 440     else
 441         aError = ERR_RSCCONT;
 442     return( aError );
 443 }
 444
 445 /*************************************************************************
 446 |*
 447 |*        RscBaseCont::GetInfoEle()
 448 |*
 449 |*        Beschreibung
 450 |*        Ersterstellung        MM 08.05.91
 451 |*        Letzte Aenderung      MM 08.05.91
 452 |*
 453 *************************************************************************/
 454 SUBINFO_STRUCT RscBaseCont::GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos ){
 455     RscBaseContInst * pClassData;
 456     SUBINFO_STRUCT      aInfo;
 457
 458     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 459
 460     if( nPos < pClassData->nEntries ){
 461         aInfo.aId        = pClassData->pEntries[ nPos ].aName;
 462         aInfo.nPos       = nPos;
 463         aInfo.pClass = pClassData->pEntries[ nPos ].aInst.pClass;
 464     }
 465     return( aInfo );
 466 }
 467
 468 /*************************************************************************
 469 |*
 470 |*        RscBaseCont::SetString()
 471 |*
 472 |*        Beschreibung
 473 |*        Ersterstellung        MM 29.04.91
 474 |*        Letzte Aenderung      MM 29.04.91
 475 |*
 476 *************************************************************************/
 477 ERRTYPE RscBaseCont::SetString( const RSCINST & rInst, const char * pStr )
 478 {
 479     RscBaseContInst * pClassData;
 480     RSCINST aTmpI;
 481     ERRTYPE aError;
 482     char        *pTmpStr;
 483
 484     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 485
 486 //?B 040991
 487 //?W 040991 sonst Endlosrekursion moeglich
 488 if( RSC_NOTYPE == pTypeClass->GetTypId() ){
 489     aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
 490     aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
 491     if( aError.IsOk() )
 492         aError = aTmpI.pClass->SetString( aTmpI, pStr );
 493     else {
 494         aError.Clear();
 495         DeletePos( rInst, pClassData->nEntries -1 );
 496         aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
 497         aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
 498         if( aError.IsOk() )
 499             aError = aTmpI.pClass->SetString( aTmpI, pStr );
 500     }
 501     if( aError.IsError() )
 502         DeletePos( rInst, pClassData->nEntries -1 );
 503 }
 504 else
 505     aError = ERR_UNKNOWN_METHOD;
 506
 507     return( aError );
 508 }
 509
 510 /*************************************************************************
 511 |*
 512 |*        RscBaseCont::SetNumber()
 513 |*
 514 |*        Beschreibung
 515 |*        Ersterstellung        MM 12.06.91
 516 |*        Letzte Aenderung      MM 12.06.91
 517 |*
 518 *************************************************************************/
 519 ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, INT32 lValue ){
 520     RscBaseContInst * pClassData;
 521     RSCINST aTmpI;
 522     ERRTYPE aError;
 523     INT32       lNumber;
 524
 525     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 526
 527 //?B 040991
 528 //?W 040991 sonst Endlosrekursion moeglich
 529 if( RSC_NOTYPE == pTypeClass->GetTypId() ){
 530     aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
 531     aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
 532     if( aError.IsOk() )
 533         aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
 534     else {
 535         aError.Clear();
 536         DeletePos( rInst, pClassData->nEntries -1 );
 537         aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
 538         aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
 539         if( aError.IsOk() )
 540             aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
 541     }
 542     if( aError.IsError() )
 543         DeletePos( rInst, pClassData->nEntries -1 );
 544 }
 545 else
 546     aError = ERR_UNKNOWN_METHOD;
 547
 548     return( aError );
 549 }
 550
 551 //==================================================================
 552 ERRTYPE RscBaseCont::SetBool
 553 (
 554     const RSCINST & rInst,
 555     BOOL bValue
 556 )
 557 {
 558     RscBaseContInst * pClassData;
 559     RSCINST aTmpI;
 560     ERRTYPE aError;
 561     BOOL        bBool;
 562
 563     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 564
 565 //?B 040991
 566 //?W 040991 sonst Endlosrekursion moeglich
 567 if( RSC_NOTYPE == pTypeClass->GetTypId() )
 568 {
 569     aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
 570     aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
 571     if( aError.IsOk() )
 572         aError = aTmpI.pClass->SetBool( aTmpI, bValue );
 573     else {
 574         aError.Clear();
 575         DeletePos( rInst, pClassData->nEntries -1 );
 576         aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
 577         aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
 578         if( aError.IsOk() )
 579             aError = aTmpI.pClass->SetBool( aTmpI, bValue );
 580     }
 581     if( aError.IsError() )
 582         DeletePos( rInst, pClassData->nEntries -1 );
 583 }
 584 else
 585     aError = ERR_UNKNOWN_METHOD;
 586
 587     return( aError );
 588 }
 589
 590 //==================================================================
 591 ERRTYPE RscBaseCont::SetConst
 592 (
 593     const RSCINST & rInst,
 594     Atom nValueId,
 595     INT32 lValue
 596 )
 597 {
 598     RscBaseContInst * pClassData;
 599     RSCINST aTmpI;
 600     ERRTYPE aError;
 601     Atom        nConst;
 602
 603     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 604
 605 //?B 040991
 606 //?W 040991 sonst Endlosrekursion moeglich
 607 if( RSC_NOTYPE == pTypeClass->GetTypId() ){
 608     aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
 609     aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
 610     if( aError.IsOk() )
 611         aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
 612     else {
 613         aError.Clear();
 614         DeletePos( rInst, pClassData->nEntries -1 );
 615         aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
 616         aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
 617         if( aError.IsOk() )
 618             aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
 619     }
 620     if( aError.IsError() )
 621         DeletePos( rInst, pClassData->nEntries -1 );
 622 }
 623 else
 624     aError = ERR_UNKNOWN_METHOD;
 625
 626     return( aError );
 627 }
 628
 629 /*************************************************************************
 630 |*
 631 |*        RscBaseCont::SetRef()
 632 |*
 633 |*        Beschreibung
 634 |*        Ersterstellung        MM 02.12.91
 635 |*        Letzte Aenderung      MM 02.12.91
 636 |*
 637 *************************************************************************/
 638 ERRTYPE RscBaseCont::SetRef( const RSCINST & rInst, const RscId & rRefId ){
 639     RscBaseContInst * pClassData;
 640     RSCINST aTmpI;
 641     ERRTYPE aError;
 642     RscId       aId;
 643
 644     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 645
 646 //?B 040991
 647 //?W 040991 sonst Endlosrekursion moeglich
 648 if( RSC_NOTYPE == pTypeClass->GetTypId() ){
 649     aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
 650     aError = aTmpI.pClass->GetRef( aTmpI, &aId );
 651     if( aError.IsOk() )
 652         aError = aTmpI.pClass->SetRef( aTmpI, rRefId );
 653     else {
 654         aError.Clear();
 655         DeletePos( rInst, pClassData->nEntries -1 );
 656         aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
 657         aError = aTmpI.pClass->GetRef( aTmpI, &aId );
 658         if( aError.IsOk() )
 659             aError = aTmpI.pClass->SetNumber( aTmpI, rRefId );
 660     }
 661     if( aError.IsError() )
 662         DeletePos( rInst, pClassData->nEntries -1 );
 663 }
 664 else
 665     aError = ERR_UNKNOWN_METHOD;
 666
 667     return( aError );
 668 }
 669
 670 /*************************************************************************
 671 |*
 672 |*        RscBaseCont::IsConsistent()
 673 |*
 674 |*        Beschreibung
 675 |*        Ersterstellung        MM 23.09.91
 676 |*        Letzte Aenderung      MM 23.09.91
 677 |*
 678 *************************************************************************/
 679 BOOL RscBaseCont::IsConsistent( const RSCINST & rInst, RscInconsList * pList ){
 680     sal_uInt32  i = 0;
 681     RscBaseContInst * pClassData;
 682     BOOL        bRet;
 683
 684     bRet = RscTop::IsConsistent( rInst, pList );
 685
 686     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 687
 688     // auf doppelten Id Testen und Reihenfolge beibehalten
 689     // Komplexitaet = n^2 / 2
 690     for( i = 0; i < pClassData->nEntries; i++ ){
 691         if( !bNoId ){
 692             if( (INT32)pClassData->pEntries[ i ].aName > 0x7FFF
 693               || (INT32)pClassData->pEntries[ i ].aName < 1 ){
 694                 bRet = FALSE;
 695                 if( pList )
 696                     pList->Insert( new RscInconsistent(
 697                         pClassData->pEntries[ i ].aName,
 698                         pClassData->pEntries[ i ].aName ) );
 699             }
 700             else if( SearchElePos( rInst, pClassData->pEntries[ i ].aName,
 701                 pClassData->pEntries[ i ].aInst.pClass, i +1 ).IsInst() )
 702             {
 703                  bRet = FALSE;
 704                  if( pList )
 705                      pList->Insert( new RscInconsistent(
 706                          pClassData->pEntries[ i        ].aName,
 707                          pClassData->pEntries[ i +1 ].aName ) );
 708              };
 709         }
 710         if( ! pClassData->pEntries[ i ].aInst.pClass->
 711               IsConsistent( pClassData->pEntries[ i ].aInst, pList ) )
 712             bRet = FALSE;
 713     };
 714
 715     return( bRet );
 716 }
 717
 718 /*************************************************************************
 719 |*
 720 |*        RscBaseCont::SetToDefault()
 721 |*
 722 |*        Beschreibung
 723 |*        Ersterstellung        MM 25.04.91
 724 |*        Letzte Aenderung      MM 25.04.91
 725 |*
 726 *************************************************************************/
 727 void RscBaseCont::SetToDefault( const RSCINST & rInst )
 728 {
 729     sal_uInt32  i = 0;
 730     RscBaseContInst * pClassData;
 731
 732     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 733
 734     for( i = 0; i < pClassData->nEntries; i++ )
 735     {
 736         pClassData->pEntries[ i ].aInst.pClass->
 737                   SetToDefault( pClassData->pEntries[ i ].aInst );
 738     };
 739
 740     RscTop::SetToDefault( rInst );
 741 }
 742
 743 /*************************************************************************
 744 |*
 745 |*        RscBaseCont::IsDefault()
 746 |*
 747 |*        Beschreibung
 748 |*        Ersterstellung        MM 25.04.91
 749 |*        Letzte Aenderung      MM 25.04.91
 750 |*
 751 *************************************************************************/
 752 BOOL RscBaseCont::IsDefault( const RSCINST & rInst ){
 753     sal_uInt32  i = 0;
 754     RscBaseContInst * pClassData;
 755
 756     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 757
 758     if( !pClassData->bDflt )
 759         return FALSE;
 760
 761     for( i = 0; i < pClassData->nEntries; i++ ){
 762         if( ! pClassData->pEntries[ i ].aInst.pClass->
 763                   IsDefault( pClassData->pEntries[ i ].aInst ) )
 764         {
 765             return( FALSE );
 766         };
 767     };
 768
 769     return( RscTop::IsDefault( rInst ) );
 770 }
 771
 772 /*************************************************************************
 773 |*
 774 |*        RscBaseCont::IsValueDefault()
 775 |*
 776 |*        Beschreibung
 777 |*        Ersterstellung        MM 25.04.91
 778 |*        Letzte Aenderung      MM 15.01.92
 779 |*
 780 *************************************************************************/
 781 BOOL RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 782 {
 783     RscBaseContInst * pClassData;
 784
 785     if( !RscTop::IsValueDefault( rInst, pDef ) )
 786         return FALSE;
 787
 788     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 789
 790     if( pClassData->nEntries )
 791         return FALSE;
 792     else
 793         return TRUE;
 794 }
 795
 796 /*************************************************************************
 797 |*
 798 |*        RscBaseCont::Delete()
 799 |*
 800 |*        Beschreibung
 801 |*        Ersterstellung        MM 12.06.91
 802 |*        Letzte Aenderung      MM 12.06.91
 803 |*
 804 *************************************************************************/
 805 void RscBaseCont::Delete( const RSCINST & rInst, RscTop * pClass,
 806                           const RscId & rId )
 807 {
 808     sal_uInt32  i = 0;
 809     RscBaseContInst * pClassData;
 810
 811     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 812     if( !pClass )
 813         pClass = pTypeClass;
 814
 815     for( i = 0; i < pClassData->nEntries; i++ ){
 816         if( pClassData->pEntries[ i ].aName == rId )
 817             if( pClassData->pEntries[ i ].aInst.pClass == pClass || !pClass ){
 818                 DeletePos( rInst, i );
 819                 return;
 820             };
 821     };
 822
 823 }
 824
 825 /*************************************************************************
 826 |*
 827 |*        RscBaseCont::DeletePos()
 828 |*
 829 |*        Beschreibung
 830 |*        Ersterstellung        MM 12.06.91
 831 |*        Letzte Aenderung      MM 12.06.91
 832 |*
 833 *************************************************************************/
 834 void RscBaseCont::DeletePos( const RSCINST & rInst, sal_uInt32 nPos ){
 835     RscBaseContInst *   pClassData;
 836     sal_uInt32                          i = 0;
 837
 838     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 839
 840     if( nPos < pClassData->nEntries ){
 841         if( 1 == pClassData->nEntries )
 842             DestroyElements( pClassData );
 843         else{
 844             pClassData->pEntries[ nPos ].Destroy();
 845             pClassData->nEntries--;
 846             for( i = nPos; i < pClassData->nEntries; i++ )
 847                 pClassData->pEntries[ i ] = pClassData->pEntries[ i + 1 ];
 848         };
 849     };
 850 }
 851
 852 /*************************************************************************
 853 |*
 854 |*        RscBaseCont::ContWriteSrc()
 855 |*
 856 |*        Beschreibung
 857 |*        Ersterstellung        MM 26.04.91
 858 |*        Letzte Aenderung      MM 26.04.91
 859 |*
 860 *************************************************************************/
 861 void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
 862                                 RscTypCont * pTC, sal_uInt32 nTab,
 863                                 const char * pVarName )
 864 {
 865     sal_uInt32  i = 0, t = 0;
 866     RscBaseContInst * pClassData;
 867
 868     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 869
 870     for( i = 0; i < pClassData->nEntries; i++ )
 871     {
 872         for( t = 0; t < nTab; t++ )
 873             fputc( '\t', fOutput );
 874         pClassData->pEntries[ i ].aInst.pClass->
 875                   WriteSrcHeader( pClassData->pEntries[ i ].aInst,
 876                                   fOutput, pTC, nTab,
 877                                   pClassData->pEntries[ i ].aName, pVarName );
 878         fprintf( fOutput, ";\n" );
 879     };
 880 }
 881
 882 /*************************************************************************
 883 |*
 884 |*        RscBaseCont::ContWriteRc()
 885 |*
 886 |*        Beschreibung
 887 |*        Ersterstellung        MM 26.04.91
 888 |*        Letzte Aenderung      MM 26.04.91
 889 |*
 890 *************************************************************************/
 891 ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
 892                               RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
 893 {
 894     sal_uInt32            i = 0;
 895     RscBaseContInst * pClassData;
 896     ERRTYPE       aError;
 897
 898     if( bExtra || bNoId )
 899     { // Nur Subresourcen schreiben, wenn bExtra == TRUE
 900         pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 901
 902         for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ ){
 903             aError = pClassData->pEntries[ i ].aInst.pClass->
 904                          WriteRcHeader( pClassData->pEntries[ i ].aInst,
 905                                         rMem, pTC,
 906                                         pClassData->pEntries[ i ].aName,
 907                                         nDeep, bExtra );
 908         }
 909     }
 910
 911     return( aError );
 912 }
 913
 914 //==================================================================
 915 void RscBaseCont::ContWriteRcAccess
 916 (
 917     FILE * fOutput,
 918     RscTypCont * pTC,
 919     const char * pName,
 920     BOOL bWriteSize
 921 )
 922 {
 923     if( (bNoId || bWriteSize) && !pTypeClass1 )
 924     {
 925         fprintf( fOutput, "\t\tsal_uInt32 nItems = *(sal_uInt32 *)(pResData+nOffset) );\n" );
 926         fprintf( fOutput, "\t\tnOffset += sizeof( sal_uInt32 );\n" );
 927
 928         fprintf( fOutput, "\t\t// Items hinzufuegen\n" );
 929         fprintf( fOutput, "\t\tfor( sal_uInt32 i = 0; i < nItems; i++ )\n" );
 930         fprintf( fOutput, "\t\t{\n" );
 931         pTypeClass->WriteRcAccess( fOutput, pTC, "Item" );
 932         fprintf( fOutput, "\t\t}\n" );
 933     }
 934     else
 935     {
 936         fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->getString( GetId() ).getStr() );
 937         fprintf( fOutput, "%s ", aCallPar2.GetBuffer() );
 938         fprintf( fOutput, "ResId( (RSHEADER_TYPE*)(pResData+nOffset) ) ) );\n" );
 939         fprintf( fOutput, "\t\tnOffset += GetObjSizeRes( (RSHEADER_TYPE*)(pResData+nOffset) );\n" );
 940     }
 941 }
 942
 943
 944 /*************************************************************************
 945 |*
 946 |*        RscBaseCont::WriteSrc()
 947 |*
 948 |*        Beschreibung
 949 |*        Ersterstellung        MM 26.04.91
 950 |*        Letzte Aenderung      MM 26.04.91
 951 |*
 952 *************************************************************************/
 953 void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 954                             RscTypCont * pTC, sal_uInt32 nTab,
 955                             const char * pVarName )
 956 {
 957     RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
 958     ContWriteSrc( rInst, fOutput, pTC, nTab, pVarName );
 959 }
 960
 961 /*************************************************************************
 962 |*
 963 |*        RscBaseCont::WriteRc()
 964 |*
 965 |*        Beschreibung
 966 |*        Ersterstellung        MM 26.04.91
 967 |*        Letzte Aenderung      MM 26.04.91
 968 |*
 969 *************************************************************************/
 970 ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
 971                               RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
 972 {
 973     ERRTYPE       aError;
 974
 975     aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
 976     if( aError.IsOk() )
 977         aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
 978
 979     return( aError );
 980 }
 981
 982 /*************************************************************************
 983 |*
 984 |*        RscBaseCont::WriteHxx()
 985 |*
 986 |*        Beschreibung
 987 |*        Ersterstellung        MM 26.04.91
 988 |*        Letzte Aenderung      MM 26.04.91
 989 |*
 990 *************************************************************************/
 991 ERRTYPE RscBaseCont::WriteHxx( const RSCINST & rInst, FILE * fOutput,
 992                                RscTypCont * pTC, const RscId & rRscId )
 993 {
 994     sal_uInt32            i = 0;
 995     RscBaseContInst * pClassData;
 996     ERRTYPE       aError;
 997
 998     aError = RscTop::WriteHxx( rInst, fOutput, pTC, rRscId );
 999
1000     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
1001
1002     for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
1003     {
1004         if( pClassData->pEntries[ i ].aName.IsId()
1005           && pClassData->pEntries[ i ].aInst.pClass->IsCodeWriteable() )
1006         {
1007             aError = pClassData->pEntries[ i ].aInst.pClass->
1008                          WriteHxx( pClassData->pEntries[ i ].aInst,
1009                                    fOutput, pTC,
1010                                    pClassData->pEntries[ i ].aName );
1011         }
1012     };
1013
1014     return( aError );
1015 }
1016
1017 /*************************************************************************
1018 |*
1019 |*        RscBaseCont::WriteCxx()
1020 |*
1021 |*        Beschreibung
1022 |*        Ersterstellung        MM 26.04.91
1023 |*        Letzte Aenderung      MM 26.04.91
1024 |*
1025 *************************************************************************/
1026 ERRTYPE RscBaseCont::WriteCxx( const RSCINST & rInst, FILE * fOutput,
1027                                RscTypCont * pTC, const RscId & rRscId )
1028 {
1029     sal_uInt32            i = 0;
1030     RscBaseContInst * pClassData;
1031     ERRTYPE       aError;
1032
1033     aError = RscTop::WriteCxx( rInst, fOutput, pTC, rRscId );
1034
1035     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
1036
1037     for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
1038     {
1039         if( pClassData->pEntries[ i ].aName.IsId()
1040           && pClassData->pEntries[ i ].aInst.pClass->IsCodeWriteable() )
1041         {
1042             aError = pClassData->pEntries[ i ].aInst.pClass->
1043                          WriteCxx( pClassData->pEntries[ i ].aInst,
1044                                    fOutput, pTC,
1045                                    pClassData->pEntries[ i ].aName );
1046         }
1047     };
1048
1049     return( aError );
1050 }
1051
1052 /*************** R s c C o n t W r i t e S r c ***************************/
1053 /*************************************************************************
1054 |*
1055 |*        RscContWriteSrc::RscContWriteSrc()
1056 |*
1057 |*        Beschreibung
1058 |*        Ersterstellung        MM 08.05.91
1059 |*        Letzte Aenderung      MM 08.05.91
1060 |*
1061 *************************************************************************/
1062 RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
1063                                  RscTop * pSuper, BOOL bNoIdent )
1064                   : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
1065 {}
1066
1067 /*************************************************************************
1068 |*
1069 |*        RscContWriteSrc::WriteSrc()
1070 |*
1071 |*        Beschreibung
1072 |*        Ersterstellung        MM 08.05.91
1073 |*        Letzte Aenderung      MM 08.05.91
1074 |*
1075 *************************************************************************/
1076 void RscContWriteSrc::WriteSrc( const RSCINST & rInst, FILE * fOutput,
1077                                 RscTypCont * pTC, sal_uInt32 nTab,
1078                                 const char * pVarName )
1079 {
1080     sal_uInt32  i;
1081
1082     RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
1083
1084     fprintf( fOutput, "\n" );
1085     for( i = 0; i < nTab; i++ )
1086         fputc( '\t', fOutput );
1087     fprintf( fOutput, "{\n" );
1088
1089     ContWriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
1090
1091     for( i = 0; i < nTab; i++ )
1092         fputc( '\t', fOutput );
1093     fprintf( fOutput, "}" );
1094 }
1095
1096 /*************** R s c C o n t *******************************************/
1097 /*************************************************************************
1098 |*
1099 |*        RscCont::RscCont()
1100 |*
1101 |*        Beschreibung
1102 |*        Ersterstellung        MM 08.05.91
1103 |*        Letzte Aenderung      MM 08.05.91
1104 |*
1105 *************************************************************************/
1106 RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, BOOL bNoIdent )
1107               : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
1108 {}
1109
1110 /*************************************************************************
1111 |*
1112 |*        RscCont::WriteRc()
1113 |*
1114 |*        Beschreibung
1115 |*        Ersterstellung        MM 08.05.91
1116 |*        Letzte Aenderung      MM 08.05.91
1117 |*
1118 *************************************************************************/
1119 ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1120                                  RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
1121 {
1122     RscBaseContInst * pClassData;
1123     ERRTYPE aError;
1124
1125     aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1126
1127     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
1128
1129     rMem.Put( pClassData->nEntries );
1130
1131     if( aError.IsOk() )
1132         aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
1133
1134     return aError;
1135 }
1136
1137 //==================================================================
1138 void RscCont::WriteRcAccess
1139 (
1140     FILE * fOutput,
1141     RscTypCont * pTC,
1142     const char * pName
1143 )
1144 {
1145     ContWriteRcAccess( fOutput, pTC, pName, TRUE );
1146 }
1147
1148 /*************************************************************************
1149 |*
1150 |*        RscContExtraData::RscContExtraData()
1151 |*
1152 |*        Beschreibung
1153 |*        Ersterstellung        MM 08.05.91
1154 |*        Letzte Aenderung      MM 08.05.91
1155 |*
1156 *************************************************************************/
1157 RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
1158                              RscTop * pSuper, BOOL bNoIdent )
1159                      : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
1160 {}
1161
1162 /*************************************************************************
1163 |*
1164 |*        RscContExtraData::WriteRc()
1165 |*
1166 |*        Beschreibung
1167 |*        Ersterstellung        MM 08.05.91
1168 |*        Letzte Aenderung      MM 08.05.91
1169 |*
1170 *************************************************************************/
1171 ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1172                              RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
1173 {
1174     ERRTYPE aError;
1175
1176     if( bExtra )
1177         aError = RscContWriteSrc::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1178     else
1179         aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1180
1181     return aError;
1182 }