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