rsc/inc/rscrange.hxx

   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