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 : #include <ctype.h>
27 :
28 : // Programmabhaengige Includes.
29 : #include <rscmgr.hxx>
30 : #include <rscdb.hxx>
31 :
32 : /****************** C O D E **********************************************/
33 : /****************** R s c M g r ******************************************/
34 : /*************************************************************************
35 : |*
36 : |* RscMgr::RscMgr()
37 : |*
38 : *************************************************************************/
39 691 : RscMgr::RscMgr( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
40 691 : : RscClass( nId, nTypeId, pSuperCl )
41 : {
42 691 : }
43 :
44 : /*************************************************************************
45 : |*
46 : |* RscMgr::Size()
47 : |*
48 : *************************************************************************/
49 15519 : sal_uInt32 RscMgr::Size()
50 : {
51 15519 : return RscClass::Size() + ALIGNED_SIZE( sizeof( RscMgrInst ) );
52 : }
53 :
54 : /*************************************************************************
55 : |*
56 : |* RscMgr::Create()
57 : |*
58 : *************************************************************************/
59 60930 : RSCINST RscMgr::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
60 60930 : RSCINST aInst;
61 : RscMgrInst * pClassData;
62 :
63 60930 : if( !pInst ){
64 1008 : aInst.pClass = this;
65 1008 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
66 : }
67 : else
68 59922 : aInst = *pInst;
69 60930 : if( !bOwnClass && rDflt.IsInst() )
70 0 : bOwnClass = rDflt.pClass->InHierarchy( this );
71 :
72 60930 : RscClass::Create( &aInst, rDflt, bOwnClass );
73 :
74 60930 : pClassData = (RscMgrInst *)(aInst.pData + RscClass::Size() );
75 60930 : pClassData->Create();
76 :
77 60930 : if( bOwnClass ){
78 199 : RscMgrInst * pDfltData = (RscMgrInst *)(rDflt.pData + RscClass::Size());
79 199 : *pClassData = *pDfltData;
80 : };
81 :
82 60930 : return( aInst );
83 : }
84 :
85 : /*************************************************************************
86 : |*
87 : |* RscMgr::Destroy()
88 : |*
89 : *************************************************************************/
90 60930 : void RscMgr::Destroy( const RSCINST & rInst ){
91 : RscMgrInst * pClassData;
92 :
93 60930 : RscClass::Destroy( rInst );
94 :
95 60930 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
96 60930 : pClassData->Destroy();
97 60930 : }
98 :
99 : /*************************************************************************
100 : |*
101 : |* RscMgr::SetToDefault()
102 : |*
103 : *************************************************************************/
104 0 : void RscMgr::SetToDefault( const RSCINST & rInst )
105 : {
106 : RscMgrInst * pClassData;
107 :
108 0 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
109 0 : pClassData->bDflt = sal_True;
110 :
111 0 : RscClass::SetToDefault( rInst );
112 0 : }
113 :
114 : /*************************************************************************
115 : |*
116 : |* RscMgr::IsDefault()
117 : |*
118 : *************************************************************************/
119 0 : sal_Bool RscMgr::IsDefault( const RSCINST & rInst ){
120 : RscMgrInst * pClassData;
121 :
122 0 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
123 0 : if( !pClassData->bDflt )
124 0 : return( sal_False );
125 :
126 0 : return( RscClass::IsDefault( rInst ) );
127 : }
128 :
129 : /*************************************************************************
130 : |*
131 : |* RscMgr::IsValueDefault()
132 : |*
133 : *************************************************************************/
134 871 : sal_Bool RscMgr::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
135 : RscMgrInst * pClassData;
136 : RscMgrInst * pDfltData;
137 :
138 871 : if( !RscClass::IsValueDefault( rInst, pDef ) )
139 0 : return sal_False;
140 :
141 871 : if( pDef ){
142 871 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
143 871 : pDfltData = (RscMgrInst *)(pDef + RscClass::Size());
144 :
145 871 : if( !pClassData->aRefId.IsId() && !pDfltData->aRefId.IsId() ){
146 867 : return sal_True;
147 : }
148 : }
149 :
150 4 : return sal_False;
151 : }
152 :
153 :
154 : /*************************************************************************
155 : |*
156 : |* RscMgr::WriteSrcHeader()
157 : |*
158 : *************************************************************************/
159 30057 : void RscMgr::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
160 : RscTypCont * pTC, sal_uInt32 nTab,
161 : const RscId & rId, const char * pVarName )
162 : {
163 : RscMgrInst * pClassData;
164 : sal_uInt32 i;
165 :
166 30057 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
167 :
168 : fprintf( fOutput, "%s %s",
169 30057 : pHS->getString( rInst.pClass->GetId() ).getStr(),
170 60114 : (rId.GetName()).getStr() );
171 30057 : if( pClassData->aRefId.IsId() )
172 5 : fprintf( fOutput, ",%s", pClassData->aRefId.GetName().getStr() );
173 : else
174 : {
175 30052 : fprintf( fOutput, "\n" );
176 65697 : for( i = 0; i < nTab; i++ )
177 35645 : fputc( '\t', fOutput );
178 30052 : fprintf( fOutput, "{\n" );
179 :
180 30052 : rInst.pClass->WriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
181 :
182 30052 : RscClass::WriteSrc( rInst, fOutput, pTC, nTab +1, pVarName);
183 :
184 65697 : for( i = 0; i < nTab; i++ )
185 35645 : fputc( '\t', fOutput );
186 30052 : fprintf( fOutput, "}" );
187 : }
188 30057 : }
189 :
190 : /*************************************************************************
191 : |*
192 : |* RscMgr::WriteSrc()
193 : |*
194 : *************************************************************************/
195 30052 : void RscMgr::WriteSrc( const RSCINST &, FILE *, RscTypCont *, sal_uInt32,
196 : const char * )
197 : {
198 30052 : }
199 :
200 : /*************************************************************************
201 : |*
202 : |* RscMgr::WriteRcHeader()
203 : |*
204 : *************************************************************************/
205 30144 : ERRTYPE RscMgr::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
206 : RscTypCont * pTC, const RscId &rId,
207 : sal_uInt32 nDeep, sal_Bool bExtra )
208 : {
209 : RscMgrInst * pClassData;
210 30144 : ERRTYPE aError;
211 30144 : ObjNode * pObjNode = NULL;
212 :
213 30144 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
214 :
215 30144 : if( pClassData->aRefId.IsId() )
216 : {
217 : //Erhoehen und abfragen um Endlosrekusion zu vermeiden
218 5 : nDeep++;
219 5 : if( nDeep > nRefDeep )
220 0 : aError = ERR_REFTODEEP;
221 : else
222 5 : pObjNode = rInst.pClass->GetRefClass()->
223 10 : GetObjNode( pClassData->aRefId );
224 5 : if( !pObjNode && pTC )
225 : {
226 0 : rtl::OStringBuffer aMsg(pHS->getString(rInst.pClass->GetId()));
227 0 : aMsg.append(' ').append(pClassData->aRefId.GetName());
228 0 : aError = WRN_MGR_REFNOTFOUND;
229 0 : pTC->pEH->Error(aError, rInst.pClass, rId, aMsg.getStr());
230 : }
231 : }
232 :
233 30144 : if( aError.IsOk() )
234 : {
235 30144 : if( pObjNode )
236 : {
237 5 : RSCINST aRefI;
238 5 : RscTop * pTmpRefClass = rInst.pClass->GetRefClass();
239 :
240 5 : aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
241 5 : if( pTmpRefClass == rInst.pClass )
242 : {
243 : aError = aRefI.pClass->WriteRcHeader( aRefI, rMem, pTC,
244 5 : rId, nDeep, bExtra );
245 : }
246 : else
247 : {
248 0 : RSCINST aRefInst = rInst.pClass->Create( NULL, aRefI );
249 : aError = aRefI.pClass->WriteRcHeader( aRefInst, rMem, pTC,
250 0 : rId, nDeep, bExtra );
251 0 : pTmpRefClass->Destroy( aRefInst );
252 : }
253 : }
254 : else
255 : {
256 : sal_uInt32 nOldSize;
257 : sal_uInt32 nLocalSize;
258 :
259 30139 : nOldSize = rMem.IncSize( 16 /*sizeof( RSHEADER_TYPE )*/ );
260 :
261 30139 : aError = rInst.pClass->WriteRc( rInst, rMem, pTC, nDeep, bExtra );
262 30139 : if( aError.IsOk() )
263 30139 : aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
264 30139 : nLocalSize = rMem.Size();
265 :
266 30139 : if( aError.IsOk() )
267 : {
268 : // RscClass wird uebersprungen
269 30139 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
270 : };
271 :
272 : /*
273 : // Definition der Struktur, aus denen die Resource aufgebaut ist
274 : struct RSHEADER_TYPE{
275 : RESOURCE_TYPE nRT; // Resource Typ
276 : sal_uInt32 nRT; // Resource Typ
277 : sal_uInt32 nGlobOff; // Globaler Offset
278 : sal_uInt32 nLocalOff; // Lokaler Offset
279 : };
280 : */
281 30139 : sal_uInt32 nID = rId;
282 30139 : rMem.PutAt( nOldSize, nID );
283 30139 : rMem.PutAt( nOldSize +4, (sal_uInt32)rInst.pClass->GetTypId() );
284 30139 : rMem.PutAt( nOldSize +8, (sal_uInt32)(rMem.Size() - nOldSize) );
285 30139 : rMem.PutAt( nOldSize +12, (sal_uInt32)(nLocalSize - nOldSize) );
286 : };
287 : };
288 :
289 30144 : return( aError );
290 : }
291 :
292 : /*************************************************************************
293 : |*
294 : |* RscMgr::WriteRc()
295 : |*
296 : *************************************************************************/
297 30139 : ERRTYPE RscMgr::WriteRc( const RSCINST &, RscWriteRc &,
298 : RscTypCont *, sal_uInt32, sal_Bool )
299 :
300 : {
301 30139 : return( ERR_OK );
302 : }
303 :
304 :
305 0 : static rtl::OString MakeSmartName( const rtl::OString& rDefName )
306 : {
307 0 : rtl::OStringBuffer aSmartName;
308 0 : if( rDefName.getStr() )
309 : {
310 0 : char * pStr = (char *)rDefName.getStr();
311 0 : aSmartName.append(static_cast<sal_Char>(toupper(*pStr)));
312 0 : while( *++pStr )
313 : {
314 0 : if( '_' == *pStr )
315 : {
316 0 : if( *++pStr )
317 0 : aSmartName.append(static_cast<sal_Char>(toupper(*pStr)));
318 : else
319 0 : break;
320 : }
321 : else
322 0 : aSmartName.append(static_cast<sal_Char>(tolower(*pStr)));
323 : }
324 : }
325 0 : return aSmartName.makeStringAndClear();
326 : }
327 :
328 0 : static rtl::OString MakeName( RscTypCont * pTypCon, RscTop * pClass,
329 : const rtl::OString& rName )
330 : {
331 0 : rtl::OStringBuffer aRet;
332 0 : if( !pTypCon->IsSmart() || isdigit( rName[0] ) )
333 : {
334 0 : aRet.append(pHS->getString( pClass->GetId() ).getStr());
335 0 : aRet.append(rName);
336 : }
337 : else
338 0 : aRet.append(MakeSmartName(rName));
339 0 : return aRet.makeStringAndClear();
340 : }
341 :
342 : /*************************************************************************
343 : |*
344 : |* RscMgr::WriteHxxHeader()
345 : |*
346 : *************************************************************************/
347 0 : ERRTYPE RscMgr::WriteHxxHeader( const RSCINST & rInst, FILE * fOutput,
348 : RscTypCont * pTC, const RscId &rId )
349 : {
350 : RscMgrInst * pClassData;
351 0 : ERRTYPE aError;
352 0 : ObjNode * pObjNode = NULL;
353 :
354 0 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
355 :
356 0 : if( pClassData->aRefId.IsId() )
357 : {
358 0 : pObjNode = rInst.pClass->GetObjNode( pClassData->aRefId );
359 0 : if( !pObjNode && pTC )
360 : {
361 0 : rtl::OStringBuffer aMsg(pHS->getString(rInst.pClass->GetId()));
362 0 : aMsg.append(' ').append(pClassData->aRefId.GetName());
363 0 : aError = WRN_MGR_REFNOTFOUND;
364 0 : pTC->pEH->Error(aError, rInst.pClass, rId, aMsg.getStr());
365 : }
366 : }
367 :
368 0 : if( pObjNode )
369 : {
370 0 : RSCINST aRefI;
371 :
372 0 : aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
373 : aError = aRefI.pClass->WriteHxxHeader( aRefI, fOutput, pTC,
374 0 : rId );
375 : }
376 0 : else if (pTC)
377 : {
378 : fprintf( fOutput, "class %s",
379 : MakeName( pTC, rInst.pClass,
380 0 : rId.GetName() ).getStr() );
381 : fprintf( fOutput, " : public %s",
382 0 : pHS->getString( rInst.pClass->GetId() ).getStr() );
383 0 : fprintf( fOutput, "\n{\nprotected:\n" );
384 :
385 0 : aError = RscClass::WriteHxx( rInst, fOutput, pTC, rId );
386 :
387 0 : RSCINST aExtraInst = rInst.pClass->GetCopyVar( rInst, nRsc_EXTRADATA );
388 0 : if( aExtraInst.IsInst() )
389 : {
390 0 : if( aExtraInst.pClass->GetCount( aExtraInst ) )
391 0 : fprintf( fOutput, " char * pExtraData;\n" );
392 : }
393 0 : if( aError.IsOk() )
394 : {
395 0 : fprintf( fOutput, "public:\n " );
396 : fprintf( fOutput, "%s%s bFreeRes = TRUE )",
397 : MakeName( pTC, rInst.pClass,
398 : rId.GetName() ).getStr(),
399 0 : (rInst.pClass->aCallParType).getStr() );
400 0 : fprintf( fOutput, ";\n};\n\n" );
401 : }
402 : };
403 0 : return aError;
404 : }
405 :
406 : /*************************************************************************
407 : |*
408 : |* RscMgr::WriteHxx()
409 : |*
410 : *************************************************************************/
411 0 : ERRTYPE RscMgr::WriteHxx( const RSCINST & rInst, FILE * fOutput,
412 : RscTypCont * pTC, const RscId & rId )
413 : {
414 0 : fprintf( fOutput, " %s", pHS->getString( rInst.pClass->GetId() ).getStr() );
415 : fprintf( fOutput, " a%s;\n",
416 0 : MakeName( pTC, rInst.pClass, rId.GetName() ).getStr() );
417 :
418 0 : return ERR_OK;
419 : }
420 :
421 : /*************************************************************************
422 : |*
423 : |* RscClass::WriteCxxHeader()
424 : |*
425 : *************************************************************************/
426 0 : ERRTYPE RscMgr::WriteCxxHeader( const RSCINST & rInst, FILE * fOutput,
427 : RscTypCont * pTC, const RscId & rId )
428 : {
429 : RscMgrInst * pClassData;
430 0 : ERRTYPE aError;
431 0 : ObjNode * pObjNode = NULL;
432 :
433 0 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
434 :
435 0 : if( pClassData->aRefId.IsId() )
436 : {
437 0 : pObjNode = rInst.pClass->GetObjNode( pClassData->aRefId );
438 0 : if( !pObjNode && pTC )
439 : {
440 0 : rtl::OStringBuffer aMsg(pHS->getString(rInst.pClass->GetId()));
441 0 : aMsg.append(' ').append(pClassData->aRefId.GetName());
442 0 : aError = WRN_MGR_REFNOTFOUND;
443 0 : pTC->pEH->Error( aError, rInst.pClass, rId, aMsg.getStr() );
444 : }
445 : }
446 :
447 0 : if( pObjNode )
448 : {
449 0 : RSCINST aRefI;
450 :
451 0 : aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
452 : aError = aRefI.pClass->WriteCxxHeader( aRefI, fOutput, pTC,
453 0 : rId );
454 : }
455 0 : else if (pTC)
456 : {
457 : fprintf( fOutput, "%s::%s",
458 : MakeName( pTC, rInst.pClass, rId.GetName() ).getStr(),
459 0 : MakeName( pTC, rInst.pClass, rId.GetName() ).getStr() );
460 0 : fprintf( fOutput, "%s", (rInst.pClass->aCallParType).getStr() );
461 0 : if( GetCount( rInst ) )
462 0 : fprintf( fOutput, " bFreeRes" );
463 0 : fprintf( fOutput, " )\n : %s", pHS->getString( rInst.pClass->GetId() ).getStr() );
464 0 : fprintf( fOutput, "%s", (rInst.pClass->aCallPar1).getStr() );
465 0 : fprintf( fOutput, " rResId )" );
466 :
467 0 : aError = RscClass::WriteCxx( rInst, fOutput, pTC, rId );
468 :
469 0 : fprintf( fOutput, "\n{\n" );
470 0 : RSCINST aExtraInst = rInst.pClass->GetCopyVar( rInst, nRsc_EXTRADATA );
471 0 : if( aExtraInst.IsInst() )
472 : {
473 0 : if( aExtraInst.pClass->GetCount( aExtraInst ) )
474 : {
475 0 : fprintf( fOutput, " //read extra data\n" );
476 : fprintf( fOutput, " pExtraData = new char "
477 0 : "[ GetRemainSizeRes() ];\n" );
478 : fprintf( fOutput, " memcpy( pExtraData, "
479 0 : "GetClassRes(), GetRemainSizeRes() );\n" );
480 0 : fprintf( fOutput, " IncrementRes( GetRemainSizeRes() );\n" );
481 : }
482 : }
483 :
484 0 : if( GetCount( rInst ) )
485 : { // Es gibt UnterResourcen
486 0 : fprintf( fOutput, " if( bFreeRes ) FreeResource();\n" );
487 : }
488 : else
489 : {
490 : fprintf( fOutput,
491 0 : " // No subresources, automatic free resource\n" );
492 : }
493 0 : fprintf( fOutput, "}\n\n" );
494 : }
495 0 : return aError;
496 : }
497 :
498 : /*************************************************************************
499 : |*
500 : |* RscClass::WriteCxx()
501 : |*
502 : *************************************************************************/
503 0 : ERRTYPE RscMgr::WriteCxx( const RSCINST & rInst, FILE * fOutput,
504 : RscTypCont * pTC, const RscId & rId )
505 : {
506 : fprintf( fOutput, ",\n a%s",
507 0 : MakeName( pTC, rInst.pClass, rId.GetName() ).getStr() );
508 0 : fprintf( fOutput, "%s", (rInst.pClass->aCallPar2).getStr() );
509 0 : fprintf( fOutput, " ResId( %s ) )", (rId.GetName()).getStr() );
510 :
511 0 : return ERR_OK;
512 : }
513 :
514 : /*************************************************************************
515 : |*
516 : |* RscArray::IsConsistent()
517 : |*
518 : *************************************************************************/
519 0 : sal_Bool RscMgr::IsConsistent( const RSCINST & rInst )
520 : {
521 : sal_Bool bRet;
522 : RscMgrInst * pClassData;
523 :
524 0 : bRet = RscClass::IsConsistent( rInst );
525 :
526 0 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
527 0 : if( pClassData->aRefId.IsId() &&
528 0 : ((pClassData->aRefId.GetNumber() < 1)
529 0 : || (pClassData->aRefId.GetNumber() > 0x7FFF)
530 0 : || IsToDeep( rInst ).IsError()) )
531 : {
532 0 : bRet = sal_False;
533 : }
534 :
535 0 : return( bRet );
536 : }
537 :
538 : /*************************************************************************
539 : |*
540 : |* RscMgr::GetRef()
541 : |*
542 : *************************************************************************/
543 16 : ERRTYPE RscMgr::GetRef( const RSCINST & rInst, RscId * pRscId ){
544 : RscMgrInst * pClassData;
545 :
546 16 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
547 16 : *pRscId = pClassData->aRefId;
548 16 : return ERR_OK;
549 : }
550 :
551 : /*************************************************************************
552 : |*
553 : |* RscMgr::IsToDeep()
554 : |*
555 : *************************************************************************/
556 12 : ERRTYPE RscMgr::IsToDeep( const RSCINST & rInst, sal_uInt32 nDeep )
557 : {
558 : RscMgrInst * pClassData;
559 12 : RscId aOldId, aId;
560 12 : ERRTYPE aError;
561 12 : RSCINST aTmpI = rInst;
562 : ObjNode * pObjNode;
563 :
564 12 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
565 :
566 40 : while( aTmpI.IsInst() && (nDeep < nRefDeep) && aError.IsOk() )
567 : {
568 : // Referenz holen
569 16 : aTmpI.pClass->GetRef( aTmpI, &aId );
570 : // Referenziertes Objekt holen
571 16 : pObjNode = aTmpI.pClass->GetObjNode( aId );
572 : // Referenzierte Objekt gefunden ?
573 16 : if( pObjNode )
574 : {
575 4 : aTmpI.pData = pObjNode->GetRscObj();
576 4 : nDeep++;
577 : }
578 : else //aTmpI.IsInst() wird sal_False, Schleife beenden
579 12 : aTmpI.pData = NULL;
580 : }
581 :
582 12 : if( nDeep >= nRefDeep )
583 : {
584 0 : pClassData->aRefId = aOldId;
585 0 : aError = ERR_REFTODEEP;
586 : }
587 :
588 12 : return( aError );
589 : }
590 :
591 : /*************************************************************************
592 : |*
593 : |* RscMgr::SetRef()
594 : |*
595 : *************************************************************************/
596 12 : ERRTYPE RscMgr::SetRef( const RSCINST & rInst, const RscId & rRefId )
597 : {
598 : RscMgrInst * pClassData;
599 12 : RscId aOldId, aId;
600 12 : ERRTYPE aError;
601 :
602 36 : if( rRefId.IsId() &&
603 24 : ((rRefId.GetNumber() < 1) || (rRefId.GetNumber() > 0x7FFF)) )
604 : {
605 0 : aError = ERR_IDRANGE;
606 : }
607 : else
608 : {
609 12 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
610 12 : aOldId = pClassData->aRefId;// Alten Wert merken
611 12 : pClassData->aRefId = rRefId;// vorher eintragen,
612 : // sonst Fehler bei rekursion
613 :
614 :
615 12 : aError = IsToDeep( rInst );
616 12 : if( aError.IsOk() )
617 12 : pClassData->bDflt = sal_False;
618 : else
619 0 : pClassData->aRefId = aOldId;
620 : }
621 :
622 12 : return( aError );
623 : }
624 :
625 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
