xref: /aoo41x/main/rsc/source/res/rscmgr.cxx (revision 477794c1)

/**************************************************************
 *
 * 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>
#include <ctype.h>

// Programmabhaengige Includes.
#include <rscmgr.hxx>
#include <rscdb.hxx>

/****************** C O D E **********************************************/
/****************** R s c M g r ******************************************/
/*************************************************************************
|*
|*	  RscMgr::RscMgr()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 26.04.91
|*	  Letzte Aenderung	MM 26.04.91
|*
*************************************************************************/
RscMgr::RscMgr( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
			: RscClass( nId, nTypeId, pSuperCl )
{
}

/*************************************************************************
|*
|*	  RscMgr::Size()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 26.04.91
|*	  Letzte Aenderung	MM 26.04.91
|*
*************************************************************************/
sal_uInt32 RscMgr::Size()
{
	return RscClass::Size() + ALIGNED_SIZE( sizeof( RscMgrInst ) );
}

/*************************************************************************
|*
|*	  RscMgr::Create()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 03.04.91
|*	  Letzte Aenderung	MM 03.04.91
|*
*************************************************************************/
RSCINST RscMgr::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
	RSCINST aInst;
	RscMgrInst * pClassData;

	if( !pInst ){
		aInst.pClass = this;
		aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
	}
	else
		aInst = *pInst;
	if( !bOwnClass && rDflt.IsInst() )
		bOwnClass = rDflt.pClass->InHierarchy( this );

	RscClass::Create( &aInst, rDflt, bOwnClass );

	pClassData = (RscMgrInst *)(aInst.pData + RscClass::Size() );
	pClassData->Create();

	if( bOwnClass ){
		RscMgrInst * pDfltData = (RscMgrInst *)(rDflt.pData + RscClass::Size());
		*pClassData = *pDfltData;
	};

	return( aInst );
}

/*************************************************************************
|*
|*	  RscMgr::Destroy()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 21.06.91
|*	  Letzte Aenderung	MM 21.06.91
|*
*************************************************************************/
void RscMgr::Destroy( const RSCINST & rInst ){
	RscMgrInst * pClassData;

	RscClass::Destroy( rInst );

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
	pClassData->Destroy();
}

/*************************************************************************
|*
|*	  RscMgr::SetToDefault()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 12.06.91
|*	  Letzte Aenderung	MM 12.06.91
|*
*************************************************************************/
void RscMgr::SetToDefault( const RSCINST & rInst )
{
	RscMgrInst * pClassData;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
	pClassData->bDflt = sal_True;

	RscClass::SetToDefault( rInst );
}

/*************************************************************************
|*
|*	  RscMgr::IsDefault()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 12.06.91
|*	  Letzte Aenderung	MM 12.06.91
|*
*************************************************************************/
sal_Bool RscMgr::IsDefault( const RSCINST & rInst ){
	RscMgrInst * pClassData;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
	if( !pClassData->bDflt )
		return( sal_False );

	return( RscClass::IsDefault( rInst ) );
}

/*************************************************************************
|*
|*	  RscMgr::IsValueDefault()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 12.06.91
|*	  Letzte Aenderung	MM 12.06.91
|*
*************************************************************************/
sal_Bool RscMgr::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
	RscMgrInst * pClassData;
	RscMgrInst * pDfltData;

	if( !RscClass::IsValueDefault( rInst, pDef ) )
		return sal_False;

	if( pDef ){
		pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
		pDfltData  = (RscMgrInst *)(pDef + RscClass::Size());

		if( !pClassData->aRefId.IsId() && !pDfltData->aRefId.IsId() ){
			return sal_True;
		}
	}

	return sal_False;
}


