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