1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 #ifndef _RSCRANGE_HXX 28 #define _RSCRANGE_HXX 29 30 #include <rscall.h> 31 #include <rscerror.h> 32 #include <rschash.hxx> 33 #include <rsctop.hxx> 34 35 /******************* R s c R a n g e *************************************/ 36 class RscRange : public RscTop 37 { 38 protected: 39 struct RscRangeInst { 40 sal_uInt16 nValue; // nValue = Ausgangswert - nMin 41 sal_Bool bDflt; // Ist Default 42 }; 43 sal_Int32 nMin; // Minimum des Bereiches 44 sal_Int32 nMax; // Maximum des Bereiches 45 sal_uInt32 nSize; 46 public: 47 RscRange( Atom nId, sal_uInt32 nTypId ); 48 virtual RSCCLASS_TYPE GetClassType() const; 49 RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool ); 50 // Der zulaessige Bereich wird gesetzt 51 ERRTYPE SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum ); 52 // Gibt die Groesse der Klasse in Bytes 53 sal_uInt32 Size(){ return nSize; } 54 // Eine Zuweisung an eine Variable 55 virtual void SetToDefault( const RSCINST & rInst ) 56 { 57 ((RscRangeInst*)rInst.pData)->bDflt = sal_True; 58 } 59 sal_Bool IsDefault( const RSCINST & rInst) 60 { 61 return( ((RscRangeInst*)rInst.pData)->bDflt ); 62 }; 63 // Als Default setzen 64 sal_Bool IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ); 65 ERRTYPE SetNumber( const RSCINST &, sal_Int32 ); 66 ERRTYPE GetNumber( const RSCINST &, sal_Int32 * ); 67 void WriteSrc( const RSCINST &, FILE * fOutput, 68 RscTypCont * pTC, sal_uInt32 nTab, const char * ); 69 ERRTYPE WriteRc( const RSCINST &, RscWriteRc & aMem, 70 RscTypCont * pTC, sal_uInt32, sal_Bool bExtra ); 71 void WriteRcAccess( FILE * fOutput, RscTypCont * pTC, 72 const char * ); 73 }; 74 75 /******************* R s c L o n g R a n g e ******************************/ 76 class RscLongRange : public RscTop 77 { 78 protected: 79 struct RscLongRangeInst 80 { 81 sal_Int32 nValue; // nValue = Ausgangswert - nMin 82 sal_Bool bDflt; // Ist Default 83 }; 84 sal_Int32 nMin; // Minimum des Bereiches 85 sal_Int32 nMax; // Maximum des Bereiches 86 sal_uInt32 nSize; 87 public: 88 RscLongRange( Atom nId, sal_uInt32 nTypId ); 89 virtual RSCCLASS_TYPE GetClassType() const; 90 RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool ); 91 // Der zulaessige Bereich wird gesetzt 92 ERRTYPE SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum ); 93 // Gibt die Groesse der Klasse in Bytes 94 sal_uInt32 Size(){ return nSize; } 95 // Eine Zuweisung an eine Variable 96 virtual void SetToDefault( const RSCINST & rInst ) 97 { 98 ((RscLongRangeInst*)rInst.pData)->bDflt = sal_True; 99 } 100 sal_Bool IsDefault( const RSCINST & rInst) 101 { 102 return( ((RscLongRangeInst*)rInst.pData)->bDflt ); 103 }; 104 // Als Default setzen 105 sal_Bool IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ); 106 ERRTYPE SetNumber( const RSCINST &, sal_Int32 ); 107 ERRTYPE GetNumber( const RSCINST &, sal_Int32 * ); 108 void WriteSrc( const RSCINST &, FILE * fOutput, 109 RscTypCont * pTC, sal_uInt32 nTab, const char * ); 110 ERRTYPE WriteRc( const RSCINST &, RscWriteRc & aMem, 111 RscTypCont * pTC, sal_uInt32, sal_Bool bExtra ); 112 void WriteRcAccess( FILE * fOutput, RscTypCont * pTC, 113 const char * ); 114 115 }; 116 117 /******************* R s c L o n g E n u m R a n g e ******************/ 118 class RscLongEnumRange : public RscLongRange 119 { 120 public: 121 RscLongEnumRange( Atom nId, sal_uInt32 nTypId ); 122 123 ERRTYPE SetConst( const RSCINST & rInst, Atom nValueId, 124 sal_Int32 nValue ); 125 }; 126 127 /******************* R s c I d R a n g e ***********************************/ 128 class RscIdRange : public RscTop 129 { 130 sal_uInt32 nSize; 131 protected: 132 sal_Int32 nMin; // Minimum des Bereiches 133 sal_Int32 nMax; // Maximum des Bereiches 134 public: 135 RscIdRange( Atom nId, sal_uInt32 nTypId ); 136 virtual RSCCLASS_TYPE GetClassType() const; 137 // Der zulaessige Bereich wird gesetzt 138 ERRTYPE SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum ){ 139 nMin = nMinimum; 140 nMax = nMaximum; 141 return ERR_OK; 142 } 143 RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool ); 144 void Destroy( const RSCINST & rInst ); 145 sal_uInt32 Size(){ return nSize; } 146 virtual void SetToDefault( const RSCINST & rInst ) 147 { 148 ((RscId*)rInst.pData)->aExp.cUnused = sal_True; 149 } 150 sal_Bool IsDefault( const RSCINST & rInst) 151 { 152 //cUnused wird fuer Defaultkennung verwendet 153 return ((RscId*)rInst.pData)->aExp.cUnused 154 ? sal_True : sal_False; 155 } 156 // Als Default setzen 157 sal_Bool IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ); 158 ERRTYPE SetNumber( const RSCINST &, sal_Int32 ); 159 ERRTYPE GetNumber( const RSCINST &, sal_Int32 * ); 160 ERRTYPE SetRef( const RSCINST &, const RscId & rRscId ); 161 ERRTYPE GetRef( const RSCINST & rInst, RscId * ); 162 void WriteSrc( const RSCINST &, FILE * fOutput, 163 RscTypCont * pTC, sal_uInt32 nTab, const char * ); 164 ERRTYPE WriteRc( const RSCINST &, RscWriteRc & aMem, 165 RscTypCont * pTC, sal_uInt32, sal_Bool bExtra ); 166 sal_Bool IsConsistent( const RSCINST & rInst, RscInconsList * pList ); 167 void WriteRcAccess( FILE * fOutput, RscTypCont * pTC, 168 const char * ); 169 170 }; 171 172 /******************* R s c B o o l ***************************************/ 173 class RscBool : public RscRange 174 { 175 public: 176 RscBool( Atom nId, sal_uInt32 nTypId ); 177 virtual RSCCLASS_TYPE GetClassType() const; 178 // Der zulaessige Bereich wird gesetzt 179 ERRTYPE SetRange( sal_Int32, sal_Int32 ){ 180 return( ERR_UNKNOWN_METHOD ); 181 }; 182 ERRTYPE SetBool( const RSCINST & rInst, sal_Bool b ){ 183 return( SetNumber( rInst, (sal_Int32)b ) ); 184 }; 185 ERRTYPE GetBool( const RSCINST & rInst, sal_Bool * pB){ 186 sal_Int32 l; 187 GetNumber( rInst, &l ); 188 *pB = (0 != l); 189 return( ERR_OK ); 190 }; 191 void WriteSrc( const RSCINST &, FILE * fOutput, 192 RscTypCont * pTC, sal_uInt32 nTab, const char * ); 193 void WriteRcAccess( FILE * fOutput, RscTypCont * pTC, 194 const char * ); 195 196 }; 197 198 class RscBreakRange : public RscRange { 199 sal_Int32 nOutRange; 200 public: 201 RscBreakRange( Atom nId, sal_uInt32 nTypId ); 202 void SetOutRange( sal_Int32 nNumber ){ 203 nOutRange = nNumber; 204 } 205 RSCINST Create( RSCINST * pInst, const RSCINST & rDfltInst, sal_Bool ); 206 ERRTYPE SetNumber( const RSCINST &, sal_Int32 ); 207 }; 208 209 #endif // _RSCRANGE_HXX 210