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 :
27 : // Programmabh�ngige Includes.
28 : #include <rsccont.hxx>
29 :
30 : #include <tools/rcid.h>
31 :
32 : /****************** C O D E **********************************************/
33 : /****************** E N T R Y S T R U C T ********************************/
34 : /*************************************************************************
35 : |*
36 : |* ENTRYSTRUCT::Destroy()
37 : |*
38 : *************************************************************************/
39 56818 : void ENTRY_STRUCT::Destroy()
40 : {
41 56818 : aName.Destroy();
42 56818 : if( aInst.IsInst() ){
43 56818 : aInst.pClass->Destroy( aInst );
44 56818 : rtl_freeMemory( aInst.pData );
45 : };
46 56818 : }
47 :
48 : /****************** R s c B a s e C o n t ********************************/
49 : /*************************************************************************
50 : |*
51 : |* RscBaseCont::RscBaseCont()
52 : |*
53 : *************************************************************************/
54 7601 : RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
55 : sal_Bool bNoIdent )
56 : : RscTop( nId, nTypeId, pSuper ),
57 7601 : nSize( 0 )
58 : {
59 7601 : pTypeClass = NULL;
60 7601 : pTypeClass1 = NULL;
61 7601 : bNoId = bNoIdent;
62 7601 : nOffInstData = RscTop::Size();
63 7601 : nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscBaseContInst ) );
64 7601 : }
65 :
66 : /*************************************************************************
67 : |*
68 : |* RscBaseCont::~RscBaseCont()
69 : |*
70 : *************************************************************************/
71 8292 : RscBaseCont::~RscBaseCont()
72 : {
73 8292 : }
74 :
75 : /*************************************************************************
76 : |*
77 : |* RscBaseCont::GetClassType()
78 : |*
79 : *************************************************************************/
80 0 : RSCCLASS_TYPE RscBaseCont::GetClassType() const
81 : {
82 0 : return RSCCLASS_COMPLEX;
83 : }
84 :
85 : /*************************************************************************
86 : |*
87 : |* DestroyElements()
88 : |*
89 : *************************************************************************/
90 65649 : void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
91 : {
92 65649 : if( pClassData->nEntries ){
93 56442 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
94 : {
95 50042 : pClassData->pEntries[ i ].Destroy();
96 : };
97 6400 : rtl_freeMemory( pClassData->pEntries );
98 6400 : pClassData->pEntries = NULL;
99 6400 : pClassData->nEntries = 0;
100 : };
101 65649 : }
102 :
103 : /*************************************************************************
104 : |*
105 : |* RscBaseCont::Create()
106 : |*
107 : *************************************************************************/
108 64403 : RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
109 : sal_Bool bOwnClass )
110 : {
111 64403 : RSCINST aInst;
112 : RscBaseContInst * pClassData;
113 :
114 64403 : if( !pInst ){
115 2479 : aInst.pClass = this;
116 2479 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
117 : }
118 : else
119 61924 : aInst = *pInst;
120 64403 : if( !bOwnClass && rDflt.IsInst() )
121 476 : bOwnClass = rDflt.pClass->InHierarchy( this );
122 :
123 64403 : RscTop::Create( &aInst, rDflt, bOwnClass );
124 :
125 64403 : pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
126 64403 : pClassData->nEntries = 0;
127 64403 : pClassData->pEntries = NULL;
128 64403 : pClassData->bDflt = sal_True;
129 :
130 64403 : if( bOwnClass ){
131 : RscBaseContInst * pDfltClassData;
132 678 : RSCINST aDfltI;
133 :
134 678 : pDfltClassData = (RscBaseContInst *)(rDflt.pData + nOffInstData);
135 :
136 678 : if( 0 != pDfltClassData->nEntries ){
137 24 : *pClassData = *pDfltClassData;
138 : pClassData->pEntries =
139 : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
140 24 : * pClassData->nEntries );
141 197 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
142 : {
143 173 : pClassData->pEntries[ i ].Create();
144 173 : pClassData->pEntries[ i ].aName =
145 346 : pDfltClassData->pEntries[ i ].aName;
146 173 : aDfltI = pDfltClassData->pEntries[ i ].aInst;
147 : pClassData->pEntries[ i ].aInst =
148 173 : aDfltI.pClass->Create( NULL, aDfltI );
149 : };
150 : };
151 : }
152 :
153 64403 : return( aInst );
154 : }
155 :
156 : /*************************************************************************
157 : |*
158 : |* RscBaseCont::Destroy()
159 : |*
160 : *************************************************************************/
161 64403 : void RscBaseCont::Destroy( const RSCINST & rInst ){
162 : RscBaseContInst * pClassData;
163 :
164 64403 : RscTop::Destroy( rInst);
165 :
166 64403 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
167 64403 : DestroyElements( pClassData );
168 64403 : }
169 :
170 : /*************************************************************************
171 : |*
172 : |* RscBaseCont::SearchEle()
173 : |*
174 : *************************************************************************/
175 29356 : RSCINST RscBaseCont::SearchElePos( const RSCINST & rInst, const RscId & rEleName,
176 : RscTop * pClass, sal_uInt32 nPos )
177 : {
178 : RscBaseContInst * pClassData;
179 :
180 29356 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
181 29356 : if( !pClass )
182 0 : pClass = pTypeClass;
183 :
184 29356 : if( rEleName.IsId() ){
185 931313 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
186 : {
187 908013 : if( pClassData->pEntries[ i ].aName == rEleName
188 6056 : && pClassData->pEntries[ i ].aInst.pClass == pClass )
189 : {
190 0 : return( pClassData->pEntries[ i ].aInst );
191 : };
192 : };
193 : };
194 29356 : return RSCINST();
195 : }
196 :
197 : /*************************************************************************
198 : |*
199 : |* RscBaseCont::SearchEle()
200 : |*
201 : *************************************************************************/
202 29356 : RSCINST RscBaseCont::SearchEle( const RSCINST & rInst, const RscId & rEleName,
203 : RscTop * pClass )
204 : {
205 29356 : return SearchElePos( rInst, rEleName, pClass, 0 );
206 : }
207 :
208 : /*************************************************************************
209 : |*
210 : |* RscBaseCont::GetElement()
211 : |*
212 : *************************************************************************/
213 56645 : ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
214 : RscTop * pCreateClass,
215 : const RSCINST & rCreateInst, RSCINST * pGetInst )
216 : {
217 : RscBaseContInst * pClassData;
218 56645 : RSCINST aTmpI;
219 56645 : ERRTYPE aError;
220 :
221 56645 : if( !bNoId && !rEleName.IsId() )
222 0 : aError = WRN_CONT_NOID;
223 56645 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
224 :
225 56645 : if( pCreateClass ){
226 51047 : if( !pCreateClass->InHierarchy( pTypeClass ) ){
227 4120 : if( pTypeClass1 ){
228 4120 : if( !pCreateClass->InHierarchy( pTypeClass1 ) ){
229 : // Falscher Typ
230 0 : return ERR_CONT_INVALIDTYPE;
231 : }
232 : }
233 : else{
234 : // Falscher Typ
235 0 : return ERR_CONT_INVALIDTYPE;
236 : };
237 : };
238 : }
239 : else
240 5598 : pCreateClass = pTypeClass;
241 :
242 56645 : pClassData->bDflt = sal_False;
243 56645 : if( !bNoId )
244 29356 : aTmpI = SearchEle( rInst, rEleName, pCreateClass );
245 : // Eintrag gefunden
246 56645 : if( aTmpI.IsInst() ){
247 0 : aError = WRN_CONT_DOUBLEID;
248 0 : if( rCreateInst.IsInst() ){
249 0 : aTmpI.pClass->Destroy( aTmpI );
250 0 : aTmpI.pClass->Create( &aTmpI, rCreateInst );
251 : };
252 : }
253 : else {
254 56645 : if( pClassData->pEntries ){
255 : pClassData->pEntries =
256 : (ENTRY_STRUCT *)rtl_reallocateMemory( pClassData->pEntries,
257 50269 : sizeof( ENTRY_STRUCT ) * (pClassData->nEntries +1) );
258 : }
259 : else {
260 : pClassData->pEntries =
261 : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
262 6376 : * (pClassData->nEntries +1) );
263 : };
264 :
265 56645 : pClassData->pEntries[ pClassData->nEntries ].Create();
266 56645 : pClassData->pEntries[ pClassData->nEntries ].aName = rEleName;
267 :
268 56645 : if( rCreateInst.IsInst() ){
269 : // Instanz mit CreateInst-Daten initialisieren
270 : pClassData->pEntries[ pClassData->nEntries ].aInst =
271 0 : pCreateClass->Create( NULL, rCreateInst );
272 : }
273 : else {
274 : pClassData->pEntries[ pClassData->nEntries ].aInst =
275 56645 : pCreateClass->Create( NULL, RSCINST() );
276 : };
277 :
278 56645 : pClassData->nEntries++;
279 56645 : aTmpI = pClassData->pEntries[ pClassData->nEntries -1 ].aInst;
280 : }
281 :
282 56645 : *pGetInst = aTmpI;
283 56645 : return aError;
284 : }
285 :
286 : /*************************************************************************
287 : |*
288 : |* RscBaseCont::GetCount()
289 : |*
290 : *************************************************************************/
291 5610 : sal_uInt32 RscBaseCont::GetCount( const RSCINST & rInst ){
292 : RscBaseContInst * pClassData;
293 :
294 5610 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
295 5610 : return( pClassData->nEntries );
296 : }
297 :
298 : /*************************************************************************
299 : |*
300 : |* RscBaseCont::GetPosEle()
301 : |*
302 : *************************************************************************/
303 0 : RSCINST RscBaseCont::GetPosEle( const RSCINST & rInst, sal_uInt32 nPos ){
304 : RscBaseContInst * pClassData;
305 :
306 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
307 :
308 0 : if( nPos < pClassData->nEntries )
309 0 : return( pClassData->pEntries[ nPos ].aInst );
310 0 : return RSCINST();
311 : }
312 :
313 : /*************************************************************************
314 : |*
315 : |* RscBaseCont::MovePosEle()
316 : |*
317 : *************************************************************************/
318 0 : ERRTYPE RscBaseCont::MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
319 : sal_uInt32 nSourcePos )
320 : {
321 0 : ERRTYPE aError;
322 : RscBaseContInst * pClassData;
323 :
324 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
325 :
326 0 : if( (nDestPos < pClassData->nEntries) && (nSourcePos < pClassData->nEntries) ){
327 0 : ENTRY_STRUCT aEntry;
328 0 : int nInc = 1;
329 0 : sal_uInt32 i = 0;
330 :
331 : // Quelle Merken
332 0 : aEntry = pClassData->pEntries[ nSourcePos ];
333 : // Richtung der for-Schleife bestimmen
334 0 : if( nDestPos < nSourcePos )
335 0 : nInc = -1;
336 :
337 0 : for( i = nSourcePos; i != nDestPos; i += nInc )
338 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + nInc ];
339 :
340 : // Zuweisung Quelle auf Ziel
341 0 : pClassData->pEntries[ nDestPos ] = aEntry;
342 : }
343 : else
344 0 : aError = ERR_RSCCONT;
345 0 : return aError;
346 : }
347 :
348 : /*************************************************************************
349 : |*
350 : |* RscBaseCont::SetPosRscId()
351 : |*
352 : *************************************************************************/
353 0 : ERRTYPE RscBaseCont::SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
354 : const RscId & rId ){
355 : RscBaseContInst * pClassData;
356 0 : RSCINST aTmpI;
357 0 : ERRTYPE aError;
358 :
359 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
360 :
361 0 : if( nPos < pClassData->nEntries ){
362 0 : if( ! (rId == pClassData->pEntries[ nPos ].aName) )
363 : aTmpI = SearchEle( rInst, rId,
364 0 : pClassData->pEntries[ nPos ].aInst.pClass );
365 0 : if( !aTmpI.IsInst() )
366 0 : pClassData->pEntries[ nPos ].aName = rId;
367 : else
368 0 : aError = ERR_RSCCONT;
369 : }
370 : else
371 0 : aError = ERR_RSCCONT;
372 0 : return( aError );
373 : }
374 :
375 : /*************************************************************************
376 : |*
377 : |* RscBaseCont::GetInfoEle()
378 : |*
379 : *************************************************************************/
380 0 : SUBINFO_STRUCT RscBaseCont::GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos ){
381 : RscBaseContInst * pClassData;
382 0 : SUBINFO_STRUCT aInfo;
383 :
384 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
385 :
386 0 : if( nPos < pClassData->nEntries ){
387 0 : aInfo.aId = pClassData->pEntries[ nPos ].aName;
388 0 : aInfo.nPos = nPos;
389 0 : aInfo.pClass = pClassData->pEntries[ nPos ].aInst.pClass;
390 : }
391 0 : return( aInfo );
392 : }
393 :
394 : /*************************************************************************
395 : |*
396 : |* RscBaseCont::SetString()
397 : |*
398 : *************************************************************************/
399 856 : ERRTYPE RscBaseCont::SetString( const RSCINST & rInst, const char * pStr )
400 : {
401 : RscBaseContInst * pClassData;
402 856 : RSCINST aTmpI;
403 856 : ERRTYPE aError;
404 : char *pTmpStr;
405 :
406 856 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
407 :
408 : //?B 040991
409 : //?W 040991 sonst Endlosrekursion moeglich
410 856 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
411 856 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
412 856 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
413 856 : if( aError.IsOk() )
414 106 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
415 : else {
416 750 : aError.Clear();
417 750 : DeletePos( rInst, pClassData->nEntries -1 );
418 750 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
419 750 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
420 750 : if( aError.IsOk() )
421 584 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
422 : }
423 856 : if( aError.IsError() )
424 166 : DeletePos( rInst, pClassData->nEntries -1 );
425 : }
426 : else
427 0 : aError = ERR_UNKNOWN_METHOD;
428 :
429 856 : return( aError );
430 : }
431 :
432 : /*************************************************************************
433 : |*
434 : |* RscBaseCont::SetNumber()
435 : |*
436 : *************************************************************************/
437 3536 : ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, sal_Int32 lValue ){
438 : RscBaseContInst * pClassData;
439 3536 : RSCINST aTmpI;
440 3536 : ERRTYPE aError;
441 : sal_Int32 lNumber;
442 :
443 3536 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
444 :
445 : //?B 040991
446 : //?W 040991 sonst Endlosrekursion moeglich
447 3536 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
448 3536 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
449 3536 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
450 3536 : if( aError.IsOk() )
451 3536 : aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
452 : else {
453 0 : aError.Clear();
454 0 : DeletePos( rInst, pClassData->nEntries -1 );
455 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
456 0 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
457 0 : if( aError.IsOk() )
458 0 : aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
459 : }
460 3536 : if( aError.IsError() )
461 0 : DeletePos( rInst, pClassData->nEntries -1 );
462 : }
463 : else
464 0 : aError = ERR_UNKNOWN_METHOD;
465 :
466 3536 : return( aError );
467 : }
468 :
469 : //==================================================================
470 0 : ERRTYPE RscBaseCont::SetBool
471 : (
472 : const RSCINST & rInst,
473 : sal_Bool bValue
474 : )
475 : {
476 : RscBaseContInst * pClassData;
477 0 : RSCINST aTmpI;
478 0 : ERRTYPE aError;
479 : sal_Bool bBool;
480 :
481 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
482 :
483 : //?B 040991
484 : //?W 040991 sonst Endlosrekursion moeglich
485 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
486 : {
487 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
488 0 : aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
489 0 : if( aError.IsOk() )
490 0 : aError = aTmpI.pClass->SetBool( aTmpI, bValue );
491 : else {
492 0 : aError.Clear();
493 0 : DeletePos( rInst, pClassData->nEntries -1 );
494 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
495 0 : aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
496 0 : if( aError.IsOk() )
497 0 : aError = aTmpI.pClass->SetBool( aTmpI, bValue );
498 : }
499 0 : if( aError.IsError() )
500 0 : DeletePos( rInst, pClassData->nEntries -1 );
501 : }
502 : else
503 0 : aError = ERR_UNKNOWN_METHOD;
504 :
505 0 : return( aError );
506 : }
507 :
508 : //==================================================================
509 0 : ERRTYPE RscBaseCont::SetConst
510 : (
511 : const RSCINST & rInst,
512 : Atom nValueId,
513 : sal_Int32 lValue
514 : )
515 : {
516 : RscBaseContInst * pClassData;
517 0 : RSCINST aTmpI;
518 0 : ERRTYPE aError;
519 : Atom nConst;
520 :
521 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
522 :
523 : //?B 040991
524 : //?W 040991 sonst Endlosrekursion moeglich
525 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
526 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
527 0 : aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
528 0 : if( aError.IsOk() )
529 0 : aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
530 : else {
531 0 : aError.Clear();
532 0 : DeletePos( rInst, pClassData->nEntries -1 );
533 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
534 0 : aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
535 0 : if( aError.IsOk() )
536 0 : aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
537 : }
538 0 : if( aError.IsError() )
539 0 : DeletePos( rInst, pClassData->nEntries -1 );
540 : }
541 : else
542 0 : aError = ERR_UNKNOWN_METHOD;
543 :
544 0 : return( aError );
545 : }
546 :
547 : /*************************************************************************
548 : |*
549 : |* RscBaseCont::SetRef()
550 : |*
551 : *************************************************************************/
552 4237 : ERRTYPE RscBaseCont::SetRef( const RSCINST & rInst, const RscId & rRefId ){
553 : RscBaseContInst * pClassData;
554 4237 : RSCINST aTmpI;
555 4237 : ERRTYPE aError;
556 4237 : RscId aId;
557 :
558 4237 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
559 :
560 : //?B 040991
561 : //?W 040991 sonst Endlosrekursion moeglich
562 4237 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
563 4237 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
564 4237 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
565 4237 : if( aError.IsOk() )
566 701 : aError = aTmpI.pClass->SetRef( aTmpI, rRefId );
567 : else {
568 3536 : aError.Clear();
569 3536 : DeletePos( rInst, pClassData->nEntries -1 );
570 3536 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
571 3536 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
572 3536 : if( aError.IsOk() )
573 3536 : aError = aTmpI.pClass->SetNumber( aTmpI, rRefId );
574 : }
575 4237 : if( aError.IsError() )
576 3536 : DeletePos( rInst, pClassData->nEntries -1 );
577 : }
578 : else
579 0 : aError = ERR_UNKNOWN_METHOD;
580 :
581 4237 : return( aError );
582 : }
583 :
584 : /*************************************************************************
585 : |*
586 : |* RscBaseCont::IsConsistent()
587 : |*
588 : *************************************************************************/
589 0 : sal_Bool RscBaseCont::IsConsistent( const RSCINST & rInst ) {
590 0 : sal_uInt32 i = 0;
591 : RscBaseContInst * pClassData;
592 : sal_Bool bRet;
593 :
594 0 : bRet = RscTop::IsConsistent( rInst );
595 :
596 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
597 :
598 : // auf doppelten Id Testen und Reihenfolge beibehalten
599 : // Komplexitaet = n^2 / 2
600 0 : for( i = 0; i < pClassData->nEntries; i++ ){
601 0 : if( !bNoId ){
602 0 : if( (sal_Int32)pClassData->pEntries[ i ].aName > 0x7FFF
603 0 : || (sal_Int32)pClassData->pEntries[ i ].aName < 1 ){
604 0 : bRet = sal_False;
605 : }
606 0 : else if( SearchElePos( rInst, pClassData->pEntries[ i ].aName,
607 0 : pClassData->pEntries[ i ].aInst.pClass, i +1 ).IsInst() )
608 : {
609 0 : bRet = sal_False;
610 : };
611 : }
612 0 : if( ! pClassData->pEntries[ i ].aInst.pClass->
613 0 : IsConsistent( pClassData->pEntries[ i ].aInst ) )
614 0 : bRet = sal_False;
615 : };
616 :
617 0 : return( bRet );
618 : }
619 :
620 : /*************************************************************************
621 : |*
622 : |* RscBaseCont::SetToDefault()
623 : |*
624 : *************************************************************************/
625 469 : void RscBaseCont::SetToDefault( const RSCINST & rInst )
626 : {
627 469 : sal_uInt32 i = 0;
628 : RscBaseContInst * pClassData;
629 :
630 469 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
631 :
632 503 : for( i = 0; i < pClassData->nEntries; i++ )
633 : {
634 102 : pClassData->pEntries[ i ].aInst.pClass->
635 102 : SetToDefault( pClassData->pEntries[ i ].aInst );
636 : };
637 :
638 469 : RscTop::SetToDefault( rInst );
639 469 : }
640 :
641 : /*************************************************************************
642 : |*
643 : |* RscBaseCont::IsDefault()
644 : |*
645 : *************************************************************************/
646 412 : sal_Bool RscBaseCont::IsDefault( const RSCINST & rInst ){
647 412 : sal_uInt32 i = 0;
648 : RscBaseContInst * pClassData;
649 :
650 412 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
651 :
652 412 : if( !pClassData->bDflt )
653 412 : return sal_False;
654 :
655 0 : for( i = 0; i < pClassData->nEntries; i++ ){
656 0 : if( ! pClassData->pEntries[ i ].aInst.pClass->
657 0 : IsDefault( pClassData->pEntries[ i ].aInst ) )
658 : {
659 0 : return( sal_False );
660 : };
661 : };
662 :
663 0 : return( RscTop::IsDefault( rInst ) );
664 : }
665 :
666 : /*************************************************************************
667 : |*
668 : |* RscBaseCont::IsValueDefault()
669 : |*
670 : *************************************************************************/
671 2646 : sal_Bool RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
672 : {
673 : RscBaseContInst * pClassData;
674 :
675 2646 : if( !RscTop::IsValueDefault( rInst, pDef ) )
676 0 : return sal_False;
677 :
678 2646 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
679 :
680 2646 : if( pClassData->nEntries )
681 1544 : return sal_False;
682 : else
683 1102 : return sal_True;
684 : }
685 :
686 : /*************************************************************************
687 : |*
688 : |* RscBaseCont::Delete()
689 : |*
690 : *************************************************************************/
691 0 : void RscBaseCont::Delete( const RSCINST & rInst, RscTop * pClass,
692 : const RscId & rId )
693 : {
694 0 : sal_uInt32 i = 0;
695 : RscBaseContInst * pClassData;
696 :
697 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
698 0 : if( !pClass )
699 0 : pClass = pTypeClass;
700 :
701 0 : for( i = 0; i < pClassData->nEntries; i++ ){
702 0 : if( pClassData->pEntries[ i ].aName == rId )
703 0 : if( pClassData->pEntries[ i ].aInst.pClass == pClass || !pClass ){
704 0 : DeletePos( rInst, i );
705 0 : return;
706 : };
707 : };
708 :
709 : }
710 :
711 : /*************************************************************************
712 : |*
713 : |* RscBaseCont::DeletePos()
714 : |*
715 : *************************************************************************/
716 8022 : void RscBaseCont::DeletePos( const RSCINST & rInst, sal_uInt32 nPos ){
717 : RscBaseContInst * pClassData;
718 :
719 8022 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
720 :
721 8022 : if( nPos < pClassData->nEntries ){
722 8022 : if( 1 == pClassData->nEntries )
723 1246 : DestroyElements( pClassData );
724 : else{
725 6776 : pClassData->pEntries[ nPos ].Destroy();
726 6776 : pClassData->nEntries--;
727 6776 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
728 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + 1 ];
729 : };
730 : };
731 8022 : }
732 :
733 : /*************************************************************************
734 : |*
735 : |* RscBaseCont::ContWriteSrc()
736 : |*
737 : *************************************************************************/
738 31591 : void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
739 : RscTypCont * pTC, sal_uInt32 nTab,
740 : const char * pVarName )
741 : {
742 31591 : sal_uInt32 i = 0, t = 0;
743 : RscBaseContInst * pClassData;
744 :
745 31591 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
746 :
747 55989 : for( i = 0; i < pClassData->nEntries; i++ )
748 : {
749 71266 : for( t = 0; t < nTab; t++ )
750 46868 : fputc( '\t', fOutput );
751 73194 : pClassData->pEntries[ i ].aInst.pClass->
752 24398 : WriteSrcHeader( pClassData->pEntries[ i ].aInst,
753 : fOutput, pTC, nTab,
754 97592 : pClassData->pEntries[ i ].aName, pVarName );
755 24398 : fprintf( fOutput, ";\n" );
756 : };
757 31591 : }
758 :
759 : /*************************************************************************
760 : |*
761 : |* RscBaseCont::ContWriteRc()
762 : |*
763 : *************************************************************************/
764 55963 : ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
765 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
766 : {
767 : RscBaseContInst * pClassData;
768 55963 : ERRTYPE aError;
769 :
770 55963 : if( bExtra || bNoId )
771 : { // Nur Subresourcen schreiben, wenn bExtra == sal_True
772 50038 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
773 :
774 74434 : for (sal_uInt32 i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
775 : {
776 73188 : aError = pClassData->pEntries[ i ].aInst.pClass->
777 24396 : WriteRcHeader( pClassData->pEntries[ i ].aInst,
778 : rMem, pTC,
779 24396 : pClassData->pEntries[ i ].aName,
780 121980 : nDeep, bExtra );
781 : }
782 : }
783 :
784 55963 : return( aError );
785 : }
786 :
787 : //==================================================================
788 0 : void RscBaseCont::ContWriteRcAccess
789 : (
790 : FILE * fOutput,
791 : RscTypCont * pTC,
792 : const char * pName,
793 : sal_Bool bWriteSize
794 : )
795 : {
796 0 : if( (bNoId || bWriteSize) && !pTypeClass1 )
797 : {
798 0 : fprintf( fOutput, "\t\tsal_uInt32 nItems = *(sal_uInt32 *)(pResData+nOffset) );\n" );
799 0 : fprintf( fOutput, "\t\tnOffset += sizeof( sal_uInt32 );\n" );
800 :
801 0 : fprintf( fOutput, "\t\t// Items hinzufuegen\n" );
802 0 : fprintf( fOutput, "\t\tfor( sal_uInt32 i = 0; i < nItems; i++ )\n" );
803 0 : fprintf( fOutput, "\t\t{\n" );
804 0 : pTypeClass->WriteRcAccess( fOutput, pTC, "Item" );
805 0 : fprintf( fOutput, "\t\t}\n" );
806 : }
807 : else
808 : {
809 0 : fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->getString( GetId() ).getStr() );
810 0 : fprintf( fOutput, "%s ", aCallPar2.getStr() );
811 0 : fprintf( fOutput, "ResId( (RSHEADER_TYPE*)(pResData+nOffset) ) ) );\n" );
812 0 : fprintf( fOutput, "\t\tnOffset += GetObjSizeRes( (RSHEADER_TYPE*)(pResData+nOffset) );\n" );
813 : }
814 0 : }
815 :
816 :
817 : /*************************************************************************
818 : |*
819 : |* RscBaseCont::WriteSrc()
820 : |*
821 : *************************************************************************/
822 30052 : void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
823 : RscTypCont * pTC, sal_uInt32 nTab,
824 : const char * pVarName )
825 : {
826 30052 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
827 30052 : ContWriteSrc( rInst, fOutput, pTC, nTab, pVarName );
828 30052 : }
829 :
830 : /*************************************************************************
831 : |*
832 : |* RscBaseCont::WriteRc()
833 : |*
834 : *************************************************************************/
835 54353 : ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
836 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
837 : {
838 54353 : ERRTYPE aError;
839 :
840 54353 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
841 54353 : if( aError.IsOk() )
842 54353 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
843 :
844 54353 : return( aError );
845 : }
846 :
847 : /*************************************************************************
848 : |*
849 : |* RscBaseCont::WriteHxx()
850 : |*
851 : *************************************************************************/
852 0 : ERRTYPE RscBaseCont::WriteHxx( const RSCINST & rInst, FILE * fOutput,
853 : RscTypCont * pTC, const RscId & rRscId )
854 : {
855 0 : sal_uInt32 i = 0;
856 : RscBaseContInst * pClassData;
857 0 : ERRTYPE aError;
858 :
859 0 : aError = RscTop::WriteHxx( rInst, fOutput, pTC, rRscId );
860 :
861 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
862 :
863 0 : for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
864 : {
865 0 : if( pClassData->pEntries[ i ].aName.IsId()
866 0 : && pClassData->pEntries[ i ].aInst.pClass->IsCodeWriteable() )
867 : {
868 0 : aError = pClassData->pEntries[ i ].aInst.pClass->
869 0 : WriteHxx( pClassData->pEntries[ i ].aInst,
870 : fOutput, pTC,
871 0 : pClassData->pEntries[ i ].aName );
872 : }
873 : };
874 :
875 0 : return( aError );
876 : }
877 :
878 : /*************************************************************************
879 : |*
880 : |* RscBaseCont::WriteCxx()
881 : |*
882 : *************************************************************************/
883 0 : ERRTYPE RscBaseCont::WriteCxx( const RSCINST & rInst, FILE * fOutput,
884 : RscTypCont * pTC, const RscId & rRscId )
885 : {
886 0 : sal_uInt32 i = 0;
887 : RscBaseContInst * pClassData;
888 0 : ERRTYPE aError;
889 :
890 0 : aError = RscTop::WriteCxx( rInst, fOutput, pTC, rRscId );
891 :
892 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
893 :
894 0 : for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
895 : {
896 0 : if( pClassData->pEntries[ i ].aName.IsId()
897 0 : && pClassData->pEntries[ i ].aInst.pClass->IsCodeWriteable() )
898 : {
899 0 : aError = pClassData->pEntries[ i ].aInst.pClass->
900 0 : WriteCxx( pClassData->pEntries[ i ].aInst,
901 : fOutput, pTC,
902 0 : pClassData->pEntries[ i ].aName );
903 : }
904 : };
905 :
906 0 : return( aError );
907 : }
908 :
909 : /*************** R s c C o n t W r i t e S r c ***************************/
910 : /*************************************************************************
911 : |*
912 : |* RscContWriteSrc::RscContWriteSrc()
913 : |*
914 : *************************************************************************/
915 6910 : RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
916 : RscTop * pSuper, sal_Bool bNoIdent )
917 6910 : : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
918 6910 : {}
919 :
920 : /*************************************************************************
921 : |*
922 : |* RscContWriteSrc::WriteSrc()
923 : |*
924 : *************************************************************************/
925 1539 : void RscContWriteSrc::WriteSrc( const RSCINST & rInst, FILE * fOutput,
926 : RscTypCont * pTC, sal_uInt32 nTab,
927 : const char * pVarName )
928 : {
929 : sal_uInt32 i;
930 :
931 1539 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
932 :
933 1539 : fprintf( fOutput, "\n" );
934 4907 : for( i = 0; i < nTab; i++ )
935 3368 : fputc( '\t', fOutput );
936 1539 : fprintf( fOutput, "{\n" );
937 :
938 1539 : ContWriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
939 :
940 4907 : for( i = 0; i < nTab; i++ )
941 3368 : fputc( '\t', fOutput );
942 1539 : fprintf( fOutput, "}" );
943 1539 : }
944 :
945 : /*************** R s c C o n t *******************************************/
946 : /*************************************************************************
947 : |*
948 : |* RscCont::RscCont()
949 : |*
950 : *************************************************************************/
951 6219 : RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, sal_Bool bNoIdent )
952 6219 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
953 6219 : {}
954 :
955 : /*************************************************************************
956 : |*
957 : |* RscCont::WriteRc()
958 : |*
959 : *************************************************************************/
960 1610 : ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
961 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
962 : {
963 : RscBaseContInst * pClassData;
964 1610 : ERRTYPE aError;
965 :
966 1610 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
967 :
968 1610 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
969 :
970 1610 : rMem.Put( pClassData->nEntries );
971 :
972 1610 : if( aError.IsOk() )
973 1610 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
974 :
975 1610 : return aError;
976 : }
977 :
978 : //==================================================================
979 0 : void RscCont::WriteRcAccess
980 : (
981 : FILE * fOutput,
982 : RscTypCont * pTC,
983 : const char * pName
984 : )
985 : {
986 0 : ContWriteRcAccess( fOutput, pTC, pName, sal_True );
987 0 : }
988 :
989 : /*************************************************************************
990 : |*
991 : |* RscContExtraData::RscContExtraData()
992 : |*
993 : *************************************************************************/
994 691 : RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
995 : RscTop * pSuper, sal_Bool bNoIdent )
996 691 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
997 691 : {}
998 :
999 : /*************************************************************************
1000 : |*
1001 : |* RscContExtraData::WriteRc()
1002 : |*
1003 : *************************************************************************/
1004 30139 : ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1005 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
1006 : {
1007 30139 : ERRTYPE aError;
1008 :
1009 30139 : if( bExtra )
1010 24214 : aError = RscContWriteSrc::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1011 : else
1012 5925 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1013 :
1014 30139 : return aError;
1015 : }
1016 :
1017 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
