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 2095 : RscFlag::RscFlag( Atom nId, sal_uInt32 nTypeId )
28 2095 : : RscConst( nId, nTypeId )
29 : {
30 2095 : }
31 :
32 62460 : sal_uInt32 RscFlag::Size()
33 : {
34 62460 : return ALIGNED_SIZE( sizeof( RscFlagInst ) *
35 : ( 1 + (nEntries -1) / (sizeof( sal_uInt32 ) * 8) ) );
36 : }
37 :
38 42 : ERRTYPE RscFlag::SetNotConst( const RSCINST & rInst, Atom nConst )
39 : {
40 42 : sal_uInt32 i = 0;
41 :
42 42 : if( nEntries != (i = GetConstPos( nConst )) )
43 : {
44 42 : sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
45 :
46 42 : i = i / (sizeof( sal_uInt32 ) * 8);
47 42 : ((RscFlagInst *)rInst.pData)[ i ].nFlags &= ~nFlag;
48 42 : ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags &= ~nFlag;
49 42 : return ERR_OK;
50 : }
51 :
52 0 : return ERR_RSCFLAG;
53 : }
54 :
55 1971 : ERRTYPE RscFlag::SetConst( const RSCINST & rInst, Atom nConst, sal_Int32 /*nVal*/ )
56 : {
57 1971 : sal_uInt32 i = 0;
58 :
59 1971 : if( nEntries != (i = GetConstPos( nConst )) )
60 : {
61 1971 : sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
62 :
63 1971 : i = i / (sizeof( sal_uInt32 ) * 8);
64 1971 : ((RscFlagInst *)rInst.pData)[ i ].nFlags |= nFlag;
65 1971 : ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags &= ~nFlag;
66 1971 : return ERR_OK;
67 : }
68 :
69 0 : return ERR_RSCFLAG;
70 : }
71 :
72 59335 : RSCINST RscFlag::CreateBasic( RSCINST * pInst )
73 : {
74 59335 : RSCINST aInst;
75 :
76 59335 : if( !pInst )
77 : {
78 1069 : aInst.pClass = this;
79 1069 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
80 : }
81 : else
82 58266 : aInst = *pInst;
83 :
84 59335 : return aInst;
85 : }
86 :
87 9169 : RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, bool bOwnClass )
88 : {
89 9169 : RSCINST aInst = CreateBasic( pInst );
90 :
91 9169 : if( !bOwnClass && rDflt.IsInst() )
92 0 : bOwnClass = rDflt.pClass->InHierarchy( this );
93 :
94 9169 : if( bOwnClass )
95 0 : memmove( aInst.pData, rDflt.pData, Size() );
96 : else
97 : {
98 19072 : for( sal_uInt32 i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
99 : {
100 9903 : ((RscFlagInst *)aInst.pData)[ i ].nFlags = 0;
101 9903 : ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
102 : }
103 : }
104 :
105 9169 : return aInst;
106 : }
107 :
108 50166 : RSCINST RscFlag::CreateClient( RSCINST * pInst, const RSCINST & rDfltI,
109 : bool bOwnClass, Atom nConstId )
110 : {
111 50166 : RSCINST aInst = CreateBasic( pInst );
112 50166 : sal_uInt32 i = 0;
113 :
114 50166 : if( !bOwnClass && rDfltI.IsInst() )
115 0 : bOwnClass = rDfltI.pClass->InHierarchy( this );
116 :
117 50166 : if( nEntries != (i = GetConstPos( nConstId )) )
118 : {
119 50166 : sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
120 50166 : i = i / (sizeof( sal_uInt32 ) * 8);
121 50166 : if( bOwnClass )
122 : {
123 : ((RscFlagInst *)aInst.pData)[ i ].nFlags &=
124 0 : ~nFlag | ((RscFlagInst *)rDfltI.pData)[ i ].nFlags;
125 : ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags &=
126 0 : ~nFlag | ((RscFlagInst *)rDfltI.pData)[ i ].nDfltFlags;
127 : }
128 : else
129 : {
130 50166 : ((RscFlagInst *)aInst.pData)[ i ].nFlags &= ~nFlag;
131 50166 : ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags |= nFlag;
132 : }
133 : }
134 :
135 50166 : 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 : ((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( ((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( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags & nFlag )
168 0 : return true ;
169 : else
170 0 : return false;
171 : }
172 0 : return true;
173 : }
174 :
175 1017 : bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
176 : Atom nConstId )
177 : {
178 1017 : sal_uInt32 i = 0, nFlag = 0;
179 :
180 1017 : if( nEntries != (i = GetConstPos( nConstId )) )
181 : {
182 1017 : nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
183 1017 : i = i / (sizeof( sal_uInt32 ) * 8);
184 :
185 1017 : if( pDef )
186 : {
187 2034 : if( (((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag) ==
188 1017 : (((RscFlagInst *)pDef)[ i ].nFlags & nFlag) )
189 : {
190 40 : return true;
191 : }
192 : }
193 : }
194 :
195 977 : 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( (((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag) !=
210 0 : (((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 977 : bool RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
226 : {
227 977 : sal_uInt32 i = 0, nFlag = 0;
228 :
229 977 : if( nEntries != (i = GetConstPos( nConstId )) )
230 : {
231 977 : nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
232 977 : i = i / (sizeof( sal_uInt32 ) * 8);
233 :
234 977 : if( ((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag )
235 977 : 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( !( ((RscFlagInst *)rInst.pData)[ nIndex ].nDfltFlags & Flag) )
253 : {
254 0 : if( bComma )
255 0 : fprintf( fOutput, ", " );
256 :
257 0 : if( ((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 966 : ERRTYPE RscFlag::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
273 : RscTypCont *, sal_uInt32, bool )
274 : {
275 966 : sal_Int32 lVal = 0;
276 966 : sal_uInt32 i = 0, Flag = 0, nIndex = 0;
277 :
278 966 : Flag = 1;
279 22885 : for( i = 0; i < nEntries; i++ )
280 : {
281 21919 : nIndex = i / (sizeof( sal_uInt32 ) * 8);
282 :
283 21919 : if( ((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag )
284 977 : lVal |= pVarArray[ i ].lValue;
285 :
286 21919 : Flag <<= 1;
287 21919 : if( !Flag )
288 363 : Flag = 1;
289 : }
290 :
291 966 : aMem.Put( (sal_Int32)lVal );
292 966 : return ERR_OK;
293 : }
294 :
295 38548 : RscClient::RscClient( Atom nId, sal_uInt32 nTypeId, RscFlag * pClass,
296 : Atom nConstantId )
297 38548 : : RscTop ( nId, nTypeId )
298 : {
299 38548 : pRefClass = pClass;
300 38548 : nConstId = nConstantId;
301 38548 : }
302 :
303 0 : RSCCLASS_TYPE RscClient::GetClassType() const
304 : {
305 0 : return RSCCLASS_BOOL;
306 : }
307 :
308 977 : void RscClient::WriteSrc( const RSCINST & rInst, FILE * fOutput,
309 : RscTypCont *, sal_uInt32, const char * )
310 : {
311 977 : if( pRefClass->IsSet( rInst, nConstId ) )
312 977 : fprintf( fOutput, "TRUE" );
313 : else
314 0 : fprintf( fOutput, "FALSE" );
315 977 : }
316 :
317 50166 : RSCINST RscClient::Create( RSCINST * pInst, const RSCINST & rDflt,
318 : bool bOwnClass )
319 : {
320 50166 : RSCINST aTmpI, aDfltI;
321 :
322 50166 : if( pInst )
323 : {
324 49842 : aTmpI.pClass = pRefClass;
325 49842 : aTmpI.pData = pInst->pData;
326 : }
327 :
328 50166 : 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 50166 : if( pInst )
339 : aTmpI = pRefClass->CreateClient( &aTmpI, aDfltI,
340 49842 : bOwnClass, nConstId );
341 : else
342 : aTmpI = pRefClass->CreateClient( NULL, aDfltI,
343 324 : bOwnClass, nConstId );
344 50166 : aTmpI.pClass = this;
345 :
346 50166 : return aTmpI;
347 : }
348 :
349 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
