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 :
21 : #include <stdlib.h>
22 : #include <stdio.h>
23 : #include <string.h>
24 :
25 : #include <rscdb.hxx>
26 : #include <rscclass.hxx>
27 :
28 : #include <tools/rcid.h>
29 : #include <tools/rc.h>
30 :
31 62600 : RscClass::RscClass( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
32 62600 : : RscTop( nId, nTypeId, pSuperCl )
33 : {
34 62600 : nEntries = 0;
35 62600 : pVarTypeList = NULL;
36 62600 : nSuperSize = RscTop::Size();
37 62600 : nSize = nSuperSize + ALIGNED_SIZE( sizeof( RscClassInst ) );
38 62600 : }
39 :
40 62600 : void RscClass::Pre_dtor()
41 : {
42 : sal_uInt32 i;
43 :
44 62600 : RscTop::Pre_dtor();
45 :
46 276066 : for( i = 0; i < nEntries; i++ )
47 : {
48 213466 : if( pVarTypeList[ i ].pDefault )
49 : {
50 7512 : pVarTypeList[ i ].pClass->Destroy(
51 2504 : RSCINST( pVarTypeList[ i ].pClass,
52 10016 : pVarTypeList[ i ].pDefault ) );
53 2504 : rtl_freeMemory( pVarTypeList[ i ].pDefault );
54 2504 : pVarTypeList[ i ].pDefault = NULL;
55 : };
56 : };
57 62600 : }
58 :
59 184670 : RscClass::~RscClass()
60 : {
61 62600 : if( pVarTypeList )
62 47576 : rtl_freeMemory( (void *)pVarTypeList );
63 122070 : }
64 :
65 0 : RSCCLASS_TYPE RscClass::GetClassType() const
66 : {
67 0 : return RSCCLASS_COMPLEX;
68 : }
69 :
70 2378579 : RSCINST RscClass::GetInstData
71 : (
72 : CLASS_DATA pData,
73 : sal_uInt32 nEle,
74 : bool bGetCopy
75 : )
76 : {
77 2378579 : RSCINST aInst;
78 :
79 2378579 : aInst.pClass = pVarTypeList[ nEle ].pClass;
80 2378579 : if( pData )
81 : {
82 1640224 : if( VAR_NODATAINST & pVarTypeList[ nEle ].nVarType )
83 : {
84 243816 : RSCINST aTmpI;
85 :
86 243816 : aTmpI.pClass = this;
87 243816 : aTmpI.pData = pData;
88 243816 : if( bGetCopy )
89 : aInst.pData = GetCopyVar(
90 : aTmpI,
91 243816 : pVarTypeList[ nEle ].nDataBaseName
92 487632 : ).pData;
93 : else
94 : aInst.pData = GetVariable(
95 : aTmpI,
96 0 : pVarTypeList[ nEle ].nDataBaseName,
97 : RSCINST()
98 0 : ).pData;
99 : }
100 1396408 : else if( VAR_POINTER & pVarTypeList[ nEle ].nVarType )
101 : {
102 714956 : if( VAR_EXTENDABLE & pVarTypeList[ nEle ].nVarType )
103 0 : aInst = *(RSCINST *) (pData + pVarTypeList[ nEle ].nOffset);
104 : else
105 714956 : aInst.pData = *(CLASS_DATA *) (pData + pVarTypeList[ nEle ].nOffset);
106 : }
107 : else
108 681452 : aInst.pData = pData + pVarTypeList[ nEle ].nOffset;
109 : };
110 2378579 : return aInst;
111 : }
112 :
113 188998 : CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle )
114 : {
115 188998 : if( pVarTypeList[ nEle ].pDefault )
116 488 : return pVarTypeList[ nEle ].pDefault;
117 :
118 188510 : return pVarTypeList[ nEle ].pClass->GetDefault().pData;
119 : }
120 :
121 690303 : void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, bool bSet )
122 : {
123 : RscClassInst * pClass;
124 :
125 690303 : pClass = (RscClassInst *)(pData + nSuperSize );
126 690303 : if( bSet )
127 226208 : pClass->nVarDflt |= ((sal_uLong)1 << nEle);
128 : else
129 464095 : pClass->nVarDflt &= ~((sal_uLong)1 << nEle);
130 690303 : }
131 :
132 876241 : bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
133 : {
134 : RscClassInst * pClass;
135 :
136 876241 : pClass = (RscClassInst *)(pData + nSuperSize );
137 876241 : return pClass->nVarDflt & ((sal_uLong)1 << nEle);
138 : }
139 :
140 157250 : RSCINST RscClass::Create( RSCINST * pInst,
141 : const RSCINST & rDflt,
142 : bool bOwnClass)
143 : {
144 : sal_uInt32 i;
145 157250 : RSCINST aInst;
146 157250 : RSCINST aMemInst, aDfltI;
147 :
148 157250 : if( !pInst )
149 : {
150 60460 : aInst.pClass = this;
151 60460 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
152 : }
153 : else
154 96790 : aInst = *pInst;
155 :
156 157250 : if( !bOwnClass && rDflt.IsInst() )
157 97 : bOwnClass = rDflt.pClass->InHierarchy( this );
158 :
159 157250 : RscTop::Create( &aInst, rDflt, bOwnClass );
160 :
161 157250 : if( bOwnClass )
162 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt =
163 154 : ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt;
164 : else
165 157096 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0);
166 :
167 896471 : for( i = 0; i < nEntries; i++ )
168 : {
169 739221 : aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, true );
170 :
171 1202308 : if( (VAR_POINTER & pVarTypeList[ i ].nVarType) &&
172 463087 : !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
173 : {
174 : CLASS_DATA * ppData;
175 304289 : if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
176 : {
177 0 : RSCINST * pInstance = (RSCINST *) (aInst.pData + pVarTypeList[ i ].nOffset );
178 0 : pInstance->pClass = pVarTypeList[ i ].pClass;
179 0 : ppData = &pInstance->pData;
180 : }
181 : else
182 304289 : ppData = (CLASS_DATA* ) (aInst.pData + pVarTypeList[ i ].nOffset );
183 :
184 304289 : *ppData = NULL;
185 304289 : if( aDfltI.IsInst() )
186 : {
187 112 : aMemInst = pVarTypeList[ i ].pClass->Create( NULL, aDfltI );
188 112 : *ppData = aMemInst.pData;
189 304289 : };
190 : }
191 : else
192 : {
193 434932 : aMemInst = GetInstData( aInst.pData, i, true );
194 434932 : aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
195 : };
196 : }
197 :
198 157250 : return aInst;
199 : }
200 :
201 157250 : void RscClass::Destroy( const RSCINST & rInst )
202 : {
203 : sal_uInt32 i;
204 :
205 157250 : RscTop::Destroy( rInst );
206 :
207 896471 : for( i = 0; i < nEntries; i++ )
208 : {
209 739221 : if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) )
210 : {
211 513079 : RSCINST aTmpI;
212 :
213 513079 : aTmpI = GetInstData( rInst.pData, i, true );
214 513079 : if( aTmpI.IsInst() )
215 : {
216 : // Objekt loeschen
217 295904 : aTmpI.pClass->Destroy( aTmpI );
218 295904 : if( pVarTypeList[ i ].nVarType & VAR_POINTER )
219 : {
220 : // Speicher freigeben
221 87114 : rtl_freeMemory( aTmpI.pData );
222 : };
223 : };
224 : }
225 : };
226 157250 : }
227 :
228 213466 : ERRTYPE RscClass::SetVariable( Atom nVarName,
229 : RscTop * pClass,
230 : RSCINST * pDflt,
231 : RSCVAR nVarType,
232 : sal_uInt32 nMask,
233 : Atom nDataBaseName)
234 : {
235 213466 : if( pVarTypeList )
236 : {
237 : pVarTypeList = (VARTYPE_STRUCT *) rtl_reallocateMemory( (void *)pVarTypeList,
238 165890 : ((nEntries +1) * sizeof( VARTYPE_STRUCT )) );
239 : }
240 : else
241 : {
242 : pVarTypeList = (VARTYPE_STRUCT *) rtl_allocateMemory( ((nEntries +1)
243 47576 : * sizeof( VARTYPE_STRUCT )) );
244 : }
245 213466 : pVarTypeList[ nEntries ].nVarName = nVarName;
246 213466 : pVarTypeList[ nEntries ].nMask = nMask;
247 213466 : pVarTypeList[ nEntries ].pClass = pClass;
248 213466 : pVarTypeList[ nEntries ].nOffset = nSize;
249 213466 : pVarTypeList[ nEntries ].nDataBaseName = nDataBaseName;
250 213466 : if( pDflt )
251 2504 : pVarTypeList[ nEntries ].pDefault = pDflt->pData;
252 : else
253 210962 : pVarTypeList[ nEntries ].pDefault = NULL;
254 :
255 213466 : pVarTypeList[ nEntries ].nVarType = ~VAR_POINTER & nVarType;
256 213466 : if( pClass->Size() > 10 || (nVarType & VAR_EXTENDABLE) )
257 113306 : pVarTypeList[ nEntries ].nVarType |= VAR_POINTER;
258 :
259 213466 : if( !(pVarTypeList[ nEntries ].nVarType & VAR_NODATAINST) )
260 : {
261 143980 : if( pVarTypeList[ nEntries ].nVarType & VAR_POINTER )
262 : {
263 53836 : if( pVarTypeList[ nEntries ].nVarType & VAR_EXTENDABLE )
264 0 : nSize += sizeof( RSCINST );
265 : else
266 53836 : nSize += sizeof( CLASS_DATA );
267 : }
268 : else
269 90144 : nSize += pClass->Size();
270 : }
271 :
272 213466 : nEntries++;
273 213466 : if( nEntries > (sizeof( sal_uLong ) * 8) )
274 : {
275 : // Bereich fuer Default zu klein
276 0 : RscExit( 16 );
277 : };
278 213466 : return ERR_OK;
279 : }
280 :
281 0 : void RscClass::EnumVariables( void * pData, VarEnumCallbackProc pProc )
282 : {
283 : sal_uInt32 i;
284 :
285 0 : RscTop::EnumVariables( pData, pProc );
286 0 : for( i = 0; i < nEntries; i ++ )
287 : {
288 0 : if( !(pVarTypeList[ i ].nVarType & VAR_NOENUM) )
289 0 : (*pProc)( pData, pVarTypeList[ i ].pClass->GetClassType(), pVarTypeList[ i ].nVarName );
290 : }
291 0 : }
292 :
293 817832 : RSCINST RscClass::GetVariable( const RSCINST & rInst,
294 : Atom nVarName,
295 : const RSCINST & rInitInst,
296 : bool bInitDflt,
297 : RscTop * pCreateClass)
298 : {
299 817832 : sal_uInt32 i = 0;
300 817832 : RSCINST aTmpI;
301 :
302 5174960 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
303 3539296 : i++;
304 :
305 817832 : if( i < nEntries )
306 : {
307 464095 : if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
308 : {
309 : aTmpI = GetVariable( rInst,
310 17358 : pVarTypeList[ i ].nDataBaseName,
311 34716 : RSCINST() );
312 17358 : aTmpI.pClass = pVarTypeList[ i ].pClass;
313 : }
314 : else
315 : {
316 : // Default Instanz generieren
317 446737 : RSCINST aDefInst = rInitInst;
318 446737 : if( !aDefInst.IsInst() && bInitDflt )
319 : {
320 : // mit dem Variablen-Default besetzen
321 226208 : aDefInst.pData = pVarTypeList[ i ].pDefault;
322 226208 : aDefInst.pClass = pVarTypeList[ i ].pClass;
323 : }
324 :
325 446737 : aTmpI = GetInstData( rInst.pData, i );
326 446737 : if( aTmpI.IsInst() )
327 : {
328 359735 : if( aDefInst.IsInst() )
329 : {
330 0 : aTmpI.pClass->Destroy( aTmpI );
331 0 : aTmpI.pClass->Create( &aTmpI, aDefInst );
332 : }
333 : }
334 : else
335 : { // Wird ueber Zeiger angegeben
336 87002 : if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
337 : {
338 : RSCINST * pInst = (RSCINST *)
339 0 : (rInst.pData + pVarTypeList[ i ].nOffset );
340 0 : if( pCreateClass && pCreateClass->InHierarchy( aTmpI.pClass ) )
341 0 : *pInst = pCreateClass->Create( NULL, aDefInst );
342 : else
343 0 : *pInst = aTmpI.pClass->Create( NULL, aDefInst );
344 0 : aTmpI = *pInst;
345 : }
346 : else
347 : {
348 : CLASS_DATA * ppData
349 87002 : = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset);
350 87002 : aTmpI = aTmpI.pClass->Create( NULL, aDefInst );
351 87002 : *ppData = aTmpI.pData;
352 : }
353 : }
354 : };
355 : // auf nicht Default setzen
356 464095 : SetVarDflt( rInst.pData, i, false );
357 464095 : return aTmpI;
358 : };
359 :
360 : return RscTop::GetVariable( rInst, nVarName, rInitInst,
361 353737 : bInitDflt, pCreateClass );
362 : }
363 :
364 442709 : RSCINST RscClass::GetCopyVar( const RSCINST & rInst, Atom nVarName)
365 : {
366 442709 : sal_uInt32 i = 0;
367 442709 : RSCINST aVarI;
368 :
369 2263359 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
370 1377941 : i++;
371 :
372 442709 : if( i < nEntries )
373 : {
374 244942 : if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
375 : {
376 0 : aVarI = GetCopyVar( rInst, pVarTypeList[ i ].nDataBaseName );
377 0 : aVarI.pClass = pVarTypeList[ i ].pClass;
378 : }
379 : else
380 : {
381 244942 : if( IsDflt( rInst.pData, i ) )
382 : {
383 : // mit Variablen Default initialiaieren
384 226208 : aVarI = GetVariable( rInst, nVarName, RSCINST(), true );
385 226208 : SetVarDflt( rInst.pData, i, true );
386 : }
387 : else
388 18734 : aVarI = GetInstData( rInst.pData, i, true );
389 :
390 : };
391 244942 : return aVarI ;
392 : };
393 :
394 197767 : return RscTop::GetCopyVar( rInst, nVarName );
395 : }
396 :
397 0 : bool RscClass::IsConsistent( const RSCINST & rInst )
398 : {
399 0 : sal_uInt32 i = 0;
400 0 : RSCINST aTmpI;
401 : bool bRet;
402 :
403 0 : bRet = RscTop::IsConsistent( rInst );
404 :
405 0 : for( i = 0; i < nEntries; i++ )
406 : {
407 0 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
408 : {
409 0 : aTmpI = GetInstData( rInst.pData, i, true );
410 :
411 0 : if( aTmpI.IsInst() )
412 0 : if( ! aTmpI.pClass->IsConsistent( aTmpI ) )
413 0 : bRet = false;
414 : }
415 : };
416 :
417 0 : return bRet;
418 : }
419 :
420 43 : void RscClass::SetToDefault( const RSCINST & rInst )
421 : {
422 : sal_uInt32 i;
423 43 : RSCINST aTmpI;
424 : RscClassInst * pClass;
425 :
426 43 : pClass = (RscClassInst *)(rInst.pData + nSuperSize );
427 :
428 147 : for( i = 0; i < nEntries; i++ )
429 : {
430 : // Variablen ohne eigenen Speicher werden vom "Datenserver"
431 : // auf Default gesetzt
432 104 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
433 : {
434 104 : aTmpI = GetInstData( rInst.pData, i, true );
435 104 : if( aTmpI.IsInst() )
436 104 : aTmpI.pClass->SetToDefault( aTmpI );
437 : }
438 : }
439 43 : pClass->nVarDflt = ~((sal_uLong)0); // alles auf Default
440 :
441 43 : RscTop::SetToDefault( rInst );
442 43 : }
443 :
444 3 : bool RscClass::IsDefault( const RSCINST & rInst )
445 : {
446 : sal_uInt32 i;
447 3 : RSCINST aTmpI;
448 :
449 3 : for( i = 0; i < nEntries; i++ )
450 : {
451 : // Variablen ohne eigenen Speicher werden vom "Datenserver"
452 : // auf Default untersucht
453 3 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
454 3 : if( !IsDflt( rInst.pData, i ) )
455 3 : return false;
456 : };
457 :
458 0 : return RscTop::IsDefault( rInst );
459 : }
460 :
461 0 : RSCINST RscClass::GetDefault( Atom nVarId )
462 : {
463 : sal_uInt32 i;
464 :
465 0 : i = 0;
466 0 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarId )
467 0 : i++;
468 :
469 0 : if( i < nEntries )
470 : {
471 0 : RSCINST aTmpI;
472 :
473 0 : aTmpI.pClass = pVarTypeList[ i ].pClass;
474 0 : aTmpI.pData = GetDfltData( i );
475 0 : return aTmpI;
476 : };
477 :
478 0 : return RscTop::GetDefault( nVarId );
479 : }
480 :
481 51099 : bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
482 : {
483 51099 : RSCINST aTmpI;
484 :
485 51099 : aTmpI = GetInstData( pData, nEle, true );
486 :
487 51099 : if( aTmpI.IsInst() )
488 : {
489 51099 : if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
490 675 : return false;
491 :
492 50424 : if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
493 : //sie haben auch die gleiche Klasse
494 50424 : return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
495 : else
496 0 : return false;
497 : }
498 0 : return true;
499 : }
500 :
501 1877 : bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
502 : {
503 1877 : RSCINST aTmpI;
504 1877 : RSCINST aDfltI;
505 :
506 1877 : if( !RscTop::IsValueDefault( rInst, pDef ) )
507 2 : return false;
508 :
509 1875 : if( pDef )
510 : {
511 3786 : for( sal_uInt32 i = 0; i < nEntries; i++ )
512 : {
513 2843 : aTmpI = GetInstData( rInst.pData, i, true );
514 2843 : if( aTmpI.IsInst() )
515 : {
516 972 : if( aTmpI.pClass != pVarTypeList[ i ].pClass )
517 : //sie haben nicht die gleiche Klasse
518 0 : return false;
519 :
520 972 : aDfltI = GetInstData( pDef, i, true );
521 972 : if( !aDfltI.IsInst() )
522 916 : aDfltI.pData = GetDfltData( i );
523 :
524 972 : if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
525 932 : return false;
526 : }
527 : }
528 : }
529 : else
530 0 : return false;
531 :
532 943 : return true;
533 : }
534 :
535 0 : void RscClass::SetDefault( const RSCINST & rInst, Atom nVarName )
536 : {
537 0 : sal_uInt32 i = 0;
538 0 : RSCINST aTmpI;
539 :
540 0 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
541 0 : i++;
542 :
543 0 : if( i < nEntries )
544 : {
545 0 : aTmpI = GetInstData( rInst.pData, i, true );
546 0 : if( aTmpI.IsInst() )
547 : {
548 0 : aTmpI.pClass->Destroy( aTmpI );
549 0 : aTmpI.pClass->Create( &aTmpI, RSCINST() );
550 0 : SetVarDflt( rInst.pData, i, true );
551 : }
552 : }
553 : else //In Superklasse nach Variable suchen
554 0 : RscTop::SetDefault( rInst, nVarName );
555 :
556 0 : }
557 :
558 :
559 72023 : void RscClass::WriteSrc( const RSCINST & rInst,
560 : FILE * fOutput,
561 : RscTypCont * pTC,
562 : sal_uInt32 nTab,
563 : const char * pVarName)
564 : {
565 72023 : sal_uInt32 i = 0, n = 0;
566 72023 : RSCINST aTmpI;
567 :
568 72023 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
569 :
570 396609 : for( i = 0; i < nEntries; i++ )
571 : {
572 324586 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
573 : {
574 : // Hack wegen Position und Dimensiuon
575 608550 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName ||
576 301019 : nRsc_WHMAPMODEId == pVarTypeList[ i ].nVarName )
577 : {
578 26862 : if( !IsDflt( rInst.pData, i ) || // MapUnit
579 13836 : !IsDflt( rInst.pData, i+1 ) || //X, Width
580 812 : !IsDflt( rInst.pData, i+2 ) ) //Y, Height
581 : {
582 : // ein Wert ist nicht Default
583 36033 : for( n = 0; n < nTab; n++ )
584 23821 : fputc( '\t', fOutput );
585 :
586 12212 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName )
587 5844 : fprintf( fOutput, "Pos = " );
588 : else
589 6368 : fprintf( fOutput, "Size = " );
590 :
591 12212 : if( !IsDflt( rInst.pData, i ) )
592 : {
593 12210 : aTmpI = GetInstData( rInst.pData, i, true );
594 : aTmpI.pClass->WriteSrcHeader(
595 12210 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
596 : }
597 :
598 12212 : fprintf( fOutput, "( " );
599 12212 : aTmpI = GetInstData( rInst.pData, i+1, true );
600 12212 : if( !aTmpI.IsInst() )
601 0 : aTmpI.pData = GetDfltData( i+1 );
602 :
603 12212 : aTmpI.pClass->WriteSrcHeader( aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
604 :
605 12212 : fprintf( fOutput, ", " );
606 12212 : aTmpI = GetInstData( rInst.pData, i+2, true );
607 :
608 12212 : if( !aTmpI.IsInst() )
609 0 : aTmpI.pData = GetDfltData( i+2 );
610 :
611 : aTmpI.pClass->WriteSrcHeader(
612 12212 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
613 12212 : fprintf( fOutput, " );\n" );
614 : }
615 13024 : i += 2; //_X, _Y oder _Widht, Height ueberlesen
616 : }
617 589014 : else if( !IsDflt( rInst.pData, i )
618 294507 : && !IsValueDflt( rInst.pData, i ) )
619 : {
620 46816 : aTmpI = GetInstData( rInst.pData, i, true );
621 :
622 46816 : if( aTmpI.IsInst() )
623 : {
624 46816 : const char * pName = pHS->getString( pVarTypeList[ i ].nVarName ).getStr();
625 :
626 162187 : for( n = 0; n < nTab; n++ )
627 115371 : fputc( '\t', fOutput );
628 :
629 46816 : fprintf( fOutput, "%s", pName );
630 46816 : fprintf( fOutput, " = " );
631 : aTmpI.pClass->WriteSrcHeader(
632 46816 : aTmpI, fOutput, pTC, nTab, RscId(), pName );
633 46816 : fprintf( fOutput, ";\n" );
634 : }
635 : };
636 : };
637 : };
638 :
639 72023 : return;
640 : }
641 :
642 24424 : sal_Int32 RscClass::GetCorrectValues( const RSCINST & rInst,
643 : sal_uInt32 nVarPos,
644 : sal_uInt32 nTupelIdx,
645 : RscTypCont * pTC)
646 : {
647 24424 : sal_Int32 nLang = 0;
648 : sal_Int32 nBaseValue;
649 :
650 : // Basiswert holen
651 24424 : RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, true );
652 24424 : aTmpI.pClass->GetNumber( aTmpI, &nBaseValue );
653 :
654 : // Sprach Delta holen
655 24424 : aTmpI = rInst.pClass->GetVariable( rInst, nRsc_DELTALANG, RSCINST() );
656 24424 : if( aTmpI.IsInst() )
657 : {
658 24424 : RscWriteRc aMem;
659 24424 : aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, false );
660 24424 : nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
661 : }
662 :
663 24424 : return nLang + nBaseValue;
664 : }
665 :
666 99397 : ERRTYPE RscClass::WriteInstRc( const RSCINST & rInst,
667 : RscWriteRc & rMem,
668 : RscTypCont * pTC,
669 : sal_uInt32 nDeep,
670 : bool bExtra)
671 : {
672 99397 : sal_uInt32 i = 0;
673 99397 : ERRTYPE aError;
674 99397 : RSCINST aTmpI;
675 99397 : sal_uInt32 nMaskOff = 0;// Offset um Maskenfeld zu addressieren
676 :
677 : // Wenn eine Variable Maskierung hat, dann Maskenfeld
678 382569 : for( i = 0; i < nEntries; i++ )
679 : {
680 296410 : if( pVarTypeList[ i ].nMask )
681 : {
682 13238 : nMaskOff = rMem.Size();
683 13238 : rMem.Put( sal_uInt32(0) );
684 13238 : break;
685 : }
686 : };
687 :
688 553519 : for( i = 0; i < nEntries && aError.IsOk(); i++ )
689 : {
690 454122 : if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
691 : {
692 305643 : if( pVarTypeList[ i ].nMask )
693 : {
694 142344 : if( !IsDflt( rInst.pData, i ) )
695 : {
696 58777 : if( nRsc_X == pVarTypeList[ i ].nVarName )
697 : {
698 5844 : sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC );
699 5844 : rMem.Put( nVal );
700 : }
701 52933 : else if( nRsc_Y == pVarTypeList[ i ].nVarName )
702 : {
703 5844 : sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC );
704 5844 : rMem.Put( nVal );
705 : }
706 47089 : else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
707 : {
708 6368 : sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC );
709 6368 : rMem.Put( nVal );
710 : }
711 40721 : else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
712 : {
713 6368 : sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC );
714 6368 : rMem.Put( nVal );
715 : }
716 : else
717 : {
718 34353 : aTmpI = GetInstData( rInst.pData, i, true );
719 : // Nur an Variable Extradata bExtra nicht auf false
720 : // setzen
721 103059 : aError = aTmpI.pClass->
722 : WriteRcHeader( aTmpI, rMem, pTC,
723 : RscId(), nDeep,
724 34353 : (nRsc_EXTRADATA == pVarTypeList[ i ].nVarName)
725 68706 : ? bExtra : false );
726 : }
727 58777 : sal_uInt32 nMask = rMem.GetLong( nMaskOff );
728 58777 : nMask |= pVarTypeList[ i ].nMask;
729 58777 : rMem.PutAt( nMaskOff, nMask );
730 : }
731 : }
732 : else
733 : {
734 163299 : if( IsDflt( rInst.pData, i ) )
735 : {
736 137658 : aTmpI.pClass = pVarTypeList[ i ].pClass;
737 137658 : aTmpI.pData = GetDfltData( i );
738 : }
739 : else
740 25641 : aTmpI = GetInstData( rInst.pData, i, true );
741 :
742 : // Nur an Variable Extradata bExtra nicht auf false
743 : // setzen
744 489897 : aError = aTmpI.pClass->
745 : WriteRcHeader( aTmpI, rMem, pTC,
746 : RscId(), nDeep,
747 163299 : (nRsc_EXTRADATA == pVarTypeList[ i ].nVarName)
748 326598 : ? bExtra : false );
749 : }
750 : }
751 : }
752 :
753 99397 : return aError;
754 : }
755 :
756 71627 : ERRTYPE RscClass::WriteRc( const RSCINST & rInst,
757 : RscWriteRc & rMem,
758 : RscTypCont * pTC,
759 : sal_uInt32 nDeep,
760 : bool bExtra)
761 : {
762 71627 : ERRTYPE aError;
763 :
764 71627 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
765 71627 : if( aError.IsOk() )
766 71627 : aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
767 :
768 71627 : return aError;
769 : }
770 :
771 626 : RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
772 626 : : RscClass( nId, nTypeId, pSuper )
773 : {
774 626 : }
775 :
776 1126 : ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
777 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra, bool bFirst )
778 : {
779 1126 : ERRTYPE aError;
780 1126 : RSCINST aFileName;
781 :
782 : //Instanz mit dem Dateinamen "FILENAME" holen
783 1126 : aFileName = RscClass::GetCopyVar( rInst, pHS->getID( "FILE", true ) );
784 1126 : if( aFileName.IsInst() )
785 : {
786 1126 : RscWriteRc aTmpMem;
787 3378 : aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC,
788 2252 : RscId(), nDeep, bExtra );
789 : // Obsolete - need changes in VCL
790 1126 : rMem.Put( sal_uInt32(0) );
791 :
792 : // Identifier schreiben
793 1126 : sal_uInt32 nId = 0xFFFFFFFF;
794 1126 : if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') )
795 : {
796 : nId = pTC->PutSysName( rInst.pClass->GetTypId(),
797 : aTmpMem.GetUTF8( 0 ),
798 1126 : 0, 0, bFirst );
799 : }
800 1126 : rMem.Put( nId );
801 3378 : aError = aFileName.pClass->WriteRcHeader( aFileName, rMem, pTC,
802 3378 : RscId(), nDeep, bExtra );
803 : }
804 : else
805 0 : aError = ERR_ERROR;
806 :
807 1126 : return aError;
808 : }
809 :
810 1126 : ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
811 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
812 : {
813 1126 : ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
814 :
815 1126 : if( this == rInst.pClass )
816 : {
817 : // nur wenn es eigen Klasse ist
818 1126 : aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra );
819 : }
820 1126 : return aError;
821 : }
822 :
823 1878 : RscTupel::RscTupel( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
824 1878 : : RscClass( nId, nTypeId, pSuper )
825 : {
826 1878 : }
827 :
828 8961 : RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
829 : const RSCINST & rInitInst )
830 : {
831 8961 : if( nPos >= nEntries )
832 : {
833 0 : return RSCINST();
834 : }
835 : else
836 8961 : return GetVariable( rInst, pVarTypeList[ nPos ].nVarName, rInitInst );
837 : }
838 :
839 2136 : void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput,
840 : RscTypCont * pTC, sal_uInt32 nTab,
841 : const char * pVarName )
842 : {
843 2136 : sal_uInt32 i = 0;
844 2136 : RSCINST aTmpI;
845 :
846 2136 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
847 :
848 2136 : fprintf( fOutput, "< " );
849 6420 : for( i = 0; i < nEntries; i++ )
850 : {
851 4284 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
852 : {
853 8568 : if( !IsDflt( rInst.pData, i )
854 4284 : && !IsValueDflt( rInst.pData, i ) )
855 : {
856 2990 : aTmpI = GetInstData( rInst.pData, i, true );
857 :
858 2990 : if( aTmpI.IsInst() )
859 : aTmpI.pClass->WriteSrcHeader(
860 2990 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
861 : else
862 0 : fprintf( fOutput, "Default" );
863 : }
864 : else
865 1294 : fprintf( fOutput, "Default" );
866 4284 : fprintf( fOutput, "; " );
867 : };
868 : };
869 2136 : fprintf( fOutput, ">" );
870 :
871 2136 : return;
872 : }
873 :
874 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
