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