/*************************************************************************
|*
|*	  RscMgr::WriteSrcHeader()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 08.04.91
|*	  Letzte Aenderung	MM 08.04.91
|*
*************************************************************************/
void RscMgr::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
							 RscTypCont * pTC, sal_uInt32 nTab,
							 const RscId & rId, const char * pVarName )
{
	RscMgrInst * pClassData;
	sal_uInt32		 i;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());

	fprintf( fOutput, "%s %s",
			 pHS->getString( rInst.pClass->GetId() ).getStr(),
			 (rId.GetName()).GetBuffer() );
	if( pClassData->aRefId.IsId() )
		fprintf( fOutput, ",%s", pClassData->aRefId.GetName().GetBuffer() );
	else
	{
		fprintf( fOutput, "\n" );
		for( i = 0; i < nTab; i++ )
			fputc( '\t', fOutput );
		fprintf( fOutput, "{\n" );

		rInst.pClass->WriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );

		RscClass::WriteSrc( rInst, fOutput, pTC, nTab +1, pVarName);

		for( i = 0; i < nTab; i++ )
			fputc( '\t', fOutput );
		fprintf( fOutput, "}" );
	}
}

/*************************************************************************
|*
|*	  RscMgr::WriteSrc()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 08.04.91
|*	  Letzte Aenderung	MM 08.04.91
|*
*************************************************************************/
void RscMgr::WriteSrc( const RSCINST &, FILE *, RscTypCont *, sal_uInt32,
						const char * )
{
}

/*************************************************************************
|*
|*	  RscMgr::WriteRcHeader()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 15.04.91
|*	  Letzte Aenderung	MM 15.04.91
|*
*************************************************************************/
ERRTYPE RscMgr::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
							   RscTypCont * pTC, const RscId &rId,
							   sal_uInt32 nDeep, sal_Bool bExtra )
{
	RscMgrInst *	pClassData;
	ERRTYPE 		aError;
	ObjNode *		pObjNode = NULL;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());

	if( pClassData->aRefId.IsId() )
	{
		//Erhoehen und abfragen um Endlosrekusion zu vermeiden
		nDeep++;
		if( nDeep > nRefDeep )
			aError = ERR_REFTODEEP;
		else
			pObjNode = rInst.pClass->GetRefClass()->
										GetObjNode( pClassData->aRefId );
		if( !pObjNode && pTC )
		{
			ByteString aMsg( pHS->getString( rInst.pClass->GetId() ).getStr() );
			aMsg += ' ';
			aMsg += pClassData->aRefId.GetName();
			aError = WRN_MGR_REFNOTFOUND;
			pTC->pEH->Error( aError, rInst.pClass, rId, aMsg.GetBuffer() );
		}
	}

	if( aError.IsOk() )
	{
		if( pObjNode )
		{
			RSCINST 	aRefI;
			RscTop *	pTmpRefClass = rInst.pClass->GetRefClass();

			aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
			if( pTmpRefClass == rInst.pClass )
			{
				aError = aRefI.pClass->WriteRcHeader( aRefI, rMem, pTC,
													   rId, nDeep, bExtra );
			}
			else
			{
				RSCINST aRefInst = rInst.pClass->Create( NULL, aRefI );
				aError = aRefI.pClass->WriteRcHeader( aRefInst, rMem, pTC,
													   rId, nDeep, bExtra );
				pTmpRefClass->Destroy( aRefInst );
			}
		}
		else
		{
			sal_uInt32			nOldSize;
			sal_uInt32			nLocalSize;

			nOldSize = rMem.IncSize( 16 /*sizeof( RSHEADER_TYPE )*/ );

			aError = rInst.pClass->WriteRc( rInst, rMem, pTC, nDeep, bExtra );
			if( aError.IsOk() )
				aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
			nLocalSize = rMem.Size();

			if( aError.IsOk() )
			{
				// RscClass wird uebersprungen
				aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
			};

			/*
			// Definition der Struktur, aus denen die Resource aufgebaut ist
			struct RSHEADER_TYPE{
				RESOURCE_TYPE	nRT;		// Resource Typ
				sal_uInt32			nRT;		// Resource Typ
				sal_uInt32			nGlobOff;	// Globaler Offset
				sal_uInt32			nLocalOff;	// Lokaler Offset
			};
			*/
			sal_uInt32 nID = rId;
			rMem.PutAt( nOldSize, nID );
			rMem.PutAt( nOldSize +4, (sal_uInt32)rInst.pClass->GetTypId() );
			rMem.PutAt( nOldSize +8, (sal_uInt32)(rMem.Size() - nOldSize) );
			rMem.PutAt( nOldSize +12, (sal_uInt32)(nLocalSize - nOldSize) );
		};
	};

	return( aError );
}

