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