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