/*************************************************************************
|*
|*	  RscMgr::WriteRc()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 26.04.91
|*	  Letzte Aenderung	MM 26.04.91
|*
*************************************************************************/
ERRTYPE RscMgr::WriteRc( const RSCINST &, RscWriteRc &,
						 RscTypCont *, sal_uInt32, sal_Bool )

{
	return( ERR_OK );
}


static ByteString MakeSmartName( const ByteString & rDefName )
{
	ByteString aSmartName;
	if( rDefName.Len() )
	{
		char * pStr = (char *)rDefName.GetBuffer();
		aSmartName = (char)toupper( *pStr );
		while( *++pStr )
		{
			if( '_' == *pStr )
			{
				if( *++pStr )
					aSmartName += (char)toupper( *pStr );
				else
					break;
			}
			else
				aSmartName += (char)tolower( *pStr );
		}
	}
	return aSmartName;
}

static ByteString MakeName( RscTypCont * pTypCon, RscTop * pClass,
							const ByteString & rName )
{
	ByteString aRet;
	if( !pTypCon->IsSmart() || isdigit( rName.GetChar(0) ) )
	{
		aRet += pHS->getString( pClass->GetId() ).getStr();
		aRet += rName;
	}
	else
		aRet += MakeSmartName( rName );
	return aRet;
}

