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