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 : #include <stdlib.h>
21 : #include <stdio.h>
22 : #include <string.h>
23 :
24 : #include <rsccont.hxx>
25 :
26 : #include <tools/rcid.h>
27 :
28 0 : void ENTRY_STRUCT::Destroy()
29 : {
30 0 : aName.Destroy();
31 0 : if( aInst.IsInst() )
32 : {
33 0 : aInst.pClass->Destroy( aInst );
34 0 : rtl_freeMemory( aInst.pData );
35 : };
36 0 : }
37 :
38 0 : RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
39 : bool bNoIdent )
40 : : RscTop( nId, nTypeId, pSuper )
41 0 : , nSize( 0 )
42 : {
43 0 : pTypeClass = NULL;
44 0 : pTypeClass1 = NULL;
45 0 : bNoId = bNoIdent;
46 0 : nOffInstData = RscTop::Size();
47 0 : nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscBaseContInst ) );
48 0 : }
49 :
50 0 : RscBaseCont::~RscBaseCont()
51 : {
52 0 : }
53 :
54 0 : RSCCLASS_TYPE RscBaseCont::GetClassType() const
55 : {
56 0 : return RSCCLASS_COMPLEX;
57 : }
58 :
59 0 : void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
60 : {
61 0 : if( pClassData->nEntries )
62 : {
63 0 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
64 : {
65 0 : pClassData->pEntries[ i ].Destroy();
66 : };
67 0 : rtl_freeMemory( pClassData->pEntries );
68 0 : pClassData->pEntries = NULL;
69 0 : pClassData->nEntries = 0;
70 : };
71 0 : }
72 :
73 0 : RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
74 : bool bOwnClass )
75 : {
76 0 : RSCINST aInst;
77 : RscBaseContInst * pClassData;
78 :
79 0 : if( !pInst )
80 : {
81 0 : aInst.pClass = this;
82 0 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
83 : }
84 : else
85 0 : aInst = *pInst;
86 :
87 0 : if( !bOwnClass && rDflt.IsInst() )
88 0 : bOwnClass = rDflt.pClass->InHierarchy( this );
89 :
90 0 : RscTop::Create( &aInst, rDflt, bOwnClass );
91 :
92 0 : pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
93 0 : pClassData->nEntries = 0;
94 0 : pClassData->pEntries = NULL;
95 0 : pClassData->bDflt = true;
96 :
97 0 : if( bOwnClass )
98 : {
99 : RscBaseContInst * pDfltClassData;
100 0 : RSCINST aDfltI;
101 :
102 0 : pDfltClassData = (RscBaseContInst *)(rDflt.pData + nOffInstData);
103 :
104 0 : if( 0 != pDfltClassData->nEntries )
105 : {
106 0 : *pClassData = *pDfltClassData;
107 : pClassData->pEntries =
108 : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
109 0 : * pClassData->nEntries );
110 0 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
111 : {
112 0 : pClassData->pEntries[ i ].Create();
113 0 : pClassData->pEntries[ i ].aName =
114 0 : pDfltClassData->pEntries[ i ].aName;
115 0 : aDfltI = pDfltClassData->pEntries[ i ].aInst;
116 : pClassData->pEntries[ i ].aInst =
117 0 : aDfltI.pClass->Create( NULL, aDfltI );
118 : };
119 : };
120 : }
121 :
122 0 : return aInst;
123 : }
124 :
125 0 : void RscBaseCont::Destroy( const RSCINST & rInst )
126 : {
127 : RscBaseContInst * pClassData;
128 :
129 0 : RscTop::Destroy( rInst);
130 :
131 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
132 0 : DestroyElements( pClassData );
133 0 : }
134 :
135 0 : RSCINST RscBaseCont::SearchElePos( const RSCINST & rInst, const RscId & rEleName,
136 : RscTop * pClass, sal_uInt32 nPos )
137 : {
138 : RscBaseContInst * pClassData;
139 :
140 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
141 0 : if( !pClass )
142 0 : pClass = pTypeClass;
143 :
144 0 : if( rEleName.IsId() )
145 : {
146 0 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
147 : {
148 0 : if( pClassData->pEntries[ i ].aName == rEleName &&
149 0 : pClassData->pEntries[ i ].aInst.pClass == pClass )
150 : {
151 0 : return( pClassData->pEntries[ i ].aInst );
152 : };
153 : };
154 : };
155 0 : return RSCINST();
156 : }
157 :
158 0 : RSCINST RscBaseCont::SearchEle( const RSCINST & rInst, const RscId & rEleName,
159 : RscTop * pClass )
160 : {
161 0 : return SearchElePos( rInst, rEleName, pClass, 0 );
162 : }
163 :
164 0 : ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
165 : RscTop * pCreateClass,
166 : const RSCINST & rCreateInst, RSCINST * pGetInst )
167 : {
168 : RscBaseContInst * pClassData;
169 0 : RSCINST aTmpI;
170 0 : ERRTYPE aError;
171 :
172 0 : if( !bNoId && !rEleName.IsId() )
173 0 : aError = WRN_CONT_NOID;
174 :
175 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
176 :
177 0 : if( pCreateClass )
178 : {
179 0 : if( !pCreateClass->InHierarchy( pTypeClass ) )
180 : {
181 0 : if( pTypeClass1 )
182 : {
183 0 : if( !pCreateClass->InHierarchy( pTypeClass1 ) )
184 : {
185 0 : return ERR_CONT_INVALIDTYPE;
186 : }
187 : }
188 : else
189 : {
190 0 : return ERR_CONT_INVALIDTYPE;
191 : };
192 : };
193 : }
194 : else
195 0 : pCreateClass = pTypeClass;
196 :
197 0 : pClassData->bDflt = false;
198 :
199 0 : if( !bNoId )
200 0 : aTmpI = SearchEle( rInst, rEleName, pCreateClass );
201 : // Eintrag gefunden
202 0 : if( aTmpI.IsInst() )
203 : {
204 0 : aError = WRN_CONT_DOUBLEID;
205 0 : if( rCreateInst.IsInst() )
206 : {
207 0 : aTmpI.pClass->Destroy( aTmpI );
208 0 : aTmpI.pClass->Create( &aTmpI, rCreateInst );
209 : };
210 : }
211 : else
212 : {
213 0 : if( pClassData->pEntries )
214 : {
215 : pClassData->pEntries =
216 : (ENTRY_STRUCT *)rtl_reallocateMemory( pClassData->pEntries,
217 0 : sizeof( ENTRY_STRUCT ) * (pClassData->nEntries +1) );
218 : }
219 : else
220 : {
221 : pClassData->pEntries =
222 : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
223 0 : * (pClassData->nEntries +1) );
224 : };
225 :
226 0 : pClassData->pEntries[ pClassData->nEntries ].Create();
227 0 : pClassData->pEntries[ pClassData->nEntries ].aName = rEleName;
228 :
229 0 : if( rCreateInst.IsInst() )
230 : {
231 : // Instanz mit CreateInst-Daten initialisieren
232 : pClassData->pEntries[ pClassData->nEntries ].aInst =
233 0 : pCreateClass->Create( NULL, rCreateInst );
234 : }
235 : else
236 : {
237 : pClassData->pEntries[ pClassData->nEntries ].aInst =
238 0 : pCreateClass->Create( NULL, RSCINST() );
239 : };
240 :
241 0 : pClassData->nEntries++;
242 0 : aTmpI = pClassData->pEntries[ pClassData->nEntries -1 ].aInst;
243 : }
244 :
245 0 : *pGetInst = aTmpI;
246 0 : return aError;
247 : }
248 :
249 0 : sal_uInt32 RscBaseCont::GetCount( const RSCINST & rInst )
250 : {
251 : RscBaseContInst * pClassData;
252 :
253 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
254 0 : return pClassData->nEntries;
255 : }
256 :
257 0 : RSCINST RscBaseCont::GetPosEle( const RSCINST & rInst, sal_uInt32 nPos )
258 : {
259 : RscBaseContInst * pClassData;
260 :
261 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
262 :
263 0 : if( nPos < pClassData->nEntries )
264 0 : return( pClassData->pEntries[ nPos ].aInst );
265 0 : return RSCINST();
266 : }
267 :
268 0 : ERRTYPE RscBaseCont::MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
269 : sal_uInt32 nSourcePos )
270 : {
271 0 : ERRTYPE aError;
272 : RscBaseContInst * pClassData;
273 :
274 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
275 :
276 0 : if( (nDestPos < pClassData->nEntries) && (nSourcePos < pClassData->nEntries) )
277 : {
278 0 : ENTRY_STRUCT aEntry;
279 0 : int nInc = 1;
280 0 : sal_uInt32 i = 0;
281 :
282 : // Quelle Merken
283 0 : aEntry = pClassData->pEntries[ nSourcePos ];
284 : // Richtung der for-Schleife bestimmen
285 0 : if( nDestPos < nSourcePos )
286 0 : nInc = -1;
287 :
288 0 : for( i = nSourcePos; i != nDestPos; i += nInc )
289 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + nInc ];
290 :
291 : // Zuweisung Quelle auf Ziel
292 0 : pClassData->pEntries[ nDestPos ] = aEntry;
293 : }
294 : else
295 0 : aError = ERR_RSCCONT;
296 :
297 0 : return aError;
298 : }
299 :
300 0 : ERRTYPE RscBaseCont::SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
301 : const RscId & rId )
302 : {
303 : RscBaseContInst * pClassData;
304 0 : RSCINST aTmpI;
305 0 : ERRTYPE aError;
306 :
307 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
308 :
309 0 : if( nPos < pClassData->nEntries )
310 : {
311 0 : if( ! (rId == pClassData->pEntries[ nPos ].aName) )
312 : aTmpI = SearchEle( rInst, rId,
313 0 : pClassData->pEntries[ nPos ].aInst.pClass );
314 0 : if( !aTmpI.IsInst() )
315 0 : pClassData->pEntries[ nPos ].aName = rId;
316 : else
317 0 : aError = ERR_RSCCONT;
318 : }
319 : else
320 0 : aError = ERR_RSCCONT;
321 :
322 0 : return aError;
323 : }
324 :
325 0 : SUBINFO_STRUCT RscBaseCont::GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos )
326 : {
327 : RscBaseContInst * pClassData;
328 0 : SUBINFO_STRUCT aInfo;
329 :
330 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
331 :
332 0 : if( nPos < pClassData->nEntries )
333 : {
334 0 : aInfo.aId = pClassData->pEntries[ nPos ].aName;
335 0 : aInfo.nPos = nPos;
336 0 : aInfo.pClass = pClassData->pEntries[ nPos ].aInst.pClass;
337 : }
338 0 : return aInfo;
339 : }
340 :
341 0 : ERRTYPE RscBaseCont::SetString( const RSCINST & rInst, const char * pStr )
342 : {
343 : RscBaseContInst * pClassData;
344 0 : RSCINST aTmpI;
345 0 : ERRTYPE aError;
346 : char *pTmpStr;
347 :
348 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
349 :
350 : // otherwise infinite recursion is possible
351 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
352 : {
353 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
354 0 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
355 :
356 0 : if( aError.IsOk() )
357 0 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
358 : else
359 : {
360 0 : aError.Clear();
361 0 : DeletePos( rInst, pClassData->nEntries -1 );
362 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
363 0 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
364 0 : if( aError.IsOk() )
365 0 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
366 : }
367 :
368 0 : if( aError.IsError() )
369 0 : DeletePos( rInst, pClassData->nEntries -1 );
370 : }
371 : else
372 0 : aError = ERR_UNKNOWN_METHOD;
373 :
374 0 : return aError;
375 : }
376 :
377 0 : ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, sal_Int32 lValue )
378 : {
379 : RscBaseContInst * pClassData;
380 0 : RSCINST aTmpI;
381 0 : ERRTYPE aError;
382 : sal_Int32 lNumber;
383 :
384 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
385 :
386 : // otherwise infinite recursion is possible
387 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
388 : {
389 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
390 0 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
391 :
392 0 : if( aError.IsOk() )
393 0 : aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
394 : else
395 : {
396 0 : aError.Clear();
397 0 : DeletePos( rInst, pClassData->nEntries -1 );
398 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
399 0 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
400 0 : if( aError.IsOk() )
401 0 : aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
402 : }
403 0 : if( aError.IsError() )
404 0 : DeletePos( rInst, pClassData->nEntries -1 );
405 : }
406 : else
407 0 : aError = ERR_UNKNOWN_METHOD;
408 :
409 0 : return aError;
410 : }
411 :
412 0 : ERRTYPE RscBaseCont::SetBool( const RSCINST & rInst,
413 : bool bValue)
414 : {
415 : RscBaseContInst * pClassData;
416 0 : RSCINST aTmpI;
417 0 : ERRTYPE aError;
418 : bool bBool;
419 :
420 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
421 :
422 : // otherwise infinite recursion is possible
423 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
424 : {
425 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
426 0 : aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
427 :
428 0 : if( aError.IsOk() )
429 0 : aError = aTmpI.pClass->SetBool( aTmpI, bValue );
430 : else
431 : {
432 0 : aError.Clear();
433 0 : DeletePos( rInst, pClassData->nEntries -1 );
434 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
435 0 : aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
436 0 : if( aError.IsOk() )
437 0 : aError = aTmpI.pClass->SetBool( aTmpI, bValue );
438 : }
439 :
440 0 : if( aError.IsError() )
441 0 : DeletePos( rInst, pClassData->nEntries -1 );
442 : }
443 : else
444 0 : aError = ERR_UNKNOWN_METHOD;
445 :
446 0 : return aError;
447 : }
448 :
449 0 : ERRTYPE RscBaseCont::SetConst( const RSCINST & rInst,
450 : Atom nValueId,
451 : sal_Int32 lValue)
452 : {
453 : RscBaseContInst * pClassData;
454 0 : RSCINST aTmpI;
455 0 : ERRTYPE aError;
456 : Atom nConst;
457 :
458 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
459 :
460 : // otherwise infinite recursion is possible
461 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
462 : {
463 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
464 0 : aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
465 :
466 0 : if( aError.IsOk() )
467 0 : aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
468 : else
469 : {
470 0 : aError.Clear();
471 0 : DeletePos( rInst, pClassData->nEntries -1 );
472 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
473 0 : aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
474 0 : if( aError.IsOk() )
475 0 : aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
476 : }
477 :
478 0 : if( aError.IsError() )
479 0 : DeletePos( rInst, pClassData->nEntries -1 );
480 : }
481 : else
482 0 : aError = ERR_UNKNOWN_METHOD;
483 :
484 0 : return aError;
485 : }
486 :
487 0 : ERRTYPE RscBaseCont::SetRef( const RSCINST & rInst, const RscId & rRefId )
488 : {
489 : RscBaseContInst * pClassData;
490 0 : RSCINST aTmpI;
491 0 : ERRTYPE aError;
492 0 : RscId aId;
493 :
494 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
495 :
496 : // otherwise infinite recursion is possible
497 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
498 : {
499 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
500 0 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
501 :
502 0 : if( aError.IsOk() )
503 0 : aError = aTmpI.pClass->SetRef( aTmpI, rRefId );
504 : else
505 : {
506 0 : aError.Clear();
507 0 : DeletePos( rInst, pClassData->nEntries -1 );
508 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
509 0 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
510 0 : if( aError.IsOk() )
511 0 : aError = aTmpI.pClass->SetNumber( aTmpI, rRefId );
512 : }
513 :
514 0 : if( aError.IsError() )
515 0 : DeletePos( rInst, pClassData->nEntries -1 );
516 : }
517 : else
518 0 : aError = ERR_UNKNOWN_METHOD;
519 :
520 0 : return aError;
521 : }
522 :
523 0 : bool RscBaseCont::IsConsistent( const RSCINST & rInst )
524 : {
525 0 : sal_uInt32 i = 0;
526 : RscBaseContInst * pClassData;
527 : bool bRet;
528 :
529 0 : bRet = RscTop::IsConsistent( rInst );
530 :
531 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
532 :
533 : // auf doppelten Id Testen und Reihenfolge beibehalten
534 : // Komplexitaet = n^2 / 2
535 0 : for( i = 0; i < pClassData->nEntries; i++ )
536 : {
537 0 : if( !bNoId )
538 : {
539 0 : if( (sal_Int32)pClassData->pEntries[ i ].aName > 0x7FFF ||
540 0 : (sal_Int32)pClassData->pEntries[ i ].aName < 1 )
541 : {
542 0 : bRet = false;
543 : }
544 0 : else if( SearchElePos( rInst, pClassData->pEntries[ i ].aName,
545 0 : pClassData->pEntries[ i ].aInst.pClass, i +1 ).IsInst() )
546 : {
547 0 : bRet = false;
548 : };
549 : }
550 0 : if( ! pClassData->pEntries[ i ].aInst.pClass->
551 0 : IsConsistent( pClassData->pEntries[ i ].aInst ) )
552 : {
553 0 : bRet = false;
554 : }
555 : };
556 :
557 0 : return bRet;
558 : }
559 :
560 0 : void RscBaseCont::SetToDefault( const RSCINST & rInst )
561 : {
562 0 : sal_uInt32 i = 0;
563 : RscBaseContInst * pClassData;
564 :
565 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
566 :
567 0 : for( i = 0; i < pClassData->nEntries; i++ )
568 : {
569 0 : pClassData->pEntries[ i ].aInst.pClass->
570 0 : SetToDefault( pClassData->pEntries[ i ].aInst );
571 : };
572 :
573 0 : RscTop::SetToDefault( rInst );
574 0 : }
575 :
576 0 : bool RscBaseCont::IsDefault( const RSCINST & rInst )
577 : {
578 0 : sal_uInt32 i = 0;
579 : RscBaseContInst * pClassData;
580 :
581 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
582 :
583 0 : if( !pClassData->bDflt )
584 0 : return false;
585 :
586 0 : for( i = 0; i < pClassData->nEntries; i++ )
587 : {
588 0 : if( ! pClassData->pEntries[ i ].aInst.pClass->
589 0 : IsDefault( pClassData->pEntries[ i ].aInst ) )
590 : {
591 0 : return( false );
592 : };
593 : };
594 :
595 0 : return RscTop::IsDefault( rInst );
596 : }
597 :
598 0 : bool RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
599 : {
600 : RscBaseContInst * pClassData;
601 :
602 0 : if( !RscTop::IsValueDefault( rInst, pDef ) )
603 0 : return false;
604 :
605 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
606 :
607 0 : if( pClassData->nEntries )
608 0 : return false;
609 : else
610 0 : return true;
611 : }
612 :
613 0 : void RscBaseCont::Delete( const RSCINST & rInst, RscTop * pClass,
614 : const RscId & rId )
615 : {
616 0 : sal_uInt32 i = 0;
617 : RscBaseContInst * pClassData;
618 :
619 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
620 0 : if( !pClass )
621 0 : pClass = pTypeClass;
622 :
623 0 : for( i = 0; i < pClassData->nEntries; i++ )
624 : {
625 0 : if( pClassData->pEntries[ i ].aName == rId )
626 : {
627 0 : if( pClassData->pEntries[ i ].aInst.pClass == pClass || !pClass )
628 : {
629 0 : DeletePos( rInst, i );
630 0 : return;
631 : };
632 : };
633 : };
634 :
635 : }
636 :
637 0 : void RscBaseCont::DeletePos( const RSCINST & rInst, sal_uInt32 nPos )
638 : {
639 : RscBaseContInst * pClassData;
640 :
641 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
642 :
643 0 : if( nPos < pClassData->nEntries )
644 : {
645 0 : if( 1 == pClassData->nEntries )
646 0 : DestroyElements( pClassData );
647 : else
648 : {
649 0 : pClassData->pEntries[ nPos ].Destroy();
650 0 : pClassData->nEntries--;
651 :
652 0 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
653 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + 1 ];
654 :
655 : };
656 : };
657 0 : }
658 :
659 0 : void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
660 : RscTypCont * pTC, sal_uInt32 nTab,
661 : const char * pVarName )
662 : {
663 0 : sal_uInt32 i = 0, t = 0;
664 : RscBaseContInst * pClassData;
665 :
666 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
667 :
668 0 : for( i = 0; i < pClassData->nEntries; i++ )
669 : {
670 0 : for( t = 0; t < nTab; t++ )
671 0 : fputc( '\t', fOutput );
672 :
673 0 : pClassData->pEntries[ i ].aInst.pClass->
674 0 : WriteSrcHeader( pClassData->pEntries[ i ].aInst,
675 : fOutput, pTC, nTab,
676 0 : pClassData->pEntries[ i ].aName, pVarName );
677 0 : fprintf( fOutput, ";\n" );
678 : };
679 0 : }
680 :
681 0 : ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
682 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
683 : {
684 : RscBaseContInst * pClassData;
685 0 : ERRTYPE aError;
686 :
687 0 : if( bExtra || bNoId )
688 : { // Nur Subresourcen schreiben, wenn bExtra == true
689 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
690 :
691 0 : for (sal_uInt32 i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
692 : {
693 0 : aError = pClassData->pEntries[ i ].aInst.pClass->
694 0 : WriteRcHeader( pClassData->pEntries[ i ].aInst,
695 : rMem, pTC,
696 0 : pClassData->pEntries[ i ].aName,
697 0 : nDeep, bExtra );
698 : }
699 : }
700 :
701 0 : return aError ;
702 : }
703 :
704 0 : void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
705 : RscTypCont * pTC, sal_uInt32 nTab,
706 : const char * pVarName )
707 : {
708 0 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
709 0 : ContWriteSrc( rInst, fOutput, pTC, nTab, pVarName );
710 0 : }
711 :
712 0 : ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
713 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
714 : {
715 0 : ERRTYPE aError;
716 :
717 0 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
718 0 : if( aError.IsOk() )
719 0 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
720 :
721 0 : return aError;
722 : }
723 :
724 0 : RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
725 : RscTop * pSuper, bool bNoIdent )
726 0 : : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
727 : {
728 0 : }
729 :
730 0 : void RscContWriteSrc::WriteSrc( const RSCINST & rInst, FILE * fOutput,
731 : RscTypCont * pTC, sal_uInt32 nTab,
732 : const char * pVarName )
733 : {
734 : sal_uInt32 i;
735 :
736 0 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
737 :
738 0 : fprintf( fOutput, "\n" );
739 0 : for( i = 0; i < nTab; i++ )
740 0 : fputc( '\t', fOutput );
741 :
742 0 : fprintf( fOutput, "{\n" );
743 :
744 0 : ContWriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
745 :
746 0 : for( i = 0; i < nTab; i++ )
747 0 : fputc( '\t', fOutput );
748 :
749 0 : fprintf( fOutput, "}" );
750 0 : }
751 :
752 0 : RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, bool bNoIdent )
753 0 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
754 : {
755 0 : }
756 :
757 0 : ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
758 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
759 : {
760 : RscBaseContInst * pClassData;
761 0 : ERRTYPE aError;
762 :
763 0 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
764 :
765 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
766 :
767 0 : rMem.Put( pClassData->nEntries );
768 :
769 0 : if( aError.IsOk() )
770 0 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
771 :
772 0 : return aError;
773 : }
774 :
775 0 : RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
776 : RscTop * pSuper, bool bNoIdent )
777 0 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
778 : {
779 0 : }
780 :
781 0 : ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
782 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
783 : {
784 0 : ERRTYPE aError;
785 :
786 0 : if( bExtra )
787 0 : aError = RscContWriteSrc::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
788 : else
789 0 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
790 :
791 0 : return aError;
792 : }
793 :
794 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
