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 37433 : RscClass::RscClass( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
32 37433 : : RscTop( nId, nTypeId, pSuperCl )
33 : {
34 37433 : nEntries = 0;
35 37433 : pVarTypeList = NULL;
36 37433 : nSuperSize = RscTop::Size();
37 37433 : nSize = nSuperSize + ALIGNED_SIZE( sizeof( RscClassInst ) );
38 37433 : }
39 :
40 37433 : void RscClass::Pre_dtor()
41 : {
42 : sal_uInt32 i;
43 :
44 37433 : RscTop::Pre_dtor();
45 :
46 172282 : for( i = 0; i < nEntries; i++ )
47 : {
48 134849 : if( pVarTypeList[ i ].pDefault )
49 : {
50 5412 : pVarTypeList[ i ].pClass->Destroy(
51 1804 : RSCINST( pVarTypeList[ i ].pClass,
52 7216 : pVarTypeList[ i ].pDefault ) );
53 1804 : rtl_freeMemory( pVarTypeList[ i ].pDefault );
54 1804 : pVarTypeList[ i ].pDefault = NULL;
55 : };
56 : };
57 37433 : }
58 :
59 110044 : RscClass::~RscClass()
60 : {
61 37433 : if( pVarTypeList )
62 29766 : rtl_freeMemory( (void *)pVarTypeList );
63 72611 : }
64 :
65 0 : RSCCLASS_TYPE RscClass::GetClassType() const
66 : {
67 0 : return RSCCLASS_COMPLEX;
68 : }
69 :
70 1285118 : RSCINST RscClass::GetInstData
71 : (
72 : CLASS_DATA pData,
73 : sal_uInt32 nEle,
74 : bool bGetCopy
75 : )
76 : {
77 1285118 : RSCINST aInst;
78 :
79 1285118 : aInst.pClass = pVarTypeList[ nEle ].pClass;
80 1285118 : if( pData )
81 : {
82 871643 : if( VAR_NODATAINST & pVarTypeList[ nEle ].nVarType )
83 : {
84 102290 : RSCINST aTmpI;
85 :
86 102290 : aTmpI.pClass = this;
87 102290 : aTmpI.pData = pData;
88 102290 : if( bGetCopy )
89 : aInst.pData = GetCopyVar(
90 : aTmpI,
91 102290 : pVarTypeList[ nEle ].nDataBaseName
92 204580 : ).pData;
93 : else
94 : aInst.pData = GetVariable(
95 : aTmpI,
96 0 : pVarTypeList[ nEle ].nDataBaseName,
97 : RSCINST()
98 0 : ).pData;
99 : }
100 769353 : else if( VAR_POINTER & pVarTypeList[ nEle ].nVarType )
101 : {
102 448060 : if( VAR_EXTENDABLE & pVarTypeList[ nEle ].nVarType )
103 0 : aInst = *(RSCINST *) (pData + pVarTypeList[ nEle ].nOffset);
104 : else
105 448060 : aInst.pData = *(CLASS_DATA *) (pData + pVarTypeList[ nEle ].nOffset);
106 : }
107 : else
108 321293 : aInst.pData = pData + pVarTypeList[ nEle ].nOffset;
109 : };
110 1285118 : return aInst;
111 : }
112 :
113 94371 : CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle )
114 : {
115 94371 : if( pVarTypeList[ nEle ].pDefault )
116 167 : return pVarTypeList[ nEle ].pDefault;
117 :
118 94204 : return pVarTypeList[ nEle ].pClass->GetDefault().pData;
119 : }
120 :
121 321227 : void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, bool bSet )
122 : {
123 : RscClassInst * pClass;
124 :
125 321227 : pClass = (RscClassInst *)(pData + nSuperSize );
126 321227 : if( bSet )
127 96686 : pClass->nVarDflt |= ((sal_uLong)1 << nEle);
128 : else
129 224541 : pClass->nVarDflt &= ~((sal_uLong)1 << nEle);
130 321227 : }
131 :
132 450136 : bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
133 : {
134 : RscClassInst * pClass;
135 :
136 450136 : pClass = (RscClassInst *)(pData + nSuperSize );
137 450136 : return pClass->nVarDflt & ((sal_uLong)1 << nEle);
138 : }
139 :
140 109916 : RSCINST RscClass::Create( RSCINST * pInst,
141 : const RSCINST & rDflt,
142 : bool bOwnClass)
143 : {
144 : sal_uInt32 i;
145 109916 : RSCINST aInst;
146 109916 : RSCINST aMemInst, aDfltI;
147 :
148 109916 : if( !pInst )
149 : {
150 50577 : aInst.pClass = this;
151 50577 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
152 : }
153 : else
154 59339 : aInst = *pInst;
155 :
156 109916 : if( !bOwnClass && rDflt.IsInst() )
157 9 : bOwnClass = rDflt.pClass->InHierarchy( this );
158 :
159 109916 : RscTop::Create( &aInst, rDflt, bOwnClass );
160 :
161 109916 : if( bOwnClass )
162 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt =
163 9 : ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt;
164 : else
165 109907 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0);
166 :
167 523427 : for( i = 0; i < nEntries; i++ )
168 : {
169 413511 : aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, true );
170 :
171 682144 : if( (VAR_POINTER & pVarTypeList[ i ].nVarType) &&
172 268633 : !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
173 : {
174 : CLASS_DATA * ppData;
175 220279 : 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 220279 : ppData = (CLASS_DATA* ) (aInst.pData + pVarTypeList[ i ].nOffset );
183 :
184 220279 : *ppData = NULL;
185 220279 : if( aDfltI.IsInst() )
186 : {
187 0 : aMemInst = pVarTypeList[ i ].pClass->Create( NULL, aDfltI );
188 0 : *ppData = aMemInst.pData;
189 220279 : };
190 : }
191 : else
192 : {
193 193232 : aMemInst = GetInstData( aInst.pData, i, true );
194 193232 : aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
195 : };
196 : }
197 :
198 109916 : return aInst;
199 : }
200 :
201 109916 : void RscClass::Destroy( const RSCINST & rInst )
202 : {
203 : sal_uInt32 i;
204 :
205 109916 : RscTop::Destroy( rInst );
206 :
207 523427 : for( i = 0; i < nEntries; i++ )
208 : {
209 413511 : if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) )
210 : {
211 316825 : RSCINST aTmpI;
212 :
213 316825 : aTmpI = GetInstData( rInst.pData, i, true );
214 316825 : if( aTmpI.IsInst() )
215 : {
216 : // Objekt loeschen
217 159263 : aTmpI.pClass->Destroy( aTmpI );
218 159263 : if( pVarTypeList[ i ].nVarType & VAR_POINTER )
219 : {
220 : // Speicher freigeben
221 62717 : rtl_freeMemory( aTmpI.pData );
222 : };
223 : };
224 : }
225 : };
226 109916 : }
227 :
228 134849 : ERRTYPE RscClass::SetVariable( Atom nVarName,
229 : RscTop * pClass,
230 : RSCINST * pDflt,
231 : RSCVAR nVarType,
232 : sal_uInt32 nMask,
233 : Atom nDataBaseName)
234 : {
235 134849 : if( pVarTypeList )
236 : {
237 : pVarTypeList = (VARTYPE_STRUCT *) rtl_reallocateMemory( (void *)pVarTypeList,
238 105083 : ((nEntries +1) * sizeof( VARTYPE_STRUCT )) );
239 : }
240 : else
241 : {
242 : pVarTypeList = (VARTYPE_STRUCT *) rtl_allocateMemory( ((nEntries +1)
243 29766 : * sizeof( VARTYPE_STRUCT )) );
244 : }
245 134849 : pVarTypeList[ nEntries ].nVarName = nVarName;
246 134849 : pVarTypeList[ nEntries ].nMask = nMask;
247 134849 : pVarTypeList[ nEntries ].pClass = pClass;
248 134849 : pVarTypeList[ nEntries ].nOffset = nSize;
249 134849 : pVarTypeList[ nEntries ].nDataBaseName = nDataBaseName;
250 134849 : if( pDflt )
251 1804 : pVarTypeList[ nEntries ].pDefault = pDflt->pData;
252 : else
253 133045 : pVarTypeList[ nEntries ].pDefault = NULL;
254 :
255 134849 : pVarTypeList[ nEntries ].nVarType = ~VAR_POINTER & nVarType;
256 134849 : if( pClass->Size() > 10 || (nVarType & VAR_EXTENDABLE) )
257 77572 : pVarTypeList[ nEntries ].nVarType |= VAR_POINTER;
258 :
259 134849 : if( !(pVarTypeList[ nEntries ].nVarType & VAR_NODATAINST) )
260 : {
261 85239 : if( pVarTypeList[ nEntries ].nVarType & VAR_POINTER )
262 : {
263 35178 : if( pVarTypeList[ nEntries ].nVarType & VAR_EXTENDABLE )
264 0 : nSize += sizeof( RSCINST );
265 : else
266 35178 : nSize += sizeof( CLASS_DATA );
267 : }
268 : else
269 50061 : nSize += pClass->Size();
270 : }
271 :
272 134849 : nEntries++;
273 134849 : if( nEntries > (sizeof( sal_uLong ) * 8) )
274 : {
275 : // Bereich fuer Default zu klein
276 0 : RscExit( 16 );
277 : };
278 134849 : 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 321866 : RSCINST RscClass::GetVariable( const RSCINST & rInst,
294 : Atom nVarName,
295 : const RSCINST & rInitInst,
296 : bool bInitDflt,
297 : RscTop * pCreateClass)
298 : {
299 321866 : sal_uInt32 i = 0;
300 321866 : RSCINST aTmpI;
301 :
302 1890061 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
303 1246329 : i++;
304 :
305 321866 : if( i < nEntries )
306 : {
307 224541 : if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
308 : {
309 : aTmpI = GetVariable( rInst,
310 5614 : pVarTypeList[ i ].nDataBaseName,
311 11228 : RSCINST() );
312 5614 : aTmpI.pClass = pVarTypeList[ i ].pClass;
313 : }
314 : else
315 : {
316 : // Default Instanz generieren
317 218927 : RSCINST aDefInst = rInitInst;
318 218927 : if( !aDefInst.IsInst() && bInitDflt )
319 : {
320 : // mit dem Variablen-Default besetzen
321 96686 : aDefInst.pData = pVarTypeList[ i ].pDefault;
322 96686 : aDefInst.pClass = pVarTypeList[ i ].pClass;
323 : }
324 :
325 218927 : aTmpI = GetInstData( rInst.pData, i );
326 218927 : if( aTmpI.IsInst() )
327 : {
328 156210 : 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 62717 : 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 62717 : = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset);
350 62717 : aTmpI = aTmpI.pClass->Create( NULL, aDefInst );
351 62717 : *ppData = aTmpI.pData;
352 : }
353 : }
354 : };
355 : // auf nicht Default setzen
356 224541 : SetVarDflt( rInst.pData, i, false );
357 224541 : return aTmpI;
358 : };
359 :
360 : return RscTop::GetVariable( rInst, nVarName, rInitInst,
361 97325 : bInitDflt, pCreateClass );
362 : }
363 :
364 163486 : RSCINST RscClass::GetCopyVar( const RSCINST & rInst, Atom nVarName)
365 : {
366 163486 : sal_uInt32 i = 0;
367 163486 : RSCINST aVarI;
368 :
369 821506 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
370 494534 : i++;
371 :
372 163486 : if( i < nEntries )
373 : {
374 103338 : 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 103338 : if( IsDflt( rInst.pData, i ) )
382 : {
383 : // mit Variablen Default initialiaieren
384 96686 : aVarI = GetVariable( rInst, nVarName, RSCINST(), true );
385 96686 : SetVarDflt( rInst.pData, i, true );
386 : }
387 : else
388 6652 : aVarI = GetInstData( rInst.pData, i, true );
389 :
390 : };
391 103338 : return aVarI ;
392 : };
393 :
394 60148 : 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 9 : void RscClass::SetToDefault( const RSCINST & rInst )
421 : {
422 : sal_uInt32 i;
423 9 : RSCINST aTmpI;
424 : RscClassInst * pClass;
425 :
426 9 : pClass = (RscClassInst *)(rInst.pData + nSuperSize );
427 :
428 45 : for( i = 0; i < nEntries; i++ )
429 : {
430 : // Variablen ohne eigenen Speicher werden vom "Datenserver"
431 : // auf Default gesetzt
432 36 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
433 : {
434 36 : aTmpI = GetInstData( rInst.pData, i, true );
435 36 : if( aTmpI.IsInst() )
436 36 : aTmpI.pClass->SetToDefault( aTmpI );
437 : }
438 : }
439 9 : pClass->nVarDflt = ~((sal_uLong)0); // alles auf Default
440 :
441 9 : RscTop::SetToDefault( rInst );
442 9 : }
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 37625 : bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
482 : {
483 37625 : RSCINST aTmpI;
484 :
485 37625 : aTmpI = GetInstData( pData, nEle, true );
486 :
487 37625 : if( aTmpI.IsInst() )
488 : {
489 37625 : if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
490 624 : return false;
491 :
492 37001 : if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
493 : //sie haben auch die gleiche Klasse
494 37001 : return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
495 : else
496 0 : return false;
497 : }
498 0 : return true;
499 : }
500 :
501 1499 : bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
502 : {
503 1499 : RSCINST aTmpI;
504 1499 : RSCINST aDfltI;
505 :
506 1499 : if( !RscTop::IsValueDefault( rInst, pDef ) )
507 2 : return false;
508 :
509 1497 : if( pDef )
510 : {
511 3026 : for( sal_uInt32 i = 0; i < nEntries; i++ )
512 : {
513 2272 : aTmpI = GetInstData( rInst.pData, i, true );
514 2272 : if( aTmpI.IsInst() )
515 : {
516 783 : if( aTmpI.pClass != pVarTypeList[ i ].pClass )
517 : //sie haben nicht die gleiche Klasse
518 0 : return false;
519 :
520 783 : aDfltI = GetInstData( pDef, i, true );
521 783 : if( !aDfltI.IsInst() )
522 729 : aDfltI.pData = GetDfltData( i );
523 :
524 783 : if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
525 743 : return false;
526 : }
527 : }
528 : }
529 : else
530 0 : return false;
531 :
532 754 : 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 51503 : void RscClass::WriteSrc( const RSCINST & rInst,
560 : FILE * fOutput,
561 : RscTypCont * pTC,
562 : sal_uInt32 nTab,
563 : const char * pVarName)
564 : {
565 51503 : sal_uInt32 i = 0, n = 0;
566 51503 : RSCINST aTmpI;
567 :
568 51503 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
569 :
570 242172 : for( i = 0; i < nEntries; i++ )
571 : {
572 190669 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
573 : {
574 : // Hack wegen Position und Dimensiuon
575 363721 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName ||
576 180893 : nRsc_WHMAPMODEId == pVarTypeList[ i ].nVarName )
577 : {
578 8020 : if( !IsDflt( rInst.pData, i ) || // MapUnit
579 4150 : !IsDflt( rInst.pData, i+1 ) || //X, Width
580 280 : !IsDflt( rInst.pData, i+2 ) ) //Y, Height
581 : {
582 : // ein Wert ist nicht Default
583 10556 : for( n = 0; n < nTab; n++ )
584 6966 : fputc( '\t', fOutput );
585 :
586 3590 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName )
587 1720 : fprintf( fOutput, "Pos = " );
588 : else
589 1870 : fprintf( fOutput, "Size = " );
590 :
591 3590 : if( !IsDflt( rInst.pData, i ) )
592 : {
593 3590 : aTmpI = GetInstData( rInst.pData, i, true );
594 : aTmpI.pClass->WriteSrcHeader(
595 3590 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
596 : }
597 :
598 3590 : fprintf( fOutput, "( " );
599 3590 : aTmpI = GetInstData( rInst.pData, i+1, true );
600 3590 : if( !aTmpI.IsInst() )
601 0 : aTmpI.pData = GetDfltData( i+1 );
602 :
603 3590 : aTmpI.pClass->WriteSrcHeader( aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
604 :
605 3590 : fprintf( fOutput, ", " );
606 3590 : aTmpI = GetInstData( rInst.pData, i+2, true );
607 :
608 3590 : if( !aTmpI.IsInst() )
609 0 : aTmpI.pData = GetDfltData( i+2 );
610 :
611 : aTmpI.pClass->WriteSrcHeader(
612 3590 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
613 3590 : fprintf( fOutput, " );\n" );
614 : }
615 3870 : i += 2; //_X, _Y oder _Width, Height ueberlesen
616 : }
617 357916 : else if( !IsDflt( rInst.pData, i )
618 178958 : && !IsValueDflt( rInst.pData, i ) )
619 : {
620 34508 : aTmpI = GetInstData( rInst.pData, i, true );
621 :
622 34508 : if( aTmpI.IsInst() )
623 : {
624 34508 : const char * pName = pHS->getString( pVarTypeList[ i ].nVarName ).getStr();
625 :
626 124804 : for( n = 0; n < nTab; n++ )
627 90296 : fputc( '\t', fOutput );
628 :
629 34508 : fprintf( fOutput, "%s", pName );
630 34508 : fprintf( fOutput, " = " );
631 : aTmpI.pClass->WriteSrcHeader(
632 34508 : aTmpI, fOutput, pTC, nTab, RscId(), pName );
633 34508 : fprintf( fOutput, ";\n" );
634 : }
635 : };
636 : };
637 : };
638 :
639 51503 : return;
640 : }
641 :
642 7180 : sal_Int32 RscClass::GetCorrectValues( const RSCINST & rInst,
643 : sal_uInt32 nVarPos,
644 : sal_uInt32 nTupelIdx,
645 : RscTypCont * pTC)
646 : {
647 7180 : sal_Int32 nLang = 0;
648 : sal_Int32 nBaseValue;
649 :
650 : // Basiswert holen
651 7180 : RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, true );
652 7180 : aTmpI.pClass->GetNumber( aTmpI, &nBaseValue );
653 :
654 : // Sprach Delta holen
655 7180 : aTmpI = rInst.pClass->GetVariable( rInst, nRsc_DELTALANG, RSCINST() );
656 7180 : if( aTmpI.IsInst() )
657 : {
658 7180 : RscWriteRc aMem;
659 7180 : aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, false );
660 7180 : nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
661 : }
662 :
663 7180 : return nLang + nBaseValue;
664 : }
665 :
666 61030 : ERRTYPE RscClass::WriteInstRc( const RSCINST & rInst,
667 : RscWriteRc & rMem,
668 : RscTypCont * pTC,
669 : sal_uInt32 nDeep,
670 : bool bExtra)
671 : {
672 61030 : sal_uInt32 i = 0;
673 61030 : ERRTYPE aError;
674 61030 : RSCINST aTmpI;
675 61030 : sal_uInt32 nMaskOff = 0;// Offset um Maskenfeld zu addressieren
676 :
677 : // Wenn eine Variable Maskierung hat, dann Maskenfeld
678 191334 : for( i = 0; i < nEntries; i++ )
679 : {
680 137725 : if( pVarTypeList[ i ].nMask )
681 : {
682 7421 : nMaskOff = rMem.Size();
683 7421 : rMem.Put( sal_uInt32(0) );
684 7421 : break;
685 : }
686 : };
687 :
688 292751 : for( i = 0; i < nEntries && aError.IsOk(); i++ )
689 : {
690 231721 : if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
691 : {
692 156721 : if( pVarTypeList[ i ].nMask )
693 : {
694 78214 : if( !IsDflt( rInst.pData, i ) )
695 : {
696 25751 : if( nRsc_X == pVarTypeList[ i ].nVarName )
697 : {
698 1720 : sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC );
699 1720 : rMem.Put( nVal );
700 : }
701 24031 : else if( nRsc_Y == pVarTypeList[ i ].nVarName )
702 : {
703 1720 : sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC );
704 1720 : rMem.Put( nVal );
705 : }
706 22311 : else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
707 : {
708 1870 : sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC );
709 1870 : rMem.Put( nVal );
710 : }
711 20441 : else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
712 : {
713 1870 : sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC );
714 1870 : rMem.Put( nVal );
715 : }
716 : else
717 : {
718 18571 : aTmpI = GetInstData( rInst.pData, i, true );
719 : // Nur an Variable Extradata bExtra nicht auf false
720 : // setzen
721 55713 : aError = aTmpI.pClass->
722 : WriteRcHeader( aTmpI, rMem, pTC,
723 : RscId(), nDeep,
724 18571 : (nRsc_EXTRADATA == pVarTypeList[ i ].nVarName)
725 37142 : ? bExtra : false );
726 : }
727 25751 : sal_uInt32 nMask = rMem.GetLong( nMaskOff );
728 25751 : nMask |= pVarTypeList[ i ].nMask;
729 25751 : rMem.PutAt( nMaskOff, nMask );
730 : }
731 : }
732 : else
733 : {
734 78507 : if( IsDflt( rInst.pData, i ) )
735 : {
736 56641 : aTmpI.pClass = pVarTypeList[ i ].pClass;
737 56641 : aTmpI.pData = GetDfltData( i );
738 : }
739 : else
740 21866 : aTmpI = GetInstData( rInst.pData, i, true );
741 :
742 : // Nur an Variable Extradata bExtra nicht auf false
743 : // setzen
744 235521 : aError = aTmpI.pClass->
745 : WriteRcHeader( aTmpI, rMem, pTC,
746 : RscId(), nDeep,
747 78507 : (nRsc_EXTRADATA == pVarTypeList[ i ].nVarName)
748 157014 : ? bExtra : false );
749 : }
750 : }
751 : }
752 :
753 61030 : return aError;
754 : }
755 :
756 37356 : ERRTYPE RscClass::WriteRc( const RSCINST & rInst,
757 : RscWriteRc & rMem,
758 : RscTypCont * pTC,
759 : sal_uInt32 nDeep,
760 : bool bExtra)
761 : {
762 37356 : ERRTYPE aError;
763 :
764 37356 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
765 37356 : if( aError.IsOk() )
766 37356 : aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
767 :
768 37356 : return aError;
769 : }
770 :
771 451 : RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
772 451 : : RscClass( nId, nTypeId, pSuper )
773 : {
774 451 : }
775 :
776 1048 : ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
777 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra, bool bFirst )
778 : {
779 1048 : ERRTYPE aError;
780 1048 : RSCINST aFileName;
781 :
782 : //Instanz mit dem Dateinamen "FILENAME" holen
783 1048 : aFileName = RscClass::GetCopyVar( rInst, pHS->getID( "FILE", true ) );
784 1048 : if( aFileName.IsInst() )
785 : {
786 1048 : RscWriteRc aTmpMem;
787 3144 : aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC,
788 2096 : RscId(), nDeep, bExtra );
789 : // Obsolete - need changes in VCL
790 1048 : rMem.Put( sal_uInt32(0) );
791 :
792 : // Identifier schreiben
793 1048 : sal_uInt32 nId = 0xFFFFFFFF;
794 1048 : if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') )
795 : {
796 : nId = pTC->PutSysName( rInst.pClass->GetTypId(),
797 : aTmpMem.GetUTF8( 0 ),
798 1048 : 0, 0, bFirst );
799 : }
800 1048 : rMem.Put( nId );
801 3144 : aError = aFileName.pClass->WriteRcHeader( aFileName, rMem, pTC,
802 3144 : RscId(), nDeep, bExtra );
803 : }
804 : else
805 0 : aError = ERR_ERROR;
806 :
807 1048 : return aError;
808 : }
809 :
810 1048 : ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
811 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
812 : {
813 1048 : ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
814 :
815 1048 : if( this == rInst.pClass )
816 : {
817 : // nur wenn es eigen Klasse ist
818 1048 : aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra );
819 : }
820 1048 : return aError;
821 : }
822 :
823 1353 : RscTupel::RscTupel( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
824 1353 : : RscClass( nId, nTypeId, pSuper )
825 : {
826 1353 : }
827 :
828 6924 : RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
829 : const RSCINST & rInitInst )
830 : {
831 6924 : if( nPos >= nEntries )
832 : {
833 0 : return RSCINST();
834 : }
835 : else
836 6924 : return GetVariable( rInst, pVarTypeList[ nPos ].nVarName, rInitInst );
837 : }
838 :
839 1542 : void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput,
840 : RscTypCont * pTC, sal_uInt32 nTab,
841 : const char * pVarName )
842 : {
843 1542 : sal_uInt32 i = 0;
844 1542 : RSCINST aTmpI;
845 :
846 1542 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
847 :
848 1542 : fprintf( fOutput, "< " );
849 4638 : for( i = 0; i < nEntries; i++ )
850 : {
851 3096 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
852 : {
853 6192 : if( !IsDflt( rInst.pData, i )
854 3096 : && !IsValueDflt( rInst.pData, i ) )
855 : {
856 2360 : aTmpI = GetInstData( rInst.pData, i, true );
857 :
858 2360 : if( aTmpI.IsInst() )
859 : aTmpI.pClass->WriteSrcHeader(
860 2360 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
861 : else
862 0 : fprintf( fOutput, "Default" );
863 : }
864 : else
865 736 : fprintf( fOutput, "Default" );
866 3096 : fprintf( fOutput, "; " );
867 : };
868 : };
869 1542 : fprintf( fOutput, ">" );
870 :
871 1542 : return;
872 : }
873 :
874 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
