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