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 : #ifndef _RSCRANGE_HXX
20 : #define _RSCRANGE_HXX
21 :
22 : #include <rscall.h>
23 : #include <rscerror.h>
24 : #include <rschash.hxx>
25 : #include <rsctop.hxx>
26 :
27 : /******************* R s c R a n g e *************************************/
28 6910 : class RscRange : public RscTop
29 : {
30 : protected:
31 : struct RscRangeInst {
32 : sal_uInt16 nValue; // nValue = Ausgangswert - nMin
33 : sal_Bool bDflt; // Ist Default
34 : };
35 : sal_Int32 nMin; // Minimum des Bereiches
36 : sal_Int32 nMax; // Maximum des Bereiches
37 : sal_uInt32 nSize;
38 : public:
39 : RscRange( Atom nId, sal_uInt32 nTypId );
40 : virtual RSCCLASS_TYPE GetClassType() const;
41 : RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool );
42 : // Der zulaessige Bereich wird gesetzt
43 : ERRTYPE SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum );
44 : // Gibt die Groesse der Klasse in Bytes
45 101577 : sal_uInt32 Size(){ return nSize; }
46 : // Eine Zuweisung an eine Variable
47 36 : virtual void SetToDefault( const RSCINST & rInst )
48 : {
49 36 : ((RscRangeInst*)rInst.pData)->bDflt = sal_True;
50 36 : }
51 0 : sal_Bool IsDefault( const RSCINST & rInst)
52 : {
53 0 : return( ((RscRangeInst*)rInst.pData)->bDflt );
54 : };
55 : // Als Default setzen
56 : sal_Bool IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef );
57 : ERRTYPE SetNumber( const RSCINST &, sal_Int32 );
58 : ERRTYPE GetNumber( const RSCINST &, sal_Int32 * );
59 : void WriteSrc( const RSCINST &, FILE * fOutput,
60 : RscTypCont * pTC, sal_uInt32 nTab, const char * );
61 : ERRTYPE WriteRc( const RSCINST &, RscWriteRc & aMem,
62 : RscTypCont * pTC, sal_uInt32, sal_Bool bExtra );
63 : void WriteRcAccess( FILE * fOutput, RscTypCont * pTC,
64 : const char * );
65 : };
66 :
67 : /******************* R s c L o n g R a n g e ******************************/
68 1382 : class RscLongRange : public RscTop
69 : {
70 : protected:
71 : struct RscLongRangeInst
72 : {
73 : sal_Int32 nValue; // nValue = Ausgangswert - nMin
74 : sal_Bool bDflt; // Ist Default
75 : };
76 : sal_Int32 nMin; // Minimum des Bereiches
77 : sal_Int32 nMax; // Maximum des Bereiches
78 : sal_uInt32 nSize;
79 : public:
80 : RscLongRange( Atom nId, sal_uInt32 nTypId );
81 : virtual RSCCLASS_TYPE GetClassType() const;
82 : RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool );
83 : // Der zulaessige Bereich wird gesetzt
84 : ERRTYPE SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum );
85 : // Gibt die Groesse der Klasse in Bytes
86 8292 : sal_uInt32 Size(){ return nSize; }
87 : // Eine Zuweisung an eine Variable
88 34 : virtual void SetToDefault( const RSCINST & rInst )
89 : {
90 34 : ((RscLongRangeInst*)rInst.pData)->bDflt = sal_True;
91 34 : }
92 0 : sal_Bool IsDefault( const RSCINST & rInst)
93 : {
94 0 : return( ((RscLongRangeInst*)rInst.pData)->bDflt );
95 : };
96 : // Als Default setzen
97 : sal_Bool IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef );
98 : ERRTYPE SetNumber( const RSCINST &, sal_Int32 );
99 : ERRTYPE GetNumber( const RSCINST &, sal_Int32 * );
100 : void WriteSrc( const RSCINST &, FILE * fOutput,
101 : RscTypCont * pTC, sal_uInt32 nTab, const char * );
102 : ERRTYPE WriteRc( const RSCINST &, RscWriteRc & aMem,
103 : RscTypCont * pTC, sal_uInt32, sal_Bool bExtra );
104 : void WriteRcAccess( FILE * fOutput, RscTypCont * pTC,
105 : const char * );
106 :
107 : };
108 :
109 : /******************* R s c L o n g E n u m R a n g e ******************/
110 691 : class RscLongEnumRange : public RscLongRange
111 : {
112 : public:
113 : RscLongEnumRange( Atom nId, sal_uInt32 nTypId );
114 :
115 : ERRTYPE SetConst( const RSCINST & rInst, Atom nValueId,
116 : sal_Int32 nValue );
117 : };
118 :
119 : /******************* R s c I d R a n g e ***********************************/
120 2073 : class RscIdRange : public RscTop
121 : {
122 : sal_uInt32 nSize;
123 : protected:
124 : sal_Int32 nMin; // Minimum des Bereiches
125 : sal_Int32 nMax; // Maximum des Bereiches
126 : public:
127 : RscIdRange( Atom nId, sal_uInt32 nTypId );
128 : virtual RSCCLASS_TYPE GetClassType() const;
129 : // Der zulaessige Bereich wird gesetzt
130 2073 : ERRTYPE SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum ){
131 2073 : nMin = nMinimum;
132 2073 : nMax = nMaximum;
133 2073 : return ERR_OK;
134 : }
135 : RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool );
136 : void Destroy( const RSCINST & rInst );
137 51134 : sal_uInt32 Size(){ return nSize; }
138 0 : virtual void SetToDefault( const RSCINST & rInst )
139 : {
140 0 : ((RscId*)rInst.pData)->aExp.cUnused = sal_True;
141 0 : }
142 0 : sal_Bool IsDefault( const RSCINST & rInst)
143 : {
144 : //cUnused wird fuer Defaultkennung verwendet
145 : return ((RscId*)rInst.pData)->aExp.cUnused
146 0 : ? sal_True : sal_False;
147 : }
148 : // Als Default setzen
149 : sal_Bool IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef );
150 : ERRTYPE SetNumber( const RSCINST &, sal_Int32 );
151 : ERRTYPE GetNumber( const RSCINST &, sal_Int32 * );
152 : ERRTYPE SetRef( const RSCINST &, const RscId & rRscId );
153 : ERRTYPE GetRef( const RSCINST & rInst, RscId * );
154 : void WriteSrc( const RSCINST &, FILE * fOutput,
155 : RscTypCont * pTC, sal_uInt32 nTab, const char * );
156 : ERRTYPE WriteRc( const RSCINST &, RscWriteRc & aMem,
157 : RscTypCont * pTC, sal_uInt32, sal_Bool bExtra );
158 : sal_Bool IsConsistent( const RSCINST & rInst );
159 : void WriteRcAccess( FILE * fOutput, RscTypCont * pTC,
160 : const char * );
161 :
162 : };
163 :
164 : /******************* R s c B o o l ***************************************/
165 691 : class RscBool : public RscRange
166 : {
167 : public:
168 : RscBool( Atom nId, sal_uInt32 nTypId );
169 : virtual RSCCLASS_TYPE GetClassType() const;
170 : // Der zulaessige Bereich wird gesetzt
171 : ERRTYPE SetRange( sal_Int32, sal_Int32 ){
172 : return( ERR_UNKNOWN_METHOD );
173 : };
174 1528 : ERRTYPE SetBool( const RSCINST & rInst, sal_Bool b ){
175 1528 : return( SetNumber( rInst, (sal_Int32)b ) );
176 : };
177 0 : ERRTYPE GetBool( const RSCINST & rInst, sal_Bool * pB){
178 : sal_Int32 l;
179 0 : GetNumber( rInst, &l );
180 0 : *pB = (0 != l);
181 0 : return( ERR_OK );
182 : };
183 : void WriteSrc( const RSCINST &, FILE * fOutput,
184 : RscTypCont * pTC, sal_uInt32 nTab, const char * );
185 : void WriteRcAccess( FILE * fOutput, RscTypCont * pTC,
186 : const char * );
187 :
188 : };
189 :
190 691 : class RscBreakRange : public RscRange {
191 : sal_Int32 nOutRange;
192 : public:
193 : RscBreakRange( Atom nId, sal_uInt32 nTypId );
194 691 : void SetOutRange( sal_Int32 nNumber ){
195 691 : nOutRange = nNumber;
196 691 : }
197 : RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool );
198 : ERRTYPE SetNumber( const RSCINST &, sal_Int32 );
199 : };
200 :
201 : #endif // _RSCRANGE_HXX
202 :
203 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
