| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_rsc.hxx" |
| /****************** I N C L U D E S **************************************/ |
| |
| // C and C++ Includes. |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| // Programmabhaengige Includes. |
| #include <rscdb.hxx> |
| #include <rscclass.hxx> |
| |
| #include <tools/fsys.hxx> |
| #include <tools/rcid.h> |
| #include <tools/rc.h> |
| |
| /****************** C O D E **********************************************/ |
| /****************** R s c C l a s s **************************************/ |
| /************************************************************************* |
| |* |
| |* RscClass::RscClass() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 25.05.91 |
| |* Letzte Aenderung MM 25.05.91 |
| |* |
| *************************************************************************/ |
| RscClass::RscClass( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl ) |
| : RscTop( nId, nTypeId, pSuperCl ) |
| { |
| nEntries = 0; |
| pVarTypeList = NULL; |
| nSuperSize = RscTop::Size(); |
| nSize = nSuperSize + ALIGNED_SIZE( sizeof( RscClassInst ) ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::Pre_dtor() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 25.05.91 |
| |* Letzte Aenderung MM 25.05.91 |
| |* |
| *************************************************************************/ |
| void RscClass::Pre_dtor() |
| { |
| sal_uInt32 i; |
| |
| RscTop::Pre_dtor(); |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| if( pVarTypeList[ i ].pDefault ) |
| { |
| pVarTypeList[ i ].pClass->Destroy( |
| RSCINST( pVarTypeList[ i ].pClass, |
| pVarTypeList[ i ].pDefault ) ); |
| rtl_freeMemory( pVarTypeList[ i ].pDefault ); |
| pVarTypeList[ i ].pDefault = NULL; |
| }; |
| }; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::~RscClass() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 25.05.91 |
| |* Letzte Aenderung MM 25.05.91 |
| |* |
| *************************************************************************/ |
| RscClass::~RscClass() |
| { |
| if( pVarTypeList ) |
| rtl_freeMemory( (void *)pVarTypeList ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::GetClassType() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 25.05.91 |
| |* Letzte Aenderung MM 25.05.91 |
| |* |
| *************************************************************************/ |
| RSCCLASS_TYPE RscClass::GetClassType() const |
| { |
| return RSCCLASS_COMPLEX; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::GetInstData() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 15.04.91 |
| |* Letzte Aenderung MM 15.04.91 |
| |* |
| *************************************************************************/ |
| RSCINST RscClass::GetInstData |
| ( |
| CLASS_DATA pData, |
| sal_uInt32 nEle, |
| sal_Bool bGetCopy |
| ) |
| { |
| RSCINST aInst; |
| |
| aInst.pClass = pVarTypeList[ nEle ].pClass; |
| if( pData ) |
| { |
| if( VAR_NODATAINST & pVarTypeList[ nEle ].nVarType ) |
| { |
| RSCINST aTmpI; |
| |
| aTmpI.pClass = this; |
| aTmpI.pData = pData; |
| if( bGetCopy ) |
| aInst.pData = GetCopyVar( |
| aTmpI, |
| pVarTypeList[ nEle ].nDataBaseName |
| ).pData; |
| else |
| aInst.pData = GetVariable( |
| aTmpI, |
| pVarTypeList[ nEle ].nDataBaseName, |
| RSCINST() |
| ).pData; |
| } |
| else if( VAR_POINTER & pVarTypeList[ nEle ].nVarType ) |
| { |
| if( VAR_EXTENDABLE & pVarTypeList[ nEle ].nVarType ) |
| aInst = *(RSCINST *) |
| (pData + pVarTypeList[ nEle ].nOffset); |
| else |
| aInst.pData = *(CLASS_DATA *) |
| (pData + pVarTypeList[ nEle ].nOffset); |
| } |
| else |
| aInst.pData = pData + pVarTypeList[ nEle ].nOffset; |
| }; |
| return( aInst ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::GetInstDflt() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle ) |
| { |
| if( pVarTypeList[ nEle ].pDefault ) |
| return pVarTypeList[ nEle ].pDefault; |
| |
| return pVarTypeList[ nEle ].pClass->GetDefault().pData; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::SetVarDflt() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 22.07.91 |
| |* Letzte Aenderung MM 22.07.91 |
| |* |
| *************************************************************************/ |
| void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, sal_Bool bSet ) |
| { |
| RscClassInst * pClass; |
| |
| pClass = (RscClassInst *)(pData + nSuperSize ); |
| if( bSet ) |
| pClass->nVarDflt |= ((sal_uLong)1 << nEle); |
| else |
| pClass->nVarDflt &= ~((sal_uLong)1 << nEle); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::IsDflt() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 22.07.91 |
| |* Letzte Aenderung MM 08.01.92 |
| |* |
| *************************************************************************/ |
| sal_Bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle ) |
| { |
| RscClassInst * pClass; |
| sal_Bool bRet; |
| |
| pClass = (RscClassInst *)(pData + nSuperSize ); |
| if( pClass->nVarDflt & ((sal_uLong)1 << nEle) ) |
| bRet = sal_True; |
| else |
| bRet = sal_False; |
| /* { |
| //Variablenname ist Default |
| RSCINST aTmpI; |
| |
| aTmpI = GetInstData( pData, nEle, sal_True ); |
| if( aTmpI.IsInst() && !aTmpI.pClass->IsDefault( aTmpI ) ) |
| bRet = sal_False; |
| } |
| */ |
| return bRet; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::Create() |
| |* |
| |* Beschreibung |
| |* Ersterstellung MM 03.04.91 |
| |* Letzte Aenderung MM 03.04.91 |
| |* |
| *************************************************************************/ |
| RSCINST RscClass::Create |
| ( |
| RSCINST * pInst, |
| const RSCINST & rDflt, |
| sal_Bool bOwnClass |
| ) |
| { |
| sal_uInt32 i; |
| CLASS_DATA * ppData; |
| RSCINST aInst; |
| RSCINST aMemInst, aDfltI; |
| |
| if( !pInst ) |
| { |
| aInst.pClass = this; |
| aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() ); |
| } |
| else |
| aInst = *pInst; |
| if( !bOwnClass && rDflt.IsInst() ) |
| bOwnClass = rDflt.pClass->InHierarchy( this ); |
| |
| RscTop::Create( &aInst, rDflt, bOwnClass ); |
| |
| if( bOwnClass ) |
| ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = |
| ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt; |
| else |
| ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0); |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, sal_True ); |
| |
| if( (VAR_POINTER & pVarTypeList[ i ].nVarType) |
| && !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) ) |
| { |
| if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType ) |
| { |
| RSCINST * pInstance = (RSCINST *) |
| (aInst.pData + pVarTypeList[ i ].nOffset ); |
| pInstance->pClass = pVarTypeList[ i ].pClass; |
| ppData = &pInstance->pData; |
| } |
| else |
| ppData = (CLASS_DATA* ) |
| (aInst.pData + pVarTypeList[ i ].nOffset ); |
| *ppData = NULL; |
| if( aDfltI.IsInst() ) |
| { |
| aMemInst = pVarTypeList[ i ].pClass->Create( NULL, aDfltI ); |
| *ppData = aMemInst.pData; |
| }; |
| } |
| else |
| { |
| aMemInst = GetInstData( aInst.pData, i, sal_True ); |
| aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI ); |
| }; |
| } |
| |
| return( aInst ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::Destroy() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscClass::Destroy( const RSCINST & rInst ) |
| { |
| sal_uInt32 i; |
| |
| RscTop::Destroy( rInst ); |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) ) |
| { |
| RSCINST aTmpI; |
| |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| if( aTmpI.IsInst() ) |
| { |
| // Objekt loeschen |
| aTmpI.pClass->Destroy( aTmpI ); |
| if( pVarTypeList[ i ].nVarType & VAR_POINTER ) |
| { |
| // Speicher freigeben |
| rtl_freeMemory( aTmpI.pData ); |
| }; |
| }; |
| } |
| }; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::SetVariable() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| ERRTYPE RscClass::SetVariable |
| ( |
| Atom nVarName, |
| RscTop * pClass, |
| RSCINST * pDflt, |
| RSCVAR nVarType, |
| sal_uInt32 nMask, |
| Atom nDataBaseName |
| ) |
| { |
| if( pVarTypeList ) |
| pVarTypeList = (VARTYPE_STRUCT *) |
| rtl_reallocateMemory( (void *)pVarTypeList, |
| ((nEntries +1) * sizeof( VARTYPE_STRUCT )) ); |
| else |
| pVarTypeList = (VARTYPE_STRUCT *) |
| rtl_allocateMemory( ((nEntries +1) |
| * sizeof( VARTYPE_STRUCT )) ); |
| |
| pVarTypeList[ nEntries ].nVarName = nVarName; |
| pVarTypeList[ nEntries ].nMask = nMask; |
| pVarTypeList[ nEntries ].pClass = pClass; |
| pVarTypeList[ nEntries ].nOffset = nSize; |
| pVarTypeList[ nEntries ].nDataBaseName = nDataBaseName; |
| if( pDflt ) |
| pVarTypeList[ nEntries ].pDefault = pDflt->pData; |
| else |
| pVarTypeList[ nEntries ].pDefault = NULL; |
| |
| pVarTypeList[ nEntries ].nVarType = ~VAR_POINTER & nVarType; |
| if( pClass->Size() > 10 || (nVarType & VAR_EXTENDABLE) ) |
| pVarTypeList[ nEntries ].nVarType |= VAR_POINTER; |
| |
| if( !(pVarTypeList[ nEntries ].nVarType & VAR_NODATAINST) ) |
| { |
| if( pVarTypeList[ nEntries ].nVarType & VAR_POINTER ) |
| { |
| if( pVarTypeList[ nEntries ].nVarType & VAR_EXTENDABLE ) |
| nSize += sizeof( RSCINST ); |
| else |
| nSize += sizeof( CLASS_DATA ); |
| } |
| else |
| nSize += pClass->Size(); |
| } |
| |
| nEntries++; |
| if( nEntries > (sizeof( sal_uLong ) * 8) ) |
| { |
| // Bereich fuer Default zu klein |
| RscExit( 16 ); |
| }; |
| return( ERR_OK ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::EnumVariable() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscClass::EnumVariables( void * pData, VarEnumCallbackProc pProc ) |
| { |
| sal_uInt32 i; |
| |
| RscTop::EnumVariables( pData, pProc ); |
| for( i = 0; i < nEntries; i ++ ) |
| { |
| if( !(pVarTypeList[ i ].nVarType & VAR_NOENUM) ) |
| (*pProc)( pData, pVarTypeList[ i ].pClass->GetClassType(), |
| pVarTypeList[ i ].nVarName ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::GetVariable() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RSCINST RscClass::GetVariable |
| ( |
| const RSCINST & rInst, |
| Atom nVarName, |
| const RSCINST & rInitInst, |
| sal_Bool bInitDflt, |
| RscTop * pCreateClass |
| ) |
| { |
| sal_uInt32 i = 0; |
| RSCINST aTmpI; |
| |
| while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName ) |
| i++; |
| if( i < nEntries ) |
| { |
| if( VAR_NODATAINST & pVarTypeList[ i ].nVarType ) |
| { |
| aTmpI = GetVariable( rInst, |
| pVarTypeList[ i ].nDataBaseName, |
| RSCINST() ); |
| aTmpI.pClass = pVarTypeList[ i ].pClass; |
| } |
| else |
| { |
| // Default Instanz generieren |
| RSCINST aDefInst = rInitInst; |
| if( !aDefInst.IsInst() && bInitDflt ) |
| { |
| // mit dem Variablen-Default besetzen |
| aDefInst.pData = pVarTypeList[ i ].pDefault; |
| aDefInst.pClass = pVarTypeList[ i ].pClass; |
| } |
| |
| aTmpI = GetInstData( rInst.pData, i ); |
| if( aTmpI.IsInst() ) |
| { |
| if( aDefInst.IsInst() ) |
| { |
| aTmpI.pClass->Destroy( aTmpI ); |
| aTmpI.pClass->Create( &aTmpI, aDefInst ); |
| } |
| } |
| else |
| { // Wird ueber Zeiger angegeben |
| if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType ) |
| { |
| RSCINST * pInst = (RSCINST *) |
| (rInst.pData + pVarTypeList[ i ].nOffset ); |
| if( pCreateClass && pCreateClass->InHierarchy( aTmpI.pClass ) ) |
| *pInst = pCreateClass->Create( NULL, aDefInst ); |
| else |
| *pInst = aTmpI.pClass->Create( NULL, aDefInst ); |
| aTmpI = *pInst; |
| } |
| else |
| { |
| CLASS_DATA * ppData |
| = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset); |
| aTmpI = aTmpI.pClass->Create( NULL, aDefInst ); |
| *ppData = aTmpI.pData; |
| } |
| } |
| }; |
| // auf nicht Default setzen |
| SetVarDflt( rInst.pData, i, sal_False ); |
| return( aTmpI ); |
| }; |
| |
| return( RscTop::GetVariable( rInst, nVarName, rInitInst, |
| bInitDflt, pCreateClass ) ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::GetCopyVar() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RSCINST RscClass::GetCopyVar |
| ( |
| const RSCINST & rInst, |
| Atom nVarName |
| ) |
| { |
| sal_uInt32 i = 0; |
| RSCINST aVarI; |
| |
| while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName ) |
| i++; |
| |
| if( i < nEntries ) |
| { |
| if( VAR_NODATAINST & pVarTypeList[ i ].nVarType ) |
| { |
| aVarI = GetCopyVar( rInst, pVarTypeList[ i ].nDataBaseName ); |
| aVarI.pClass = pVarTypeList[ i ].pClass; |
| } |
| else |
| { |
| if( IsDflt( rInst.pData, i ) ) |
| { |
| // mit Variablen Default initialiaieren |
| aVarI = GetVariable( rInst, nVarName, RSCINST(), sal_True ); |
| SetVarDflt( rInst.pData, i, sal_True ); |
| } |
| else |
| aVarI = GetInstData( rInst.pData, i, sal_True ); |
| |
| }; |
| return aVarI ; |
| }; |
| |
| return RscTop::GetCopyVar( rInst, nVarName ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::IsConsistent() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| sal_Bool RscClass::IsConsistent( const RSCINST & rInst, RscInconsList * pList ) |
| { |
| sal_uInt32 i = 0; |
| RSCINST aTmpI; |
| sal_Bool bRet; |
| |
| bRet = RscTop::IsConsistent( rInst, pList ); |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| |
| if( aTmpI.IsInst() ) |
| if( ! aTmpI.pClass->IsConsistent( aTmpI, pList ) ) |
| bRet = sal_False; |
| } |
| }; |
| |
| return( bRet ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::SetToDefault() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscClass::SetToDefault( const RSCINST & rInst ) |
| { |
| sal_uInt32 i; |
| RSCINST aTmpI; |
| RscClassInst * pClass; |
| |
| pClass = (RscClassInst *)(rInst.pData + nSuperSize ); |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| // Variablen ohne eigenen Speicher werden vom "Datenserver" |
| // auf Default gesetzt |
| if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| if( aTmpI.IsInst() ) |
| aTmpI.pClass->SetToDefault( aTmpI ); |
| } |
| } |
| pClass->nVarDflt = ~((sal_uLong)0); // alles auf Default |
| |
| RscTop::SetToDefault( rInst ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::IsDefault() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| sal_Bool RscClass::IsDefault( const RSCINST & rInst ) |
| { |
| sal_uInt32 i; |
| RSCINST aTmpI; |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| // Variablen ohne eigenen Speicher werden vom "Datenserver" |
| // auf Default untersucht |
| if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) ) |
| if( !IsDflt( rInst.pData, i ) ) |
| return( sal_False ); |
| }; |
| |
| return( RscTop::IsDefault( rInst ) ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::GetDefault() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RSCINST RscClass::GetDefault( Atom nVarId ) |
| { |
| sal_uInt32 i; |
| |
| i = 0; |
| while( i < nEntries && pVarTypeList[ i ].nVarName != nVarId ) |
| i++; |
| if( i < nEntries ) |
| { |
| RSCINST aTmpI; |
| |
| aTmpI.pClass = pVarTypeList[ i ].pClass; |
| aTmpI.pData = GetDfltData( i ); |
| return( aTmpI ); |
| }; |
| |
| return( RscTop::GetDefault( nVarId ) ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::IsValueDflt() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| sal_Bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle ) |
| { |
| RSCINST aTmpI; |
| |
| aTmpI = GetInstData( pData, nEle, sal_True ); |
| |
| if( aTmpI.IsInst() ) |
| { |
| if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType ) |
| return sal_False; |
| |
| if( aTmpI.pClass == pVarTypeList[ nEle ].pClass ) |
| //sie haben auch die gleiche Klasse |
| return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) ); |
| else |
| return sal_False; |
| } |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::IsValueDefault() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| sal_Bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ) |
| { |
| sal_uInt32 i = 0; |
| RSCINST aTmpI; |
| RSCINST aDfltI; |
| |
| if( !RscTop::IsValueDefault( rInst, pDef ) ) |
| return sal_False; |
| |
| if( pDef ) |
| { |
| for( i = 0; i < nEntries; i++ ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| if( aTmpI.IsInst() ) |
| { |
| if( aTmpI.pClass != pVarTypeList[ i ].pClass ) |
| //sie haben nicht die gleiche Klasse |
| return sal_False; |
| |
| aDfltI = GetInstData( pDef, i, sal_True ); |
| if( !aDfltI.IsInst() ) |
| aDfltI.pData = GetDfltData( i ); |
| |
| if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) ) |
| return sal_False; |
| } |
| } |
| } |
| else |
| return sal_False; |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::SetDefault() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscClass::SetDefault( const RSCINST & rInst, Atom nVarName ) |
| { |
| sal_uInt32 i = 0; |
| RSCINST aTmpI; |
| |
| while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName ) |
| i++; |
| |
| if( i < nEntries ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| if( aTmpI.IsInst() ) |
| { |
| aTmpI.pClass->Destroy( aTmpI ); |
| aTmpI.pClass->Create( &aTmpI, RSCINST() ); |
| SetVarDflt( rInst.pData, i, sal_True ); |
| } |
| } |
| else //In Superklasse nach Variable suchen |
| RscTop::SetDefault( rInst, nVarName ); |
| |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* RscClass::WriteSrc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscClass::WriteSrc |
| ( |
| const RSCINST & rInst, |
| FILE * fOutput, |
| RscTypCont * pTC, |
| sal_uInt32 nTab, |
| const char * pVarName |
| ) |
| { |
| sal_uInt32 i = 0, n = 0; |
| RSCINST aTmpI; |
| |
| RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName ); |
| |
| for( i = 0; i < nEntries; i++ ) |
| { |
| if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) ) |
| { |
| // Hack wegen Position und Dimensiuon |
| if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName |
| || nRsc_WHMAPMODEId == pVarTypeList[ i ].nVarName ) |
| { |
| if( !IsDflt( rInst.pData, i ) //MapUnit |
| || !IsDflt( rInst.pData, i+1 ) //X, Width |
| || !IsDflt( rInst.pData, i+2 ) )//Y, Height |
| {// ein Wert ist nicht Default |
| for( n = 0; n < nTab; n++ ) |
| fputc( '\t', fOutput ); |
| if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName ) |
| fprintf( fOutput, "Pos = " ); |
| else |
| fprintf( fOutput, "Size = " ); |
| |
| if( !IsDflt( rInst.pData, i ) ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| aTmpI.pClass->WriteSrcHeader( |
| aTmpI, fOutput, pTC, nTab, RscId(), pVarName ); |
| } |
| |
| fprintf( fOutput, "( " ); |
| aTmpI = GetInstData( rInst.pData, i+1, sal_True ); |
| if( !aTmpI.IsInst() ) |
| aTmpI.pData = GetDfltData( i+1 ); |
| aTmpI.pClass->WriteSrcHeader( |
| aTmpI, fOutput, pTC, nTab, RscId(), pVarName ); |
| |
| fprintf( fOutput, ", " ); |
| aTmpI = GetInstData( rInst.pData, i+2, sal_True ); |
| if( !aTmpI.IsInst() ) |
| aTmpI.pData = GetDfltData( i+2 ); |
| aTmpI.pClass->WriteSrcHeader( |
| aTmpI, fOutput, pTC, nTab, RscId(), pVarName ); |
| fprintf( fOutput, " );\n" ); |
| } |
| i += 2; //_X, _Y oder _Widht, Height ueberlesen |
| } |
| else if( !IsDflt( rInst.pData, i ) |
| && !IsValueDflt( rInst.pData, i ) ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| |
| if( aTmpI.IsInst() ) |
| { |
| const char * pName = pHS->getString( pVarTypeList[ i ].nVarName ).getStr(); |
| |
| for( n = 0; n < nTab; n++ ) |
| fputc( '\t', fOutput ); |
| fprintf( fOutput, "%s", pName ); |
| fprintf( fOutput, " = " ); |
| aTmpI.pClass->WriteSrcHeader( |
| aTmpI, fOutput, pTC, nTab, RscId(), pName ); |
| fprintf( fOutput, ";\n" ); |
| } |
| }; |
| }; |
| }; |
| |
| return; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::WriteInstRc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| sal_Int32 RscClass::GetCorrectValues |
| ( |
| const RSCINST & rInst, |
| sal_uInt32 nVarPos, |
| sal_uInt32 nTupelIdx, |
| RscTypCont * pTC |
| ) |
| { |
| sal_Int32 nLang = 0; |
| sal_Int32 nBaseValue; |
| |
| // Basiswert holen |
| RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, sal_True ); |
| aTmpI.pClass->GetNumber( aTmpI, &nBaseValue ); |
| |
| // Sprach Delta holen |
| aTmpI = rInst.pClass->GetVariable( rInst, nRsc_DELTALANG, RSCINST() ); |
| if( aTmpI.IsInst() ) |
| { |
| RscWriteRc aMem; |
| aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, sal_False ); |
| nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) ); |
| } |
| |
| return nLang + nBaseValue; |
| } |
| |
| ERRTYPE RscClass::WriteInstRc |
| ( |
| const RSCINST & rInst, |
| RscWriteRc & rMem, |
| RscTypCont * pTC, |
| sal_uInt32 nDeep, |
| sal_Bool bExtra |
| ) |
| { |
| sal_uInt32 i = 0; |
| ERRTYPE aError; |
| RSCINST aTmpI; |
| sal_uInt32 nMaskOff = 0;// Offset um Maskenfeld zu addressieren |
| |
| // Wenn eine Variable Maskierung hat, dann Maskenfeld |
| for( i = 0; i < nEntries; i++ ) |
| { |
| if( pVarTypeList[ i ].nMask ) |
| { |
| nMaskOff = rMem.Size(); |
| rMem.Put( sal_uInt32(0) ); |
| break; |
| } |
| }; |
| |
| for( i = 0; i < nEntries && aError.IsOk(); i++ ) |
| { |
| if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType )) |
| { |
| if( pVarTypeList[ i ].nMask ) |
| { |
| if( !IsDflt( rInst.pData, i ) ) |
| { |
| if( nRsc_X == pVarTypeList[ i ].nVarName ) |
| { |
| sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC ); |
| rMem.Put( nVal ); |
| } |
| else if( nRsc_Y == pVarTypeList[ i ].nVarName ) |
| { |
| sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC ); |
| rMem.Put( nVal ); |
| } |
| else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName ) |
| { |
| sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC ); |
| rMem.Put( nVal ); |
| } |
| else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName ) |
| { |
| sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC ); |
| rMem.Put( nVal ); |
| } |
| else |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| // Nur an Variable Extradata bExtra nicht auf sal_False |
| // setzen |
| aError = aTmpI.pClass-> |
| WriteRcHeader( aTmpI, rMem, pTC, |
| RscId(), nDeep, |
| (nRsc_EXTRADATA |
| == pVarTypeList[ i ].nVarName) |
| ? bExtra : sal_False ); |
| } |
| sal_uInt32 nMask = rMem.GetLong( nMaskOff ); |
| nMask |= pVarTypeList[ i ].nMask; |
| rMem.PutAt( nMaskOff, nMask ); |
| } |
| } |
| else{ |
| if( IsDflt( rInst.pData, i ) ) |
| { |
| aTmpI.pClass = pVarTypeList[ i ].pClass; |
| aTmpI.pData = GetDfltData( i ); |
| } |
| else |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| // Nur an Variable Extradata bExtra nicht auf sal_False |
| // setzen |
| aError = aTmpI.pClass-> |
| WriteRcHeader( aTmpI, rMem, pTC, |
| RscId(), nDeep, |
| (nRsc_EXTRADATA |
| == pVarTypeList[ i ].nVarName) |
| ? bExtra : sal_False ); |
| } |
| } |
| } |
| |
| return( aError ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::WriteRc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| ERRTYPE RscClass::WriteRc |
| ( |
| const RSCINST & rInst, |
| RscWriteRc & rMem, |
| RscTypCont * pTC, |
| sal_uInt32 nDeep, |
| sal_Bool bExtra |
| ) |
| { |
| ERRTYPE aError; |
| |
| aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra ); |
| if( aError.IsOk() ) |
| aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra ); |
| |
| return( aError ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscClass::WriteSyntax() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscClass::WriteSyntax( FILE * fOutput, RscTypCont * pTC ) |
| { |
| RscTop::WriteSyntax( fOutput, pTC ); |
| |
| sal_uInt32 i; |
| // Wenn eine Variable Maskierung hat, dann Maskenfeld |
| fprintf( fOutput, "\t//%s\n", pHS->getString( GetId() ).getStr() ); |
| for( i = 0; i < nEntries; i++ ) |
| { |
| fprintf( fOutput, "\t%s", pHS->getString( pVarTypeList[ i ].nVarName ).getStr() ); |
| sal_uInt32 n = strlen( pHS->getString( pVarTypeList[ i ].nVarName ).getStr() ); |
| while( n < 20 ) |
| { |
| putc( ' ', fOutput ); |
| n++; |
| } |
| fprintf( fOutput, " = %s;\n", |
| pHS->getString( pVarTypeList[ i ].pClass->GetId() ).getStr() ); |
| }; |
| } |
| |
| //================================================================== |
| void RscClass::WriteRcAccess |
| ( |
| FILE * fOutput, |
| RscTypCont * /*pTC*/, |
| const char * pName |
| ) |
| { |
| fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->getString( GetId() ).getStr() ); |
| fprintf( fOutput, "%s ", aCallPar2.GetBuffer() ); |
| fprintf( fOutput, "ResId( (RSHEADER_TYPE*)(pResData+nOffset) ) ) );\n" ); |
| fprintf( fOutput, "\t\tnOffset += GetObjSizeRes( (RSHEADER_TYPE*)(pResData+nOffset) );\n" ); |
| } |
| |
| //================================================================== |
| void RscClass::WriteRcCtor( FILE * fOutput, RscTypCont * pTC ) |
| { |
| if( GetId() != InvalidAtom ) |
| { |
| // Konstruktor |
| fprintf( fOutput, "%s::%s%s bFreeResource )", |
| pHS->getString( GetId() ).getStr(), |
| pHS->getString( GetId() ).getStr(), |
| aCallParType.GetBuffer() ); |
| if( GetSuperClass() ) |
| { |
| // Superaufruf |
| fprintf( fOutput, "\n\t: %s", pHS->getString( GetSuperClass()->GetId() ).getStr() ); |
| fprintf( fOutput, "%s", GetSuperClass()->aCallPar1.GetBuffer() ); |
| fprintf( fOutput, " rResId.SetRT2( 0x%lx ) )", |
| sal::static_int_cast< unsigned long >(GetTypId()) ); |
| } |
| fprintf( fOutput, "\n{\n" ); |
| fprintf( fOutput, "\tsal_uInt32\tnObjMask;\n" ); |
| fprintf( fOutput, "\tsal_uInt32\tnOffset = 0;\n" ); |
| fprintf( fOutput, "\tBYTE *\tpResData;\n\n" ); |
| fprintf( fOutput, "\tpResData = (tBYTE *)GetClassRes();\n\n" ); |
| fprintf( fOutput, "\tnObjMask = *(sal_uInt32*)pResData;\n" ); |
| fprintf( fOutput, "\tnOffset += 4;\n\n" ); |
| |
| for( sal_uInt32 i = 0; i < nEntries; i++ ) |
| { |
| if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType )) |
| { |
| fprintf( fOutput, "\tif( nObjMask & 0x%lx )\n\t{\n", |
| sal::static_int_cast< unsigned long >( |
| pVarTypeList[ i ].nMask) ); |
| |
| pVarTypeList[ i ].pClass->WriteRcAccess( fOutput, pTC, |
| pHS->getString( pVarTypeList[ i ].nVarName ).getStr() ); |
| |
| fprintf( fOutput, "\t}\n" ); |
| } |
| } |
| fprintf( fOutput, "\tIncrementRes( nOffset );\n" ); |
| fprintf( fOutput, "\tif( bFreeResource )\n" ); |
| fprintf( fOutput, "\t\tFreeResource();\n" ); |
| fprintf( fOutput, "}\n\n" ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscSysDepend::RscSysDepend() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper ) |
| : RscClass( nId, nTypeId, pSuper ) |
| {} |
| |
| /************************************************************************* |
| |* |
| |* RscSysDepend::WriteRc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem, |
| RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra, sal_Bool bFirst ) |
| { |
| sal_uInt32 nId = 0xFFFFFFFF; |
| ERRTYPE aError; |
| RSCINST aFileName; |
| |
| //Instanz mit dem Dateinamen "FILENAME" holen |
| aFileName = RscClass::GetCopyVar( rInst, pHS->getID( "FILE", true ) ); |
| if( aFileName.IsInst() ) |
| { |
| RscWriteRc aTmpMem; |
| aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC, |
| RscId(), nDeep, bExtra ); |
| // Obsolete - need changes in VCL |
| rMem.Put( sal_uInt32(0) ); |
| |
| // Identifier schreiben |
| if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') ) |
| { |
| nId = pTC->PutSysName( rInst.pClass->GetTypId(), |
| aTmpMem.GetUTF8( 0 ), |
| 0, 0, bFirst ); |
| } |
| rMem.Put( nId ); |
| aError = aFileName.pClass->WriteRcHeader( aFileName, rMem, pTC, |
| RscId(), nDeep, bExtra ); |
| } |
| else |
| aError = ERR_ERROR; |
| |
| return( aError ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscSysDepend::WriteRc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem, |
| RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra ) |
| { |
| ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra ); |
| |
| if( this == rInst.pClass ) |
| // nur wenn es eigen Klasse ist |
| aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra ); |
| return aError; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscFirstSysDepend::RscFirstSysDepend() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RscFirstSysDepend::RscFirstSysDepend( Atom nId, sal_uInt32 nTypeId, |
| RscTop * pSuper ) |
| : RscSysDepend( nId, nTypeId, pSuper ) |
| {} |
| |
| /************************************************************************* |
| |* |
| |* RscFirstSysDepend::WriteRc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| ERRTYPE RscFirstSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem, |
| RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra ) |
| { |
| ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra ); |
| aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra, sal_True ); |
| return aError; |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscTupel::RscTupel() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RscTupel::RscTupel( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper ) |
| : RscClass( nId, nTypeId, pSuper ) |
| {} |
| |
| /************************************************************************* |
| |* |
| |* RscTupel::GetTupelVar() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos, |
| const RSCINST & rInitInst ) |
| { |
| if( nPos >= nEntries ) |
| { |
| return RSCINST(); |
| } |
| else |
| return GetVariable( rInst, pVarTypeList[ nPos ].nVarName, rInitInst ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* RscTupel::WriteSrc() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput, |
| RscTypCont * pTC, sal_uInt32 nTab, |
| const char * pVarName ) |
| { |
| sal_uInt32 i = 0; |
| RSCINST aTmpI; |
| |
| RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName ); |
| |
| fprintf( fOutput, "< " ); |
| for( i = 0; i < nEntries; i++ ) |
| { |
| if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) ) |
| { |
| if( !IsDflt( rInst.pData, i ) |
| && !IsValueDflt( rInst.pData, i ) ) |
| { |
| aTmpI = GetInstData( rInst.pData, i, sal_True ); |
| |
| if( aTmpI.IsInst() ) |
| aTmpI.pClass->WriteSrcHeader( |
| aTmpI, fOutput, pTC, nTab, RscId(), pVarName ); |
| else |
| fprintf( fOutput, "Default" ); |
| } |
| else |
| fprintf( fOutput, "Default" ); |
| fprintf( fOutput, "; " ); |
| }; |
| }; |
| fprintf( fOutput, ">" ); |
| |
| return; |
| } |