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 : /****************** I N C L U D E S **************************************/
21 :
22 : // C and C++ Includes.
23 : #include <stdlib.h>
24 : #include <stdio.h>
25 : #include <string.h>
26 :
27 : // Programmabhaengige Includes.
28 : #include <rscdb.hxx>
29 : #include <rscclass.hxx>
30 :
31 : #include <tools/fsys.hxx>
32 : #include <tools/rcid.h>
33 : #include <tools/rc.h>
34 :
35 : /****************** C O D E **********************************************/
36 : /****************** R s c C l a s s **************************************/
37 : /*************************************************************************
38 : |*
39 : |* RscClass::RscClass()
40 : |*
41 : *************************************************************************/
42 69100 : RscClass::RscClass( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
43 69100 : : RscTop( nId, nTypeId, pSuperCl )
44 : {
45 69100 : nEntries = 0;
46 69100 : pVarTypeList = NULL;
47 69100 : nSuperSize = RscTop::Size();
48 69100 : nSize = nSuperSize + ALIGNED_SIZE( sizeof( RscClassInst ) );
49 69100 : }
50 :
51 : /*************************************************************************
52 : |*
53 : |* RscClass::Pre_dtor()
54 : |*
55 : *************************************************************************/
56 69100 : void RscClass::Pre_dtor()
57 : {
58 : sal_uInt32 i;
59 :
60 69100 : RscTop::Pre_dtor();
61 :
62 304731 : for( i = 0; i < nEntries; i++ )
63 : {
64 235631 : if( pVarTypeList[ i ].pDefault )
65 : {
66 8292 : pVarTypeList[ i ].pClass->Destroy(
67 2764 : RSCINST( pVarTypeList[ i ].pClass,
68 11056 : pVarTypeList[ i ].pDefault ) );
69 2764 : rtl_freeMemory( pVarTypeList[ i ].pDefault );
70 2764 : pVarTypeList[ i ].pDefault = NULL;
71 : };
72 : };
73 69100 : }
74 :
75 : /*************************************************************************
76 : |*
77 : |* RscClass::~RscClass()
78 : |*
79 : *************************************************************************/
80 203845 : RscClass::~RscClass()
81 : {
82 69100 : if( pVarTypeList )
83 52516 : rtl_freeMemory( (void *)pVarTypeList );
84 134745 : }
85 :
86 : /*************************************************************************
87 : |*
88 : |* RscClass::GetClassType()
89 : |*
90 : *************************************************************************/
91 0 : RSCCLASS_TYPE RscClass::GetClassType() const
92 : {
93 0 : return RSCCLASS_COMPLEX;
94 : }
95 :
96 : /*************************************************************************
97 : |*
98 : |* RscClass::GetInstData()
99 : |*
100 : *************************************************************************/
101 2987367 : RSCINST RscClass::GetInstData
102 : (
103 : CLASS_DATA pData,
104 : sal_uInt32 nEle,
105 : sal_Bool bGetCopy
106 : )
107 : {
108 2987367 : RSCINST aInst;
109 :
110 2987367 : aInst.pClass = pVarTypeList[ nEle ].pClass;
111 2987367 : if( pData )
112 : {
113 2070897 : if( VAR_NODATAINST & pVarTypeList[ nEle ].nVarType )
114 : {
115 322539 : RSCINST aTmpI;
116 :
117 322539 : aTmpI.pClass = this;
118 322539 : aTmpI.pData = pData;
119 322539 : if( bGetCopy )
120 : aInst.pData = GetCopyVar(
121 : aTmpI,
122 322539 : pVarTypeList[ nEle ].nDataBaseName
123 645078 : ).pData;
124 : else
125 : aInst.pData = GetVariable(
126 : aTmpI,
127 0 : pVarTypeList[ nEle ].nDataBaseName,
128 : RSCINST()
129 0 : ).pData;
130 : }
131 1748358 : else if( VAR_POINTER & pVarTypeList[ nEle ].nVarType )
132 : {
133 863496 : if( VAR_EXTENDABLE & pVarTypeList[ nEle ].nVarType )
134 : aInst = *(RSCINST *)
135 0 : (pData + pVarTypeList[ nEle ].nOffset);
136 : else
137 : aInst.pData = *(CLASS_DATA *)
138 863496 : (pData + pVarTypeList[ nEle ].nOffset);
139 : }
140 : else
141 884862 : aInst.pData = pData + pVarTypeList[ nEle ].nOffset;
142 : };
143 2987367 : return( aInst );
144 : }
145 :
146 : /*************************************************************************
147 : |*
148 : |* RscClass::GetInstDflt()
149 : |*
150 : |* Beschreibung
151 : |*
152 : *************************************************************************/
153 242454 : CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle )
154 : {
155 242454 : if( pVarTypeList[ nEle ].pDefault )
156 701 : return pVarTypeList[ nEle ].pDefault;
157 :
158 241753 : return pVarTypeList[ nEle ].pClass->GetDefault().pData;
159 : }
160 :
161 : /*************************************************************************
162 : |*
163 : |* RscClass::SetVarDflt()
164 : |*
165 : *************************************************************************/
166 893593 : void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, sal_Bool bSet )
167 : {
168 : RscClassInst * pClass;
169 :
170 893593 : pClass = (RscClassInst *)(pData + nSuperSize );
171 893593 : if( bSet )
172 297492 : pClass->nVarDflt |= ((sal_uLong)1 << nEle);
173 : else
174 596101 : pClass->nVarDflt &= ~((sal_uLong)1 << nEle);
175 893593 : }
176 :
177 : /*************************************************************************
178 : |*
179 : |* RscClass::IsDflt()
180 : |*
181 : *************************************************************************/
182 1114607 : sal_Bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
183 : {
184 : RscClassInst * pClass;
185 : sal_Bool bRet;
186 :
187 1114607 : pClass = (RscClassInst *)(pData + nSuperSize );
188 1114607 : if( pClass->nVarDflt & ((sal_uLong)1 << nEle) )
189 890546 : bRet = sal_True;
190 : else
191 224061 : bRet = sal_False;
192 1114607 : return bRet;
193 : }
194 :
195 : /*************************************************************************
196 : |*
197 : |* RscClass::Create()
198 : |*
199 : *************************************************************************/
200 183341 : RSCINST RscClass::Create
201 : (
202 : RSCINST * pInst,
203 : const RSCINST & rDflt,
204 : sal_Bool bOwnClass
205 : )
206 : {
207 : sal_uInt32 i;
208 : CLASS_DATA * ppData;
209 183341 : RSCINST aInst;
210 183341 : RSCINST aMemInst, aDfltI;
211 :
212 183341 : if( !pInst )
213 : {
214 65762 : aInst.pClass = this;
215 65762 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
216 : }
217 : else
218 117579 : aInst = *pInst;
219 183341 : if( !bOwnClass && rDflt.IsInst() )
220 275 : bOwnClass = rDflt.pClass->InHierarchy( this );
221 :
222 183341 : RscTop::Create( &aInst, rDflt, bOwnClass );
223 :
224 183341 : if( bOwnClass )
225 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt =
226 728 : ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt;
227 : else
228 182613 : ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0);
229 :
230 1103877 : for( i = 0; i < nEntries; i++ )
231 : {
232 920536 : aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, sal_True );
233 :
234 1490811 : if( (VAR_POINTER & pVarTypeList[ i ].nVarType)
235 570275 : && !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
236 : {
237 351171 : if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
238 : {
239 : RSCINST * pInstance = (RSCINST *)
240 0 : (aInst.pData + pVarTypeList[ i ].nOffset );
241 0 : pInstance->pClass = pVarTypeList[ i ].pClass;
242 0 : ppData = &pInstance->pData;
243 : }
244 : else
245 : ppData = (CLASS_DATA* )
246 351171 : (aInst.pData + pVarTypeList[ i ].nOffset );
247 351171 : *ppData = NULL;
248 351171 : if( aDfltI.IsInst() )
249 : {
250 432 : aMemInst = pVarTypeList[ i ].pClass->Create( NULL, aDfltI );
251 432 : *ppData = aMemInst.pData;
252 351171 : };
253 : }
254 : else
255 : {
256 569365 : aMemInst = GetInstData( aInst.pData, i, sal_True );
257 569365 : aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
258 : };
259 : }
260 :
261 183341 : return( aInst );
262 : }
263 :
264 : /*************************************************************************
265 : |*
266 : |* RscClass::Destroy()
267 : |*
268 : |* Beschreibung
269 : |*
270 : *************************************************************************/
271 183341 : void RscClass::Destroy( const RSCINST & rInst )
272 : {
273 : sal_uInt32 i;
274 :
275 183341 : RscTop::Destroy( rInst );
276 :
277 1103877 : for( i = 0; i < nEntries; i++ )
278 : {
279 920536 : if( !(pVarTypeList[ i ].nVarType & VAR_NODATAINST) )
280 : {
281 622986 : RSCINST aTmpI;
282 :
283 622986 : aTmpI = GetInstData( rInst.pData, i, sal_True );
284 622986 : if( aTmpI.IsInst() )
285 : {
286 : // Objekt loeschen
287 372678 : aTmpI.pClass->Destroy( aTmpI );
288 372678 : if( pVarTypeList[ i ].nVarType & VAR_POINTER )
289 : {
290 : // Speicher freigeben
291 100863 : rtl_freeMemory( aTmpI.pData );
292 : };
293 : };
294 : }
295 : };
296 183341 : }
297 :
298 : /*************************************************************************
299 : |*
300 : |* RscClass::SetVariable()
301 : |*
302 : |* Beschreibung
303 : |*
304 : *************************************************************************/
305 235631 : ERRTYPE RscClass::SetVariable
306 : (
307 : Atom nVarName,
308 : RscTop * pClass,
309 : RSCINST * pDflt,
310 : RSCVAR nVarType,
311 : sal_uInt32 nMask,
312 : Atom nDataBaseName
313 : )
314 : {
315 235631 : if( pVarTypeList )
316 : pVarTypeList = (VARTYPE_STRUCT *)
317 : rtl_reallocateMemory( (void *)pVarTypeList,
318 183115 : ((nEntries +1) * sizeof( VARTYPE_STRUCT )) );
319 : else
320 : pVarTypeList = (VARTYPE_STRUCT *)
321 : rtl_allocateMemory( ((nEntries +1)
322 52516 : * sizeof( VARTYPE_STRUCT )) );
323 :
324 235631 : pVarTypeList[ nEntries ].nVarName = nVarName;
325 235631 : pVarTypeList[ nEntries ].nMask = nMask;
326 235631 : pVarTypeList[ nEntries ].pClass = pClass;
327 235631 : pVarTypeList[ nEntries ].nOffset = nSize;
328 235631 : pVarTypeList[ nEntries ].nDataBaseName = nDataBaseName;
329 235631 : if( pDflt )
330 2764 : pVarTypeList[ nEntries ].pDefault = pDflt->pData;
331 : else
332 232867 : pVarTypeList[ nEntries ].pDefault = NULL;
333 :
334 235631 : pVarTypeList[ nEntries ].nVarType = ~VAR_POINTER & nVarType;
335 235631 : if( pClass->Size() > 10 || (nVarType & VAR_EXTENDABLE) )
336 125071 : pVarTypeList[ nEntries ].nVarType |= VAR_POINTER;
337 :
338 235631 : if( !(pVarTypeList[ nEntries ].nVarType & VAR_NODATAINST) )
339 : {
340 158930 : if( pVarTypeList[ nEntries ].nVarType & VAR_POINTER )
341 : {
342 59426 : if( pVarTypeList[ nEntries ].nVarType & VAR_EXTENDABLE )
343 0 : nSize += sizeof( RSCINST );
344 : else
345 59426 : nSize += sizeof( CLASS_DATA );
346 : }
347 : else
348 99504 : nSize += pClass->Size();
349 : }
350 :
351 235631 : nEntries++;
352 235631 : if( nEntries > (sizeof( sal_uLong ) * 8) )
353 : {
354 : // Bereich fuer Default zu klein
355 0 : RscExit( 16 );
356 : };
357 235631 : return( ERR_OK );
358 : }
359 :
360 : /*************************************************************************
361 : |*
362 : |* RscClass::EnumVariable()
363 : |*
364 : |* Beschreibung
365 : |*
366 : *************************************************************************/
367 0 : void RscClass::EnumVariables( void * pData, VarEnumCallbackProc pProc )
368 : {
369 : sal_uInt32 i;
370 :
371 0 : RscTop::EnumVariables( pData, pProc );
372 0 : for( i = 0; i < nEntries; i ++ )
373 : {
374 0 : if( !(pVarTypeList[ i ].nVarType & VAR_NOENUM) )
375 0 : (*pProc)( pData, pVarTypeList[ i ].pClass->GetClassType(),
376 0 : pVarTypeList[ i ].nVarName );
377 : }
378 0 : }
379 :
380 : /*************************************************************************
381 : |*
382 : |* RscClass::GetVariable()
383 : |*
384 : |* Beschreibung
385 : |*
386 : *************************************************************************/
387 1091492 : RSCINST RscClass::GetVariable
388 : (
389 : const RSCINST & rInst,
390 : Atom nVarName,
391 : const RSCINST & rInitInst,
392 : sal_Bool bInitDflt,
393 : RscTop * pCreateClass
394 : )
395 : {
396 1091492 : sal_uInt32 i = 0;
397 1091492 : RSCINST aTmpI;
398 :
399 6986606 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
400 4803622 : i++;
401 1091492 : if( i < nEntries )
402 : {
403 596101 : if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
404 : {
405 : aTmpI = GetVariable( rInst,
406 23425 : pVarTypeList[ i ].nDataBaseName,
407 46850 : RSCINST() );
408 23425 : aTmpI.pClass = pVarTypeList[ i ].pClass;
409 : }
410 : else
411 : {
412 : // Default Instanz generieren
413 572676 : RSCINST aDefInst = rInitInst;
414 572676 : if( !aDefInst.IsInst() && bInitDflt )
415 : {
416 : // mit dem Variablen-Default besetzen
417 297492 : aDefInst.pData = pVarTypeList[ i ].pDefault;
418 297492 : aDefInst.pClass = pVarTypeList[ i ].pClass;
419 : }
420 :
421 572676 : aTmpI = GetInstData( rInst.pData, i );
422 572676 : if( aTmpI.IsInst() )
423 : {
424 472245 : if( aDefInst.IsInst() )
425 : {
426 0 : aTmpI.pClass->Destroy( aTmpI );
427 0 : aTmpI.pClass->Create( &aTmpI, aDefInst );
428 : }
429 : }
430 : else
431 : { // Wird ueber Zeiger angegeben
432 100431 : if( VAR_EXTENDABLE & pVarTypeList[ i ].nVarType )
433 : {
434 : RSCINST * pInst = (RSCINST *)
435 0 : (rInst.pData + pVarTypeList[ i ].nOffset );
436 0 : if( pCreateClass && pCreateClass->InHierarchy( aTmpI.pClass ) )
437 0 : *pInst = pCreateClass->Create( NULL, aDefInst );
438 : else
439 0 : *pInst = aTmpI.pClass->Create( NULL, aDefInst );
440 0 : aTmpI = *pInst;
441 : }
442 : else
443 : {
444 : CLASS_DATA * ppData
445 100431 : = (CLASS_DATA *)(rInst.pData + pVarTypeList[ i ].nOffset);
446 100431 : aTmpI = aTmpI.pClass->Create( NULL, aDefInst );
447 100431 : *ppData = aTmpI.pData;
448 : }
449 : }
450 : };
451 : // auf nicht Default setzen
452 596101 : SetVarDflt( rInst.pData, i, sal_False );
453 596101 : return( aTmpI );
454 : };
455 :
456 : return( RscTop::GetVariable( rInst, nVarName, rInitInst,
457 495391 : bInitDflt, pCreateClass ) );
458 : }
459 :
460 : /*************************************************************************
461 : |*
462 : |* RscClass::GetCopyVar()
463 : |*
464 : |* Beschreibung
465 : |*
466 : *************************************************************************/
467 597276 : RSCINST RscClass::GetCopyVar
468 : (
469 : const RSCINST & rInst,
470 : Atom nVarName
471 : )
472 : {
473 597276 : sal_uInt32 i = 0;
474 597276 : RSCINST aVarI;
475 :
476 3047506 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
477 1852954 : i++;
478 :
479 597276 : if( i < nEntries )
480 : {
481 323530 : if( VAR_NODATAINST & pVarTypeList[ i ].nVarType )
482 : {
483 0 : aVarI = GetCopyVar( rInst, pVarTypeList[ i ].nDataBaseName );
484 0 : aVarI.pClass = pVarTypeList[ i ].pClass;
485 : }
486 : else
487 : {
488 323530 : if( IsDflt( rInst.pData, i ) )
489 : {
490 : // mit Variablen Default initialiaieren
491 297492 : aVarI = GetVariable( rInst, nVarName, RSCINST(), sal_True );
492 297492 : SetVarDflt( rInst.pData, i, sal_True );
493 : }
494 : else
495 26038 : aVarI = GetInstData( rInst.pData, i, sal_True );
496 :
497 : };
498 323530 : return aVarI ;
499 : };
500 :
501 273746 : return RscTop::GetCopyVar( rInst, nVarName );
502 : }
503 :
504 : /*************************************************************************
505 : |*
506 : |* RscClass::IsConsistent()
507 : |*
508 : |* Beschreibung
509 : |*
510 : *************************************************************************/
511 0 : sal_Bool RscClass::IsConsistent( const RSCINST & rInst )
512 : {
513 0 : sal_uInt32 i = 0;
514 0 : RSCINST aTmpI;
515 : sal_Bool bRet;
516 :
517 0 : bRet = RscTop::IsConsistent( rInst );
518 :
519 0 : for( i = 0; i < nEntries; i++ )
520 : {
521 0 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
522 : {
523 0 : aTmpI = GetInstData( rInst.pData, i, sal_True );
524 :
525 0 : if( aTmpI.IsInst() )
526 0 : if( ! aTmpI.pClass->IsConsistent( aTmpI ) )
527 0 : bRet = sal_False;
528 : }
529 : };
530 :
531 0 : return( bRet );
532 : }
533 :
534 : /*************************************************************************
535 : |*
536 : |* RscClass::SetToDefault()
537 : |*
538 : |* Beschreibung
539 : |*
540 : *************************************************************************/
541 43 : void RscClass::SetToDefault( const RSCINST & rInst )
542 : {
543 : sal_uInt32 i;
544 43 : RSCINST aTmpI;
545 : RscClassInst * pClass;
546 :
547 43 : pClass = (RscClassInst *)(rInst.pData + nSuperSize );
548 :
549 147 : for( i = 0; i < nEntries; i++ )
550 : {
551 : // Variablen ohne eigenen Speicher werden vom "Datenserver"
552 : // auf Default gesetzt
553 104 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
554 : {
555 104 : aTmpI = GetInstData( rInst.pData, i, sal_True );
556 104 : if( aTmpI.IsInst() )
557 104 : aTmpI.pClass->SetToDefault( aTmpI );
558 : }
559 : }
560 43 : pClass->nVarDflt = ~((sal_uLong)0); // alles auf Default
561 :
562 43 : RscTop::SetToDefault( rInst );
563 43 : }
564 :
565 : /*************************************************************************
566 : |*
567 : |* RscClass::IsDefault()
568 : |*
569 : |* Beschreibung
570 : |*
571 : *************************************************************************/
572 3 : sal_Bool RscClass::IsDefault( const RSCINST & rInst )
573 : {
574 : sal_uInt32 i;
575 3 : RSCINST aTmpI;
576 :
577 3 : for( i = 0; i < nEntries; i++ )
578 : {
579 : // Variablen ohne eigenen Speicher werden vom "Datenserver"
580 : // auf Default untersucht
581 3 : if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
582 3 : if( !IsDflt( rInst.pData, i ) )
583 3 : return( sal_False );
584 : };
585 :
586 0 : return( RscTop::IsDefault( rInst ) );
587 : }
588 :
589 : /*************************************************************************
590 : |*
591 : |* RscClass::GetDefault()
592 : |*
593 : |* Beschreibung
594 : |*
595 : *************************************************************************/
596 0 : RSCINST RscClass::GetDefault( Atom nVarId )
597 : {
598 : sal_uInt32 i;
599 :
600 0 : i = 0;
601 0 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarId )
602 0 : i++;
603 0 : if( i < nEntries )
604 : {
605 0 : RSCINST aTmpI;
606 :
607 0 : aTmpI.pClass = pVarTypeList[ i ].pClass;
608 0 : aTmpI.pData = GetDfltData( i );
609 0 : return( aTmpI );
610 : };
611 :
612 0 : return( RscTop::GetDefault( nVarId ) );
613 : }
614 :
615 : /*************************************************************************
616 : |*
617 : |* RscClass::IsValueDflt()
618 : |*
619 : |* Beschreibung
620 : |*
621 : *************************************************************************/
622 58487 : sal_Bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
623 : {
624 58487 : RSCINST aTmpI;
625 :
626 58487 : aTmpI = GetInstData( pData, nEle, sal_True );
627 :
628 58487 : if( aTmpI.IsInst() )
629 : {
630 58487 : if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
631 734 : return sal_False;
632 :
633 57753 : if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
634 : //sie haben auch die gleiche Klasse
635 57753 : return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
636 : else
637 0 : return sal_False;
638 : }
639 0 : return sal_True;
640 : }
641 :
642 : /*************************************************************************
643 : |*
644 : |* RscClass::IsValueDefault()
645 : |*
646 : |* Beschreibung
647 : |*
648 : *************************************************************************/
649 1758 : sal_Bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
650 : {
651 1758 : RSCINST aTmpI;
652 1758 : RSCINST aDfltI;
653 :
654 1758 : if( !RscTop::IsValueDefault( rInst, pDef ) )
655 4 : return sal_False;
656 :
657 1754 : if( pDef )
658 : {
659 3550 : for( sal_uInt32 i = 0; i < nEntries; i++ )
660 : {
661 2668 : aTmpI = GetInstData( rInst.pData, i, sal_True );
662 2668 : if( aTmpI.IsInst() )
663 : {
664 919 : if( aTmpI.pClass != pVarTypeList[ i ].pClass )
665 : //sie haben nicht die gleiche Klasse
666 0 : return sal_False;
667 :
668 919 : aDfltI = GetInstData( pDef, i, sal_True );
669 919 : if( !aDfltI.IsInst() )
670 845 : aDfltI.pData = GetDfltData( i );
671 :
672 919 : if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
673 872 : return sal_False;
674 : }
675 : }
676 : }
677 : else
678 0 : return sal_False;
679 :
680 882 : return sal_True;
681 : }
682 :
683 : /*************************************************************************
684 : |*
685 : |* RscClass::SetDefault()
686 : |*
687 : |* Beschreibung
688 : |*
689 : *************************************************************************/
690 0 : void RscClass::SetDefault( const RSCINST & rInst, Atom nVarName )
691 : {
692 0 : sal_uInt32 i = 0;
693 0 : RSCINST aTmpI;
694 :
695 0 : while( i < nEntries && pVarTypeList[ i ].nVarName != nVarName )
696 0 : i++;
697 :
698 0 : if( i < nEntries )
699 : {
700 0 : aTmpI = GetInstData( rInst.pData, i, sal_True );
701 0 : if( aTmpI.IsInst() )
702 : {
703 0 : aTmpI.pClass->Destroy( aTmpI );
704 0 : aTmpI.pClass->Create( &aTmpI, RSCINST() );
705 0 : SetVarDflt( rInst.pData, i, sal_True );
706 : }
707 : }
708 : else //In Superklasse nach Variable suchen
709 0 : RscTop::SetDefault( rInst, nVarName );
710 :
711 0 : }
712 :
713 :
714 : /*************************************************************************
715 : |*
716 : |* RscClass::WriteSrc()
717 : |*
718 : |* Beschreibung
719 : |*
720 : *************************************************************************/
721 83470 : void RscClass::WriteSrc
722 : (
723 : const RSCINST & rInst,
724 : FILE * fOutput,
725 : RscTypCont * pTC,
726 : sal_uInt32 nTab,
727 : const char * pVarName
728 : )
729 : {
730 83470 : sal_uInt32 i = 0, n = 0;
731 83470 : RSCINST aTmpI;
732 :
733 83470 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
734 :
735 482806 : for( i = 0; i < nEntries; i++ )
736 : {
737 399336 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
738 : {
739 : // Hack wegen Position und Dimensiuon
740 745063 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName
741 367995 : || nRsc_WHMAPMODEId == pVarTypeList[ i ].nVarName )
742 : {
743 20236 : if( !IsDflt( rInst.pData, i ) //MapUnit
744 1046 : || !IsDflt( rInst.pData, i+1 ) //X, Width
745 1044 : || !IsDflt( rInst.pData, i+2 ) )//Y, Height
746 : {// ein Wert ist nicht Default
747 51113 : for( n = 0; n < nTab; n++ )
748 34011 : fputc( '\t', fOutput );
749 17102 : if( nRsc_XYMAPMODEId == pVarTypeList[ i ].nVarName )
750 8227 : fprintf( fOutput, "Pos = " );
751 : else
752 8875 : fprintf( fOutput, "Size = " );
753 :
754 17102 : if( !IsDflt( rInst.pData, i ) )
755 : {
756 17100 : aTmpI = GetInstData( rInst.pData, i, sal_True );
757 : aTmpI.pClass->WriteSrcHeader(
758 17100 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
759 : }
760 :
761 17102 : fprintf( fOutput, "( " );
762 17102 : aTmpI = GetInstData( rInst.pData, i+1, sal_True );
763 17102 : if( !aTmpI.IsInst() )
764 0 : aTmpI.pData = GetDfltData( i+1 );
765 : aTmpI.pClass->WriteSrcHeader(
766 17102 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
767 :
768 17102 : fprintf( fOutput, ", " );
769 17102 : aTmpI = GetInstData( rInst.pData, i+2, sal_True );
770 17102 : if( !aTmpI.IsInst() )
771 0 : aTmpI.pData = GetDfltData( i+2 );
772 : aTmpI.pClass->WriteSrcHeader(
773 17102 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
774 17102 : fprintf( fOutput, " );\n" );
775 : }
776 18146 : i += 2; //_X, _Y oder _Widht, Height ueberlesen
777 : }
778 413681 : else if( !IsDflt( rInst.pData, i )
779 54759 : && !IsValueDflt( rInst.pData, i ) )
780 : {
781 53630 : aTmpI = GetInstData( rInst.pData, i, sal_True );
782 :
783 53630 : if( aTmpI.IsInst() )
784 : {
785 53630 : const char * pName = pHS->getString( pVarTypeList[ i ].nVarName ).getStr();
786 :
787 183426 : for( n = 0; n < nTab; n++ )
788 129796 : fputc( '\t', fOutput );
789 53630 : fprintf( fOutput, "%s", pName );
790 53630 : fprintf( fOutput, " = " );
791 : aTmpI.pClass->WriteSrcHeader(
792 53630 : aTmpI, fOutput, pTC, nTab, RscId(), pName );
793 53630 : fprintf( fOutput, ";\n" );
794 : }
795 : };
796 : };
797 : };
798 :
799 83470 : return;
800 : }
801 :
802 : /*************************************************************************
803 : |*
804 : |* RscClass::WriteInstRc()
805 : |*
806 : |* Beschreibung
807 : |*
808 : *************************************************************************/
809 34204 : sal_Int32 RscClass::GetCorrectValues
810 : (
811 : const RSCINST & rInst,
812 : sal_uInt32 nVarPos,
813 : sal_uInt32 nTupelIdx,
814 : RscTypCont * pTC
815 : )
816 : {
817 34204 : sal_Int32 nLang = 0;
818 : sal_Int32 nBaseValue;
819 :
820 : // Basiswert holen
821 34204 : RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, sal_True );
822 34204 : aTmpI.pClass->GetNumber( aTmpI, &nBaseValue );
823 :
824 : // Sprach Delta holen
825 34204 : aTmpI = rInst.pClass->GetVariable( rInst, nRsc_DELTALANG, RSCINST() );
826 34204 : if( aTmpI.IsInst() )
827 : {
828 34204 : RscWriteRc aMem;
829 34204 : aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, sal_False );
830 34204 : nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
831 : }
832 :
833 34204 : return nLang + nBaseValue;
834 : }
835 :
836 120911 : ERRTYPE RscClass::WriteInstRc
837 : (
838 : const RSCINST & rInst,
839 : RscWriteRc & rMem,
840 : RscTypCont * pTC,
841 : sal_uInt32 nDeep,
842 : sal_Bool bExtra
843 : )
844 : {
845 120911 : sal_uInt32 i = 0;
846 120911 : ERRTYPE aError;
847 120911 : RSCINST aTmpI;
848 120911 : sal_uInt32 nMaskOff = 0;// Offset um Maskenfeld zu addressieren
849 :
850 : // Wenn eine Variable Maskierung hat, dann Maskenfeld
851 490020 : for( i = 0; i < nEntries; i++ )
852 : {
853 385399 : if( pVarTypeList[ i ].nMask )
854 : {
855 16290 : nMaskOff = rMem.Size();
856 16290 : rMem.Put( sal_uInt32(0) );
857 16290 : break;
858 : }
859 : };
860 :
861 700005 : for( i = 0; i < nEntries && aError.IsOk(); i++ )
862 : {
863 579094 : if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
864 : {
865 390026 : if( pVarTypeList[ i ].nMask )
866 : {
867 178200 : if( !IsDflt( rInst.pData, i ) )
868 : {
869 77361 : if( nRsc_X == pVarTypeList[ i ].nVarName )
870 : {
871 8227 : sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC );
872 8227 : rMem.Put( nVal );
873 : }
874 69134 : else if( nRsc_Y == pVarTypeList[ i ].nVarName )
875 : {
876 8227 : sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC );
877 8227 : rMem.Put( nVal );
878 : }
879 60907 : else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
880 : {
881 8875 : sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC );
882 8875 : rMem.Put( nVal );
883 : }
884 52032 : else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
885 : {
886 8875 : sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC );
887 8875 : rMem.Put( nVal );
888 : }
889 : else
890 : {
891 43157 : aTmpI = GetInstData( rInst.pData, i, sal_True );
892 : // Nur an Variable Extradata bExtra nicht auf sal_False
893 : // setzen
894 : aError = aTmpI.pClass->
895 : WriteRcHeader( aTmpI, rMem, pTC,
896 : RscId(), nDeep,
897 : (nRsc_EXTRADATA
898 43157 : == pVarTypeList[ i ].nVarName)
899 86314 : ? bExtra : sal_False );
900 : }
901 77361 : sal_uInt32 nMask = rMem.GetLong( nMaskOff );
902 77361 : nMask |= pVarTypeList[ i ].nMask;
903 77361 : rMem.PutAt( nMaskOff, nMask );
904 : }
905 : }
906 : else{
907 211826 : if( IsDflt( rInst.pData, i ) )
908 : {
909 183856 : aTmpI.pClass = pVarTypeList[ i ].pClass;
910 183856 : aTmpI.pData = GetDfltData( i );
911 : }
912 : else
913 27970 : aTmpI = GetInstData( rInst.pData, i, sal_True );
914 : // Nur an Variable Extradata bExtra nicht auf sal_False
915 : // setzen
916 : aError = aTmpI.pClass->
917 : WriteRcHeader( aTmpI, rMem, pTC,
918 : RscId(), nDeep,
919 : (nRsc_EXTRADATA
920 211826 : == pVarTypeList[ i ].nVarName)
921 423652 : ? bExtra : sal_False );
922 : }
923 : }
924 : }
925 :
926 120911 : return( aError );
927 : }
928 :
929 : /*************************************************************************
930 : |*
931 : |* RscClass::WriteRc()
932 : |*
933 : |* Beschreibung
934 : |*
935 : *************************************************************************/
936 90772 : ERRTYPE RscClass::WriteRc
937 : (
938 : const RSCINST & rInst,
939 : RscWriteRc & rMem,
940 : RscTypCont * pTC,
941 : sal_uInt32 nDeep,
942 : sal_Bool bExtra
943 : )
944 : {
945 90772 : ERRTYPE aError;
946 :
947 90772 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
948 90772 : if( aError.IsOk() )
949 90772 : aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
950 :
951 90772 : return( aError );
952 : }
953 :
954 : /*************************************************************************
955 : |*
956 : |* RscClass::WriteSyntax()
957 : |*
958 : |* Beschreibung
959 : |*
960 : *************************************************************************/
961 0 : void RscClass::WriteSyntax( FILE * fOutput, RscTypCont * pTC )
962 : {
963 0 : RscTop::WriteSyntax( fOutput, pTC );
964 :
965 : sal_uInt32 i;
966 : // Wenn eine Variable Maskierung hat, dann Maskenfeld
967 0 : fprintf( fOutput, "\t//%s\n", pHS->getString( GetId() ).getStr() );
968 0 : for( i = 0; i < nEntries; i++ )
969 : {
970 0 : fprintf( fOutput, "\t%s", pHS->getString( pVarTypeList[ i ].nVarName ).getStr() );
971 0 : sal_uInt32 n = strlen( pHS->getString( pVarTypeList[ i ].nVarName ).getStr() );
972 0 : while( n < 20 )
973 : {
974 0 : putc( ' ', fOutput );
975 0 : n++;
976 : }
977 : fprintf( fOutput, " = %s;\n",
978 0 : pHS->getString( pVarTypeList[ i ].pClass->GetId() ).getStr() );
979 : };
980 0 : }
981 :
982 : //==================================================================
983 0 : void RscClass::WriteRcAccess
984 : (
985 : FILE * fOutput,
986 : RscTypCont * /*pTC*/,
987 : const char * pName
988 : )
989 : {
990 0 : fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->getString( GetId() ).getStr() );
991 0 : fprintf( fOutput, "%s ", aCallPar2.getStr() );
992 0 : fprintf( fOutput, "ResId( (RSHEADER_TYPE*)(pResData+nOffset) ) ) );\n" );
993 0 : fprintf( fOutput, "\t\tnOffset += GetObjSizeRes( (RSHEADER_TYPE*)(pResData+nOffset) );\n" );
994 0 : }
995 :
996 : //==================================================================
997 0 : void RscClass::WriteRcCtor( FILE * fOutput, RscTypCont * pTC )
998 : {
999 0 : if( GetId() != InvalidAtom )
1000 : {
1001 : // Konstruktor
1002 : fprintf( fOutput, "%s::%s%s bFreeResource )",
1003 0 : pHS->getString( GetId() ).getStr(),
1004 0 : pHS->getString( GetId() ).getStr(),
1005 0 : aCallParType.getStr() );
1006 0 : if( GetSuperClass() )
1007 : {
1008 : // Superaufruf
1009 0 : fprintf( fOutput, "\n\t: %s", pHS->getString( GetSuperClass()->GetId() ).getStr() );
1010 0 : fprintf( fOutput, "%s", GetSuperClass()->aCallPar1.getStr() );
1011 : fprintf( fOutput, " rResId.SetRT2( 0x%lx ) )",
1012 0 : sal::static_int_cast< unsigned long >(GetTypId()) );
1013 : }
1014 0 : fprintf( fOutput, "\n{\n" );
1015 0 : fprintf( fOutput, "\tsal_uInt32\tnObjMask;\n" );
1016 0 : fprintf( fOutput, "\tsal_uInt32\tnOffset = 0;\n" );
1017 0 : fprintf( fOutput, "\tBYTE *\tpResData;\n\n" );
1018 0 : fprintf( fOutput, "\tpResData = (tBYTE *)GetClassRes();\n\n" );
1019 0 : fprintf( fOutput, "\tnObjMask = *(sal_uInt32*)pResData;\n" );
1020 0 : fprintf( fOutput, "\tnOffset += 4;\n\n" );
1021 :
1022 0 : for( sal_uInt32 i = 0; i < nEntries; i++ )
1023 : {
1024 0 : if( !((VAR_NODATAINST | VAR_NORC) & pVarTypeList[ i ].nVarType ))
1025 : {
1026 : fprintf( fOutput, "\tif( nObjMask & 0x%lx )\n\t{\n",
1027 : sal::static_int_cast< unsigned long >(
1028 0 : pVarTypeList[ i ].nMask) );
1029 :
1030 0 : pVarTypeList[ i ].pClass->WriteRcAccess( fOutput, pTC,
1031 0 : pHS->getString( pVarTypeList[ i ].nVarName ).getStr() );
1032 :
1033 0 : fprintf( fOutput, "\t}\n" );
1034 : }
1035 : }
1036 0 : fprintf( fOutput, "\tIncrementRes( nOffset );\n" );
1037 0 : fprintf( fOutput, "\tif( bFreeResource )\n" );
1038 0 : fprintf( fOutput, "\t\tFreeResource();\n" );
1039 0 : fprintf( fOutput, "}\n\n" );
1040 : }
1041 0 : }
1042 :
1043 : /*************************************************************************
1044 : |*
1045 : |* RscSysDepend::RscSysDepend()
1046 : |*
1047 : |* Beschreibung
1048 : |*
1049 : *************************************************************************/
1050 691 : RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
1051 691 : : RscClass( nId, nTypeId, pSuper )
1052 691 : {}
1053 :
1054 : /*************************************************************************
1055 : |*
1056 : |* RscSysDepend::WriteRc()
1057 : |*
1058 : |* Beschreibung
1059 : |*
1060 : *************************************************************************/
1061 991 : ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
1062 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra, sal_Bool bFirst )
1063 : {
1064 991 : ERRTYPE aError;
1065 991 : RSCINST aFileName;
1066 :
1067 : //Instanz mit dem Dateinamen "FILENAME" holen
1068 991 : aFileName = RscClass::GetCopyVar( rInst, pHS->getID( "FILE", true ) );
1069 991 : if( aFileName.IsInst() )
1070 : {
1071 991 : RscWriteRc aTmpMem;
1072 : aError = aFileName.pClass->WriteRcHeader( aFileName, aTmpMem, pTC,
1073 991 : RscId(), nDeep, bExtra );
1074 : // Obsolete - need changes in VCL
1075 991 : rMem.Put( sal_uInt32(0) );
1076 :
1077 : // Identifier schreiben
1078 991 : sal_uInt32 nId = 0xFFFFFFFF;
1079 991 : if( aTmpMem.Size() && pTC && (*aTmpMem.GetUTF8( 0 ) != '\0') )
1080 : {
1081 : nId = pTC->PutSysName( rInst.pClass->GetTypId(),
1082 : aTmpMem.GetUTF8( 0 ),
1083 991 : 0, 0, bFirst );
1084 : }
1085 991 : rMem.Put( nId );
1086 : aError = aFileName.pClass->WriteRcHeader( aFileName, rMem, pTC,
1087 991 : RscId(), nDeep, bExtra );
1088 : }
1089 : else
1090 0 : aError = ERR_ERROR;
1091 :
1092 991 : return( aError );
1093 : }
1094 :
1095 : /*************************************************************************
1096 : |*
1097 : |* RscSysDepend::WriteRc()
1098 : |*
1099 : |* Beschreibung
1100 : |*
1101 : *************************************************************************/
1102 991 : ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1103 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
1104 : {
1105 991 : ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1106 :
1107 991 : if( this == rInst.pClass )
1108 : // nur wenn es eigen Klasse ist
1109 991 : aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra );
1110 991 : return aError;
1111 : }
1112 :
1113 : /*************************************************************************
1114 : |*
1115 : |* RscTupel::RscTupel()
1116 : |*
1117 : |* Beschreibung
1118 : |*
1119 : *************************************************************************/
1120 2073 : RscTupel::RscTupel( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
1121 2073 : : RscClass( nId, nTypeId, pSuper )
1122 2073 : {}
1123 :
1124 : /*************************************************************************
1125 : |*
1126 : |* RscTupel::GetTupelVar()
1127 : |*
1128 : |* Beschreibung
1129 : |*
1130 : *************************************************************************/
1131 9868 : RSCINST RscTupel::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
1132 : const RSCINST & rInitInst )
1133 : {
1134 9868 : if( nPos >= nEntries )
1135 : {
1136 0 : return RSCINST();
1137 : }
1138 : else
1139 9868 : return GetVariable( rInst, pVarTypeList[ nPos ].nVarName, rInitInst );
1140 : }
1141 :
1142 : /*************************************************************************
1143 : |*
1144 : |* RscTupel::WriteSrc()
1145 : |*
1146 : |* Beschreibung
1147 : |*
1148 : *************************************************************************/
1149 2388 : void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput,
1150 : RscTypCont * pTC, sal_uInt32 nTab,
1151 : const char * pVarName )
1152 : {
1153 2388 : sal_uInt32 i = 0;
1154 2388 : RSCINST aTmpI;
1155 :
1156 2388 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
1157 :
1158 2388 : fprintf( fOutput, "< " );
1159 7176 : for( i = 0; i < nEntries; i++ )
1160 : {
1161 4788 : if( !(VAR_HIDDEN & pVarTypeList[ i ].nVarType) )
1162 : {
1163 8516 : if( !IsDflt( rInst.pData, i )
1164 3728 : && !IsValueDflt( rInst.pData, i ) )
1165 : {
1166 3323 : aTmpI = GetInstData( rInst.pData, i, sal_True );
1167 :
1168 3323 : if( aTmpI.IsInst() )
1169 : aTmpI.pClass->WriteSrcHeader(
1170 3323 : aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
1171 : else
1172 0 : fprintf( fOutput, "Default" );
1173 : }
1174 : else
1175 1465 : fprintf( fOutput, "Default" );
1176 4788 : fprintf( fOutput, "; " );
1177 : };
1178 : };
1179 2388 : fprintf( fOutput, ">" );
1180 :
1181 2388 : return;
1182 : }
1183 :
1184 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
