rsc/source/res/rscclass.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_rsc.hxx"
  30 /****************** I N C L U D E S **************************************/
  31
  32 // C and C++ Includes.
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36
  37 // Programmabhaengige Includes.
  38 #include <rscdb.hxx>
  39 #include <rscclass.hxx>
  40
  41 #include <tools/fsys.hxx>
  42 #include <tools/rcid.h>
  43 #include <tools/rc.h>
  44
  45 /****************** C O D E **********************************************/
  46 /****************** R s c C l a s s **************************************/
  47 /*************************************************************************
  48 |*
  49 |*    RscClass::RscClass()
  50 |*
  51 |*    Beschreibung
  52 |*    Ersterstellung    MM 25.05.91
  53 |*    Letzte Aenderung  MM 25.05.91
  54 |*
  55 *************************************************************************/
  56 RscClass::RscClass( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
  57     : RscTop( nId, nTypeId, pSuperCl )
  58 {
  59     nEntries = 0;
  60     pVarTypeList = NULL;
  61     nSuperSize = RscTop::Size();
  62     nSize = nSuperSize + ALIGNED_SIZE( sizeof( RscClassInst ) );
  63 }
  64
  65 /*************************************************************************
  66 |*
  67 |*    RscClass::Pre_dtor()
  68 |*
  69 |*    Beschreibung
  70 |*    Ersterstellung    MM 25.05.91
  71 |*    Letzte Aenderung  MM 25.05.91
  72 |*
  73 *************************************************************************/
  74 void RscClass::Pre_dtor()
  75 {
  76     sal_uInt32  i;
  77
  78     RscTop::Pre_dtor();
  79
  80     for( i = 0; i < nEntries; i++ )
  81     {
  82         if( pVarTypeList[ i ].pDefault )
  83         {
  84             pVarTypeList[ i ].pClass->Destroy(
  85                          RSCINST( pVarTypeList[ i ].pClass,
  86                                   pVarTypeList[ i ].pDefault ) );
  87             rtl_freeMemory( pVarTypeList[ i ].pDefault );
  88             pVarTypeList[ i ].pDefault = NULL;
  89         };
  90     };
  91 }
  92
  93 /*************************************************************************
  94 |*
  95 |*    RscClass::~RscClass()
  96 |*
  97 |*    Beschreibung
  98 |*    Ersterstellung    MM 25.05.91
  99 |*    Letzte Aenderung  MM 25.05.91
 100 |*
 101 *************************************************************************/
 102 RscClass::~RscClass()
 103 {
 104     if( pVarTypeList )
 105         rtl_freeMemory( (void *)pVarTypeList );
 106 }
 107
 108 /*************************************************************************
 109 |*
 110 |*    RscClass::GetClassType()
 111 |*
 112 |*    Beschreibung
 113 |*    Ersterstellung    MM 25.05.91
 114 |*    Letzte Aenderung  MM 25.05.91
 115 |*
 116 *************************************************************************/
 117 RSCCLASS_TYPE RscClass::GetClassType() const
 118 {
 119     return RSCCLASS_COMPLEX;
 120 }
 121
 122 /*************************************************************************
 123 |*
 124 |*    RscClass::GetInstData()
 125 |*
 126 |*    Beschreibung
 127 |*    Ersterstellung    MM 15.04.91
 128 |*    Letzte Aenderung  MM 15.04.91
 129 |*
 130 *************************************************************************/
 131 RSCINST RscClass::GetInstData
 132 (
 133     CLASS_DATA pData,
 134     sal_uInt32 nEle,
 135     sal_Bool bGetCopy
 136 )
 137 {
 138     RSCINST aInst;
 139
 140     aInst.pClass = pVarTypeList[ nEle ].pClass;
 141     if( pData )
 142     {
 143         if( VAR_NODATAINST & pVarTypeList[ nEle ].nVarType )
 144         {
 145             RSCINST aTmpI;
 146
 147             aTmpI.pClass = this;
 148             aTmpI.pData = pData;
 149             if( bGetCopy )
 150                 aInst.pData = GetCopyVar(
 151                                   aTmpI,
 152                                   pVarTypeList[ nEle ].nDataBaseName
 153                               ).pData;
 154             else
 155                 aInst.pData = GetVariable(
 156                                   aTmpI,
 157                                   pVarTypeList[ nEle ].nDataBaseName,
 158                                   RSCINST()
 159                               ).pData;
 160         }
 161         else if( VAR_POINTER & pVarTypeList[ nEle ].nVarType )
 162         {
 163             if( VAR_EXTENDABLE & pVarTypeList[ nEle ].nVarType )
 164                 aInst = *(RSCINST *)
 165                               (pData + pVarTypeList[ nEle ].nOffset);
 166             else
 167                 aInst.pData = *(CLASS_DATA *)
 168                               (pData + pVarTypeList[ nEle ].nOffset);
 169         }
 170         else
 171             aInst.pData = pData + pVarTypeList[ nEle ].nOffset;
 172     };
 173     return( aInst );
 174 }
 175
 176 /*************************************************************************
 177 |*
 178 |*    RscClass::GetInstDflt()
 179 |*
 180 |*    Beschreibung
 181 |*
 182 *************************************************************************/
 183 CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle )
 184 {
 185     if( pVarTypeList[ nEle ].pDefault )
 186         return pVarTypeList[ nEle ].pDefault;
 187
 188     return pVarTypeList[ nEle ].pClass->GetDefault().pData;
 189 }
 190
 191 /*************************************************************************
 192 |*
 193 |*    RscClass::SetVarDflt()
 194 |*
 195 |*    Beschreibung
 196 |*    Ersterstellung    MM 22.07.91
 197 |*    Letzte Aenderung  MM 22.07.91
 198 |*
 199 *************************************************************************/
 200 void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, sal_Bool bSet )
 201 {
 202     RscClassInst * pClass;
 203
 204     pClass = (RscClassInst *)(pData + nSuperSize );
 205     if( bSet )
 206         pClass->nVarDflt |= ((sal_uLong)1 << nEle);
 207     else
 208         pClass->nVarDflt &= ~((sal_uLong)1 << nEle);
 209 }
 210
 211 /*************************************************************************
 212 |*
 213 |*    RscClass::IsDflt()
 214 |*
 215 |*    Beschreibung
 216 |*    Ersterstellung    MM 22.07.91
 217 |*    Letzte Aenderung  MM 08.01.92
 218 |*
 219 *************************************************************************/
 220 sal_Bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
 221 {
 222     RscClassInst *  pClass;
 223     sal_Bool            bRet;
 224
 225     pClass = (RscClassInst *)(pData + nSuperSize );
 226     if( pClass->nVarDflt & ((sal_uLong)1 << nEle) )
 227         bRet = sal_True;
 228     else
 229         bRet = sal_False;
 230 /*  {
 231         //Variablenname ist Default
 232         RSCINST aTmpI;
 233
 234         aTmpI = GetInstData( pData, nEle, sal_True );
 235         if( aTmpI.IsInst() && !aTmpI.pClass->IsDefault( aTmpI ) )
 236             bRet = sal_False;
 237     }
 238 */
 239     return bRet;
 240 }
 241
 242 /*************************************************************************
 243 |*
 244 |*    RscClass::Create()
 245 |*
 246 |*    Beschreibung
 247 |*    Ersterstellung    MM 03.04.91
 248 |*    Letzte Aenderung  MM 03.04.91
 249 |*
 250 *************************************************************************/
 251 RSCINST RscClass::Create
 252 (
 253     RSCINST * pInst,
 254     const RSCINST & rDflt,
 255     sal_Bool bOwnClass
 256 )
 257 {
 258     sal_uInt32  i;
 259     CLASS_DATA  * ppData;
 260     RSCINST aInst;
 261     RSCINST aMemInst, aDfltI;
 262
 263     if( !pInst )
 264     {
 265         aInst.pClass = this;
 266         aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
 267     }
 268     else
 269         aInst = *pInst;
 270     if( !bOwnClass && rDflt.IsInst() )
 271         bOwnClass = rDflt.pClass->InHierarchy( this );
 272
 273     RscTop::Create( &aInst, rDflt, bOwnClass );
 274
 275     if( bOwnClass )
 276         ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt =
 277             ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt;
 278     else
 279         ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0);
 280
 281     for( i = 0; i < nEntries; i++ )
 282     {
 283         aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, sal_True );
 284
 285         if( (VAR_POINTER & pVarTypeList[ i ].nVarType)
 286           && !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
 287         {
 288             if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
 289             {
 290                 RSCINST * pInstance = (RSCINST *)
 291                         (aInst.pData + pVarTypeList[ i ].nOffset );
 292                 pInstance->pClass = pVarTypeList[ i ].pClass;
 293                 ppData = &pInstance->pData;
 294             }
 295             else
 296                 ppData = (CLASS_DATA* )
 297                         (aInst.pData + pVarTypeList[ i ].nOffset );
 298             *ppData = NULL;
 299             if( aDfltI.IsInst() )
 300             {
 301                 aMemInst = pVarTypeList[ i ].pClass->Create( NULL, aDfltI );
 302                 *ppData = aMemInst.pData;
 303             };
 304         }
 305         else
 306         {
 307             aMemInst = GetInstData( aInst.pData, i, sal_True );
 308             aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
 309         };
 310     }
 311
 312     return( aInst );
 313 }
 314
 315 /*************************************************************************
 316 |*
 317 |*    RscClass::Destroy()
 318 |*
 319 |*    Beschreibung
 320 |*
 321 *************************************************************************/
 322 void RscClass::Destroy( const RSCINST & rInst )
 323 {
 324     sal_uInt32  i;
 325
 326     RscTop::Destroy( rInst );
 327
 328     for( i = 0; i < nEntries; i++ )
 329     {
 330         if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) )
 331         {
 332             RSCINST aTmpI;
 333
 334             aTmpI = GetInstData( rInst.pData, i, sal_True );
 335             if( aTmpI.IsInst() )
 336             {
 337                 // Objekt loeschen
 338                 aTmpI.pClass->Destroy( aTmpI );
 339                 if( pVarTypeList[ i ].nVarType & VAR_POINTER )
 340                 {
 341                     // Speicher freigeben
 342                     rtl_freeMemory( aTmpI.pData );
 343                 };
 344             };
 345         }
 346     };
 347 }
 348
 349 /*************************************************************************
 350 |*
 351 |*    RscClass::SetVariable()
 352 |*
 353 |*    Beschreibung
 354 |*
 355 *************************************************************************/
 356 ERRTYPE RscClass::SetVariable
 357 (
 358     Atom nVarName,
 359     RscTop * pClass,
 360     RSCINST * pDflt,
 361     RSCVAR nVarType,
 362     sal_uInt32 nMask,
 363     Atom nDataBaseName
 364 )
 365 {
 366     if( pVarTypeList )
 367         pVarTypeList = (VARTYPE_STRUCT *)
 368                  rtl_reallocateMemory( (void *)pVarTypeList,
 369                  ((nEntries +1) * sizeof( VARTYPE_STRUCT )) );
 370     else
 371         pVarTypeList = (VARTYPE_STRUCT *)
 372             rtl_allocateMemory( ((nEntries +1)
 373                             * sizeof( VARTYPE_STRUCT )) );
 374
 375     pVarTypeList[ nEntries ].nVarName       = nVarName;
 376     pVarTypeList[ nEntries ].nMask          = nMask;
 377     pVarTypeList[ nEntries ].pClass         = pClass;
 378     pVarTypeList[ nEntries ].nOffset        = nSize;
 379     pVarTypeList[ nEntries ].nDataBaseName  = nDataBaseName;
 380     if( pDflt )
 381         pVarTypeList[ nEntries ].pDefault = pDflt->pData;
 382     else
 383         pVarTypeList[ nEntries ].pDefault = NULL;
 384
 385     pVarTypeList[ nEntries ].nVarType = ~VAR_POINTER & nVarType;
 386     if( pClass->Size() > 10 || (nVarType & VAR_EXTENDABLE) )
 387         pVarTypeList[ nEntries ].nVarType |= VAR_POINTER;
 388
 389     if( !(pVarTypeList[ nEntries ].nVarType & VAR_NODATAINST) )
 390     {
 391         if( pVarTypeList[ nEntries ].nVarType & VAR_POINTER )
 392         {
 393             if( pVarTypeList[ nEntries ].nVarType & VAR_EXTENDABLE )
 394                 nSize += sizeof( RSCINST );
 395             else
 396                 nSize += sizeof( CLASS_DATA );
 397         }
 398         else
 399             nSize += pClass->Size();
 400     }
 401
 402     nEntries++;
 403     if( nEntries > (sizeof( sal_uLong ) * 8) )
 404     {
 405         // Bereich fuer Default zu klein
 406         RscExit( 16 );
 407     };
 408     return( ERR_OK );
 409 }
 410
 411 /*************************************************************************
 412 |*
 413 |*    RscClass::EnumVariable()
 414 |*
 415 |*    Beschreibung
 416 |*
 417 *************************************************************************/
 418 void RscClass::EnumVariables( void * pData, VarEnumCallbackProc pProc )
 419 {
 420     sal_uInt32 i;
 421
 422     RscTop::EnumVariables( pData, pProc );
 423     for( i = 0; i < nEntries; i ++ )
 424     {
 425         if( !(pVarTypeList[ i ].nVarType & VAR_NOENUM) )
 426             (*pProc)( pData, pVarTypeList[ i ].pClass->GetClassType(),
 427                         pVarTypeList[ i ].nVarName );
 428     }
 429 }
 430
 431 /*************************************************************************
 432 |*
 433 |*    RscClass::GetVariable()
 434 |*
 435 |*    Beschreibung
 436 |*
 437 *************************************************************************/
 438 RSCINST RscClass::GetVariable
 439 (
 440     const RSCINST & rInst,
 441     Atom nVarName,
 442     const RSCINST & rInitInst,
 443     sal_Bool bInitDflt,
 444     RscTop * pCreateClass
 445 )
 446 {
 447     sal_uInt32  i = 0;
 448     RSCINST aTmpI;
 449
 450     while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
 451         i++;
 452     if( i < nEntries )
 453     {
 454         if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
 455         {
 456             aTmpI = GetVariable( rInst,
 457                                  pVarTypeList[ i ].nDataBaseName,
 458                                  RSCINST() );
 459             aTmpI.pClass = pVarTypeList[ i ].pClass;
 460         }
 461         else
 462         {
 463             // Default Instanz generieren
 464             RSCINST aDefInst = rInitInst;
 465             if( !aDefInst.IsInst() && bInitDflt )
 466             {
 467                 // mit dem Variablen-Default besetzen
 468                 aDefInst.pData  = pVarTypeList[ i ].pDefault;
 469                 aDefInst.pClass = pVarTypeList[ i ].pClass;
 470             }
 471
 472             aTmpI = GetInstData( rInst.pData, i );
 473             if( aTmpI.IsInst() )
 474             {
 475                 if( aDefInst.IsInst() )
 476                 {
 477                     aTmpI.pClass->Destroy( aTmpI );
 478                     aTmpI.pClass->Create( &aTmpI, aDefInst );
 479                 }
 480             }
 481             else
 482             { // Wird ueber Zeiger angegeben
 483                 if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
 484                 {
 485                     RSCINST * pInst = (RSCINST *)
 486                             (rInst.pData + pVarTypeList[ i ].nOffset );
 487                     if( pCreateClass && pCreateClass->InHierarchy( aTmpI.pClass ) )
 488                         *pInst = pCreateClass->Create( NULL, aDefInst );
 489                     else
 490                         *pInst = aTmpI.pClass->Create( NULL, aDefInst );
 491                     aTmpI = *pInst;
 492                 }
 493                 else
 494                 {
 495                     CLASS_DATA  * ppData
 496                         = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset);
 497                     aTmpI = aTmpI.pClass->Create( NULL, aDefInst );
 498                     *ppData = aTmpI.pData;
 499                 }
 500             }
 501         };
 502         // auf nicht Default setzen
 503         SetVarDflt( rInst.pData, i, sal_False );
 504         return( aTmpI );
 505     };
 506
 507     return( RscTop::GetVariable( rInst, nVarName, rInitInst,
 508                                 bInitDflt, pCreateClass ) );
 509 }
 510
 511 /*************************************************************************
 512 |*
 513 |*    RscClass::GetCopyVar()
 514 |*
 515 |*    Beschreibung
 516 |*
 517 *************************************************************************/
 518 RSCINST RscClass::GetCopyVar
 519 (
 520     const RSCINST & rInst,
 521     Atom nVarName
 522 )
 523 {
 524     sal_uInt32  i = 0;
 525     RSCINST aVarI;
 526
 527     while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
 528         i++;
 529
 530     if( i < nEntries )
 531     {
 532         if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
 533         {
 534             aVarI = GetCopyVar( rInst, pVarTypeList[ i ].nDataBaseName );
 535             aVarI.pClass = pVarTypeList[ i ].pClass;
 536         }
 537         else
 538         {
 539             if( IsDflt( rInst.pData, i ) )
 540             {
 541                 // mit Variablen Default initialiaieren
 542                 aVarI = GetVariable( rInst, nVarName, RSCINST(), sal_True );
 543                 SetVarDflt( rInst.pData, i, sal_True );
 544             }
 545             else
 546                 aVarI = GetInstData( rInst.pData, i, sal_True );
 547
 548         };
 549         return aVarI ;
 550     };
 551
 552     return RscTop::GetCopyVar( rInst, nVarName );
 553 }
 554
 555 /*************************************************************************
 556 |*
 557 |*    RscClass::IsConsistent()
 558 |*
 559 |*    Beschreibung
 560 |*
 561 *************************************************************************/
 562 sal_Bool RscClass::IsConsistent( const RSCINST & rInst, RscInconsList * pList )
 563 {
 564     sal_uInt32  i = 0;
 565     RSCINST aTmpI;
 566     sal_Bool    bRet;
 567
 568     bRet = RscTop::IsConsistent( rInst, pList );
 569
 570     for( i = 0; i < nEntries; i++ )
 571     {
 572         if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
 573         {
 574             aTmpI = GetInstData( rInst.pData, i, sal_True );
 575
 576             if( aTmpI.IsInst() )
 577                 if( ! aTmpI.pClass->IsConsistent( aTmpI, pList ) )
 578                     bRet = sal_False;
 579         }
 580     };
 581
 582     return( bRet );
 583 }
 584
 585 /*************************************************************************
 586 |*
 587 |*    RscClass::SetToDefault()
 588 |*
 589 |*    Beschreibung
 590 |*
 591 *************************************************************************/
 592 void RscClass::SetToDefault( const RSCINST & rInst )
 593 {
 594     sal_uInt32  i;
 595     RSCINST aTmpI;
 596     RscClassInst *  pClass;
 597
 598     pClass = (RscClassInst *)(rInst.pData + nSuperSize );
 599
 600     for( i = 0; i < nEntries; i++ )
 601     {
 602         // Variablen ohne eigenen Speicher werden vom "Datenserver"
 603         // auf Default gesetzt
 604         if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
 605         {
 606             aTmpI = GetInstData( rInst.pData, i, sal_True );
 607             if( aTmpI.IsInst() )
 608                 aTmpI.pClass->SetToDefault( aTmpI );
 609         }
 610     }
 611     pClass->nVarDflt = ~((sal_uLong)0); // alles auf Default
 612
 613     RscTop::SetToDefault( rInst );
 614 }
 615
 616 /*************************************************************************
 617 |*
 618 |*    RscClass::IsDefault()
 619 |*
 620 |*    Beschreibung
 621 |*
 622 *************************************************************************/
 623 sal_Bool RscClass::IsDefault( const RSCINST & rInst )
 624 {
 625     sal_uInt32  i;
 626     RSCINST aTmpI;
 627
 628     for( i = 0; i < nEntries; i++ )
 629     {
 630         // Variablen ohne eigenen Speicher werden vom "Datenserver"
 631         // auf Default untersucht
 632         if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
 633             if( !IsDflt( rInst.pData, i ) )
 634                 return( sal_False );
 635     };
 636
 637     return( RscTop::IsDefault( rInst ) );
 638 }
 639
 640 /*************************************************************************
 641 |*
 642 |*    RscClass::GetDefault()
 643 |*
 644 |*    Beschreibung
 645 |*
 646 *************************************************************************/
 647 RSCINST RscClass::GetDefault( Atom nVarId )
 648 {
 649     sal_uInt32  i;
 650
 651     i = 0;
 652     while( i < nEntries && pVarTypeList[ i ].nVarName != nVarId )
 653         i++;
 654     if( i < nEntries )
 655     {
 656         RSCINST aTmpI;
 657
 658         aTmpI.pClass = pVarTypeList[ i ].pClass;
 659         aTmpI.pData  = GetDfltData( i );
 660         return( aTmpI );
 661     };
 662
 663     return( RscTop::GetDefault( nVarId ) );
 664 }
 665
 666 /*************************************************************************
 667 |*
 668 |*    RscClass::IsValueDflt()
 669 |*
 670 |*    Beschreibung
 671 |*
 672 *************************************************************************/
 673 sal_Bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
 674 {
 675     RSCINST aTmpI;
 676
 677     aTmpI = GetInstData( pData, nEle, sal_True );
 678
 679     if( aTmpI.IsInst() )
 680     {
 681         if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
 682             return sal_False;
 683
 684         if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
 685             //sie haben auch die gleiche Klasse
 686             return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
 687         else
 688             return sal_False;
 689     }
 690     return sal_True;
 691 }
 692
 693 /*************************************************************************
 694 |*
 695 |*    RscClass::IsValueDefault()
 696 |*
 697 |*    Beschreibung
 698 |*
 699 *************************************************************************/
 700 sal_Bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 701 {
 702     sal_uInt32  i = 0;
 703     RSCINST aTmpI;
 704     RSCINST aDfltI;
 705
 706     if( !RscTop::IsValueDefault( rInst, pDef ) )
 707         return sal_False;
 708
 709     if( pDef )
 710     {
 711         for( i = 0; i < nEntries; i++ )
 712         {
 713             aTmpI = GetInstData( rInst.pData, i, sal_True );
 714             if( aTmpI.IsInst() )
 715             {
 716                 if( aTmpI.pClass != pVarTypeList[ i ].pClass )
 717                     //sie haben nicht die gleiche Klasse
 718                     return sal_False;
 719
 720                 aDfltI = GetInstData( pDef, i, sal_True );
 721                 if( !aDfltI.IsInst() )
 722                     aDfltI.pData = GetDfltData( i );
 723
 724                 if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
 725                     return sal_False;
 726             }
 727         }
 728     }
 729     else
 730         return sal_False;
 731
 732     return sal_True;
 733 }
 734
 735 /*************************************************************************
 736 |*
 737 |*    RscClass::SetDefault()
 738 |*
 739 |*    Beschreibung
 740 |*
 741 *************************************************************************/
 742 void RscClass::SetDefault( const RSCINST & rInst, Atom nVarName )
 743 {
 744     sal_uInt32  i = 0;
 745     RSCINST aTmpI;
 746
 747     while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
 748         i++;
 749
 750     if( i < nEntries )
 751     {
 752         aTmpI = GetInstData( rInst.pData, i, sal_True );
 753         if( aTmpI.IsInst() )
 754         {
 755             aTmpI.pClass->Destroy( aTmpI );
 756             aTmpI.pClass->Create( &aTmpI, RSCINST() );
 757             SetVarDflt( rInst.pData, i, sal_True );
 758         }
 759     }
 760     else //In Superklasse nach Variable suchen
 761         RscTop::SetDefault( rInst, nVarName );
 762
 763 }
 764
 765
 766 /*************************************************************************
 767 |*
 768 |*    RscClass::WriteSrc()
 769 |*
 770 |*    Beschreibung
 771 |*
 772 *************************************************************************/
 773 void RscClass::WriteSrc
 774 (
 775     const RSCINST & rInst,
 776     FILE * fOutput,
 777     RscTypCont * pTC,
 778     sal_uInt32 nTab,
 779     const char * pVarName
 780 )
 781 {
 782     sal_uInt32  i = 0, n = 0;
 783     RSCINST aTmpI;
 784
 785     RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
 786
 787     for( i = 0; i < nEntries; i++ )
 788     {
 789         if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
 790         {
 791             // Hack wegen Position und Dimensiuon
 792             if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName
 793               || nRsc_WHMAPMODEId == pVarTypeList[ i ].nVarName )
 794             {
 795                 if( !IsDflt( rInst.pData, i )     //MapUnit
 796                   || !IsDflt( rInst.pData, i+1 )  //X, Width
 797                   || !IsDflt( rInst.pData, i+2 ) )//Y, Height
 798                 {// ein Wert ist nicht Default
 799                     for( n = 0; n < nTab; n++ )
 800                         fputc( '\t', fOutput );
 801                     if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName )
 802                         fprintf( fOutput, "Pos = " );
 803                     else
 804                         fprintf( fOutput, "Size = " );
 805
 806                     if( !IsDflt( rInst.pData, i ) )
 807                     {
 808                         aTmpI = GetInstData( rInst.pData, i, sal_True );
 809                         aTmpI.pClass->WriteSrcHeader(
 810                               aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
 811                     }
 812
 813                     fprintf( fOutput, "( " );
 814                     aTmpI = GetInstData( rInst.pData, i+1, sal_True );
 815                     if( !aTmpI.IsInst() )
 816                         aTmpI.pData = GetDfltData( i+1 );
 817                     aTmpI.pClass->WriteSrcHeader(
 818                               aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
 819
 820                     fprintf( fOutput, ", " );
 821                     aTmpI = GetInstData( rInst.pData, i+2, sal_True );
 822                     if( !aTmpI.IsInst() )
 823                         aTmpI.pData = GetDfltData( i+2 );
 824                     aTmpI.pClass->WriteSrcHeader(
 825                               aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
 826                     fprintf( fOutput, " );\n" );
 827                 }
 828                 i += 2; //_X, _Y oder _Widht, Height ueberlesen
 829             }
 830             else if( !IsDflt( rInst.pData, i )
 831               && !IsValueDflt( rInst.pData, i ) )
 832             {
 833                 aTmpI = GetInstData( rInst.pData, i, sal_True );
 834
 835                 if( aTmpI.IsInst() )
 836                 {
 837                     const char * pName = pHS->getString( pVarTypeList[ i ].nVarName ).getStr();
 838
 839                     for( n = 0; n < nTab; n++ )
 840                         fputc( '\t', fOutput );
 841                     fprintf( fOutput, "%s", pName );
 842                     fprintf( fOutput, " = " );
 843                     aTmpI.pClass->WriteSrcHeader(
 844                               aTmpI, fOutput, pTC, nTab, RscId(), pName );
 845                     fprintf( fOutput, ";\n" );
 846                 }
 847             };
 848         };
 849     };
 850
 851     return;
 852 }
 853
 854 /*************************************************************************
 855 |*
 856 |*    RscClass::WriteInstRc()
 857 |*
 858 |*    Beschreibung
 859 |*
 860 *************************************************************************/
 861 sal_Int32 RscClass::GetCorrectValues
 862 (
 863     const RSCINST & rInst,
 864     sal_uInt32 nVarPos,
 865     sal_uInt32 nTupelIdx,
 866     RscTypCont * pTC
 867 )
 868 {
 869     sal_Int32 nLang = 0;
 870     sal_Int32 nBaseValue;
 871
 872     // Basiswert holen
 873     RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, sal_True );
 874     aTmpI.pClass->GetNumber( aTmpI, &nBaseValue );
 875
 876     // Sprach Delta holen
 877     aTmpI = rInst.pClass->GetVariable( rInst, nRsc_DELTALANG, RSCINST() );
 878     if( aTmpI.IsInst() )
 879     {
 880         RscWriteRc aMem;
 881         aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, sal_False );
 882         nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
 883     }
 884
 885     return nLang + nBaseValue;
 886 }
 887
 888 ERRTYPE RscClass::WriteInstRc
 889 (
 890     const RSCINST & rInst,
 891     RscWriteRc & rMem,
 892     RscTypCont * pTC,
 893     sal_uInt32 nDeep,
 894     sal_Bool bExtra
 895 )
 896 {
 897     sal_uInt32 i = 0;
 898     ERRTYPE aError;
 899     RSCINST aTmpI;
 900     sal_uInt32  nMaskOff = 0;// Offset um Maskenfeld zu addressieren
 901
 902     // Wenn eine Variable Maskierung hat, dann Maskenfeld
 903     for( i = 0; i < nEntries; i++ )
 904     {
 905         if( pVarTypeList[ i ].nMask )
 906         {
 907             nMaskOff = rMem.Size();
 908             rMem.Put( sal_uInt32(0) );
 909             break;
 910         }
 911     };
 912
 913     for( i = 0; i < nEntries && aError.IsOk(); i++ )
 914     {
 915         if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
 916         {
 917             if( pVarTypeList[ i ].nMask )
 918             {
 919                 if( !IsDflt( rInst.pData, i ) )
 920                 {
 921                     if( nRsc_X == pVarTypeList[ i ].nVarName )
 922                     {
 923                         sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC );
 924                         rMem.Put( nVal );
 925                     }
 926                     else if( nRsc_Y == pVarTypeList[ i ].nVarName )
 927                     {
 928                         sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC );
 929                         rMem.Put( nVal );
 930                     }
 931                     else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
 932                     {
 933                         sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC );
 934                         rMem.Put( nVal );
 935                     }
 936                     else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
 937                     {
 938                         sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC );
 939                         rMem.Put( nVal );
 940                     }
 941                     else
 942                     {
 943                         aTmpI = GetInstData( rInst.pData, i, sal_True );
 944                         // Nur an Variable Extradata bExtra nicht auf sal_False
 945                         // setzen
 946                         aError = aTmpI.pClass->
 947                             WriteRcHeader( aTmpI, rMem, pTC,
 948                                         RscId(), nDeep,
 949                                         (nRsc_EXTRADATA
 950                                         == pVarTypeList[ i ].nVarName)
 951                                         ? bExtra : sal_False );
 952                     }
 953                     sal_uInt32 nMask = rMem.GetLong( nMaskOff );
 954                     nMask |= pVarTypeList[ i ].nMask;
 955                     rMem.PutAt( nMaskOff, nMask );
 956                 }
 957             }
 958             else{
 959                 if( IsDflt( rInst.pData, i ) )
 960                 {
 961                     aTmpI.pClass = pVarTypeList[ i ].pClass;
 962                     aTmpI.pData  = GetDfltData( i );
 963                 }
 964                 else
 965                     aTmpI = GetInstData( rInst.pData, i, sal_True );
 966                 // Nur an Variable Extradata bExtra nicht auf sal_False
 967                 // setzen
 968                 aError = aTmpI.pClass->
 969                             WriteRcHeader( aTmpI, rMem, pTC,
 970                                         RscId(), nDeep,
 971                                         (nRsc_EXTRADATA
 972                                         == pVarTypeList[ i ].nVarName)
 973                                         ? bExtra : sal_False );
 974             }
 975         }
 976     }
 977
 978     return( aError );
 979 }
 980
 981 /*************************************************************************
 982 |*
 983 |*    RscClass::WriteRc()
 984 |*
 985 |*    Beschreibung
 986 |*
 987 *************************************************************************/
 988 ERRTYPE RscClass::WriteRc
 989 (
 990     const RSCINST & rInst,
 991     RscWriteRc & rMem,
 992     RscTypCont * pTC,
 993     sal_uInt32 nDeep,
 994     sal_Bool bExtra
 995 )
 996 {
 997     ERRTYPE aError;
 998
 999     aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1000     if( aError.IsOk() )
1001         aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
1002
1003     return( aError );
1004 }
1005
1006 /*************************************************************************
1007 |*
1008 |*    RscClass::WriteSyntax()
1009 |*
1010 |*    Beschreibung
1011 |*
1012 *************************************************************************/
1013 void RscClass::WriteSyntax( FILE * fOutput, RscTypCont * pTC )
1014 {
1015     RscTop::WriteSyntax( fOutput, pTC );
1016
1017     sal_uInt32 i;
1018     // Wenn eine Variable Maskierung hat, dann Maskenfeld
1019     fprintf( fOutput, "\t//%s\n", pHS->getString( GetId() ).getStr() );
1020     for( i = 0; i < nEntries; i++ )
1021     {
1022         fprintf( fOutput, "\t%s", pHS->getString( pVarTypeList[ i ].nVarName ).getStr() );
1023         sal_uInt32 n = strlen( pHS->getString( pVarTypeList[ i ].nVarName ).getStr() );
1024         while( n < 20 )
1025         {
1026             putc( ' ', fOutput );
1027             n++;
1028         }
1029         fprintf( fOutput, " = %s;\n",
1030                 pHS->getString( pVarTypeList[ i ].pClass->GetId() ).getStr() );
1031     };
1032 }
1033
1034 //==================================================================
1035 void RscClass::WriteRcAccess
1036 (
1037     FILE * fOutput,
1038     RscTypCont * /*pTC*/,
1039     const char * pName
1040 )
1041 {
1042     fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->getString( GetId() ).getStr() );
1043     fprintf( fOutput, "%s ", aCallPar2.GetBuffer() );
1044     fprintf( fOutput, "ResId( (RSHEADER_TYPE*)(pResData+nOffset) ) ) );\n" );
1045     fprintf( fOutput, "\t\tnOffset += GetObjSizeRes( (RSHEADER_TYPE*)(pResData+nOffset) );\n" );
1046 }
1047
1048 //==================================================================
1049 void RscClass::WriteRcCtor( FILE * fOutput, RscTypCont * pTC )
1050 {
1051     if( GetId() != InvalidAtom )
1052     {
1053         // Konstruktor
1054         fprintf( fOutput, "%s::%s%s bFreeResource )",
1055                 pHS->getString( GetId() ).getStr(),
1056                 pHS->getString( GetId() ).getStr(),
1057                 aCallParType.GetBuffer() );
1058         if( GetSuperClass() )
1059         {
1060             // Superaufruf
1061             fprintf( fOutput, "\n\t: %s", pHS->getString( GetSuperClass()->GetId() ).getStr() );
1062             fprintf( fOutput, "%s", GetSuperClass()->aCallPar1.GetBuffer() );
1063             fprintf( fOutput, " rResId.SetRT2( 0x%lx ) )",
1064                      sal::static_int_cast< unsigned long >(GetTypId()) );
1065         }
1066         fprintf( fOutput, "\n{\n" );
1067         fprintf( fOutput, "\tsal_uInt32\tnObjMask;\n" );
1068         fprintf( fOutput, "\tsal_uInt32\tnOffset = 0;\n" );
1069         fprintf( fOutput, "\tBYTE *\tpResData;\n\n" );
1070         fprintf( fOutput, "\tpResData = (tBYTE *)GetClassRes();\n\n" );
1071         fprintf( fOutput, "\tnObjMask = *(sal_uInt32*)pResData;\n" );
1072         fprintf( fOutput, "\tnOffset += 4;\n\n" );
1073
1074         for( sal_uInt32 i = 0; i < nEntries; i++ )
1075         {
1076             if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
1077             {
1078                 fprintf( fOutput, "\tif( nObjMask & 0x%lx )\n\t{\n",
1079                          sal::static_int_cast< unsigned long >(
1080                              pVarTypeList[ i ].nMask) );
1081
1082                 pVarTypeList[ i ].pClass->WriteRcAccess( fOutput, pTC,
1083                                     pHS->getString( pVarTypeList[ i ].nVarName ).getStr() );
1084
1085                 fprintf( fOutput, "\t}\n" );
1086             }
1087         }
1088         fprintf( fOutput, "\tIncrementRes( nOffset );\n" );
1089         fprintf( fOutput, "\tif( bFreeResource )\n" );
1090         fprintf( fOutput, "\t\tFreeResource();\n" );
1091         fprintf( fOutput, "}\n\n" );
1092     }
1093 }
1094
1095 /*************************************************************************
1096 |*
1097 |*    RscSysDepend::RscSysDepend()
1098 |*
1099 |*    Beschreibung
1100 |*
1101 *************************************************************************/
1102 RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
1103             : RscClass( nId, nTypeId, pSuper )
1104 {}
1105
1106 /*************************************************************************
1107 |*
1108 |*    RscSysDepend::WriteRc()
1109 |*
1110 |*    Beschreibung
1111 |*
1112 *************************************************************************/
1113 ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
1114                 RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra, sal_Bool bFirst )
1115 {
1116     sal_uInt32  nId = 0xFFFFFFFF;
1117     ERRTYPE     aError;
1118     RSCINST     aFileName;
1119
1120     //Instanz mit dem Dateinamen "FILENAME" holen
1121     aFileName = RscClass::GetCopyVar( rInst, pHS->getID( "FILE", true ) );
1122     if( aFileName.IsInst() )
1123     {
1124         RscWriteRc aTmpMem;
1125         aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC,
1126                                                   RscId(), nDeep, bExtra );
1127         // Obsolete - need changes in VCL
1128         rMem.Put( sal_uInt32(0) );
1129
1130         // Identifier schreiben
1131         if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') )
1132         {
1133             nId = pTC->PutSysName( rInst.pClass->GetTypId(),
1134                                    aTmpMem.GetUTF8( 0 ),
1135                                    0, 0, bFirst );
1136         }
1137         rMem.Put( nId );
1138         aError = aFileName.pClass->WriteRcHeader( aFileName, rMem, pTC,
1139                                                   RscId(), nDeep, bExtra );
1140     }
1141     else
1142         aError = ERR_ERROR;
1143
1144     return( aError );
1145 }
1146
1147 /*************************************************************************
1148 |*
1149 |*    RscSysDepend::WriteRc()
1150 |*
1151 |*    Beschreibung
1152 |*
1153 *************************************************************************/
1154 ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1155                             RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
1156 {
1157     ERRTYPE     aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1158
1159     if( this == rInst.pClass )
1160         // nur wenn es eigen Klasse ist
1161         aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra );
1162     return aError;
1163 }
1164
1165 /*************************************************************************
1166 |*
1167 |*    RscFirstSysDepend::RscFirstSysDepend()
1168 |*
1169 |*    Beschreibung
1170 |*
1171 *************************************************************************/
1172 RscFirstSysDepend::RscFirstSysDepend( Atom nId, sal_uInt32 nTypeId,
1173                                         RscTop * pSuper )
1174             : RscSysDepend( nId, nTypeId, pSuper )
1175 {}
1176
1177 /*************************************************************************
1178 |*
1179 |*    RscFirstSysDepend::WriteRc()
1180 |*
1181 |*    Beschreibung
1182 |*
1183 *************************************************************************/
1184 ERRTYPE RscFirstSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1185                             RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
1186 {
1187     ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1188     aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra, sal_True );
1189     return aError;
1190 }
1191
1192 /*************************************************************************
1193 |*
1194 |*    RscTupel::RscTupel()
1195 |*
1196 |*    Beschreibung
1197 |*
1198 *************************************************************************/
1199 RscTupel::RscTupel( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
1200     : RscClass( nId, nTypeId, pSuper )
1201 {}
1202
1203 /*************************************************************************
1204 |*
1205 |*    RscTupel::GetTupelVar()
1206 |*
1207 |*    Beschreibung
1208 |*
1209 *************************************************************************/
1210 RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
1211                                  const RSCINST & rInitInst )
1212 {
1213     if( nPos >= nEntries )
1214     {
1215         return RSCINST();
1216     }
1217     else
1218         return GetVariable( rInst, pVarTypeList[ nPos ].nVarName, rInitInst );
1219 }
1220
1221 /*************************************************************************
1222 |*
1223 |*    RscTupel::WriteSrc()
1224 |*
1225 |*    Beschreibung
1226 |*
1227 *************************************************************************/
1228 void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput,
1229                          RscTypCont * pTC, sal_uInt32 nTab,
1230                          const char * pVarName )
1231 {
1232     sal_uInt32  i = 0;
1233     RSCINST aTmpI;
1234
1235     RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
1236
1237     fprintf( fOutput, "< " );
1238     for( i = 0; i < nEntries; i++ )
1239     {
1240         if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
1241         {
1242             if( !IsDflt( rInst.pData, i )
1243               && !IsValueDflt( rInst.pData, i ) )
1244             {
1245                 aTmpI = GetInstData( rInst.pData, i, sal_True );
1246
1247                 if( aTmpI.IsInst() )
1248                     aTmpI.pClass->WriteSrcHeader(
1249                               aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
1250                 else
1251                     fprintf( fOutput, "Default" );
1252             }
1253             else
1254                 fprintf( fOutput, "Default" );
1255             fprintf( fOutput, "; " );
1256         };
1257     };
1258     fprintf( fOutput, ">" );
1259
1260     return;
1261 }