summaryrefslogtreecommitdiff
path: root/rsc/source/res/rscclass.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'rsc/source/res/rscclass.cxx')
-rw-r--r--rsc/source/res/rscclass.cxx1324
1 files changed, 1324 insertions, 0 deletions
diff --git a/rsc/source/res/rscclass.cxx b/rsc/source/res/rscclass.cxx
new file mode 100644
index 000000000000..30de42d9a174
--- /dev/null
+++ b/rsc/source/res/rscclass.cxx
@@ -0,0 +1,1324 @@
+/*************************************************************************
+ *
+ * $RCSfile: rscclass.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:42:55 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+/************************************************************************
+
+ Source Code Control System - Header
+
+ $Header: /zpool/svn/migration/cvs_rep_09_09_08/code/rsc/source/res/rscclass.cxx,v 1.1.1.1 2000-09-18 16:42:55 hr Exp $
+
+ Source Code Control System - Update
+
+ $Log: not supported by cvs2svn $
+ Revision 1.39 2000/09/17 12:51:11 willem.vandorp
+ OpenOffice header added.
+
+ Revision 1.38 2000/07/26 17:13:22 willem.vandorp
+ Headers/footers replaced
+
+ Revision 1.37 2000/07/12 11:38:05 th
+ Unicode
+
+ Revision 1.36 1999/11/24 17:54:35 th
+ remove dependencies to vcl
+
+ Revision 1.35 1999/09/08 09:24:59 mm
+ BigEndian/LittleEndian komplett durchgezogen
+
+ Revision 1.34 1999/09/07 13:30:05 mm
+ UniCode
+
+**************************************************************************/
+/****************** I N C L U D E S **************************************/
+
+// C and C++ Includes.
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Programmabhaengige Includes.
+#ifndef _RSCDB_HXX
+#include <rscdb.hxx>
+#endif
+#ifndef _RSCCLASS_HXX
+#include <rscclass.hxx>
+#endif
+
+#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( HASHID nId, USHORT 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()
+{
+ USHORT 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 ) );
+ RscMem::Free( 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 )
+ RscMem::Free( (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,
+ USHORT nEle,
+ 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( USHORT 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, USHORT nEle, BOOL bSet )
+{
+ RscClassInst * pClass;
+
+ pClass = (RscClassInst *)(pData + nSuperSize );
+ if( bSet )
+ pClass->nVarDflt |= ((ULONG)1 << nEle);
+ else
+ pClass->nVarDflt &= ~((ULONG)1 << nEle);
+}
+
+/*************************************************************************
+|*
+|* RscClass::IsDflt()
+|*
+|* Beschreibung
+|* Ersterstellung MM 22.07.91
+|* Letzte Aenderung MM 08.01.92
+|*
+*************************************************************************/
+BOOL RscClass::IsDflt( CLASS_DATA pData, USHORT nEle )
+{
+ RscClassInst * pClass;
+ BOOL bRet;
+
+ pClass = (RscClassInst *)(pData + nSuperSize );
+ if( pClass->nVarDflt & ((ULONG)1 << nEle) )
+ bRet = TRUE;
+ else
+ bRet = FALSE;
+/* {
+ //Variablenname ist Default
+ RSCINST aTmpI;
+
+ aTmpI = GetInstData( pData, nEle, TRUE );
+ if( aTmpI.IsInst() && !aTmpI.pClass->IsDefault( aTmpI ) )
+ bRet = 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,
+ BOOL bOwnClass
+)
+{
+ USHORT i;
+ CLASS_DATA * ppData;
+ RSCINST aInst;
+ RSCINST aMemInst, aDfltI;
+
+ if( !pInst )
+ {
+ aInst.pClass = this;
+ aInst.pData = (CLASS_DATA) RscMem::Malloc( 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 = 0xFFFFFFFF;
+
+ for( i = 0; i < nEntries; i++ )
+ {
+ aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, TRUE );
+
+ if( (VAR_POINTER & pVarTypeList[ i ].nVarType)
+ && !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
+ {
+ if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
+ {
+ RSCINST * pInst = (RSCINST *)
+ (aInst.pData + pVarTypeList[ i ].nOffset );
+ pInst->pClass = pVarTypeList[ i ].pClass;
+ ppData = &pInst->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, TRUE );
+ aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
+ };
+ }
+
+ return( aInst );
+}
+
+/*************************************************************************
+|*
+|* RscClass::Destroy()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+void RscClass::Destroy( const RSCINST & rInst )
+{
+ USHORT i;
+
+ RscTop::Destroy( rInst );
+
+ for( i = 0; i < nEntries; i++ )
+ {
+ if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) )
+ {
+ RSCINST aTmpI;
+
+ aTmpI = GetInstData( rInst.pData, i, TRUE );
+ if( aTmpI.IsInst() )
+ {
+ // Objekt loeschen
+ aTmpI.pClass->Destroy( aTmpI );
+ if( pVarTypeList[ i ].nVarType & VAR_POINTER )
+ {
+ // Speicher freigeben
+ RscMem::Free( aTmpI.pData );
+ };
+ };
+ }
+ };
+}
+
+/*************************************************************************
+|*
+|* RscClass::SetVariable()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+ERRTYPE RscClass::SetVariable
+(
+ HASHID nVarName,
+ RscTop * pClass,
+ RSCINST * pDflt,
+ RSCVAR nVarType,
+ USHORT nMask,
+ HASHID nDataBaseName
+)
+{
+ if( pVarTypeList )
+ pVarTypeList = (VARTYPE_STRUCT *)
+ RscMem::Realloc( (void *)pVarTypeList,
+ (USHORT)((nEntries +1) * sizeof( VARTYPE_STRUCT )) );
+ else
+ pVarTypeList = (VARTYPE_STRUCT *)
+ RscMem::Malloc( (USHORT)((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( ULONG ) * 8) )
+ {
+ // Bereich fuer Default zu klein
+ RscExit( 16 );
+ };
+ return( ERR_OK );
+}
+
+/*************************************************************************
+|*
+|* RscClass::EnumVariable()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+void RscClass::EnumVariables( void * pData, VarEnumCallbackProc pProc )
+{
+ USHORT 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,
+ HASHID nVarName,
+ const RSCINST & rInitInst,
+ BOOL bInitDflt,
+ RscTop * pCreateClass
+)
+{
+ USHORT i;
+ RSCINST aTmpI;
+
+ i = 0;
+ 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 aDfltInst = rInitInst;
+ if( !aDfltInst.IsInst() && bInitDflt )
+ {
+ // mit dem Variablen-Default besetzen
+ aDfltInst.pData = pVarTypeList[ i ].pDefault;
+ aDfltInst.pClass = pVarTypeList[ i ].pClass;
+ }
+
+ aTmpI = GetInstData( rInst.pData, i );
+ if( aTmpI.IsInst() )
+ {
+ if( aDfltInst.IsInst() )
+ {
+ aTmpI.pClass->Destroy( aTmpI );
+ aTmpI.pClass->Create( &aTmpI, aDfltInst );
+ }
+ }
+ 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, aDfltInst );
+ else
+ *pInst = aTmpI.pClass->Create( NULL, aDfltInst );
+ aTmpI = *pInst;
+ }
+ else
+ {
+ CLASS_DATA * ppData
+ = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset);
+ aTmpI = aTmpI.pClass->Create( NULL, aDfltInst );
+ *ppData = aTmpI.pData;
+ }
+ }
+ };
+ // auf nicht Default setzen
+ SetVarDflt( rInst.pData, i, FALSE );
+ return( aTmpI );
+ };
+
+ return( RscTop::GetVariable( rInst, nVarName, rInitInst,
+ bInitDflt, pCreateClass ) );
+}
+
+/*************************************************************************
+|*
+|* RscClass::GetCopyVar()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+RSCINST RscClass::GetCopyVar
+(
+ const RSCINST & rInst,
+ HASHID nVarName
+)
+{
+ USHORT i;
+ RSCINST aVarI;
+
+ i = 0;
+ 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(), TRUE );
+ SetVarDflt( rInst.pData, i, TRUE );
+ }
+ else
+ aVarI = GetInstData( rInst.pData, i, TRUE );
+
+ };
+ return aVarI ;
+ };
+
+ return RscTop::GetCopyVar( rInst, nVarName );
+}
+
+/*************************************************************************
+|*
+|* RscClass::IsConsistent()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+BOOL RscClass::IsConsistent( const RSCINST & rInst, RscInconsList * pList )
+{
+ USHORT i;
+ RSCINST aTmpI;
+ BOOL bRet;
+
+ bRet = RscTop::IsConsistent( rInst, pList );
+
+ for( i = 0; i < nEntries; i++ )
+ {
+ if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
+ {
+ aTmpI = GetInstData( rInst.pData, i, TRUE );
+
+ if( aTmpI.IsInst() )
+ if( ! aTmpI.pClass->IsConsistent( aTmpI, pList ) )
+ bRet = FALSE;
+ }
+ };
+
+ return( bRet );
+}
+
+/*************************************************************************
+|*
+|* RscClass::SetToDefault()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+void RscClass::SetToDefault( const RSCINST & rInst )
+{
+ USHORT 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, TRUE );
+ if( aTmpI.IsInst() )
+ aTmpI.pClass->SetToDefault( aTmpI );
+ }
+ }
+ pClass->nVarDflt = 0xFFFFFFFF; // alles auf Default
+
+ RscTop::SetToDefault( rInst );
+}
+
+/*************************************************************************
+|*
+|* RscClass::IsDefault()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+BOOL RscClass::IsDefault( const RSCINST & rInst )
+{
+ USHORT 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( FALSE );
+ };
+
+ return( RscTop::IsDefault( rInst ) );
+}
+
+/*************************************************************************
+|*
+|* RscClass::GetDefault()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+RSCINST RscClass::GetDefault( HASHID nVarId )
+{
+ USHORT 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
+|*
+*************************************************************************/
+BOOL RscClass::IsValueDflt( CLASS_DATA pData, USHORT nEle )
+{
+ RSCINST aTmpI;
+
+ aTmpI = GetInstData( pData, nEle, TRUE );
+
+ if( aTmpI.IsInst() )
+ {
+ if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
+ return FALSE;
+
+ if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
+ //sie haben auch die gleiche Klasse
+ return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
+ else
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/*************************************************************************
+|*
+|* RscClass::IsValueDefault()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+BOOL RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+{
+ USHORT i;
+ RSCINST aTmpI;
+ RSCINST aDfltI;
+
+ if( !RscTop::IsValueDefault( rInst, pDef ) )
+ return FALSE;
+
+ if( pDef )
+ {
+ for( i = 0; i < nEntries; i++ )
+ {
+ aTmpI = GetInstData( rInst.pData, i, TRUE );
+ if( aTmpI.IsInst() )
+ {
+ if( aTmpI.pClass != pVarTypeList[ i ].pClass )
+ //sie haben nicht die gleiche Klasse
+ return FALSE;
+
+ aDfltI = GetInstData( pDef, i, TRUE );
+ if( !aDfltI.IsInst() )
+ aDfltI.pData = GetDfltData( i );
+
+ if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
+ return FALSE;
+ }
+ }
+ }
+ else
+ return FALSE;
+
+ return TRUE;
+}
+
+/*************************************************************************
+|*
+|* RscClass::SetDefault()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+void RscClass::SetDefault( const RSCINST & rInst, HASHID nVarName )
+{
+ USHORT i;
+ RSCINST aTmpI;
+
+ i = 0;
+ while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
+ i++;
+
+ if( i < nEntries )
+ {
+ aTmpI = GetInstData( rInst.pData, i, TRUE );
+ if( aTmpI.IsInst() )
+ {
+ aTmpI.pClass->Destroy( aTmpI );
+ aTmpI.pClass->Create( &aTmpI, RSCINST() );
+ SetVarDflt( rInst.pData, i, TRUE );
+ }
+ }
+ else //In Superklasse nach Variable suchen
+ RscTop::SetDefault( rInst, nVarName );
+
+}
+
+
+/*************************************************************************
+|*
+|* RscClass::WriteSrc()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+void RscClass::WriteSrc
+(
+ const RSCINST & rInst,
+ FILE * fOutput,
+ RscTypCont * pTC,
+ USHORT nTab,
+ const char * pVarName
+)
+{
+ USHORT i, n;
+ 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, TRUE );
+ aTmpI.pClass->WriteSrcHeader(
+ aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
+ }
+
+ fprintf( fOutput, "( " );
+ aTmpI = GetInstData( rInst.pData, i+1, 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, 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, TRUE );
+
+ if( aTmpI.IsInst() )
+ {
+ char * pName = pHS->Get( pVarTypeList[ i ].nVarName );
+
+ 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
+|*
+*************************************************************************/
+long RscClass::GetCorrectValues
+(
+ const RSCINST & rInst,
+ USHORT nVarPos,
+ USHORT nTupelIdx,
+ RscTypCont * pTC
+)
+{
+ long nLang = 0;
+ long nBaseValue;
+
+ // Basiswert holen
+ RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, 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, FALSE );
+ nLang = (short)aMem.GetShort( nTupelIdx * sizeof( short ) );
+ }
+
+ return nLang + nBaseValue;
+}
+
+ERRTYPE RscClass::WriteInstRc
+(
+ const RSCINST & rInst,
+ RscWriteRc & rMem,
+ RscTypCont * pTC,
+ USHORT nDeep,
+ BOOL bExtra
+)
+{
+ USHORT i;
+ ERRTYPE aError;
+ RSCINST aTmpI;
+ USHORT nMaskOff;// 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( (USHORT)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 )
+ {
+ INT32 nVal = GetCorrectValues( rInst, i, 0, pTC );
+ rMem.Put( nVal );
+ }
+ else if( nRsc_Y == pVarTypeList[ i ].nVarName )
+ {
+ INT32 nVal = GetCorrectValues( rInst, i, 1, pTC );
+ rMem.Put( nVal );
+ }
+ else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
+ {
+ INT32 nVal = GetCorrectValues( rInst, i, 2, pTC );
+ rMem.Put( nVal );
+ }
+ else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
+ {
+ INT32 nVal = GetCorrectValues( rInst, i, 3, pTC );
+ rMem.Put( nVal );
+ }
+ else
+ {
+ aTmpI = GetInstData( rInst.pData, i, TRUE );
+ // Nur an Variable Extradata bExtra nicht auf FALSE
+ // setzen
+ aError = aTmpI.pClass->
+ WriteRcHeader( aTmpI, rMem, pTC,
+ RscId(), nDeep,
+ (nRsc_EXTRADATA
+ == pVarTypeList[ i ].nVarName)
+ ? bExtra : FALSE );
+ }
+ USHORT nMask = rMem.GetShort( 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, TRUE );
+ // Nur an Variable Extradata bExtra nicht auf FALSE
+ // setzen
+ aError = aTmpI.pClass->
+ WriteRcHeader( aTmpI, rMem, pTC,
+ RscId(), nDeep,
+ (nRsc_EXTRADATA
+ == pVarTypeList[ i ].nVarName)
+ ? bExtra : FALSE );
+ }
+ }
+ }
+
+ return( aError );
+}
+
+/*************************************************************************
+|*
+|* RscClass::WriteRc()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+ERRTYPE RscClass::WriteRc
+(
+ const RSCINST & rInst,
+ RscWriteRc & rMem,
+ RscTypCont * pTC,
+ USHORT nDeep,
+ 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 );
+
+ USHORT i;
+ // Wenn eine Variable Maskierung hat, dann Maskenfeld
+ fprintf( fOutput, "\t//%s\n", pHS->Get( GetId() ) );
+ for( i = 0; i < nEntries; i++ )
+ {
+ fprintf( fOutput, "\t%s", pHS->Get( pVarTypeList[ i ].nVarName ) );
+ USHORT n = strlen( pHS->Get( pVarTypeList[ i ].nVarName ) );
+ while( n < 20 )
+ {
+ putc( ' ', fOutput );
+ n++;
+ }
+ fprintf( fOutput, " = %s;\n",
+ pHS->Get( pVarTypeList[ i ].pClass->GetId() ) );
+ };
+}
+
+//==================================================================
+void RscClass::WriteRcAccess
+(
+ FILE * fOutput,
+ RscTypCont * pTC,
+ const char * pName
+)
+{
+ fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->Get( GetId() ) );
+ 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() != HASH_NONAME )
+ {
+ // Konstruktor
+ fprintf( fOutput, "%s::%s%s bFreeResource )",
+ pHS->Get( GetId() ), pHS->Get( GetId() ),
+ aCallParType.GetBuffer() );
+ if( GetSuperClass() )
+ {
+ // Superaufruf
+ fprintf( fOutput, "\n\t: %s", pHS->Get( GetSuperClass()->GetId() ) );
+ fprintf( fOutput, "%s", GetSuperClass()->aCallPar1.GetBuffer() );
+ fprintf( fOutput, " rResId.SetRT2( 0x%x ) )", GetTypId() );
+ }
+ fprintf( fOutput, "\n{\n" );
+ fprintf( fOutput, "\tUSHORT\tnObjMask;\n" );
+ fprintf( fOutput, "\tUSHORT\tnOffset = 0;\n" );
+ fprintf( fOutput, "\tBYTE *\tpResData;\n\n" );
+ fprintf( fOutput, "\tpResData = (BYTE *)GetClassRes();\n\n" );
+ fprintf( fOutput, "\tnObjMask = *(USHORT*)pResData;\n" );
+ fprintf( fOutput, "\tnOffset += 2;\n\n" );
+
+ for( USHORT i = 0; i < nEntries; i++ )
+ {
+ if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
+ {
+ fprintf( fOutput, "\tif( nObjMask & 0x%x )\n\t{\n",
+ pVarTypeList[ i ].nMask );
+
+ pVarTypeList[ i ].pClass->WriteRcAccess( fOutput, pTC,
+ pHS->Get( pVarTypeList[ i ].nVarName ) );
+
+ 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( HASHID nId, USHORT nTypeId, RscTop * pSuper )
+ : RscClass( nId, nTypeId, pSuper )
+{}
+
+/*************************************************************************
+|*
+|* RscSysDepend::WriteRc()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
+ RscTypCont * pTC, USHORT nDeep, BOOL bExtra, BOOL bFirst )
+{
+ USHORT nId = 0xFFFF;
+ ERRTYPE aError;
+ RSCINST aFileName;
+
+ //Instanz mit dem Dateinamen "FILENAME" holen
+ aFileName = RscClass::GetCopyVar( rInst, pHS->Test( "FILE" ) );
+ if( aFileName.IsInst() )
+ {
+ RscWriteRc aTmpMem;
+ aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC,
+ RscId(), nDeep, bExtra );
+ // Obsolete - need changes in VCL
+ rMem.Put( (USHORT)0 );
+
+ // Identifier schreiben
+ if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') )
+ {
+ nId = pTC->PutSysName( rInst.pClass->GetTypId(),
+ aTmpMem.GetUTF8( 0 ),
+ 0, (USHORT)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, USHORT nDeep, 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( HASHID nId, USHORT nTypeId,
+ RscTop * pSuper )
+ : RscSysDepend( nId, nTypeId, pSuper )
+{}
+
+/*************************************************************************
+|*
+|* RscFirstSysDepend::WriteRc()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+ERRTYPE RscFirstSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
+ RscTypCont * pTC, USHORT nDeep, BOOL bExtra )
+{
+ ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
+ aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra, TRUE );
+ return aError;
+}
+
+/*************************************************************************
+|*
+|* RscTupel::RscTupel()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+RscTupel::RscTupel( HASHID nId, USHORT nTypeId, RscTop * pSuper )
+ : RscClass( nId, nTypeId, pSuper )
+{}
+
+/*************************************************************************
+|*
+|* RscTupel::GetTupelVar()
+|*
+|* Beschreibung
+|*
+*************************************************************************/
+RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, USHORT 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, USHORT nTab,
+ const char * pVarName )
+{
+ USHORT i;
+ 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, 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;
+}