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 41658 : void ENTRY_STRUCT::Destroy()
29 : {
30 41658 : aName.Destroy();
31 41658 : if( aInst.IsInst() )
32 : {
33 41658 : aInst.pClass->Destroy( aInst );
34 41658 : rtl_freeMemory( aInst.pData );
35 : }
36 41658 : }
37 :
38 4190 : RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
39 : bool bNoIdent )
40 : : RscTop( nId, nTypeId, pSuper )
41 4190 : , nSize( 0 )
42 : {
43 4190 : pTypeClass = NULL;
44 4190 : pTypeClass1 = NULL;
45 4190 : bNoId = bNoIdent;
46 4190 : nOffInstData = RscTop::Size();
47 4190 : nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscBaseContInst ) );
48 4190 : }
49 :
50 4609 : RscBaseCont::~RscBaseCont()
51 : {
52 4609 : }
53 :
54 0 : RSCCLASS_TYPE RscBaseCont::GetClassType() const
55 : {
56 0 : return RSCCLASS_COMPLEX;
57 : }
58 :
59 48123 : void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
60 : {
61 48123 : if( pClassData->nEntries )
62 : {
63 38126 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
64 : {
65 33308 : pClassData->pEntries[ i ].Destroy();
66 : }
67 4818 : rtl_freeMemory( pClassData->pEntries );
68 4818 : pClassData->pEntries = NULL;
69 4818 : pClassData->nEntries = 0;
70 : }
71 48123 : }
72 :
73 46643 : RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
74 : bool bOwnClass )
75 : {
76 46643 : RSCINST aInst;
77 : RscBaseContInst * pClassData;
78 :
79 46643 : if( !pInst )
80 : {
81 1982 : aInst.pClass = this;
82 1982 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
83 : }
84 : else
85 44661 : aInst = *pInst;
86 :
87 46643 : if( !bOwnClass && rDflt.IsInst() )
88 154 : bOwnClass = rDflt.pClass->InHierarchy( this );
89 :
90 46643 : RscTop::Create( &aInst, rDflt, bOwnClass );
91 :
92 46643 : pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
93 46643 : pClassData->nEntries = 0;
94 46643 : pClassData->pEntries = NULL;
95 46643 : pClassData->bDflt = true;
96 :
97 46643 : if( bOwnClass )
98 : {
99 : RscBaseContInst * pDfltClassData;
100 154 : RSCINST aDfltI;
101 :
102 154 : pDfltClassData = (RscBaseContInst *)(rDflt.pData + nOffInstData);
103 :
104 154 : 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 46643 : return aInst;
123 : }
124 :
125 46643 : void RscBaseCont::Destroy( const RSCINST & rInst )
126 : {
127 : RscBaseContInst * pClassData;
128 :
129 46643 : RscTop::Destroy( rInst);
130 :
131 46643 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
132 46643 : DestroyElements( pClassData );
133 46643 : }
134 :
135 14534 : RSCINST RscBaseCont::SearchElePos( const RSCINST & rInst, const RscId & rEleName,
136 : RscTop * pClass, sal_uInt32 nPos )
137 : {
138 : RscBaseContInst * pClassData;
139 :
140 14534 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
141 14534 : if( !pClass )
142 0 : pClass = pTypeClass;
143 :
144 14534 : if( rEleName.IsId() )
145 : {
146 1140246 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
147 : {
148 1125966 : if( pClassData->pEntries[ i ].aName == rEleName &&
149 254 : pClassData->pEntries[ i ].aInst.pClass == pClass )
150 : {
151 0 : return( pClassData->pEntries[ i ].aInst );
152 : }
153 : }
154 : }
155 14534 : return RSCINST();
156 : }
157 :
158 14534 : RSCINST RscBaseCont::SearchEle( const RSCINST & rInst, const RscId & rEleName,
159 : RscTop * pClass )
160 : {
161 14534 : return SearchElePos( rInst, rEleName, pClass, 0 );
162 : }
163 :
164 41658 : ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
165 : RscTop * pCreateClass,
166 : const RSCINST & rCreateInst, RSCINST * pGetInst )
167 : {
168 : RscBaseContInst * pClassData;
169 41658 : RSCINST aTmpI;
170 41658 : ERRTYPE aError;
171 :
172 41658 : if( !bNoId && !rEleName.IsId() )
173 0 : aError = WRN_CONT_NOID;
174 :
175 41658 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
176 :
177 41658 : if( pCreateClass )
178 : {
179 37903 : if( !pCreateClass->InHierarchy( pTypeClass ) )
180 : {
181 5188 : if( pTypeClass1 )
182 : {
183 5188 : 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 3755 : pCreateClass = pTypeClass;
196 :
197 41658 : pClassData->bDflt = false;
198 :
199 41658 : if( !bNoId )
200 14534 : aTmpI = SearchEle( rInst, rEleName, pCreateClass );
201 : // Eintrag gefunden
202 41658 : 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 41658 : if( pClassData->pEntries )
214 : {
215 : pClassData->pEntries =
216 : (ENTRY_STRUCT *)rtl_reallocateMemory( pClassData->pEntries,
217 36840 : sizeof( ENTRY_STRUCT ) * (pClassData->nEntries +1) );
218 : }
219 : else
220 : {
221 : pClassData->pEntries =
222 : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
223 4818 : * (pClassData->nEntries +1) );
224 : }
225 :
226 41658 : pClassData->pEntries[ pClassData->nEntries ].Create();
227 41658 : pClassData->pEntries[ pClassData->nEntries ].aName = rEleName;
228 :
229 41658 : 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 41658 : pCreateClass->Create( NULL, RSCINST() );
239 : }
240 :
241 41658 : pClassData->nEntries++;
242 41658 : aTmpI = pClassData->pEntries[ pClassData->nEntries -1 ].aInst;
243 : }
244 :
245 41658 : *pGetInst = aTmpI;
246 41658 : return aError;
247 : }
248 :
249 4560 : sal_uInt32 RscBaseCont::GetCount( const RSCINST & rInst )
250 : {
251 : RscBaseContInst * pClassData;
252 :
253 4560 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
254 4560 : 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 876 : ERRTYPE RscBaseCont::SetString( const RSCINST & rInst, const char * pStr )
342 : {
343 : RscBaseContInst * pClassData;
344 876 : RSCINST aTmpI;
345 876 : ERRTYPE aError;
346 : char *pTmpStr;
347 :
348 876 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
349 :
350 : // otherwise infinite recursion is possible
351 876 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
352 : {
353 876 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
354 876 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
355 :
356 876 : if( aError.IsOk() )
357 60 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
358 : else
359 : {
360 816 : aError.Clear();
361 816 : DeletePos( rInst, pClassData->nEntries -1 );
362 816 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
363 816 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
364 816 : if( aError.IsOk() )
365 726 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
366 : }
367 :
368 876 : if( aError.IsError() )
369 90 : DeletePos( rInst, pClassData->nEntries -1 );
370 : }
371 : else
372 0 : aError = ERR_UNKNOWN_METHOD;
373 :
374 876 : return aError;
375 : }
376 :
377 4462 : ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, sal_Int32 lValue )
378 : {
379 : RscBaseContInst * pClassData;
380 4462 : RSCINST aTmpI;
381 4462 : ERRTYPE aError;
382 : sal_Int32 lNumber;
383 :
384 4462 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
385 :
386 : // otherwise infinite recursion is possible
387 4462 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
388 : {
389 4462 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
390 4462 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
391 :
392 4462 : if( aError.IsOk() )
393 4462 : 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 4462 : if( aError.IsError() )
404 0 : DeletePos( rInst, pClassData->nEntries -1 );
405 : }
406 : else
407 0 : aError = ERR_UNKNOWN_METHOD;
408 :
409 4462 : 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 5127 : ERRTYPE RscBaseCont::SetRef( const RSCINST & rInst, const RscId & rRefId )
488 : {
489 : RscBaseContInst * pClassData;
490 5127 : RSCINST aTmpI;
491 5127 : ERRTYPE aError;
492 5127 : RscId aId;
493 :
494 5127 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
495 :
496 : // otherwise infinite recursion is possible
497 5127 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
498 : {
499 5127 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
500 5127 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
501 :
502 5127 : if( aError.IsOk() )
503 665 : aError = aTmpI.pClass->SetRef( aTmpI, rRefId );
504 : else
505 : {
506 4462 : aError.Clear();
507 4462 : DeletePos( rInst, pClassData->nEntries -1 );
508 4462 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
509 4462 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
510 4462 : if( aError.IsOk() )
511 4462 : aError = aTmpI.pClass->SetNumber( aTmpI, rRefId );
512 : }
513 :
514 5127 : if( aError.IsError() )
515 4462 : DeletePos( rInst, pClassData->nEntries -1 );
516 : }
517 : else
518 0 : aError = ERR_UNKNOWN_METHOD;
519 :
520 5127 : 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 154 : void RscBaseCont::SetToDefault( const RSCINST & rInst )
561 : {
562 154 : sal_uInt32 i = 0;
563 : RscBaseContInst * pClassData;
564 :
565 154 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
566 :
567 154 : 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 154 : RscTop::SetToDefault( rInst );
574 154 : }
575 :
576 220 : bool RscBaseCont::IsDefault( const RSCINST & rInst )
577 : {
578 220 : sal_uInt32 i = 0;
579 : RscBaseContInst * pClassData;
580 :
581 220 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
582 :
583 220 : if( !pClassData->bDflt )
584 220 : 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 1858 : bool RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
599 : {
600 : RscBaseContInst * pClassData;
601 :
602 1858 : if( !RscTop::IsValueDefault( rInst, pDef ) )
603 0 : return false;
604 :
605 1858 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
606 :
607 1858 : if( pClassData->nEntries )
608 1137 : return false;
609 : else
610 721 : 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 9830 : void RscBaseCont::DeletePos( const RSCINST & rInst, sal_uInt32 nPos )
638 : {
639 : RscBaseContInst * pClassData;
640 :
641 9830 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
642 :
643 9830 : if( nPos < pClassData->nEntries )
644 : {
645 9830 : if( 1 == pClassData->nEntries )
646 1480 : DestroyElements( pClassData );
647 : else
648 : {
649 8350 : pClassData->pEntries[ nPos ].Destroy();
650 8350 : pClassData->nEntries--;
651 :
652 8350 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
653 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + 1 ];
654 :
655 : }
656 : }
657 9830 : }
658 :
659 22975 : void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
660 : RscTypCont * pTC, sal_uInt32 nTab,
661 : const char * pVarName )
662 : {
663 22975 : sal_uInt32 i = 0, t = 0;
664 : RscBaseContInst * pClassData;
665 :
666 22975 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
667 :
668 38889 : for( i = 0; i < pClassData->nEntries; i++ )
669 : {
670 51937 : for( t = 0; t < nTab; t++ )
671 36023 : fputc( '\t', fOutput );
672 :
673 47742 : pClassData->pEntries[ i ].aInst.pClass->
674 15914 : WriteSrcHeader( pClassData->pEntries[ i ].aInst,
675 : fOutput, pTC, nTab,
676 63656 : pClassData->pEntries[ i ].aName, pVarName );
677 15914 : fprintf( fOutput, ";\n" );
678 : }
679 22975 : }
680 :
681 39477 : ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
682 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
683 : {
684 : RscBaseContInst * pClassData;
685 39477 : ERRTYPE aError;
686 :
687 39477 : if( bExtra || bNoId )
688 : { // Nur Subresourcen schreiben, wenn bExtra == true
689 34437 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
690 :
691 50354 : for (sal_uInt32 i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
692 : {
693 79585 : aError = pClassData->pEntries[ i ].aInst.pClass->
694 15917 : WriteRcHeader( pClassData->pEntries[ i ].aInst,
695 : rMem, pTC,
696 15917 : pClassData->pEntries[ i ].aName,
697 31834 : nDeep, bExtra );
698 : }
699 : }
700 :
701 39477 : return aError ;
702 : }
703 :
704 21838 : void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
705 : RscTypCont * pTC, sal_uInt32 nTab,
706 : const char * pVarName )
707 : {
708 21838 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
709 21838 : ContWriteSrc( rInst, fOutput, pTC, nTab, pVarName );
710 21838 : }
711 :
712 38752 : ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
713 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
714 : {
715 38752 : ERRTYPE aError;
716 :
717 38752 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
718 38752 : if( aError.IsOk() )
719 38752 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
720 :
721 38752 : return aError;
722 : }
723 :
724 3771 : RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
725 : RscTop * pSuper, bool bNoIdent )
726 3771 : : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
727 : {
728 3771 : }
729 :
730 1137 : 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 1137 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
737 :
738 1137 : fprintf( fOutput, "\n" );
739 3679 : for( i = 0; i < nTab; i++ )
740 2542 : fputc( '\t', fOutput );
741 :
742 1137 : fprintf( fOutput, "{\n" );
743 :
744 1137 : ContWriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
745 :
746 3679 : for( i = 0; i < nTab; i++ )
747 2542 : fputc( '\t', fOutput );
748 :
749 1137 : fprintf( fOutput, "}" );
750 1137 : }
751 :
752 3352 : RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, bool bNoIdent )
753 3352 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
754 : {
755 3352 : }
756 :
757 725 : ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
758 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
759 : {
760 : RscBaseContInst * pClassData;
761 725 : ERRTYPE aError;
762 :
763 725 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
764 :
765 725 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
766 :
767 725 : rMem.Put( pClassData->nEntries );
768 :
769 725 : if( aError.IsOk() )
770 725 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
771 :
772 725 : return aError;
773 : }
774 :
775 419 : RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
776 : RscTop * pSuper, bool bNoIdent )
777 419 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
778 : {
779 419 : }
780 :
781 21896 : ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
782 : RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
783 : {
784 21896 : ERRTYPE aError;
785 :
786 21896 : if( bExtra )
787 16856 : aError = RscContWriteSrc::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
788 : else
789 5040 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
790 :
791 21896 : return aError;
792 : }
793 :
794 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