/*************************************************************************
|*
|*	  RscMgr::WriteHxxHeader()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 29.05.91
|*	  Letzte Aenderung	MM 29.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::WriteHxxHeader( const RSCINST & rInst, FILE * fOutput,
								RscTypCont * pTC, const RscId &rId )
{
	RscMgrInst *	pClassData;
	ERRTYPE 		aError;
	ObjNode *		pObjNode = NULL;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());

	if( pClassData->aRefId.IsId() )
	{
		pObjNode = rInst.pClass->GetObjNode( pClassData->aRefId );
		if( !pObjNode && pTC )
		{
			ByteString	aMsg( pHS->getString( rInst.pClass->GetId() ).getStr() );
			aMsg += ' ';
			aMsg += pClassData->aRefId.GetName();
			aError = WRN_MGR_REFNOTFOUND;
			pTC->pEH->Error( aError, rInst.pClass, rId, aMsg.GetBuffer() );
		}
	}

	if( pObjNode )
	{
		RSCINST 	aRefI;

		aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
		aError = aRefI.pClass->WriteHxxHeader( aRefI, fOutput, pTC,
											   rId );
	}
	else if (pTC)
	{
		fprintf( fOutput, "class %s",
						  MakeName( pTC, rInst.pClass,
									rId.GetName() ).GetBuffer() );
		fprintf( fOutput, " : public %s",
				 pHS->getString( rInst.pClass->GetId() ).getStr() );
		fprintf( fOutput, "\n{\nprotected:\n" );

		aError = RscClass::WriteHxx( rInst, fOutput, pTC, rId );

		RSCINST aExtraInst = rInst.pClass->GetCopyVar( rInst, nRsc_EXTRADATA );
		if( aExtraInst.IsInst() )
		{
			if( aExtraInst.pClass->GetCount( aExtraInst ) )
				fprintf( fOutput, "    char * pExtraData;\n" );
		}
		if( aError.IsOk() )
		{
			fprintf( fOutput, "public:\n    " );
			fprintf( fOutput, "%s%s bFreeRes = TRUE )",
					 MakeName( pTC, rInst.pClass,
							   rId.GetName() ).GetBuffer(),
					 (rInst.pClass->aCallParType).GetBuffer() );
			fprintf( fOutput, ";\n};\n\n" );
		}
	};
	return aError;
}

/*************************************************************************
|*
|*	  RscMgr::WriteHxx()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 29.05.91
|*	  Letzte Aenderung	MM 29.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::WriteHxx( const RSCINST & rInst, FILE * fOutput,
						  RscTypCont * pTC, const RscId & rId )
{
	fprintf( fOutput, "    %s", pHS->getString( rInst.pClass->GetId() ).getStr() );
	fprintf( fOutput, " a%s;\n",
			 MakeName( pTC, rInst.pClass, rId.GetName() ).GetBuffer() );

	return ERR_OK;
}

/*************************************************************************
|*
|*	  RscClass::WriteCxxHeader()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 29.05.91
|*	  Letzte Aenderung	MM 29.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::WriteCxxHeader( const RSCINST & rInst, FILE * fOutput,
								RscTypCont * pTC, const RscId & rId )
{
	RscMgrInst *	pClassData;
	ERRTYPE 		aError;
	ObjNode *		pObjNode = NULL;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());

	if( pClassData->aRefId.IsId() )
	{
		pObjNode = rInst.pClass->GetObjNode( pClassData->aRefId );
		if( !pObjNode && pTC )
		{
			ByteString	aMsg( pHS->getString( rInst.pClass->GetId() ).getStr() );
			aMsg += ' ';
			aMsg += pClassData->aRefId.GetName();
			aError = WRN_MGR_REFNOTFOUND;
			pTC->pEH->Error( aError, rInst.pClass, rId, aMsg.GetBuffer() );
		}
	}

	if( pObjNode )
	{
		RSCINST 	aRefI;

		aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
		aError = aRefI.pClass->WriteCxxHeader( aRefI, fOutput, pTC,
											   rId );
	}
	else if (pTC)
	{
		fprintf( fOutput, "%s::%s",
				 MakeName( pTC, rInst.pClass, rId.GetName() ).GetBuffer(),
				 MakeName( pTC, rInst.pClass, rId.GetName() ).GetBuffer() );
		fprintf( fOutput, "%s", (rInst.pClass->aCallParType).GetBuffer() );
		if( GetCount( rInst ) )
			fprintf( fOutput, " bFreeRes" );
		fprintf( fOutput, " )\n    : %s", pHS->getString( rInst.pClass->GetId() ).getStr() );
		fprintf( fOutput, "%s", (rInst.pClass->aCallPar1).GetBuffer() );
		fprintf( fOutput, " rResId )" );

		aError = RscClass::WriteCxx( rInst, fOutput, pTC, rId );

		fprintf( fOutput, "\n{\n" );
		RSCINST aExtraInst = rInst.pClass->GetCopyVar( rInst, nRsc_EXTRADATA );
		if( aExtraInst.IsInst() )
		{
			if( aExtraInst.pClass->GetCount( aExtraInst ) )
			{
				fprintf( fOutput, "    //read extra data\n" );
				fprintf( fOutput, "    pExtraData = new char "
								"[ GetRemainSizeRes() ];\n" );
				fprintf( fOutput, "    memcpy( pExtraData, "
								"GetClassRes(), GetRemainSizeRes() );\n" );
				fprintf( fOutput, "    IncrementRes( GetRemainSizeRes() );\n" );
			}
		}

		if( GetCount( rInst ) )
		{ // Es gibt UnterResourcen
			fprintf( fOutput, "    if( bFreeRes ) FreeResource();\n" );
		}
		else
		{
			fprintf( fOutput,
					"    // No subresources, automatic free resource\n" );
		}
		fprintf( fOutput, "}\n\n" );
	}
	return aError;
}

/*************************************************************************
|*
|*	  RscClass::WriteCxx()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 29.05.91
|*	  Letzte Aenderung	MM 29.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::WriteCxx( const RSCINST & rInst, FILE * fOutput,
						  RscTypCont * pTC, const RscId & rId )
{
	fprintf( fOutput, ",\n    a%s",
			 MakeName( pTC, rInst.pClass, rId.GetName() ).GetBuffer() );
	fprintf( fOutput, "%s", (rInst.pClass->aCallPar2).GetBuffer() );
	fprintf( fOutput, " ResId( %s ) )", (rId.GetName()).GetBuffer() );

	return ERR_OK;
}

/*************************************************************************
|*
|*	  RscArray::IsConsistent()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 23.09.91
|*	  Letzte Aenderung	MM 23.09.91
|*
*************************************************************************/
sal_Bool RscMgr::IsConsistent( const RSCINST & rInst, RscInconsList * pList )
{
	sal_Bool	bRet;
	RscMgrInst * pClassData;

	bRet = RscClass::IsConsistent( rInst, pList );

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
	if( pClassData->aRefId.IsId() &&
	  ((pClassData->aRefId.GetNumber() < 1)
		|| (pClassData->aRefId.GetNumber() > 0x7FFF)
		|| IsToDeep( rInst ).IsError()) )
	{
		if( pList )
			pList->Insert(
				new RscInconsistent( pClassData->aRefId,
									 pClassData->aRefId ) );
		bRet = sal_False;
	}

	return( bRet );
}

