rsc/inc/rsctop.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rsctop.hxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _RSCTOP_HXX
  31 #define _RSCTOP_HXX
  32
  33 #include <rscerror.h>
  34 #include <rsctools.hxx>
  35 #include <rschash.hxx>
  36 #include <rscclobj.hxx>
  37
  38 /****************** T Y P E S ********************************************/
  39 typedef sal_uInt32 RSCVAR;
  40 #define VAR_POINTER     0x0001
  41 #define VAR_HIDDEN              0x0002
  42 #define VAR_NODATAINST  0x0004
  43 #define VAR_NORC                0x0008
  44 #define VAR_SVDYNAMIC   0x0010
  45 #define VAR_NOENUM              0x0020
  46 #define VAR_EXTENDABLE  0x0040  /* Auch die Ableitung einer Klasse kann angegeben werden */
  47
  48 /****************** C L A S S E S ****************************************/
  49 /******************* R s c C l a s s *************************************/
  50 class RscTop : public RefNode
  51 {
  52     RscTop *            pSuperClass;
  53     RSCINST             aDfltInst;
  54     sal_uInt32                  nTypId;
  55     RscTop *            pRefClass;
  56
  57 protected:
  58                     RscTop( Atom nId, sal_uInt32 nTypIdent,
  59                             RscTop * pSuperCl = NULL );
  60
  61 public:
  62     ByteString          aCallPar1;              // Klassenaufruf ohne Typen bis ResId
  63     ByteString          aCallPar2;              // Klassenaufruf ohne Typen ab ResId
  64     ByteString          aCallParType;   // Klassenaufruf mit Typen
  65
  66             void        SetSuperClass( RscTop * pClass )
  67                     {
  68                         pSuperClass = pClass;
  69                     }
  70             RscTop* GetSuperClass() const
  71                     { return pSuperClass; }
  72                     // Gibt den Typidentifier zurueck
  73             sal_uInt32  GetTypId() const
  74                     { return nTypId; };
  75                     // Gibt die Oberklasse zurueck
  76             BOOL        InHierarchy( RscTop * pClass );
  77             BOOL        IsCodeWriteable() const
  78                     {
  79                         return( 0 != aCallParType.Len() );
  80                     }
  81             void        SetCallPar( const ByteString & rPar1, const ByteString & rPar2,
  82                                 const ByteString & rParType );
  83             void        SetRefClass( RscTop * pRef ) { pRefClass = pRef; }
  84             RscTop* GetRefClass() const { return pRefClass; }
  85     virtual RSCCLASS_TYPE GetClassType() const = 0;
  86             RSCINST GetDefault();
  87
  88                     // Vorbereitung auf den dtor aufruf
  89                     // Da die Klassen gegenseitige Abhaengigkeiten
  90                     // aufweisen koennen, kann man im dtor nicht davon
  91                     // ausgehen, dass alle Klassenzeiger noch gueltig sind
  92     virtual void        Pre_dtor();
  93
  94     virtual Atom        GetConstant( sal_uInt32 );
  95
  96     virtual RscTop *    GetTypeClass() const;
  97
  98                     // Gibt die Groesse der Klasse in Bytes
  99     virtual sal_uInt32  Size();
 100
 101                     // Gibt die Referenz zurueck
 102     virtual ERRTYPE GetRef( const RSCINST & rInst, RscId * );
 103
 104                     // Gibt die Referenz zurueck
 105     virtual ERRTYPE SetRef( const RSCINST & rInst, const RscId & rRefId );
 106
 107                     // Variable anlegen
 108     virtual ERRTYPE SetVariable( Atom nVarName, RscTop * pClass,
 109                                  RSCINST * pDflt = NULL,
 110                                  RSCVAR nVarType = 0, sal_uInt32 nMask = 0,
 111                                  Atom nDataBaseName = InvalidAtom );
 112
 113                     // Zaehlt alle Variablen auf
 114     virtual void        EnumVariables( void * pData, VarEnumCallbackProc );
 115
 116                     // Liefert Instanz der Variablen zurueck
 117                     // pData, pClass im return koennen NULL sein
 118     virtual RSCINST GetVariable( const RSCINST & rInst, Atom nVarName,
 119                                  const RSCINST & rInitInst,
 120                                  BOOL nInitDflt = FALSE,
 121                                  RscTop * pCreateClass = NULL );
 122     virtual RSCINST GetCopyVar( const RSCINST & rInst, Atom nVarName );
 123
 124     virtual RSCINST GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
 125                                  const RSCINST & rInitInst );
 126
 127                     // Liefert Instanz aus einem Feld zurueck
 128                     // pGetInst im return kann NULL sein
 129     virtual ERRTYPE GetElement( const RSCINST & rInst, const RscId & rEleName,
 130                                 RscTop *pCreateClass, const RSCINST & rCreateInst,
 131                                 RSCINST * pGetInst );
 132
 133                     // Liefert Instanz aus einem Feld zurueck
 134                     // pGetInst im return kann NULL sein
 135     virtual ERRTYPE GetValueEle( const RSCINST & rInst, INT32 lValue,
 136                                 RscTop * pCreateClass,
 137                                 RSCINST * pGetInst );
 138
 139                     // Liefert Instanz aus einem Feld zurueck
 140                     // pGetInst im return kann NULL sein
 141     virtual ERRTYPE GetArrayEle( const RSCINST & rInst, Atom nId,
 142                                 RscTop * pCreateClass,
 143                                 RSCINST * pGetInst );
 144
 145     virtual RSCINST SearchEle( const RSCINST & rInst, const RscId & rEleName,
 146                                RscTop * pClass );
 147
 148                     // Liefert Instanz an der Position zurueck
 149     virtual RSCINST GetPosEle( const RSCINST & rInst, sal_uInt32 nPos );
 150
 151                     // verschiebt eine Instanz
 152     virtual ERRTYPE MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
 153                                 sal_uInt32 nSourcePos );
 154
 155                     // aendert RscId an Position
 156     virtual ERRTYPE SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
 157                                  const RscId & rRscId);
 158
 159                     // Liefert Information ueber Instanz
 160                     // an der Position zurueck
 161     virtual SUBINFO_STRUCT GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos );
 162
 163                     // Anzahl der Eintraege
 164     virtual sal_uInt32 GetCount( const RSCINST & rInst );
 165
 166                     // Eine Zuweisung an eine Variable
 167     virtual ERRTYPE SetNumber( const RSCINST & rInst, INT32 lValue );
 168
 169                     // Eine Zuweisung an eine Variable
 170     virtual ERRTYPE SetBool( const RSCINST & rInst, BOOL bValue );
 171
 172                     // Eine Zuweisung an eine Variable
 173     virtual ERRTYPE SetConst( const RSCINST & rInst, Atom nValueId,
 174                               INT32 nValue );
 175
 176                     // Eine Zuweisung an eine Variable
 177     virtual ERRTYPE SetNotConst( const RSCINST & rInst, Atom nId );
 178
 179     virtual ERRTYPE SetString( const RSCINST & rInst, const char * pStr );
 180
 181     virtual ERRTYPE GetNumber( const RSCINST & rInst, INT32 * pN );
 182
 183     virtual ERRTYPE GetBool( const RSCINST & rInst, BOOL * pB );
 184
 185     virtual ERRTYPE GetConst( const RSCINST & rInst, Atom * pH );
 186
 187     virtual ERRTYPE GetString( const RSCINST & rInst, char ** ppStr );
 188
 189     virtual RSCINST Create( RSCINST * pInst,
 190                             const RSCINST & rDefInst, BOOL bOwnClass = FALSE );
 191
 192                     // Instanz zerstoeren
 193     virtual void        Destroy( const RSCINST & rInst );
 194
 195                     // prueft auf konsistenz
 196     virtual BOOL        IsConsistent( const RSCINST & rInst,
 197                                   RscInconsList * pList = NULL );
 198
 199                     // Alles auf Default setzen
 200     virtual void        SetToDefault( const RSCINST & rInst );
 201
 202                     // Ist Eingabe = Default
 203     virtual BOOL        IsDefault( const RSCINST & rInst );
 204
 205                     // Gleiche Werte auf Default setzen
 206     virtual BOOL        IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef );
 207
 208                     // Instanz auf Default setzen
 209     virtual void        SetDefault( const RSCINST & rInst, Atom nVarId );
 210
 211                     // Default zu einer Variablen holen
 212     virtual RSCINST GetDefault( Atom nVarId );
 213
 214     virtual void        Delete( const RSCINST & rInst, RscTop * pClass,
 215                             const RscId & rId );
 216
 217     virtual void        DeletePos( const RSCINST & rInst, sal_uInt32 nPos );
 218
 219                     // Schreibt den Kopf und das Ende einer Resource
 220                     // Script Datei
 221     virtual void        WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
 222                                     RscTypCont * pTC, sal_uInt32 nTab,
 223                                     const RscId & aId, const char * );
 224     virtual void        WriteSrc( const RSCINST & rInst, FILE * fOutput,
 225                               RscTypCont * pTC, sal_uInt32 nTab,const char * );
 226     virtual ERRTYPE WriteRcHeader( const RSCINST & rInst, RscWriteRc & aMem,
 227                                    RscTypCont * pTC, const RscId & aId,
 228                                     sal_uInt32 nDeep, BOOL bExtra );
 229     virtual ERRTYPE WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
 230                              RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra );
 231
 232     // Weiterleitung an Superklassen wird unterbunden
 233     virtual ERRTYPE WriteHxxHeader( const RSCINST & rInst, FILE * fOutput,
 234                                     RscTypCont * pTC, const RscId & rId );
 235     virtual ERRTYPE WriteHxx( const RSCINST & rInst, FILE * fOutput,
 236                               RscTypCont * pTC, const RscId &rId );
 237     virtual ERRTYPE WriteCxxHeader( const RSCINST & rInst, FILE * fOutput,
 238                                     RscTypCont * pTC, const RscId &rId );
 239     virtual ERRTYPE WriteCxx( const RSCINST & rInst, FILE * fOutput,
 240                               RscTypCont * pTC, const RscId &rId );
 241
 242             void WriteSyntaxHeader( FILE * fOutput, RscTypCont * pTC  );
 243     virtual void WriteSyntax( FILE * fOutput, RscTypCont * pTC );
 244
 245     virtual void        WriteRcAccess( FILE * fOutput, RscTypCont * pTC,
 246                                     const char * );
 247     virtual void        WriteRcCtor( FILE * fOutput, RscTypCont * pTC );
 248 };
 249
 250 #endif //_RSCTOP_HXX