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 <cstdlib>
24 : #include <cstdio>
25 : #include <cstring>
26 :
27 : // Solar Definitionen
28 : #include <tools/solar.h>
29 :
30 : // Programmabhaengige Includes.
31 : #include <rscconst.hxx>
32 : #include <rscall.h>
33 : #include <rschash.hxx>
34 : #include <tools/resid.hxx>
35 :
36 : /****************** C O D E **********************************************/
37 : /****************** R s c C o n s t **************************************/
38 : /*************************************************************************
39 : |*
40 : |* RscConst::RscConst()
41 : |*
42 : *************************************************************************/
43 15202 : RscConst::RscConst( Atom nId, sal_uInt32 nTypeId )
44 15202 : : RscTop( nId, nTypeId )
45 : {
46 15202 : pVarArray = NULL;
47 15202 : nEntries = 0;
48 15202 : }
49 :
50 : /*************************************************************************
51 : |*
52 : |* RscConst::~RscConst()
53 : |*
54 : *************************************************************************/
55 30404 : RscConst::~RscConst()
56 : {
57 15202 : if( pVarArray )
58 15202 : rtl_freeMemory( (void *)pVarArray );
59 15202 : }
60 :
61 : /*************************************************************************
62 : |*
63 : |* RscConst::GetClassType()
64 : |*
65 : *************************************************************************/
66 0 : RSCCLASS_TYPE RscConst::GetClassType() const
67 : {
68 0 : return RSCCLASS_CONST;
69 : }
70 :
71 : /*************************************************************************
72 : |*
73 : |* RscConst::SetConstance()
74 : |*
75 : *************************************************************************/
76 749735 : ERRTYPE RscConst::SetConstant( Atom nVarName, sal_Int32 lValue ){
77 749735 : if( pVarArray )
78 : pVarArray = (VarEle *)
79 : rtl_reallocateMemory( (void *)pVarArray,
80 734533 : ((nEntries +1) * sizeof( VarEle )) );
81 : else
82 : pVarArray = (VarEle *)
83 15202 : rtl_allocateMemory( ((nEntries +1) * sizeof( VarEle )) );
84 749735 : pVarArray[ nEntries ].nId = nVarName;
85 749735 : pVarArray[ nEntries ].lValue = lValue;
86 749735 : nEntries++;
87 :
88 749735 : return( ERR_OK );
89 : }
90 :
91 : /*************************************************************************
92 : |*
93 : |* RscConst::GetConstance()
94 : |*
95 : *************************************************************************/
96 0 : Atom RscConst::GetConstant( sal_uInt32 nPos ){
97 0 : if( nPos < nEntries )
98 0 : return pVarArray[ nPos ].nId;
99 0 : return( InvalidAtom );
100 : }
101 :
102 : /*************************************************************************
103 : |*
104 : |* RscConst::GetConstValue()
105 : |*
106 : *************************************************************************/
107 41981 : sal_Bool RscConst::GetConstValue( Atom nConst, sal_Int32 * pValue ) const
108 : {
109 41981 : sal_uInt32 i = 0;
110 :
111 210057 : for( i = 0; i < nEntries; i++ )
112 210057 : if( pVarArray[ i ].nId == nConst )
113 : {
114 41981 : *pValue = pVarArray[ i ].lValue;
115 41981 : return sal_True;
116 : }
117 0 : return sal_False;
118 : }
119 :
120 : /*************************************************************************
121 : |*
122 : |* RscConst::GetValueConst()
123 : |*
124 : *************************************************************************/
125 62997 : sal_Bool RscConst::GetValueConst( sal_Int32 lValue, Atom * pConst ) const
126 : {
127 62997 : sal_uInt32 i = 0;
128 :
129 315198 : for( i = 0; i < nEntries; i++ )
130 315198 : if( pVarArray[ i ].lValue == lValue )
131 : {
132 62997 : *pConst = pVarArray[ i ].nId;
133 62997 : return sal_True;
134 : }
135 0 : return sal_False;
136 : }
137 :
138 : /*************************************************************************
139 : |*
140 : |* RscConst::GetConstPos()
141 : |*
142 : |* Beschreibung Sucht die Position der Konstanten
143 : |* Return = nEntries, nicht gefunden
144 : |* Return = Position im Feld
145 : |*
146 : *************************************************************************/
147 383163 : sal_uInt32 RscConst::GetConstPos( Atom nConst )
148 : {
149 383163 : sal_uInt32 i = 0;
150 :
151 4908248 : for( i = 0; i < nEntries; i++ )
152 : {
153 4908248 : if( pVarArray[ i ].nId == nConst )
154 383163 : return( i );
155 : }
156 :
157 0 : return( nEntries );
158 : }
159 :
160 : /*************************************************************************
161 : |*
162 : |* RscEnum::WriteSyntax()
163 : |*
164 : *************************************************************************/
165 0 : void RscConst::WriteSyntax( FILE * fOutput, RscTypCont * pTC )
166 : {
167 0 : RscTop::WriteSyntax( fOutput, pTC );
168 :
169 0 : sal_uInt32 i = 0;
170 : // Wenn eine Variable Maskierung hat, dann Maskenfeld
171 0 : fprintf( fOutput, "\t" );
172 0 : for( i = 0; i < nEntries; i++ )
173 : {
174 0 : fprintf( fOutput, "%s, ", pHS->getString( pVarArray[ i ].nId ).getStr() );
175 0 : if( 3 == (i % 4) && i < sal_uInt32(nEntries -1) )
176 0 : fprintf( fOutput, "\n\t" );
177 : };
178 0 : fprintf( fOutput, "\n" );
179 0 : }
180 :
181 : //==================================================================
182 0 : void RscConst::WriteRcAccess
183 : (
184 : FILE * fOutput,
185 : RscTypCont * /*pTC*/,
186 : const char * pName
187 : )
188 : {
189 0 : fprintf( fOutput, "\t\tSet%s( %s( ", pName, pHS->getString( GetId() ).getStr() );
190 0 : fprintf( fOutput, "*(short*)(pResData+nOffset) ) );\n" );
191 0 : fprintf( fOutput, "\t\tnOffset += sizeof( short );\n" );
192 0 : }
193 :
194 : /****************** R s c E n u m ****************************************/
195 : /*************************************************************************
196 : |*
197 : |* RscEnum::RscEnum()
198 : |*
199 : *************************************************************************/
200 11747 : RscEnum::RscEnum( Atom nId, sal_uInt32 nTypeId )
201 11747 : : RscConst( nId, nTypeId )
202 : {
203 11747 : nSize = ALIGNED_SIZE( sizeof( RscEnumInst ) );
204 11747 : }
205 :
206 : /*************************************************************************
207 : |*
208 : |* RscEnum::SetConst()
209 : |*
210 : *************************************************************************/
211 35256 : ERRTYPE RscEnum::SetConst( const RSCINST & rInst, Atom nConst, sal_Int32 /*nVal*/ )
212 : {
213 35256 : sal_uInt32 i = 0;
214 :
215 35256 : if( nEntries != (i = GetConstPos( nConst )) )
216 : {
217 35256 : ((RscEnumInst *)rInst.pData)->nValue = i;
218 35256 : ((RscEnumInst *)rInst.pData)->bDflt = sal_False;
219 35256 : return( ERR_OK );
220 : };
221 :
222 0 : return( ERR_RSCENUM );
223 : }
224 :
225 : /*************************************************************************
226 : |*
227 : |* RscEnum::SetNumber()
228 : |*
229 : *************************************************************************/
230 1 : ERRTYPE RscEnum::SetNumber( const RSCINST & rInst, sal_Int32 lValue )
231 : {
232 1 : sal_uInt32 i = 0;
233 :
234 6 : for( i = 0; i < nEntries; i++ ){
235 6 : if( (sal_Int32)pVarArray[ i ].lValue == lValue )
236 1 : return( SetConst( rInst, pVarArray[ i ].nId, lValue ) );
237 : };
238 :
239 0 : return( ERR_RSCENUM );
240 : }
241 :
242 : /*************************************************************************
243 : |*
244 : |* RscEnum::GetConst()
245 : |*
246 : *************************************************************************/
247 0 : ERRTYPE RscEnum::GetConst( const RSCINST & rInst, Atom * pH ){
248 0 : *pH = pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].nId;
249 0 : return( ERR_OK );
250 : }
251 :
252 : /*************************************************************************
253 : |*
254 : |* RscEnum::GetNumber()
255 : |*
256 : *************************************************************************/
257 0 : ERRTYPE RscEnum::GetNumber( const RSCINST & rInst, sal_Int32 * pNumber ){
258 0 : *pNumber = pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].lValue;
259 0 : return( ERR_OK );
260 : }
261 :
262 : /*************************************************************************
263 : |*
264 : |* RscEnum::Create()
265 : |*
266 : *************************************************************************/
267 60233 : RSCINST RscEnum::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
268 60233 : RSCINST aInst;
269 :
270 60233 : if( !pInst ){
271 281 : aInst.pClass = this;
272 : aInst.pData = (CLASS_DATA)
273 281 : rtl_allocateMemory( sizeof( RscEnumInst ) );
274 : }
275 : else
276 59952 : aInst = *pInst;
277 60233 : if( !bOwnClass && rDflt.IsInst() )
278 369 : bOwnClass = rDflt.pClass->InHierarchy( this );
279 :
280 60233 : if( bOwnClass )
281 369 : memmove( aInst.pData, rDflt.pData, Size() );
282 : else{
283 59864 : ((RscEnumInst *)aInst.pData)->nValue = 0;
284 59864 : ((RscEnumInst *)aInst.pData)->bDflt = sal_True;
285 : }
286 :
287 60233 : return( aInst );
288 : }
289 :
290 : /*************************************************************************
291 : |*
292 : |* RscEnum::IsValueDefault()
293 : |*
294 : *************************************************************************/
295 674 : sal_Bool RscEnum::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
296 674 : if( pDef ){
297 674 : if( ((RscEnumInst*)rInst.pData)->nValue ==
298 : ((RscEnumInst*)pDef)->nValue )
299 : {
300 107 : return sal_True;
301 : }
302 : }
303 :
304 567 : return sal_False;
305 : }
306 :
307 : /*************************************************************************
308 : |*
309 : |* RscEnum::WriteSrc()
310 : |*
311 : *************************************************************************/
312 17667 : void RscEnum::WriteSrc( const RSCINST & rInst, FILE * fOutput,
313 : RscTypCont *, sal_uInt32, const char * )
314 : {
315 : fprintf( fOutput, "%s", pHS->getString(
316 17667 : pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].nId ).getStr() );
317 17667 : }
318 :
319 : /*************************************************************************
320 : |*
321 : |* RscEnum::WriteRc()
322 : |*
323 : *************************************************************************/
324 18386 : ERRTYPE RscEnum::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
325 : RscTypCont *, sal_uInt32, sal_Bool )
326 : {
327 18386 : aMem.Put( (sal_Int32)pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].lValue );
328 18386 : return( ERR_OK );
329 : }
330 :
331 691 : RscLangEnum::RscLangEnum()
332 : : RscEnum( pHS->getID( "LangEnum" ), RSC_NOTYPE ),
333 691 : mnLangId( 0x400 )
334 : {
335 691 : }
336 :
337 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
