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 22207 : RscClass::RscClass( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
32 22207 : : RscTop( nId, nTypeId, pSuperCl )
33 : {
34 22207 : nEntries = 0;
35 22207 : pVarTypeList = NULL;
36 22207 : nSuperSize = RscTop::Size();
37 22207 : nSize = nSuperSize + ALIGNED_SIZE( sizeof( RscClassInst ) );
38 22207 : }
39 :
40 22207 : void RscClass::Pre_dtor()
41 : {
42 : sal_uInt32 i;
43 :
44 22207 : RscTop::Pre_dtor();
45 :
46 124443 : for( i = 0; i < nEntries; i++ )
47 : {
48 102236 : if( pVarTypeList[ i ].pDefault )
49 : {
50 1257 : pVarTypeList[ i ].pClass->Destroy(
51 419 : RSCINST( pVarTypeList[ i ].pClass,
52 1676 : pVarTypeList[ i ].pDefault ) );
53 419 : rtl_freeMemory( pVarTypeList[ i ].pDefault );
54 419 : pVarTypeList[ i ].pDefault = NULL;
55 : }
56 : }
57 22207 : }
58 :
59 64526 : RscClass::~RscClass()
60 : {
61 22207 : if( pVarTypeList )
62 20950 : rtl_freeMemory( (void *)pVarTypeList );
63 42319 : }
64 :
65 0 : RSCCLASS_TYPE RscClass::GetClassType() const
66 : {
67 0 : return RSCCLASS_COMPLEX;
68 : }
69 :
70 885340 : RSCINST RscClass::GetInstData
71 : (
72 : CLASS_DATA pData,
73 : sal_uInt32 nEle,
74 : bool bGetCopy
75 : )
76 : {
77 885340 : RSCINST aInst;
78 :
79 885340 : aInst.pClass = pVarTypeList[ nEle ].pClass;
80 885340 : if( pData )
81 : {
82 590558 : if( VAR_NODATAINST & pVarTypeList[ nEle ].nVarType )
83 : {
84 51836 : RSCINST aTmpI;
85 :
86 51836 : aTmpI.pClass = this;
87 51836 : aTmpI.pData = pData;
88 51836 : if( bGetCopy )
89 : aInst.pData = GetCopyVar(
90 : aTmpI,
91 51836 : pVarTypeList[ nEle ].nDataBaseName
92 103672 : ).pData;
93 : else
94 : aInst.pData = GetVariable(
95 : aTmpI,
96 0 : pVarTypeList[ nEle ].nDataBaseName,
97 : RSCINST()
98 0 : ).pData;
99 : }
100 538722 : else if( VAR_POINTER & pVarTypeList[ nEle ].nVarType )
101 : {
102 377971 : if( VAR_EXTENDABLE & pVarTypeList[ nEle ].nVarType )
103 0 : aInst = *(RSCINST *) (pData + pVarTypeList[ nEle ].nOffset);
104 : else
105 377971 : aInst.pData = *(CLASS_DATA *) (pData + pVarTypeList[ nEle ].nOffset);
106 : }
107 : else
108 160751 : aInst.pData = pData + pVarTypeList[ nEle ].nOffset;
109 : }
110 885340 : return aInst;
111 : }
112 :
113 61069 : CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle )
114 : {
115 61069 : if( pVarTypeList[ nEle ].pDefault )
116 45 : return pVarTypeList[ nEle ].pDefault;
117 :
118 61024 : return pVarTypeList[ nEle ].pClass->GetDefault().pData;
119 : }
120 :
121 190736 : void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, bool bSet )
122 : {
123 : RscClassInst * pClass;
124 :
125 190736 : pClass = (RscClassInst *)(pData + nSuperSize );
126 190736 : if( bSet )
127 49842 : pClass->nVarDflt |= ((sal_uLong)1 << nEle);
128 : else
129 140894 : pClass->nVarDflt &= ~((sal_uLong)1 << nEle);
130 190736 : }
131 :
132 296658 : bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
133 : {
134 : RscClassInst * pClass;
135 :
136 296658 : pClass = (RscClassInst *)(pData + nSuperSize );
137 296658 : return pClass->nVarDflt & ((sal_uLong)1 << nEle);
138 : }
139 :
140 93268 : RSCINST RscClass::Create( RSCINST * pInst,
141 : const RSCINST & rDflt,
142 : bool bOwnClass)
143 : {
144 : sal_uInt32 i;
145 93268 : RSCINST aInst;
146 93268 : RSCINST aMemInst, aDfltI;
147 :
148 93268 : if( !pInst )
149 : {
150 46878 : aInst.pClass = this;
151 46878 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
152 : }
153 : else
154 46390 : aInst = *pInst;
155 :
156 93268 : if( !bOwnClass && rDflt.IsInst() )
157 9 : bOwnClass = rDflt.pClass->InHierarchy( this );
158 :
159 93268 : RscTop::Create( &aInst, rDflt, bOwnClass );
160 :
161 93268 : if( bOwnClass )
162 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt =
163 9 : ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt;
164 : else
165 93259 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0);
166 :
167 388086 : for( i = 0; i < nEntries; i++ )
168 : {
169 294818 : aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, true );
170 :
171 500936 : if( (VAR_POINTER & pVarTypeList[ i ].nVarType) &&
172 206118 : !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
173 : {
174 : CLASS_DATA * ppData;
175 196896 : 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 196896 : ppData = (CLASS_DATA* ) (aInst.pData + pVarTypeList[ i ].nOffset );
183 :
184 196896 : *ppData = NULL;
185 196896 : if( aDfltI.IsInst() )
186 : {
187 0 : aMemInst = pVarTypeList[ i ].pClass->Create( NULL, aDfltI );
188 0 : *ppData = aMemInst.pData;
189 196896 : }
190 : }
191 : else
192 : {
193 97922 : aMemInst = GetInstData( aInst.pData, i, true );
194 97922 : aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
195 : }
196 : }
197 :
198 93268 : return aInst;
199 : }
200 :
201 93268 : void RscClass::Destroy( const RSCINST & rInst )
202 : {
203 : sal_uInt32 i;
204 :
205 93268 : RscTop::Destroy( rInst );
206 :
207 388086 : for( i = 0; i < nEntries; i++ )
208 : {
209 294818 : if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) )
210 : {
211 244976 : RSCINST aTmpI;
212 :
213 244976 : aTmpI = GetInstData( rInst.pData, i, true );
214 244976 : if( aTmpI.IsInst() )
215 : {
216 : // Objekt loeschen
217 108858 : aTmpI.pClass->Destroy( aTmpI );
218 108858 : if( pVarTypeList[ i ].nVarType & VAR_POINTER )
219 : {
220 : // Speicher freigeben
221 60778 : rtl_freeMemory( aTmpI.pData );
222 : }
223 : }
224 : }
225 : }
226 93268 : }
227 :
228 102236 : ERRTYPE RscClass::SetVariable( Atom nVarName,
229 : RscTop * pClass,
230 : RSCINST * pDflt,
231 : RSCVAR nVarType,
232 : sal_uInt32 nMask,
233 : Atom nDataBaseName)
234 : {
235 102236 : if( pVarTypeList )
236 : {
237 : pVarTypeList = (VARTYPE_STRUCT *) rtl_reallocateMemory( (void *)pVarTypeList,
238 81286 : ((nEntries +1) * sizeof( VARTYPE_STRUCT )) );
239 : }
240 : else
241 : {
242 20950 : pVarTypeList = (VARTYPE_STRUCT *) rtl_allocateMemory( ((nEntries +1)
243 20950 : * sizeof( VARTYPE_STRUCT )) );
244 : }
245 102236 : pVarTypeList[ nEntries ].nVarName = nVarName;
246 102236 : pVarTypeList[ nEntries ].nMask = nMask;
247 102236 : pVarTypeList[ nEntries ].pClass = pClass;
248 102236 : pVarTypeList[ nEntries ].nOffset = nSize;
249 102236 : pVarTypeList[ nEntries ].nDataBaseName = nDataBaseName;
250 102236 : if( pDflt )
251 419 : pVarTypeList[ nEntries ].pDefault = pDflt->pData;
252 : else
253 101817 : pVarTypeList[ nEntries ].pDefault = NULL;
254 :
255 102236 : pVarTypeList[ nEntries ].nVarType = ~VAR_POINTER & nVarType;
256 102236 : if( pClass->Size() > 10 || (nVarType & VAR_EXTENDABLE) )
257 66621 : pVarTypeList[ nEntries ].nVarType |= VAR_POINTER;
258 :
259 102236 : if( !(pVarTypeList[ nEntries ].nVarType & VAR_NODATAINST) )
260 : {
261 63688 : if( pVarTypeList[ nEntries ].nVarType & VAR_POINTER )
262 : {
263 34777 : if( pVarTypeList[ nEntries ].nVarType & VAR_EXTENDABLE )
264 0 : nSize += sizeof( RSCINST );
265 : else
266 34777 : nSize += sizeof( CLASS_DATA );
267 : }
268 : else
269 28911 : nSize += pClass->Size();
270 : }
271 :
272 102236 : nEntries++;
273 102236 : if( nEntries > (sizeof( sal_uLong ) * 8) )
274 : {
275 : // Bereich fuer Default zu klein
276 0 : RscExit( 16 );
277 : }
278 102236 : 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 161736 : RSCINST RscClass::GetVariable( const RSCINST & rInst,
294 : Atom nVarName,
295 : const RSCINST & rInitInst,
296 : bool bInitDflt,
297 : RscTop * pCreateClass)
298 : {
299 161736 : sal_uInt32 i = 0;
300 161736 : RSCINST aTmpI;
301 :
302 786875 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
303 463403 : i++;
304 :
305 161736 : if( i < nEntries )
306 : {
307 140894 : if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
308 : {
309 : aTmpI = GetVariable( rInst,
310 2003 : pVarTypeList[ i ].nDataBaseName,
311 4006 : RSCINST() );
312 2003 : aTmpI.pClass = pVarTypeList[ i ].pClass;
313 : }
314 : else
315 : {
316 : // Default Instanz generieren
317 138891 : RSCINST aDefInst = rInitInst;
318 138891 : if( !aDefInst.IsInst() && bInitDflt )
319 : {
320 : // mit dem Variablen-Default besetzen
321 49842 : aDefInst.pData = pVarTypeList[ i ].pDefault;
322 49842 : aDefInst.pClass = pVarTypeList[ i ].pClass;
323 : }
324 :
325 138891 : aTmpI = GetInstData( rInst.pData, i );
326 138891 : if( aTmpI.IsInst() )
327 : {
328 78113 : 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 60778 : 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 60778 : = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset);
350 60778 : aTmpI = aTmpI.pClass->Create( NULL, aDefInst );
351 60778 : *ppData = aTmpI.pData;
352 : }
353 : }
354 : }
355 : // auf nicht Default setzen
356 140894 : SetVarDflt( rInst.pData, i, false );
357 140894 : return aTmpI;
358 : }
359 :
360 : return RscTop::GetVariable( rInst, nVarName, rInitInst,
361 20842 : bInitDflt, pCreateClass );
362 : }
363 :
364 65089 : RSCINST RscClass::GetCopyVar( const RSCINST & rInst, Atom nVarName)
365 : {
366 65089 : sal_uInt32 i = 0;
367 65089 : RSCINST aVarI;
368 :
369 296951 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
370 166773 : i++;
371 :
372 65089 : if( i < nEntries )
373 : {
374 52843 : 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 52843 : if( IsDflt( rInst.pData, i ) )
382 : {
383 : // mit Variablen Default initialiaieren
384 49842 : aVarI = GetVariable( rInst, nVarName, RSCINST(), true );
385 49842 : SetVarDflt( rInst.pData, i, true );
386 : }
387 : else
388 3001 : aVarI = GetInstData( rInst.pData, i, true );
389 :
390 : }
391 52843 : return aVarI ;
392 : }
393 :
394 12246 : 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 33202 : bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
482 : {
483 33202 : RSCINST aTmpI;
484 :
485 33202 : aTmpI = GetInstData( pData, nEle, true );
486 :
487 33202 : if( aTmpI.IsInst() )
488 : {
489 33202 : if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
490 588 : return false;
491 :
492 32614 : if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
493 : //sie haben auch die gleiche Klasse
494 32614 : return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
495 : else
496 0 : return false;
497 : }
498 0 : return true;
499 : }
500 :
501 1303 : bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
502 : {
503 1303 : RSCINST aTmpI;
504 1303 : RSCINST aDfltI;
505 :
506 1303 : if( !RscTop::IsValueDefault( rInst, pDef ) )
507 1 : return false;
508 :
509 1302 : if( pDef )
510 : {
511 2632 : for( sal_uInt32 i = 0; i < nEntries; i++ )
512 : {
513 1977 : aTmpI = GetInstData( rInst.pData, i, true );
514 1977 : if( aTmpI.IsInst() )
515 : {
516 687 : if( aTmpI.pClass != pVarTypeList[ i ].pClass )
517 : //sie haben nicht die gleiche Klasse
518 0 : return false;
519 :
520 687 : aDfltI = GetInstData( pDef, i, true );
521 687 : if( !aDfltI.IsInst() )
522 639 : aDfltI.pData = GetDfltData( i );
523 :
524 687 : if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
525 647 : return false;
526 : }
527 : }
528 : }
529 : else
530 0 : return false;
531 :
532 655 : 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 44048 : void RscClass::WriteSrc( const RSCINST & rInst,
560 : FILE * fOutput,
561 : RscTypCont * pTC,
562 : sal_uInt32 nTab,
563 : const char * pVarName)
564 : {
565 44048 : sal_uInt32 i = 0, n = 0;
566 44048 : RSCINST aTmpI;
567 :
568 44048 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
569 :
570 184918 : for( i = 0; i < nEntries; i++ )
571 : {
572 140870 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
573 : {
574 : // Hack wegen Position und Dimensiuon
575 272227 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName ||
576 135932 : nRsc_WHMAPMODEId == pVarTypeList[ i ].nVarName )
577 : {
578 1543 : if( !IsDflt( rInst.pData, i ) || // MapUnit
579 817 : !IsDflt( rInst.pData, i+1 ) || //X, Width
580 91 : !IsDflt( rInst.pData, i+2 ) ) //Y, Height
581 : {
582 : // ein Wert ist nicht Default
583 1809 : for( n = 0; n < nTab; n++ )
584 1174 : fputc( '\t', fOutput );
585 :
586 635 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName )
587 299 : fprintf( fOutput, "Pos = " );
588 : else
589 336 : fprintf( fOutput, "Size = " );
590 :
591 635 : if( !IsDflt( rInst.pData, i ) )
592 : {
593 635 : aTmpI = GetInstData( rInst.pData, i, true );
594 : aTmpI.pClass->WriteSrcHeader(
595 635 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
596 : }
597 :
598 635 : fprintf( fOutput, "( " );
599 635 : aTmpI = GetInstData( rInst.pData, i+1, true );
600 635 : if( !aTmpI.IsInst() )
601 0 : aTmpI.pData = GetDfltData( i+1 );
602 :
603 635 : aTmpI.pClass->WriteSrcHeader( aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
604 :
605 635 : fprintf( fOutput, ", " );
606 635 : aTmpI = GetInstData( rInst.pData, i+2, true );
607 :
608 635 : if( !aTmpI.IsInst() )
609 0 : aTmpI.pData = GetDfltData( i+2 );
610 :
611 : aTmpI.pClass->WriteSrcHeader(
612 635 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
613 635 : fprintf( fOutput, " );\n" );
614 : }
615 726 : i += 2; //_X, _Y oder _Width, Height ueberlesen
616 : }
617 271138 : else if( !IsDflt( rInst.pData, i )
618 135569 : && !IsValueDflt( rInst.pData, i ) )
619 : {
620 30388 : aTmpI = GetInstData( rInst.pData, i, true );
621 :
622 30388 : if( aTmpI.IsInst() )
623 : {
624 30388 : const char * pName = pHS->getString( pVarTypeList[ i ].nVarName ).getStr();
625 :
626 111227 : for( n = 0; n < nTab; n++ )
627 80839 : fputc( '\t', fOutput );
628 :
629 30388 : fprintf( fOutput, "%s", pName );
630 30388 : fprintf( fOutput, " = " );
631 : aTmpI.pClass->WriteSrcHeader(
632 30388 : aTmpI, fOutput, pTC, nTab, RscId(), pName );
633 30388 : fprintf( fOutput, ";\n" );
634 : }
635 : }
636 : }
637 : }
638 :
639 44048 : return;
640 : }
641 :
642 1270 : sal_Int32 RscClass::GetCorrectValues( const RSCINST & rInst,
643 : sal_uInt32 nVarPos,
644 : sal_uInt32 nTupelIdx,
645 : RscTypCont * pTC)
646 : {
647 1270 : sal_Int32 nLang = 0;
648 : sal_Int32 nBaseValue;
649 :
650 : // Basiswert holen
651 1270 : RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, true );
652 1270 : aTmpI.pClass->GetNumber( aTmpI, &nBaseValue );
653 :
654 : // Sprach Delta holen
655 1270 : aTmpI = rInst.pClass->GetVariable( rInst, nRsc_DELTALANG, RSCINST() );
656 1270 : if( aTmpI.IsInst() )
657 : {
658 1270 : RscWriteRc aMem;
659 1270 : aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, false );
660 1270 : nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
661 : }
662 :
663 1270 : return nLang + nBaseValue;
664 : }
665 :
666 47602 : ERRTYPE RscClass::WriteInstRc( const RSCINST & rInst,
667 : RscWriteRc & rMem,
668 : RscTypCont * pTC,
669 : sal_uInt32 nDeep,
670 : bool bExtra)
671 : {
672 47602 : sal_uInt32 i = 0;
673 47602 : ERRTYPE aError;
674 47602 : RSCINST aTmpI;
675 47602 : sal_uInt32 nMaskOff = 0;// Offset um Maskenfeld zu addressieren
676 :
677 : // Wenn eine Variable Maskierung hat, dann Maskenfeld
678 123486 : for( i = 0; i < nEntries; i++ )
679 : {
680 81374 : if( pVarTypeList[ i ].nMask )
681 : {
682 5490 : nMaskOff = rMem.Size();
683 5490 : rMem.Put( sal_uInt32(0) );
684 5490 : break;
685 : }
686 : }
687 :
688 199465 : for( i = 0; i < nEntries && aError.IsOk(); i++ )
689 : {
690 151863 : if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
691 : {
692 103676 : if( pVarTypeList[ i ].nMask )
693 : {
694 55370 : if( !IsDflt( rInst.pData, i ) )
695 : {
696 14738 : if( nRsc_X == pVarTypeList[ i ].nVarName )
697 : {
698 299 : sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC );
699 299 : rMem.Put( nVal );
700 : }
701 14439 : else if( nRsc_Y == pVarTypeList[ i ].nVarName )
702 : {
703 299 : sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC );
704 299 : rMem.Put( nVal );
705 : }
706 14140 : else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
707 : {
708 336 : sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC );
709 336 : rMem.Put( nVal );
710 : }
711 13804 : else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
712 : {
713 336 : sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC );
714 336 : rMem.Put( nVal );
715 : }
716 : else
717 : {
718 13468 : aTmpI = GetInstData( rInst.pData, i, true );
719 : // Nur an Variable Extradata bExtra nicht auf false
720 : // setzen
721 40404 : aError = aTmpI.pClass->
722 : WriteRcHeader( aTmpI, rMem, pTC,
723 : RscId(), nDeep,
724 26936 : (nRsc_EXTRADATA == pVarTypeList[ i ].nVarName) && bExtra );
725 : }
726 14738 : sal_uInt32 nMask = rMem.GetLong( nMaskOff );
727 14738 : nMask |= pVarTypeList[ i ].nMask;
728 14738 : rMem.PutAt( nMaskOff, nMask );
729 : }
730 : }
731 : else
732 : {
733 48306 : if( IsDflt( rInst.pData, i ) )
734 : {
735 27816 : aTmpI.pClass = pVarTypeList[ i ].pClass;
736 27816 : aTmpI.pData = GetDfltData( i );
737 : }
738 : else
739 20490 : aTmpI = GetInstData( rInst.pData, i, true );
740 :
741 : // Nur an Variable Extradata bExtra nicht auf false
742 : // setzen
743 144918 : aError = aTmpI.pClass->
744 : WriteRcHeader( aTmpI, rMem, pTC,
745 : RscId(), nDeep,
746 96612 : (nRsc_EXTRADATA == pVarTypeList[ i ].nVarName) && bExtra );
747 : }
748 : }
749 : }
750 :
751 47602 : return aError;
752 : }
753 :
754 25706 : ERRTYPE RscClass::WriteRc( const RSCINST & rInst,
755 : RscWriteRc & rMem,
756 : RscTypCont * pTC,
757 : sal_uInt32 nDeep,
758 : bool bExtra)
759 : {
760 25706 : ERRTYPE aError;
761 :
762 25706 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
763 25706 : if( aError.IsOk() )
764 25706 : aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
765 :
766 25706 : return aError;
767 : }
768 :
769 419 : RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
770 419 : : RscClass( nId, nTypeId, pSuper )
771 : {
772 419 : }
773 :
774 1007 : ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
775 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra, bool bFirst )
776 : {
777 1007 : ERRTYPE aError;
778 1007 : RSCINST aFileName;
779 :
780 : //Instanz mit dem Dateinamen "FILENAME" holen
781 1007 : aFileName = RscClass::GetCopyVar( rInst, pHS->getID( "FILE", true ) );
782 1007 : if( aFileName.IsInst() )
783 : {
784 1007 : RscWriteRc aTmpMem;
785 3021 : aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC,
786 2014 : RscId(), nDeep, bExtra );
787 : // Obsolete - need changes in VCL
788 1007 : rMem.Put( sal_uInt32(0) );
789 :
790 : // Identifier schreiben
791 1007 : sal_uInt32 nId = 0xFFFFFFFF;
792 1007 : if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') )
793 : {
794 : nId = pTC->PutSysName( rInst.pClass->GetTypId(),
795 : aTmpMem.GetUTF8( 0 ),
796 1007 : 0, 0, bFirst );
797 : }
798 1007 : rMem.Put( nId );
799 3021 : aError = aFileName.pClass->WriteRcHeader( aFileName, rMem, pTC,
800 3021 : RscId(), nDeep, bExtra );
801 : }
802 : else
803 0 : aError = ERR_ERROR;
804 :
805 1007 : return aError;
806 : }
807 :
808 1007 : ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
809 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
810 : {
811 1007 : ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
812 :
813 1007 : if( this == rInst.pClass )
814 : {
815 : // nur wenn es eigen Klasse ist
816 1007 : aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra );
817 : }
818 1007 : return aError;
819 : }
820 :
821 1257 : RscTupel::RscTupel( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
822 1257 : : RscClass( nId, nTypeId, pSuper )
823 : {
824 1257 : }
825 :
826 6745 : RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
827 : const RSCINST & rInitInst )
828 : {
829 6745 : if( nPos >= nEntries )
830 : {
831 0 : return RSCINST();
832 : }
833 : else
834 6745 : return GetVariable( rInst, pVarTypeList[ nPos ].nVarName, rInitInst );
835 : }
836 :
837 1506 : void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput,
838 : RscTypCont * pTC, sal_uInt32 nTab,
839 : const char * pVarName )
840 : {
841 1506 : sal_uInt32 i = 0;
842 1506 : RSCINST aTmpI;
843 :
844 1506 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
845 :
846 1506 : fprintf( fOutput, "< " );
847 4530 : for( i = 0; i < nEntries; i++ )
848 : {
849 3024 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
850 : {
851 6048 : if( !IsDflt( rInst.pData, i )
852 3024 : && !IsValueDflt( rInst.pData, i ) )
853 : {
854 2309 : aTmpI = GetInstData( rInst.pData, i, true );
855 :
856 2309 : if( aTmpI.IsInst() )
857 : aTmpI.pClass->WriteSrcHeader(
858 2309 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
859 : else
860 0 : fprintf( fOutput, "Default" );
861 : }
862 : else
863 715 : fprintf( fOutput, "Default" );
864 3024 : fprintf( fOutput, "; " );
865 : }
866 : }
867 1506 : fprintf( fOutput, ">" );
868 :
869 1506 : return;
870 : }
871 :
872 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
