Branch data 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 : 1440 : RscMgr::RscMgr( Atom nId, sal_uInt32 nTypeId, RscTop * pSuperCl )
40 : 1440 : : RscClass( nId, nTypeId, pSuperCl )
41 : : {
42 : 1440 : }
43 : :
44 : : /*************************************************************************
45 : : |*
46 : : |* RscMgr::Size()
47 : : |*
48 : : *************************************************************************/
49 : 32212 : sal_uInt32 RscMgr::Size()
50 : : {
51 : 32212 : return RscClass::Size() + ALIGNED_SIZE( sizeof( RscMgrInst ) );
52 : : }
53 : :
54 : : /*************************************************************************
55 : : |*
56 : : |* RscMgr::Create()
57 : : |*
58 : : *************************************************************************/
59 : 126054 : RSCINST RscMgr::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
60 : 126054 : RSCINST aInst;
61 : : RscMgrInst * pClassData;
62 : :
63 [ + + ]: 126054 : if( !pInst ){
64 : 1972 : aInst.pClass = this;
65 : 1972 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
66 : : }
67 : : else
68 : 124082 : aInst = *pInst;
69 [ + + ][ - + ]: 126054 : if( !bOwnClass && rDflt.IsInst() )
[ - + ]
70 : 0 : bOwnClass = rDflt.pClass->InHierarchy( this );
71 : :
72 : 126054 : RscClass::Create( &aInst, rDflt, bOwnClass );
73 : :
74 : 126054 : pClassData = (RscMgrInst *)(aInst.pData + RscClass::Size() );
75 : 126054 : pClassData->Create();
76 : :
77 [ + + ]: 126054 : if( bOwnClass ){
78 : 398 : RscMgrInst * pDfltData = (RscMgrInst *)(rDflt.pData + RscClass::Size());
79 : 398 : *pClassData = *pDfltData;
80 : : };
81 : :
82 : 126054 : return( aInst );
83 : : }
84 : :
85 : : /*************************************************************************
86 : : |*
87 : : |* RscMgr::Destroy()
88 : : |*
89 : : *************************************************************************/
90 : 126054 : void RscMgr::Destroy( const RSCINST & rInst ){
91 : : RscMgrInst * pClassData;
92 : :
93 : 126054 : RscClass::Destroy( rInst );
94 : :
95 : 126054 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
96 : 126054 : pClassData->Destroy();
97 : 126054 : }
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 : 1844 : sal_Bool RscMgr::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
135 : : RscMgrInst * pClassData;
136 : : RscMgrInst * pDfltData;
137 : :
138 [ - + ]: 1844 : if( !RscClass::IsValueDefault( rInst, pDef ) )
139 : 0 : return sal_False;
140 : :
141 [ + - ]: 1844 : if( pDef ){
142 : 1844 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
143 : 1844 : pDfltData = (RscMgrInst *)(pDef + RscClass::Size());
144 : :
145 [ + - ][ + + ]: 1844 : if( !pClassData->aRefId.IsId() && !pDfltData->aRefId.IsId() ){
[ + + ]
146 : 1836 : return sal_True;
147 : : }
148 : : }
149 : :
150 : 1844 : return sal_False;
151 : : }
152 : :
153 : :
154 : : /*************************************************************************
155 : : |*
156 : : |* RscMgr::WriteSrcHeader()
157 : : |*
158 : : *************************************************************************/
159 : 62174 : 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 : 62174 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
167 : :
168 : : fprintf( fOutput, "%s %s",
169 [ + - ][ + - ]: 62174 : pHS->getString( rInst.pClass->GetId() ).getStr(),
170 [ + - ]: 124348 : (rId.GetName()).getStr() );
171 [ + + ]: 62174 : if( pClassData->aRefId.IsId() )
172 [ + - ]: 10 : fprintf( fOutput, ",%s", pClassData->aRefId.GetName().getStr() );
173 : : else
174 : : {
175 : 62164 : fprintf( fOutput, "\n" );
176 [ + + ]: 136200 : for( i = 0; i < nTab; i++ )
177 : 74036 : fputc( '\t', fOutput );
178 : 62164 : fprintf( fOutput, "{\n" );
179 : :
180 : 62164 : rInst.pClass->WriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
181 : :
182 : 62164 : RscClass::WriteSrc( rInst, fOutput, pTC, nTab +1, pVarName);
183 : :
184 [ + + ]: 136200 : for( i = 0; i < nTab; i++ )
185 : 74036 : fputc( '\t', fOutput );
186 : 62164 : fprintf( fOutput, "}" );
187 : : }
188 : 62174 : }
189 : :
190 : : /*************************************************************************
191 : : |*
192 : : |* RscMgr::WriteSrc()
193 : : |*
194 : : *************************************************************************/
195 : 62164 : void RscMgr::WriteSrc( const RSCINST &, FILE *, RscTypCont *, sal_uInt32,
196 : : const char * )
197 : : {
198 : 62164 : }
199 : :
200 : : /*************************************************************************
201 : : |*
202 : : |* RscMgr::WriteRcHeader()
203 : : |*
204 : : *************************************************************************/
205 : 62346 : 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 : 62346 : ERRTYPE aError;
211 : 62346 : ObjNode * pObjNode = NULL;
212 : :
213 : 62346 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
214 : :
215 [ + + ]: 62346 : if( pClassData->aRefId.IsId() )
216 : : {
217 : : //Erhoehen und abfragen um Endlosrekusion zu vermeiden
218 : 10 : nDeep++;
219 [ - + ]: 10 : if( nDeep > nRefDeep )
220 [ # # ]: 0 : aError = ERR_REFTODEEP;
221 : : else
222 : 10 : pObjNode = rInst.pClass->GetRefClass()->
223 : 10 : GetObjNode( pClassData->aRefId );
224 [ - + ][ # # ]: 10 : 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 [ + - ]: 62346 : if( aError.IsOk() )
234 : : {
235 [ + + ]: 62346 : if( pObjNode )
236 : : {
237 : 10 : RSCINST aRefI;
238 : 10 : RscTop * pTmpRefClass = rInst.pClass->GetRefClass();
239 : :
240 : 10 : aRefI = RSCINST( rInst.pClass, pObjNode->GetRscObj() );
241 [ + - ]: 10 : if( pTmpRefClass == rInst.pClass )
242 : : {
243 : : aError = aRefI.pClass->WriteRcHeader( aRefI, rMem, pTC,
244 [ + - ][ + - ]: 10 : 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 [ # # ]: 10 : pTmpRefClass->Destroy( aRefInst );
252 : : }
253 : : }
254 : : else
255 : : {
256 : : sal_uInt32 nOldSize;
257 : : sal_uInt32 nLocalSize;
258 : :
259 : 62336 : nOldSize = rMem.IncSize( 16 /*sizeof( RSHEADER_TYPE )*/ );
260 : :
261 [ + - ]: 62336 : aError = rInst.pClass->WriteRc( rInst, rMem, pTC, nDeep, bExtra );
262 [ + - ]: 62336 : if( aError.IsOk() )
263 [ + - ]: 62336 : aError = WriteInstRc( rInst, rMem, pTC, nDeep, bExtra );
264 : 62336 : nLocalSize = rMem.Size();
265 : :
266 [ + - ]: 62336 : if( aError.IsOk() )
267 : : {
268 : : // RscClass wird uebersprungen
269 [ + - ]: 62336 : 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 : 62336 : sal_uInt32 nID = rId;
282 : 62336 : rMem.PutAt( nOldSize, nID );
283 : 62336 : rMem.PutAt( nOldSize +4, (sal_uInt32)rInst.pClass->GetTypId() );
284 : 62336 : rMem.PutAt( nOldSize +8, (sal_uInt32)(rMem.Size() - nOldSize) );
285 : 62336 : rMem.PutAt( nOldSize +12, (sal_uInt32)(nLocalSize - nOldSize) );
286 : : };
287 : : };
288 : :
289 : 62346 : return( aError );
290 : : }
291 : :
292 : : /*************************************************************************
293 : : |*
294 : : |* RscMgr::WriteRc()
295 : : |*
296 : : *************************************************************************/
297 : 62336 : ERRTYPE RscMgr::WriteRc( const RSCINST &, RscWriteRc &,
298 : : RscTypCont *, sal_uInt32, sal_Bool )
299 : :
300 : : {
301 : 62336 : 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 : 32 : ERRTYPE RscMgr::GetRef( const RSCINST & rInst, RscId * pRscId ){
544 : : RscMgrInst * pClassData;
545 : :
546 : 32 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
547 : 32 : *pRscId = pClassData->aRefId;
548 : 32 : return ERR_OK;
549 : : }
550 : :
551 : : /*************************************************************************
552 : : |*
553 : : |* RscMgr::IsToDeep()
554 : : |*
555 : : *************************************************************************/
556 : 24 : ERRTYPE RscMgr::IsToDeep( const RSCINST & rInst, sal_uInt32 nDeep )
557 : : {
558 : : RscMgrInst * pClassData;
559 : 24 : RscId aOldId, aId;
560 : 24 : ERRTYPE aError;
561 : 24 : RSCINST aTmpI = rInst;
562 : : ObjNode * pObjNode;
563 : :
564 : 24 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
565 : :
566 [ + + ][ + - ]: 56 : while( aTmpI.IsInst() && (nDeep < nRefDeep) && aError.IsOk() )
[ + - ][ + + ]
567 : : {
568 : : // Referenz holen
569 [ + - ]: 32 : aTmpI.pClass->GetRef( aTmpI, &aId );
570 : : // Referenziertes Objekt holen
571 [ + - ]: 32 : pObjNode = aTmpI.pClass->GetObjNode( aId );
572 : : // Referenzierte Objekt gefunden ?
573 [ + + ]: 32 : if( pObjNode )
574 : : {
575 : 8 : aTmpI.pData = pObjNode->GetRscObj();
576 : 8 : nDeep++;
577 : : }
578 : : else //aTmpI.IsInst() wird sal_False, Schleife beenden
579 : 24 : aTmpI.pData = NULL;
580 : : }
581 : :
582 [ - + ]: 24 : if( nDeep >= nRefDeep )
583 : : {
584 [ # # ]: 0 : pClassData->aRefId = aOldId;
585 [ # # ]: 0 : aError = ERR_REFTODEEP;
586 : : }
587 : :
588 [ + - ][ + - ]: 24 : return( aError );
589 : : }
590 : :
591 : : /*************************************************************************
592 : : |*
593 : : |* RscMgr::SetRef()
594 : : |*
595 : : *************************************************************************/
596 : 24 : ERRTYPE RscMgr::SetRef( const RSCINST & rInst, const RscId & rRefId )
597 : : {
598 : : RscMgrInst * pClassData;
599 : 24 : RscId aOldId, aId;
600 : 24 : ERRTYPE aError;
601 : :
602 [ + - ][ - + ]: 72 : if( rRefId.IsId() &&
[ - + ][ + - ]
603 [ + - ][ + - ]: 48 : ((rRefId.GetNumber() < 1) || (rRefId.GetNumber() > 0x7FFF)) )
604 : : {
605 [ # # ]: 0 : aError = ERR_IDRANGE;
606 : : }
607 : : else
608 : : {
609 : 24 : pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
610 [ + - ]: 24 : aOldId = pClassData->aRefId;// Alten Wert merken
611 [ + - ]: 24 : pClassData->aRefId = rRefId;// vorher eintragen,
612 : : // sonst Fehler bei rekursion
613 : :
614 : :
615 [ + - ][ + - ]: 24 : aError = IsToDeep( rInst );
616 [ + - ]: 24 : if( aError.IsOk() )
617 : 24 : pClassData->bDflt = sal_False;
618 : : else
619 [ # # ]: 0 : pClassData->aRefId = aOldId;
620 : : }
621 : :
622 [ + - ][ + - ]: 24 : return( aError );
623 : : }
624 : :
625 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
