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