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 :
21 : #include <stdlib.h>
22 : #include <stdio.h>
23 : #include <string.h>
24 :
25 : #include <rscflag.hxx>
26 :
27 2085 : RscFlag::RscFlag( Atom nId, sal_uInt32 nTypeId )
28 2085 : : RscConst( nId, nTypeId )
29 : {
30 2085 : }
31 :
32 57661 : sal_uInt32 RscFlag::Size()
33 : {
34 57661 : return ALIGNED_SIZE( sizeof( RscFlagInst ) *
35 : ( 1 + (nEntries -1) / (sizeof( sal_uInt32 ) * 8) ) );
36 : }
37 :
38 17 : ERRTYPE RscFlag::SetNotConst( const RSCINST & rInst, Atom nConst )
39 : {
40 17 : sal_uInt32 i = 0;
41 :
42 17 : if( nEntries != (i = GetConstPos( nConst )) )
43 : {
44 17 : sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
45 :
46 17 : i = i / (sizeof( sal_uInt32 ) * 8);
47 17 : reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nFlags &= ~nFlag;
48 17 : reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nDfltFlags &= ~nFlag;
49 17 : return ERR_OK;
50 : }
51 :
52 0 : return ERR_RSCFLAG;
53 : }
54 :
55 1009 : ERRTYPE RscFlag::SetConst( const RSCINST & rInst, Atom nConst, sal_Int32 /*nVal*/ )
56 : {
57 1009 : sal_uInt32 i = 0;
58 :
59 1009 : if( nEntries != (i = GetConstPos( nConst )) )
60 : {
61 1009 : sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
62 :
63 1009 : i = i / (sizeof( sal_uInt32 ) * 8);
64 1009 : reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nFlags |= nFlag;
65 1009 : reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nDfltFlags &= ~nFlag;
66 1009 : return ERR_OK;
67 : }
68 :
69 0 : return ERR_RSCFLAG;
70 : }
71 :
72 48829 : RSCINST RscFlag::CreateBasic( RSCINST * pInst )
73 : {
74 48829 : RSCINST aInst;
75 :
76 48829 : if( !pInst )
77 : {
78 511 : aInst.pClass = this;
79 511 : aInst.pData = static_cast<CLASS_DATA>(rtl_allocateMemory( Size() ));
80 : }
81 : else
82 48318 : aInst = *pInst;
83 :
84 48829 : return aInst;
85 : }
86 :
87 7773 : RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, bool bOwnClass )
88 : {
89 7773 : RSCINST aInst = CreateBasic( pInst );
90 :
91 7773 : if( !bOwnClass && rDflt.IsInst() )
92 0 : bOwnClass = rDflt.pClass->InHierarchy( this );
93 :
94 7773 : if( bOwnClass )
95 0 : memmove( aInst.pData, rDflt.pData, Size() );
96 : else
97 : {
98 15867 : for( sal_uInt32 i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
99 : {
100 8094 : reinterpret_cast<RscFlagInst *>(aInst.pData)[ i ].nFlags = 0;
101 8094 : reinterpret_cast<RscFlagInst *>(aInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
102 : }
103 : }
104 :
105 7773 : return aInst;
106 : }
107 :
108 41056 : RSCINST RscFlag::CreateClient( RSCINST * pInst, const RSCINST & rDfltI,
109 : bool bOwnClass, Atom nConstId )
110 : {
111 41056 : RSCINST aInst = CreateBasic( pInst );
112 41056 : sal_uInt32 i = 0;
113 :
114 41056 : if( !bOwnClass && rDfltI.IsInst() )
115 0 : bOwnClass = rDfltI.pClass->InHierarchy( this );
116 :
117 41056 : if( nEntries != (i = GetConstPos( nConstId )) )
118 : {
119 41056 : sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
120 41056 : i = i / (sizeof( sal_uInt32 ) * 8);
121 41056 : if( bOwnClass )
122 : {
123 : reinterpret_cast<RscFlagInst *>(aInst.pData)[ i ].nFlags &=
124 0 : ~nFlag | reinterpret_cast<RscFlagInst *>(rDfltI.pData)[ i ].nFlags;
125 : reinterpret_cast<RscFlagInst *>(aInst.pData)[ i ].nDfltFlags &=
126 0 : ~nFlag | reinterpret_cast<RscFlagInst *>(rDfltI.pData)[ i ].nDfltFlags;
127 : }
128 : else
129 : {
130 41056 : reinterpret_cast<RscFlagInst *>(aInst.pData)[ i ].nFlags &= ~nFlag;
131 41056 : reinterpret_cast<RscFlagInst *>(aInst.pData)[ i ].nDfltFlags |= nFlag;
132 : }
133 : }
134 :
135 41056 : return aInst;
136 : }
137 :
138 0 : void RscFlag::SetToDefault( const RSCINST & rInst )
139 : {
140 0 : sal_uInt32 i = 0;
141 :
142 0 : for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
143 0 : reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
144 0 : }
145 :
146 0 : bool RscFlag::IsDefault( const RSCINST & rInst )
147 : {
148 0 : sal_uInt32 i = 0;
149 :
150 0 : for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
151 : {
152 0 : if( reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nDfltFlags != 0xFFFFFFFF )
153 0 : return false;
154 : }
155 0 : return true;
156 : }
157 :
158 0 : bool RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
159 : {
160 0 : sal_uInt32 i = 0, nFlag = 0;
161 :
162 0 : if( nEntries != (i = GetConstPos( nConstId )) )
163 : {
164 0 : nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
165 0 : i = i / (sizeof( sal_uInt32 ) * 8);
166 :
167 0 : if( reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nDfltFlags & nFlag )
168 0 : return true ;
169 : else
170 0 : return false;
171 : }
172 0 : return true;
173 : }
174 :
175 516 : bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
176 : Atom nConstId )
177 : {
178 516 : sal_uInt32 i = 0, nFlag = 0;
179 :
180 516 : if( nEntries != (i = GetConstPos( nConstId )) )
181 : {
182 516 : nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
183 516 : i = i / (sizeof( sal_uInt32 ) * 8);
184 :
185 516 : if( pDef )
186 : {
187 1032 : if( (reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nFlags & nFlag) ==
188 516 : (reinterpret_cast<RscFlagInst *>(pDef)[ i ].nFlags & nFlag) )
189 : {
190 15 : return true;
191 : }
192 : }
193 : }
194 :
195 501 : return false;
196 : }
197 :
198 0 : bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
199 : {
200 0 : if( pDef )
201 : {
202 0 : sal_uInt32 Flag = 0, nIndex = 0;
203 :
204 0 : Flag = 1;
205 0 : for( sal_uInt32 i = 0; i < nEntries; i++ )
206 : {
207 0 : nIndex = i / (sizeof( sal_uInt32 ) * 8);
208 :
209 0 : if( (reinterpret_cast<RscFlagInst *>(rInst.pData)[ nIndex ].nFlags & Flag) !=
210 0 : (reinterpret_cast<RscFlagInst *>(pDef)[ nIndex ].nFlags & Flag) )
211 : {
212 0 : return false;
213 : }
214 0 : Flag <<= 1;
215 0 : if( !Flag )
216 0 : Flag = 1;
217 : }
218 : }
219 : else
220 0 : return false;
221 :
222 0 : return true;
223 : }
224 :
225 501 : bool RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
226 : {
227 501 : sal_uInt32 i = 0, nFlag = 0;
228 :
229 501 : if( nEntries != (i = GetConstPos( nConstId )) )
230 : {
231 501 : nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
232 501 : i = i / (sizeof( sal_uInt32 ) * 8);
233 :
234 501 : if( reinterpret_cast<RscFlagInst *>(rInst.pData)[ i ].nFlags & nFlag )
235 501 : return true;
236 : else
237 0 : return false;
238 : }
239 0 : return true;
240 : }
241 :
242 0 : void RscFlag::WriteSrc( const RSCINST & rInst, FILE * fOutput,
243 : RscTypCont *, sal_uInt32, const char * )
244 : {
245 0 : sal_uInt32 i = 0, Flag = 0, nIndex = 0;
246 0 : bool bComma = false;
247 :
248 0 : Flag = 1;
249 0 : for( i = 0; i < nEntries; i++ )
250 : {
251 0 : nIndex = i / (sizeof( sal_uInt32 ) * 8);
252 0 : if( !( reinterpret_cast<RscFlagInst *>(rInst.pData)[ nIndex ].nDfltFlags & Flag) )
253 : {
254 0 : if( bComma )
255 0 : fprintf( fOutput, ", " );
256 :
257 0 : if( reinterpret_cast<RscFlagInst *>(rInst.pData)[ nIndex ].nFlags & Flag )
258 0 : fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
259 : else
260 : {
261 0 : fprintf( fOutput, "not " );
262 0 : fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
263 : }
264 0 : bComma = true;
265 : }
266 0 : Flag <<= 1;
267 0 : if( !Flag )
268 0 : Flag = 1;
269 : }
270 0 : }
271 :
272 491 : ERRTYPE RscFlag::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
273 : RscTypCont *, sal_uInt32, bool )
274 : {
275 491 : sal_Int32 lVal = 0;
276 491 : sal_uInt32 i = 0, Flag = 0, nIndex = 0;
277 :
278 491 : Flag = 1;
279 10384 : for( i = 0; i < nEntries; i++ )
280 : {
281 9893 : nIndex = i / (sizeof( sal_uInt32 ) * 8);
282 :
283 9893 : if( reinterpret_cast<RscFlagInst *>(rInst.pData)[ nIndex ].nFlags & Flag )
284 501 : lVal |= pVarArray[ i ].lValue;
285 :
286 9893 : Flag <<= 1;
287 9893 : if( !Flag )
288 158 : Flag = 1;
289 : }
290 :
291 491 : aMem.Put( (sal_Int32)lVal );
292 491 : return ERR_OK;
293 : }
294 :
295 37530 : RscClient::RscClient( Atom nId, sal_uInt32 nTypeId, RscFlag * pClass,
296 : Atom nConstantId )
297 37530 : : RscTop ( nId, nTypeId )
298 : {
299 37530 : pRefClass = pClass;
300 37530 : nConstId = nConstantId;
301 37530 : }
302 :
303 0 : RSCCLASS_TYPE RscClient::GetClassType() const
304 : {
305 0 : return RSCCLASS_BOOL;
306 : }
307 :
308 501 : void RscClient::WriteSrc( const RSCINST & rInst, FILE * fOutput,
309 : RscTypCont *, sal_uInt32, const char * )
310 : {
311 501 : if( pRefClass->IsSet( rInst, nConstId ) )
312 501 : fprintf( fOutput, "TRUE" );
313 : else
314 0 : fprintf( fOutput, "FALSE" );
315 501 : }
316 :
317 41056 : RSCINST RscClient::Create( RSCINST * pInst, const RSCINST & rDflt,
318 : bool bOwnClass )
319 : {
320 41056 : RSCINST aTmpI, aDfltI;
321 :
322 41056 : if( pInst )
323 : {
324 40876 : aTmpI.pClass = pRefClass;
325 40876 : aTmpI.pData = pInst->pData;
326 : }
327 :
328 41056 : if( !bOwnClass && rDflt.IsInst() )
329 : {
330 0 : bOwnClass = rDflt.pClass->InHierarchy( this );
331 0 : if( bOwnClass )
332 : {
333 0 : aDfltI.pClass = pRefClass;
334 0 : aDfltI.pData = rDflt.pData;
335 : }
336 : }
337 :
338 41056 : if( pInst )
339 : aTmpI = pRefClass->CreateClient( &aTmpI, aDfltI,
340 40876 : bOwnClass, nConstId );
341 : else
342 : aTmpI = pRefClass->CreateClient( NULL, aDfltI,
343 180 : bOwnClass, nConstId );
344 41056 : aTmpI.pClass = this;
345 :
346 41056 : return aTmpI;
347 : }
348 :
349 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