/*************************************************************************
|*
|*	  RscMgr::GetRef()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 15.05.91
|*	  Letzte Aenderung	MM 15.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::GetRef( const RSCINST & rInst, RscId * pRscId ){
	RscMgrInst * pClassData;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
	*pRscId = pClassData->aRefId;
	return ERR_OK;
}

/*************************************************************************
|*
|*	  RscMgr::IsToDeep()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 15.05.91
|*	  Letzte Aenderung	MM 15.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::IsToDeep( const RSCINST & rInst, sal_uInt32 nDeep )
{
	RscMgrInst *	pClassData;
	RscId			aOldId, aId;
	ERRTYPE 		aError;
	RSCINST 		aTmpI = rInst;
	ObjNode *		pObjNode;

	pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());

	while( aTmpI.IsInst() && (nDeep < nRefDeep) && aError.IsOk() )
	{
		// Referenz holen
		aTmpI.pClass->GetRef( aTmpI, &aId );
		// Referenziertes Objekt holen
		pObjNode = aTmpI.pClass->GetObjNode( aId );
		// Referenzierte Objekt gefunden ?
		if( pObjNode )
		{
			aTmpI.pData = pObjNode->GetRscObj();
			nDeep++;
		}
		else //aTmpI.IsInst() wird sal_False, Schleife beenden
			aTmpI.pData = NULL;
	}

	if( nDeep >= nRefDeep )
	{
		pClassData->aRefId = aOldId;
		aError			   = ERR_REFTODEEP;
	}

	return( aError );
}

/*************************************************************************
|*
|*	  RscMgr::SetRef()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 15.05.91
|*	  Letzte Aenderung	MM 15.05.91
|*
*************************************************************************/
ERRTYPE RscMgr::SetRef( const RSCINST & rInst, const RscId & rRefId )
{
	RscMgrInst *	pClassData;
	RscId			aOldId, aId;
	ERRTYPE 		aError;
	RSCINST 		aTmpI = rInst;

	if( rRefId.IsId() &&
	  ((rRefId.GetNumber() < 1) || (rRefId.GetNumber() > 0x7FFF)) )
	{
		aError = ERR_IDRANGE;
	}
	else
	{
		pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
		aOldId = pClassData->aRefId;// Alten Wert merken
		pClassData->aRefId = rRefId;// vorher eintragen,
									// sonst Fehler bei rekursion


		aError = IsToDeep( rInst );
		if( aError.IsOk() )
			pClassData->bDflt  = sal_False;
		else
			pClassData->aRefId = aOldId;
	}

	return( aError );
}