11 files changed, 283 insertions, 283 deletions

diff --git a/rsc/source/res/rscall.cxx b/rsc/source/res/rscall.cxx
index 4bd3db7b9aae..26193d4cae51 100644
--- a/rsc/source/res/rscall.cxx
+++ b/rsc/source/res/rscall.cxx
@@ -50,11 +50,11 @@ Atom    nRsc_EXTRADATA = InvalidAtom;
 
 void InitRscCompiler()
 {
-    pStdParType      = new ByteString( "( const ResId & rResId, BOOL" );
+    pStdParType      = new ByteString( "( const ResId & rResId, sal_Bool" );
     pStdPar1         = new ByteString( '(' );
     pStdPar2         = new ByteString( '(' );
 
-    pWinParType      = new ByteString( "( Window * pParent, const ResId & rResId, BOOL" );
+    pWinParType      = new ByteString( "( Window * pParent, const ResId & rResId, sal_Bool" );
     pWinPar1         = new ByteString( "( pParent," );
     pWinPar2         = new ByteString( "( this," );
     nRefDeep         = 10;
diff --git a/rsc/source/res/rscarray.cxx b/rsc/source/res/rscarray.cxx
index a3030ef65b64..656bcfc7a1d3 100644
--- a/rsc/source/res/rscarray.cxx
+++ b/rsc/source/res/rscarray.cxx
@@ -143,7 +143,7 @@ static RscInstNode * Create( RscInstNode * pNode )
 }
 
 RSCINST RscArray::Create( RSCINST * pInst, const RSCINST & rDflt,
-                          BOOL bOwnClass )
+                          sal_Bool bOwnClass )
 {
     RSCINST aInst;
     RscArrayInst *  pClassData;
@@ -212,7 +212,7 @@ void RscArray::Destroy( const RSCINST & rInst )
 ERRTYPE RscArray::GetValueEle
 (
     const RSCINST & rInst,
-    INT32 lValue,
+    sal_Int32 lValue,
     RscTop * pCreateClass,
     RSCINST * pGetInst
 )
@@ -280,7 +280,7 @@ ERRTYPE RscArray::GetArrayEle
     RSCINST * pGetInst
 )
 {
-    INT32  lValue;
+    sal_Int32  lValue;
     if( !pTypeClass->GetConstValue( nId, &lValue ) )
     { // nicht gefunden
         return ERR_ARRAY_INVALIDINDEX;
@@ -294,31 +294,31 @@ ERRTYPE RscArray::GetArrayEle
 |*    RscArray::IsConsistent()
 |*
 *************************************************************************/
-static BOOL IsConsistent( RscInstNode * pNode )
+static sal_Bool IsConsistent( RscInstNode * pNode )
 {
-    BOOL bRet = TRUE;
+    sal_Bool bRet = sal_True;
 
     if( pNode )
     {
         bRet = pNode->aInst.pClass->IsConsistent( pNode->aInst );
         if( !IsConsistent( pNode->Left() ) )
-            bRet = FALSE;
+            bRet = sal_False;
         if( !IsConsistent( pNode->Right() ) )
-            bRet = FALSE;
+            bRet = sal_False;
     }
     return bRet;
 }
 
-BOOL RscArray::IsConsistent( const RSCINST & rInst )
+sal_Bool RscArray::IsConsistent( const RSCINST & rInst )
 {
     RscArrayInst * pClassData;
-    BOOL    bRet;
+    sal_Bool    bRet;
 
     bRet = RscTop::IsConsistent( rInst );
 
     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
     if( !::IsConsistent( pClassData->pNode ) )
-        bRet = FALSE;
+        bRet = sal_False;
 
     return( bRet );
 }
@@ -354,9 +354,9 @@ void RscArray::SetToDefault( const RSCINST & rInst )
 |*    RscArray::IsDefault()
 |*
 *************************************************************************/
-static BOOL IsDefault( RscInstNode * pNode )
+static sal_Bool IsDefault( RscInstNode * pNode )
 {
-    BOOL bRet = TRUE;
+    sal_Bool bRet = sal_True;
 
     if( pNode )
     {
@@ -369,13 +369,13 @@ static BOOL IsDefault( RscInstNode * pNode )
     return bRet;
 }
 
-BOOL RscArray::IsDefault( const RSCINST & rInst )
+sal_Bool RscArray::IsDefault( const RSCINST & rInst )
 {
     RscArrayInst * pClassData;
 
     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
 
-    BOOL bRet = ::IsDefault( pClassData->pNode );
+    sal_Bool bRet = ::IsDefault( pClassData->pNode );
 
     if( bRet )
         bRet = RscTop::IsDefault( rInst );
@@ -387,9 +387,9 @@ BOOL RscArray::IsDefault( const RSCINST & rInst )
 |*    RscArray::IsValueDefault()
 |*
 *************************************************************************/
-static BOOL IsValueDefault( RscInstNode * pNode, CLASS_DATA pDef )
+static sal_Bool IsValueDefault( RscInstNode * pNode, CLASS_DATA pDef )
 {
-    BOOL bRet = TRUE;
+    sal_Bool bRet = sal_True;
 
     if( pNode )
     {
@@ -402,10 +402,10 @@ static BOOL IsValueDefault( RscInstNode * pNode, CLASS_DATA pDef )
     return bRet;
 }
 
-BOOL RscArray::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+sal_Bool RscArray::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 {
     RscArrayInst * pClassData;
-    BOOL bRet;
+    sal_Bool bRet;
 
     bRet = RscTop::IsValueDefault( rInst, pDef );
 
@@ -520,7 +520,7 @@ void RscArray::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*    Beschreibung
 *************************************************************************/
 ERRTYPE RscArray::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                            RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                            RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     ERRTYPE aError;
     RscArrayInst * pClassData;
@@ -617,7 +617,7 @@ void RscClassArray::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 *************************************************************************/
 ERRTYPE RscClassArray::WriteRcHeader( const RSCINST & rInst, RscWriteRc & aMem,
                                        RscTypCont * pTC, const RscId & aId,
-                                       sal_uInt32 nDeep, BOOL bExtra )
+                                       sal_uInt32 nDeep, sal_Bool bExtra )
 {
     // Eigenen Typ schreiben
     return GetSuperClass()->WriteRcHeader( rInst, aMem, pTC, aId,
diff --git a/rsc/source/res/rscclass.cxx b/rsc/source/res/rscclass.cxx
index ad2a45e66892..6f2939cd2fd2 100644
--- a/rsc/source/res/rscclass.cxx
+++ b/rsc/source/res/rscclass.cxx
@@ -113,7 +113,7 @@ RSCINST RscClass::GetInstData
 (
     CLASS_DATA pData,
     sal_uInt32 nEle,
-    BOOL bGetCopy
+    sal_Bool bGetCopy
 )
 {
     RSCINST aInst;
@@ -174,15 +174,15 @@ CLASS_DATA RscClass::GetDfltData( sal_uInt32 nEle )
 |*    RscClass::SetVarDflt()
 |*
 *************************************************************************/
-void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, BOOL bSet )
+void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, sal_Bool bSet )
 {
     RscClassInst * pClass;
 
     pClass = (RscClassInst *)(pData + nSuperSize );
     if( bSet )
-        pClass->nVarDflt |= ((ULONG)1 << nEle);
+        pClass->nVarDflt |= ((sal_uLong)1 << nEle);
     else
-        pClass->nVarDflt &= ~((ULONG)1 << nEle);
+        pClass->nVarDflt &= ~((sal_uLong)1 << nEle);
 }
 
 /*************************************************************************
@@ -190,16 +190,16 @@ void RscClass::SetVarDflt( CLASS_DATA pData, sal_uInt32 nEle, BOOL bSet )
 |*    RscClass::IsDflt()
 |*
 *************************************************************************/
-BOOL RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
+sal_Bool RscClass::IsDflt( CLASS_DATA pData, sal_uInt32 nEle )
 {
     RscClassInst *  pClass;
-    BOOL            bRet;
+    sal_Bool            bRet;
 
     pClass = (RscClassInst *)(pData + nSuperSize );
-    if( pClass->nVarDflt & ((ULONG)1 << nEle) )
-        bRet = TRUE;
+    if( pClass->nVarDflt & ((sal_uLong)1 << nEle) )
+        bRet = sal_True;
     else
-        bRet = FALSE;
+        bRet = sal_False;
     return bRet;
 }
 
@@ -212,7 +212,7 @@ RSCINST RscClass::Create
 (
     RSCINST * pInst,
     const RSCINST & rDflt,
-    BOOL bOwnClass
+    sal_Bool bOwnClass
 )
 {
     sal_uInt32  i;
@@ -236,11 +236,11 @@ RSCINST RscClass::Create
         ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt =
             ((RscClassInst *)(rDflt.pData + nSuperSize))->nVarDflt;
     else
-        ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((ULONG)0);
+        ((RscClassInst *)(aInst.pData + nSuperSize))->nVarDflt = ~((sal_uLong)0);
 
     for( i = 0; i < nEntries; i++ )
     {
-        aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, TRUE );
+        aDfltI = GetInstData( bOwnClass ? rDflt.pData : NULL, i, sal_True );
 
         if( (VAR_POINTER & pVarTypeList[ i ].nVarType)
           && !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
@@ -264,7 +264,7 @@ RSCINST RscClass::Create
         }
         else
         {
-            aMemInst = GetInstData( aInst.pData, i, TRUE );
+            aMemInst = GetInstData( aInst.pData, i, sal_True );
             aMemInst = aMemInst.pClass->Create( &aMemInst, aDfltI );
         };
     }
@@ -291,7 +291,7 @@ void RscClass::Destroy( const RSCINST & rInst )
         {
             RSCINST aTmpI;
 
-            aTmpI = GetInstData( rInst.pData, i, TRUE );
+            aTmpI = GetInstData( rInst.pData, i, sal_True );
             if( aTmpI.IsInst() )
             {
                 // Objekt loeschen
@@ -360,7 +360,7 @@ ERRTYPE RscClass::SetVariable
     }
 
     nEntries++;
-    if( nEntries > (sizeof( ULONG ) * 8) )
+    if( nEntries > (sizeof( sal_uLong ) * 8) )
     {
         // Bereich fuer Default zu klein
         RscExit( 16 );
@@ -400,7 +400,7 @@ RSCINST RscClass::GetVariable
     const RSCINST & rInst,
     Atom nVarName,
     const RSCINST & rInitInst,
-    BOOL bInitDflt,
+    sal_Bool bInitDflt,
     RscTop * pCreateClass
 )
 {
@@ -460,7 +460,7 @@ RSCINST RscClass::GetVariable
             }
         };
         // auf nicht Default setzen
-        SetVarDflt( rInst.pData, i, FALSE );
+        SetVarDflt( rInst.pData, i, sal_False );
         return( aTmpI );
     };
 
@@ -499,11 +499,11 @@ RSCINST RscClass::GetCopyVar
             if( IsDflt( rInst.pData, i ) )
             {
                 // mit Variablen Default initialiaieren
-                aVarI = GetVariable( rInst, nVarName, RSCINST(), TRUE );
-                SetVarDflt( rInst.pData, i, TRUE );
+                aVarI = GetVariable( rInst, nVarName, RSCINST(), sal_True );
+                SetVarDflt( rInst.pData, i, sal_True );
             }
             else
-                aVarI = GetInstData( rInst.pData, i, TRUE );
+                aVarI = GetInstData( rInst.pData, i, sal_True );
 
         };
         return aVarI ;
@@ -519,11 +519,11 @@ RSCINST RscClass::GetCopyVar
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL RscClass::IsConsistent( const RSCINST & rInst )
+sal_Bool RscClass::IsConsistent( const RSCINST & rInst )
 {
     sal_uInt32  i = 0;
     RSCINST aTmpI;
-    BOOL    bRet;
+    sal_Bool    bRet;
 
     bRet = RscTop::IsConsistent( rInst );
 
@@ -531,11 +531,11 @@ BOOL RscClass::IsConsistent( const RSCINST & rInst )
     {
         if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
         {
-            aTmpI = GetInstData( rInst.pData, i, TRUE );
+            aTmpI = GetInstData( rInst.pData, i, sal_True );
 
             if( aTmpI.IsInst() )
                 if( ! aTmpI.pClass->IsConsistent( aTmpI ) )
-                    bRet = FALSE;
+                    bRet = sal_False;
         }
     };
 
@@ -563,12 +563,12 @@ void RscClass::SetToDefault( const RSCINST & rInst )
         // auf Default gesetzt
         if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
         {
-            aTmpI = GetInstData( rInst.pData, i, TRUE );
+            aTmpI = GetInstData( rInst.pData, i, sal_True );
             if( aTmpI.IsInst() )
                 aTmpI.pClass->SetToDefault( aTmpI );
         }
     }
-    pClass->nVarDflt = ~((ULONG)0); // alles auf Default
+    pClass->nVarDflt = ~((sal_uLong)0); // alles auf Default
 
     RscTop::SetToDefault( rInst );
 }
@@ -580,7 +580,7 @@ void RscClass::SetToDefault( const RSCINST & rInst )
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL RscClass::IsDefault( const RSCINST & rInst )
+sal_Bool RscClass::IsDefault( const RSCINST & rInst )
 {
     sal_uInt32  i;
     RSCINST aTmpI;
@@ -591,7 +591,7 @@ BOOL RscClass::IsDefault( const RSCINST & rInst )
         // auf Default untersucht
         if( !(VAR_NODATAINST & pVarTypeList[ i ].nVarType) )
             if( !IsDflt( rInst.pData, i ) )
-                return( FALSE );
+                return( sal_False );
     };
 
     return( RscTop::IsDefault( rInst ) );
@@ -630,24 +630,24 @@ RSCINST RscClass::GetDefault( Atom nVarId )
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
+sal_Bool RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
 {
     RSCINST aTmpI;
 
-    aTmpI = GetInstData( pData, nEle, TRUE );
+    aTmpI = GetInstData( pData, nEle, sal_True );
 
     if( aTmpI.IsInst() )
     {
         if( VAR_SVDYNAMIC & pVarTypeList[ nEle ].nVarType )
-            return FALSE;
+            return sal_False;
 
         if( aTmpI.pClass == pVarTypeList[ nEle ].pClass )
             //sie haben auch die gleiche Klasse
             return aTmpI.pClass->IsValueDefault( aTmpI, GetDfltData( nEle ) );
         else
-            return FALSE;
+            return sal_False;
     }
-    return TRUE;
+    return sal_True;
 }
 
 /*************************************************************************
@@ -657,39 +657,39 @@ BOOL RscClass::IsValueDflt( CLASS_DATA pData, sal_uInt32 nEle )
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+sal_Bool RscClass::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 {
     sal_uInt32  i = 0;
     RSCINST aTmpI;
     RSCINST aDfltI;
 
     if( !RscTop::IsValueDefault( rInst, pDef ) )
-        return FALSE;
+        return sal_False;
 
     if( pDef )
     {
         for( i = 0; i < nEntries; i++ )
         {
-            aTmpI = GetInstData( rInst.pData, i, TRUE );
+            aTmpI = GetInstData( rInst.pData, i, sal_True );
             if( aTmpI.IsInst() )
             {
                 if( aTmpI.pClass != pVarTypeList[ i ].pClass )
                     //sie haben nicht die gleiche Klasse
-                    return FALSE;
+                    return sal_False;
 
-                aDfltI = GetInstData( pDef, i, TRUE );
+                aDfltI = GetInstData( pDef, i, sal_True );
                 if( !aDfltI.IsInst() )
                     aDfltI.pData = GetDfltData( i );
 
                 if( !aTmpI.pClass->IsValueDefault( aTmpI, aDfltI.pData ) )
-                    return FALSE;
+                    return sal_False;
             }
         }
     }
     else
-        return FALSE;
+        return sal_False;
 
-    return TRUE;
+    return sal_True;
 }
 
 /*************************************************************************
@@ -709,12 +709,12 @@ void RscClass::SetDefault( const RSCINST & rInst, Atom nVarName )
 
     if( i < nEntries )
     {
-        aTmpI = GetInstData( rInst.pData, i, TRUE );
+        aTmpI = GetInstData( rInst.pData, i, sal_True );
         if( aTmpI.IsInst() )
         {
             aTmpI.pClass->Destroy( aTmpI );
             aTmpI.pClass->Create( &aTmpI, RSCINST() );
-            SetVarDflt( rInst.pData, i, TRUE );
+            SetVarDflt( rInst.pData, i, sal_True );
         }
     }
     else //In Superklasse nach Variable suchen
@@ -765,20 +765,20 @@ void RscClass::WriteSrc
 
                     if( !IsDflt( rInst.pData, i ) )
                     {
-                        aTmpI = GetInstData( rInst.pData, i, TRUE );
+                        aTmpI = GetInstData( rInst.pData, i, sal_True );
                         aTmpI.pClass->WriteSrcHeader(
                               aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
                     }
 
                     fprintf( fOutput, "( " );
-                    aTmpI = GetInstData( rInst.pData, i+1, TRUE );
+                    aTmpI = GetInstData( rInst.pData, i+1, sal_True );
                     if( !aTmpI.IsInst() )
                         aTmpI.pData = GetDfltData( i+1 );
                     aTmpI.pClass->WriteSrcHeader(
                               aTmpI, fOutput, pTC, nTab, RscId(), pVarName );
 
                     fprintf( fOutput, ", " );
-                    aTmpI = GetInstData( rInst.pData, i+2, TRUE );
+                    aTmpI = GetInstData( rInst.pData, i+2, sal_True );
                     if( !aTmpI.IsInst() )
                         aTmpI.pData = GetDfltData( i+2 );
                     aTmpI.pClass->WriteSrcHeader(
@@ -790,7 +790,7 @@ void RscClass::WriteSrc
             else if( !IsDflt( rInst.pData, i )
               && !IsValueDflt( rInst.pData, i ) )
             {
-                aTmpI = GetInstData( rInst.pData, i, TRUE );
+                aTmpI = GetInstData( rInst.pData, i, sal_True );
 
                 if( aTmpI.IsInst() )
                 {
@@ -818,7 +818,7 @@ void RscClass::WriteSrc
 |*    Beschreibung
 |*
 *************************************************************************/
-INT32 RscClass::GetCorrectValues
+sal_Int32 RscClass::GetCorrectValues
 (
     const RSCINST & rInst,
     sal_uInt32 nVarPos,
@@ -826,11 +826,11 @@ INT32 RscClass::GetCorrectValues
     RscTypCont * pTC
 )
 {
-    INT32 nLang = 0;
-    INT32 nBaseValue;
+    sal_Int32 nLang = 0;
+    sal_Int32 nBaseValue;
 
     // Basiswert holen
-    RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, TRUE );
+    RSCINST aTmpI = GetInstData( rInst.pData, nVarPos, sal_True );
     aTmpI.pClass->GetNumber( aTmpI, &nBaseValue );
 
     // Sprach Delta holen
@@ -838,8 +838,8 @@ INT32 RscClass::GetCorrectValues
     if( aTmpI.IsInst() )
     {
         RscWriteRc aMem;
-        aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, FALSE );
-        nLang = (INT32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
+        aTmpI.pClass->WriteRc( aTmpI, aMem, pTC, 0, sal_False );
+        nLang = (sal_Int32)aMem.GetShort( nTupelIdx * sizeof(sal_uInt16) );
     }
 
     return nLang + nBaseValue;
@@ -851,7 +851,7 @@ ERRTYPE RscClass::WriteInstRc
     RscWriteRc & rMem,
     RscTypCont * pTC,
     sal_uInt32 nDeep,
-    BOOL bExtra
+    sal_Bool bExtra
 )
 {
     sal_uInt32 i = 0;
@@ -880,35 +880,35 @@ ERRTYPE RscClass::WriteInstRc
                 {
                     if( nRsc_X == pVarTypeList[ i ].nVarName )
                     {
-                        INT32 nVal = GetCorrectValues( rInst, i, 0, pTC );
+                        sal_Int32 nVal = GetCorrectValues( rInst, i, 0, pTC );
                         rMem.Put( nVal );
                     }
                     else if( nRsc_Y == pVarTypeList[ i ].nVarName )
                     {
-                        INT32 nVal = GetCorrectValues( rInst, i, 1, pTC );
+                        sal_Int32 nVal = GetCorrectValues( rInst, i, 1, pTC );
                         rMem.Put( nVal );
                     }
                     else if( nRsc_WIDTH == pVarTypeList[ i ].nVarName )
                     {
-                        INT32 nVal = GetCorrectValues( rInst, i, 2, pTC );
+                        sal_Int32 nVal = GetCorrectValues( rInst, i, 2, pTC );
                         rMem.Put( nVal );
                     }
                     else if( nRsc_HEIGHT == pVarTypeList[ i ].nVarName )
                     {
-                        INT32 nVal = GetCorrectValues( rInst, i, 3, pTC );
+                        sal_Int32 nVal = GetCorrectValues( rInst, i, 3, pTC );
                         rMem.Put( nVal );
                     }
                     else
                     {
-                        aTmpI = GetInstData( rInst.pData, i, TRUE );
-                        // Nur an Variable Extradata bExtra nicht auf FALSE
+                        aTmpI = GetInstData( rInst.pData, i, sal_True );
+                        // Nur an Variable Extradata bExtra nicht auf sal_False
                         // setzen
                         aError = aTmpI.pClass->
                             WriteRcHeader( aTmpI, rMem, pTC,
                                         RscId(), nDeep,
                                         (nRsc_EXTRADATA
                                         == pVarTypeList[ i ].nVarName)
-                                        ? bExtra : FALSE );
+                                        ? bExtra : sal_False );
                     }
                     sal_uInt32 nMask = rMem.GetLong( nMaskOff );
                     nMask |= pVarTypeList[ i ].nMask;
@@ -922,15 +922,15 @@ ERRTYPE RscClass::WriteInstRc
                     aTmpI.pData  = GetDfltData( i );
                 }
                 else
-                    aTmpI = GetInstData( rInst.pData, i, TRUE );
-                // Nur an Variable Extradata bExtra nicht auf FALSE
+                    aTmpI = GetInstData( rInst.pData, i, sal_True );
+                // Nur an Variable Extradata bExtra nicht auf sal_False
                 // setzen
                 aError = aTmpI.pClass->
                             WriteRcHeader( aTmpI, rMem, pTC,
                                         RscId(), nDeep,
                                         (nRsc_EXTRADATA
                                         == pVarTypeList[ i ].nVarName)
-                                        ? bExtra : FALSE );
+                                        ? bExtra : sal_False );
             }
         }
     }
@@ -951,7 +951,7 @@ ERRTYPE RscClass::WriteRc
     RscWriteRc & rMem,
     RscTypCont * pTC,
     sal_uInt32 nDeep,
-    BOOL bExtra
+    sal_Bool bExtra
 )
 {
     ERRTYPE aError;
@@ -1027,7 +1027,7 @@ void RscClass::WriteRcCtor( FILE * fOutput, RscTypCont * pTC )
         fprintf( fOutput, "\tsal_uInt32\tnObjMask;\n" );
         fprintf( fOutput, "\tsal_uInt32\tnOffset = 0;\n" );
         fprintf( fOutput, "\tBYTE *\tpResData;\n\n" );
-        fprintf( fOutput, "\tpResData = (BYTE *)GetClassRes();\n\n" );
+        fprintf( fOutput, "\tpResData = (tBYTE *)GetClassRes();\n\n" );
         fprintf( fOutput, "\tnObjMask = *(sal_uInt32*)pResData;\n" );
         fprintf( fOutput, "\tnOffset += 4;\n\n" );
 
@@ -1071,7 +1071,7 @@ RscSysDepend::RscSysDepend( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper )
 |*
 *************************************************************************/
 ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem,
-                RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra, BOOL bFirst )
+                RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra, sal_Bool bFirst )
 {
     sal_uInt32  nId = 0xFFFFFFFF;
     ERRTYPE     aError;
@@ -1112,7 +1112,7 @@ ERRTYPE RscSysDepend::WriteSysDependRc( const RSCINST & rInst, RscWriteRc & rMem
 |*
 *************************************************************************/
 ERRTYPE RscSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                            RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                            RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     ERRTYPE     aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
 
@@ -1142,10 +1142,10 @@ RscFirstSysDepend::RscFirstSysDepend( Atom nId, sal_uInt32 nTypeId,
 |*
 *************************************************************************/
 ERRTYPE RscFirstSysDepend::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                            RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                            RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     ERRTYPE aError = RscClass::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
-    aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra, TRUE );
+    aError = WriteSysDependRc( rInst, rMem, pTC, nDeep, bExtra, sal_True );
     return aError;
 }
 
@@ -1202,7 +1202,7 @@ void RscTupel::WriteSrc( const RSCINST & rInst, FILE * fOutput,
             if( !IsDflt( rInst.pData, i )
               && !IsValueDflt( rInst.pData, i ) )
             {
-                aTmpI = GetInstData( rInst.pData, i, TRUE );
+                aTmpI = GetInstData( rInst.pData, i, sal_True );
 
                 if( aTmpI.IsInst() )
                     aTmpI.pClass->WriteSrcHeader(
diff --git a/rsc/source/res/rscclobj.cxx b/rsc/source/res/rscclobj.cxx
index 895c778525e8..7005c9b38f09 100644
--- a/rsc/source/res/rscclobj.cxx
+++ b/rsc/source/res/rscclobj.cxx
@@ -67,16 +67,16 @@ sal_uInt32 RefNode::GetId() const
 |*    RefNode::PutObjNode()
 |*
 *************************************************************************/
-BOOL RefNode::PutObjNode( ObjNode * pPutObject ){
+sal_Bool RefNode::PutObjNode( ObjNode * pPutObject ){
 // insert a node in the b-tree pObjBiTree
 // if the node with the same name is in pObjBiTree,
-// return FALSE and no insert,
+// return sal_False and no insert,
 
     if( pObjBiTree )
         return( pObjBiTree->Insert( pPutObject ) );
 
     pObjBiTree = pPutObject;
-    return( TRUE );
+    return( sal_True );
 }
 
 /****************** O b j N o d e ****************************************/
@@ -101,7 +101,7 @@ ObjNode * RefNode :: GetObjNode( const RscId & rRscId ){
 |*    ObjNode::ObjNode()
 |*
 *************************************************************************/
-ObjNode::ObjNode( const RscId & rId, CLASS_DATA pData, ULONG lKey ){
+ObjNode::ObjNode( const RscId & rId, CLASS_DATA pData, sal_uLong lKey ){
     pRscObj  = pData;
     aRscId   = rId;
     lFileKey = lKey;
@@ -112,7 +112,7 @@ ObjNode::ObjNode( const RscId & rId, CLASS_DATA pData, ULONG lKey ){
 |*    ObjNode::DelObjNode()
 |*
 *************************************************************************/
-ObjNode * ObjNode::DelObjNode( RscTop * pClass, ULONG nFileKey ){
+ObjNode * ObjNode::DelObjNode( RscTop * pClass, sal_uLong nFileKey ){
     ObjNode * pRetNode = this;
 
     if( Right() )
@@ -152,33 +152,33 @@ sal_uInt32 ObjNode::GetId() const
 |*    ObjNode::IsConsistent()
 |*
 *************************************************************************/
-BOOL ObjNode::IsConsistent()
+sal_Bool ObjNode::IsConsistent()
 {
-    BOOL bRet = TRUE;
+    sal_Bool bRet = sal_True;
 
     if( (long)aRscId > 0x7FFF || (long)aRscId < 1 )
     {
-        bRet = FALSE;
+        bRet = sal_False;
     }
     else
     {
         if( Left() )
         {
             if( !((ObjNode *)Left())->IsConsistent() )
-                bRet = FALSE;
+                bRet = sal_False;
             if( ((ObjNode *)Left())->aRscId >= aRscId )
             {
-                bRet = FALSE;
+                bRet = sal_False;
             }
         };
         if( Right() )
         {
             if( ((ObjNode *)Right())->aRscId <= aRscId )
             {
-                bRet = FALSE;
+                bRet = sal_False;
             }
             if( !((ObjNode *)Right())->IsConsistent() )
-                bRet = FALSE;
+                bRet = sal_False;
         };
     };
 
diff --git a/rsc/source/res/rscconst.cxx b/rsc/source/res/rscconst.cxx
index 9903fe27c076..04f7b1ae00b1 100644
--- a/rsc/source/res/rscconst.cxx
+++ b/rsc/source/res/rscconst.cxx
@@ -84,7 +84,7 @@ RSCCLASS_TYPE RscConst::GetClassType() const
 |*    RscConst::SetConstance()
 |*
 *************************************************************************/
-ERRTYPE RscConst::SetConstant( Atom nVarName, INT32 lValue ){
+ERRTYPE RscConst::SetConstant( Atom nVarName, sal_Int32 lValue ){
     if( pVarArray )
         pVarArray = (VarEle *)
             rtl_reallocateMemory( (void *)pVarArray,
@@ -115,7 +115,7 @@ Atom RscConst::GetConstant( sal_uInt32 nPos ){
 |*    RscConst::GetConstValue()
 |*
 *************************************************************************/
-BOOL RscConst::GetConstValue( Atom nConst, INT32 * pValue ) const
+sal_Bool RscConst::GetConstValue( Atom nConst, sal_Int32 * pValue ) const
 {
     sal_uInt32 i = 0;
 
@@ -123,9 +123,9 @@ BOOL RscConst::GetConstValue( Atom nConst, INT32 * pValue ) const
         if( pVarArray[ i ].nId == nConst )
         {
             *pValue = pVarArray[ i ].lValue;
-            return TRUE;
+            return sal_True;
         }
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -133,7 +133,7 @@ BOOL RscConst::GetConstValue( Atom nConst, INT32 * pValue ) const
 |*    RscConst::GetValueConst()
 |*
 *************************************************************************/
-BOOL RscConst::GetValueConst( INT32 lValue, Atom * pConst ) const
+sal_Bool RscConst::GetValueConst( sal_Int32 lValue, Atom * pConst ) const
 {
     sal_uInt32 i = 0;
 
@@ -141,9 +141,9 @@ BOOL RscConst::GetValueConst( INT32 lValue, Atom * pConst ) const
         if( pVarArray[ i ].lValue == lValue )
         {
             *pConst = pVarArray[ i ].nId;
-            return TRUE;
+            return sal_True;
         }
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -219,14 +219,14 @@ RscEnum::RscEnum( Atom nId, sal_uInt32 nTypeId )
 |*    RscEnum::SetConst()
 |*
 *************************************************************************/
-ERRTYPE RscEnum::SetConst( const RSCINST & rInst, Atom nConst, INT32 /*nVal*/ )
+ERRTYPE RscEnum::SetConst( const RSCINST & rInst, Atom nConst, sal_Int32 /*nVal*/ )
 {
     sal_uInt32 i = 0;
 
     if( nEntries != (i = GetConstPos( nConst )) )
     {
         ((RscEnumInst *)rInst.pData)->nValue = i;
-        ((RscEnumInst *)rInst.pData)->bDflt = FALSE;
+        ((RscEnumInst *)rInst.pData)->bDflt = sal_False;
         return( ERR_OK );
     };
 
@@ -238,12 +238,12 @@ ERRTYPE RscEnum::SetConst( const RSCINST & rInst, Atom nConst, INT32 /*nVal*/ )
 |*    RscEnum::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscEnum::SetNumber( const RSCINST & rInst, INT32 lValue )
+ERRTYPE RscEnum::SetNumber( const RSCINST & rInst, sal_Int32 lValue )
 {
     sal_uInt32  i = 0;
 
     for( i = 0; i < nEntries; i++ ){
-        if( (INT32)pVarArray[ i ].lValue == lValue )
+        if( (sal_Int32)pVarArray[ i ].lValue == lValue )
             return( SetConst( rInst, pVarArray[ i ].nId, lValue ) );
     };
 
@@ -265,7 +265,7 @@ ERRTYPE RscEnum::GetConst( const RSCINST & rInst, Atom * pH ){
 |*    RscEnum::GetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscEnum::GetNumber( const RSCINST & rInst, INT32 * pNumber ){
+ERRTYPE RscEnum::GetNumber( const RSCINST & rInst, sal_Int32 * pNumber ){
     *pNumber = pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].lValue;
     return( ERR_OK );
 }
@@ -275,7 +275,7 @@ ERRTYPE RscEnum::GetNumber( const RSCINST & rInst, INT32 * pNumber ){
 |*    RscEnum::Create()
 |*
 *************************************************************************/
-RSCINST RscEnum::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass ){
+RSCINST RscEnum::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
     RSCINST aInst;
 
     if( !pInst ){
@@ -292,7 +292,7 @@ RSCINST RscEnum::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass
         memmove( aInst.pData, rDflt.pData, Size() );
     else{
         ((RscEnumInst *)aInst.pData)->nValue = 0;
-        ((RscEnumInst *)aInst.pData)->bDflt = TRUE;
+        ((RscEnumInst *)aInst.pData)->bDflt = sal_True;
     }
 
     return( aInst );
@@ -303,16 +303,16 @@ RSCINST RscEnum::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass
 |*    RscEnum::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscEnum::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
+sal_Bool RscEnum::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
     if( pDef ){
         if( ((RscEnumInst*)rInst.pData)->nValue ==
           ((RscEnumInst*)pDef)->nValue )
         {
-            return TRUE;
+            return sal_True;
         }
     }
 
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -333,9 +333,9 @@ void RscEnum::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscEnum::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
-                          RscTypCont *, sal_uInt32, BOOL )
+                          RscTypCont *, sal_uInt32, sal_Bool )
 {
-    aMem.Put( (INT32)pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].lValue );
+    aMem.Put( (sal_Int32)pVarArray[ ((RscEnumInst *)rInst.pData)->nValue ].lValue );
     return( ERR_OK );
 }
 
diff --git a/rsc/source/res/rsccont.cxx b/rsc/source/res/rsccont.cxx
index e2b49d7d9ab7..c39be82b5c7e 100644
--- a/rsc/source/res/rsccont.cxx
+++ b/rsc/source/res/rsccont.cxx
@@ -63,7 +63,7 @@ void ENTRY_STRUCT::Destroy()
 |*
 *************************************************************************/
 RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
-                          BOOL bNoIdent )
+                          sal_Bool bNoIdent )
     : RscTop( nId, nTypeId, pSuper ),
       nSize( 0 )
 {
@@ -118,7 +118,7 @@ void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
 |*
 *************************************************************************/
 RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
-                             BOOL bOwnClass )
+                             sal_Bool bOwnClass )
 {
     sal_uInt32  i = 0;
     RSCINST aInst;
@@ -138,7 +138,7 @@ RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
     pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
     pClassData->nEntries = 0;
     pClassData->pEntries = NULL;
-    pClassData->bDflt = TRUE;
+    pClassData->bDflt = sal_True;
 
     if( bOwnClass ){
         RscBaseContInst *   pDfltClassData;
@@ -251,7 +251,7 @@ ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
     else
         pCreateClass = pTypeClass;
 
-    pClassData->bDflt = FALSE;
+    pClassData->bDflt = sal_False;
     if( !bNoId )
         aTmpI = SearchEle( rInst, rEleName, pCreateClass );
     // Eintrag gefunden
@@ -446,11 +446,11 @@ else
 |*    RscBaseCont::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, INT32 lValue ){
+ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, sal_Int32 lValue ){
     RscBaseContInst * pClassData;
     RSCINST aTmpI;
     ERRTYPE aError;
-    INT32   lNumber;
+    sal_Int32   lNumber;
 
     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 
@@ -482,13 +482,13 @@ else
 ERRTYPE RscBaseCont::SetBool
 (
     const RSCINST & rInst,
-    BOOL bValue
+    sal_Bool bValue
 )
 {
     RscBaseContInst * pClassData;
     RSCINST aTmpI;
     ERRTYPE aError;
-    BOOL    bBool;
+    sal_Bool    bBool;
 
     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 
@@ -522,7 +522,7 @@ ERRTYPE RscBaseCont::SetConst
 (
     const RSCINST & rInst,
     Atom nValueId,
-    INT32 lValue
+    sal_Int32 lValue
 )
 {
     RscBaseContInst * pClassData;
@@ -598,10 +598,10 @@ else
 |*    RscBaseCont::IsConsistent()
 |*
 *************************************************************************/
-BOOL RscBaseCont::IsConsistent( const RSCINST & rInst ) {
+sal_Bool RscBaseCont::IsConsistent( const RSCINST & rInst ) {
     sal_uInt32  i = 0;
     RscBaseContInst * pClassData;
-    BOOL    bRet;
+    sal_Bool    bRet;
 
     bRet = RscTop::IsConsistent( rInst );
 
@@ -611,19 +611,19 @@ BOOL RscBaseCont::IsConsistent( const RSCINST & rInst ) {
     // Komplexitaet = n^2 / 2
     for( i = 0; i < pClassData->nEntries; i++ ){
         if( !bNoId ){
-            if( (INT32)pClassData->pEntries[ i ].aName > 0x7FFF
-              || (INT32)pClassData->pEntries[ i ].aName < 1 ){
-                bRet = FALSE;
+            if( (sal_Int32)pClassData->pEntries[ i ].aName > 0x7FFF
+              || (sal_Int32)pClassData->pEntries[ i ].aName < 1 ){
+                bRet = sal_False;
             }
             else if( SearchElePos( rInst, pClassData->pEntries[ i ].aName,
                 pClassData->pEntries[ i ].aInst.pClass, i +1 ).IsInst() )
             {
-                 bRet = FALSE;
+                 bRet = sal_False;
              };
         }
         if( ! pClassData->pEntries[ i ].aInst.pClass->
               IsConsistent( pClassData->pEntries[ i ].aInst ) )
-            bRet = FALSE;
+            bRet = sal_False;
     };
 
     return( bRet );
@@ -655,20 +655,20 @@ void RscBaseCont::SetToDefault( const RSCINST & rInst )
 |*    RscBaseCont::IsDefault()
 |*
 *************************************************************************/
-BOOL RscBaseCont::IsDefault( const RSCINST & rInst ){
+sal_Bool RscBaseCont::IsDefault( const RSCINST & rInst ){
     sal_uInt32  i = 0;
     RscBaseContInst * pClassData;
 
     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 
     if( !pClassData->bDflt )
-        return FALSE;
+        return sal_False;
 
     for( i = 0; i < pClassData->nEntries; i++ ){
         if( ! pClassData->pEntries[ i ].aInst.pClass->
                   IsDefault( pClassData->pEntries[ i ].aInst ) )
         {
-            return( FALSE );
+            return( sal_False );
         };
     };
 
@@ -680,19 +680,19 @@ BOOL RscBaseCont::IsDefault( const RSCINST & rInst ){
 |*    RscBaseCont::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+sal_Bool RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 {
     RscBaseContInst * pClassData;
 
     if( !RscTop::IsValueDefault( rInst, pDef ) )
-        return FALSE;
+        return sal_False;
 
     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 
     if( pClassData->nEntries )
-        return FALSE;
+        return sal_False;
     else
-        return TRUE;
+        return sal_True;
 }
 
 /*************************************************************************
@@ -775,14 +775,14 @@ void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                              RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                              RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     sal_uInt32        i = 0;
     RscBaseContInst * pClassData;
     ERRTYPE       aError;
 
     if( bExtra || bNoId )
-    { // Nur Subresourcen schreiben, wenn bExtra == TRUE
+    { // Nur Subresourcen schreiben, wenn bExtra == sal_True
         pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
 
         for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ ){
@@ -803,7 +803,7 @@ void RscBaseCont::ContWriteRcAccess
     FILE * fOutput,
     RscTypCont * pTC,
     const char * pName,
-    BOOL bWriteSize
+    sal_Bool bWriteSize
 )
 {
     if( (bNoId || bWriteSize) && !pTypeClass1 )
@@ -846,7 +846,7 @@ void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                              RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                              RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     ERRTYPE       aError;
 
@@ -926,7 +926,7 @@ ERRTYPE RscBaseCont::WriteCxx( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
-                                 RscTop * pSuper, BOOL bNoIdent )
+                                 RscTop * pSuper, sal_Bool bNoIdent )
                   : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
 {}
 
@@ -961,7 +961,7 @@ void RscContWriteSrc::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*    RscCont::RscCont()
 |*
 *************************************************************************/
-RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, BOOL bNoIdent )
+RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, sal_Bool bNoIdent )
               : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
 {}
 
@@ -971,7 +971,7 @@ RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, BOOL bNoIdent )
 |*
 *************************************************************************/
 ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                                 RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                                 RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     RscBaseContInst * pClassData;
     ERRTYPE aError;
@@ -996,7 +996,7 @@ void RscCont::WriteRcAccess
     const char * pName
 )
 {
-    ContWriteRcAccess( fOutput, pTC, pName, TRUE );
+    ContWriteRcAccess( fOutput, pTC, pName, sal_True );
 }
 
 /*************************************************************************
@@ -1005,7 +1005,7 @@ void RscCont::WriteRcAccess
 |*
 *************************************************************************/
 RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
-                             RscTop * pSuper, BOOL bNoIdent )
+                             RscTop * pSuper, sal_Bool bNoIdent )
                      : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
 {}
 
@@ -1015,7 +1015,7 @@ RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
 |*
 *************************************************************************/
 ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                             RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                             RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     ERRTYPE aError;
 
diff --git a/rsc/source/res/rscflag.cxx b/rsc/source/res/rscflag.cxx
index 3f88b34dffd2..aeaf2fd2e43d 100644
--- a/rsc/source/res/rscflag.cxx
+++ b/rsc/source/res/rscflag.cxx
@@ -87,7 +87,7 @@ ERRTYPE RscFlag::SetNotConst( const RSCINST & rInst, Atom nConst )
 |*    RscFlag::SetConst()
 |*
 *************************************************************************/
-ERRTYPE RscFlag::SetConst( const RSCINST & rInst, Atom nConst, INT32 /*nVal*/ )
+ERRTYPE RscFlag::SetConst( const RSCINST & rInst, Atom nConst, sal_Int32 /*nVal*/ )
 {
     sal_uInt32 i = 0, nFlag = 0;
 
@@ -126,7 +126,7 @@ RSCINST RscFlag::CreateBasic( RSCINST * pInst )
 |*    RscFlag::Create()
 |*
 *************************************************************************/
-RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass )
+RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass )
 {
     RSCINST aInst = CreateBasic( pInst );
     sal_uInt32  i = 0;
@@ -154,7 +154,7 @@ RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass
 |*
 *************************************************************************/
 RSCINST RscFlag::CreateClient( RSCINST * pInst, const RSCINST & rDfltI,
-                               BOOL bOwnClass, Atom nConstId )
+                               sal_Bool bOwnClass, Atom nConstId )
 {
     RSCINST aInst = CreateBasic( pInst );
     sal_uInt32 i = 0, nFlag = 0;
@@ -198,17 +198,17 @@ void RscFlag::SetToDefault( const RSCINST & rInst )
 |*    RscFlag::IsDlft()
 |*
 *************************************************************************/
-BOOL RscFlag::IsDefault( const RSCINST & rInst )
+sal_Bool RscFlag::IsDefault( const RSCINST & rInst )
 {
     sal_uInt32 i = 0;
 
     for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
         if( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags != 0xFFFFFFFF )
-            return( FALSE );
-    return( TRUE );
+            return( sal_False );
+    return( sal_True );
 }
 
-BOOL RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
+sal_Bool RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
 {
     sal_uInt32 i = 0, nFlag = 0;
 
@@ -216,11 +216,11 @@ BOOL RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
         i = i / (sizeof( sal_uInt32 ) * 8);
         if( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags & nFlag )
-            return( TRUE );
+            return( sal_True );
         else
-            return( FALSE );
+            return( sal_False );
     };
-    return( TRUE );
+    return( sal_True );
 }
 
 /*************************************************************************
@@ -228,7 +228,7 @@ BOOL RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
 |*    RscFlag::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
+sal_Bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
                               Atom nConstId )
 {
     sal_uInt32 i = 0, nFlag = 0;
@@ -241,15 +241,15 @@ BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
             if( (((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag)
               == (((RscFlagInst *)pDef)[ i ].nFlags & nFlag) )
             {
-                return TRUE;
+                return sal_True;
             }
         }
     };
 
-    return FALSE;
+    return sal_False;
 }
 
-BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+sal_Bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 {
     sal_uInt32 i = 0;
 
@@ -262,7 +262,7 @@ BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
             if( (((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag)
               != (((RscFlagInst *)pDef)[ nIndex ].nFlags & Flag)  )
             {
-                return FALSE;
+                return sal_False;
             }
             Flag <<= 1;
             if( !Flag )
@@ -270,9 +270,9 @@ BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
         };
     }
     else
-        return FALSE;
+        return sal_False;
 
-    return TRUE;
+    return sal_True;
 }
 
 /*************************************************************************
@@ -280,7 +280,7 @@ BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 |*    RscFlag::IsSet()
 |*
 *************************************************************************/
-BOOL RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
+sal_Bool RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
 {
     sal_uInt32 i = 0, nFlag = 0;
 
@@ -288,11 +288,11 @@ BOOL RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
         i = i / (sizeof( sal_uInt32 ) * 8);
         if( ((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag )
-            return( TRUE );
+            return( sal_True );
         else
-            return( FALSE );
+            return( sal_False );
     };
-    return( TRUE );
+    return( sal_True );
 }
 
 /*************************************************************************
@@ -304,7 +304,7 @@ void RscFlag::WriteSrc( const RSCINST & rInst, FILE * fOutput,
                         RscTypCont *, sal_uInt32, const char * )
 {
     sal_uInt32  i = 0, Flag = 0, nIndex = 0;
-    BOOL    bComma = FALSE;
+    sal_Bool    bComma = sal_False;
 
     Flag = 1;
     for( i = 0; i < nEntries; i++ ){
@@ -318,7 +318,7 @@ void RscFlag::WriteSrc( const RSCINST & rInst, FILE * fOutput,
                 fprintf( fOutput, "not " );
                 fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
             }
-            bComma = TRUE;
+            bComma = sal_True;
         }
         Flag <<= 1;
         if( !Flag )
@@ -332,9 +332,9 @@ void RscFlag::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscFlag::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
-                          RscTypCont *, sal_uInt32, BOOL )
+                          RscTypCont *, sal_uInt32, sal_Bool )
 {
-    INT32   lVal = 0;
+    sal_Int32   lVal = 0;
     sal_uInt32  i = 0, Flag = 0, nIndex = 0;
 
     Flag = 1;
@@ -348,7 +348,7 @@ ERRTYPE RscFlag::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
             Flag = 1;
     };
 
-    aMem.Put( (INT32)lVal );
+    aMem.Put( (sal_Int32)lVal );
     return( ERR_OK );
 }
 
@@ -395,7 +395,7 @@ void RscClient::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 RSCINST RscClient::Create( RSCINST * pInst, const RSCINST & rDflt,
-                           BOOL bOwnClass )
+                           sal_Bool bOwnClass )
 {
     RSCINST aTmpI, aDfltI;
 
diff --git a/rsc/source/res/rscmgr.cxx b/rsc/source/res/rscmgr.cxx
index 7a44aa4d8921..1e65962099a8 100644
--- a/rsc/source/res/rscmgr.cxx
+++ b/rsc/source/res/rscmgr.cxx
@@ -67,7 +67,7 @@ sal_uInt32 RscMgr::Size()
 |*    RscMgr::Create()
 |*
 *************************************************************************/
-RSCINST RscMgr::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass ){
+RSCINST RscMgr::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
     RSCINST aInst;
     RscMgrInst * pClassData;
 
@@ -117,7 +117,7 @@ void RscMgr::SetToDefault( const RSCINST & rInst )
     RscMgrInst * pClassData;
 
     pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
-    pClassData->bDflt = TRUE;
+    pClassData->bDflt = sal_True;
 
     RscClass::SetToDefault( rInst );
 }
@@ -127,12 +127,12 @@ void RscMgr::SetToDefault( const RSCINST & rInst )
 |*    RscMgr::IsDefault()
 |*
 *************************************************************************/
-BOOL RscMgr::IsDefault( const RSCINST & rInst ){
+sal_Bool RscMgr::IsDefault( const RSCINST & rInst ){
     RscMgrInst * pClassData;
 
     pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
     if( !pClassData->bDflt )
-        return( FALSE );
+        return( sal_False );
 
     return( RscClass::IsDefault( rInst ) );
 }
@@ -142,23 +142,23 @@ BOOL RscMgr::IsDefault( const RSCINST & rInst ){
 |*    RscMgr::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscMgr::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
+sal_Bool RscMgr::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
     RscMgrInst * pClassData;
     RscMgrInst * pDfltData;
 
     if( !RscClass::IsValueDefault( rInst, pDef ) )
-        return FALSE;
+        return sal_False;
 
     if( pDef ){
         pClassData = (RscMgrInst *)(rInst.pData + RscClass::Size());
         pDfltData  = (RscMgrInst *)(pDef + RscClass::Size());
 
         if( !pClassData->aRefId.IsId() && !pDfltData->aRefId.IsId() ){
-            return TRUE;
+            return sal_True;
         }
     }
 
-    return FALSE;
+    return sal_False;
 }
 
 
@@ -215,7 +215,7 @@ void RscMgr::WriteSrc( const RSCINST &, FILE *, RscTypCont *, sal_uInt32,
 *************************************************************************/
 ERRTYPE RscMgr::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
                                RscTypCont * pTC, const RscId &rId,
-                               sal_uInt32 nDeep, BOOL bExtra )
+                               sal_uInt32 nDeep, sal_Bool bExtra )
 {
     RscMgrInst *    pClassData;
     ERRTYPE         aError;
@@ -307,7 +307,7 @@ ERRTYPE RscMgr::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
 |*
 *************************************************************************/
 ERRTYPE RscMgr::WriteRc( const RSCINST &, RscWriteRc &,
-                         RscTypCont *, sal_uInt32, BOOL )
+                         RscTypCont *, sal_uInt32, sal_Bool )
 
 {
     return( ERR_OK );
@@ -530,9 +530,9 @@ ERRTYPE RscMgr::WriteCxx( const RSCINST & rInst, FILE * fOutput,
 |*    RscArray::IsConsistent()
 |*
 *************************************************************************/
-BOOL RscMgr::IsConsistent( const RSCINST & rInst )
+sal_Bool RscMgr::IsConsistent( const RSCINST & rInst )
 {
-    BOOL    bRet;
+    sal_Bool    bRet;
     RscMgrInst * pClassData;
 
     bRet = RscClass::IsConsistent( rInst );
@@ -543,7 +543,7 @@ BOOL RscMgr::IsConsistent( const RSCINST & rInst )
         || (pClassData->aRefId.GetNumber() > 0x7FFF)
         || IsToDeep( rInst ).IsError()) )
     {
-        bRet = FALSE;
+        bRet = sal_False;
     }
 
     return( bRet );
@@ -589,7 +589,7 @@ ERRTYPE RscMgr::IsToDeep( const RSCINST & rInst, sal_uInt32 nDeep )
             aTmpI.pData = pObjNode->GetRscObj();
             nDeep++;
         }
-        else //aTmpI.IsInst() wird FALSE, Schleife beenden
+        else //aTmpI.IsInst() wird sal_False, Schleife beenden
             aTmpI.pData = NULL;
     }
 
@@ -628,7 +628,7 @@ ERRTYPE RscMgr::SetRef( const RSCINST & rInst, const RscId & rRefId )
 
         aError = IsToDeep( rInst );
         if( aError.IsOk() )
-            pClassData->bDflt  = FALSE;
+            pClassData->bDflt  = sal_False;
         else
             pClassData->aRefId = aOldId;
     }
diff --git a/rsc/source/res/rscrange.cxx b/rsc/source/res/rscrange.cxx
index 0e1aa26736b6..132133d5fe76 100644
--- a/rsc/source/res/rscrange.cxx
+++ b/rsc/source/res/rscrange.cxx
@@ -71,7 +71,7 @@ RSCCLASS_TYPE RscRange::GetClassType() const
 |*    RscRange::SetRange()
 |*
 *************************************************************************/
-ERRTYPE RscRange::SetRange( INT32 nMinimum, INT32 nMaximum )
+ERRTYPE RscRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
 {
     if( nMinimum > nMaximum )
     {
@@ -92,18 +92,18 @@ ERRTYPE RscRange::SetRange( INT32 nMinimum, INT32 nMaximum )
 |*    RscRange::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+sal_Bool RscRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 {
     if( pDef )
     {
         if( ((RscRangeInst*)rInst.pData)->nValue ==
           ((RscRangeInst*)pDef)->nValue )
         {
-            return TRUE;
+            return sal_True;
         }
     }
 
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -111,12 +111,12 @@ BOOL RscRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 |*    RscRange::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscRange::SetNumber( const RSCINST & rInst, INT32 nValue )
+ERRTYPE RscRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
 {
     if( nMax < nValue || nMin > nValue )
         return( ERR_RSCRANGE_OUTDEFSET );
     ((RscRangeInst *)rInst.pData)->nValue = (sal_uInt16)( nValue - nMin );
-    ((RscRangeInst *)rInst.pData)->bDflt = FALSE;
+    ((RscRangeInst *)rInst.pData)->bDflt = sal_False;
     return( ERR_OK );
 }
 
@@ -125,7 +125,7 @@ ERRTYPE RscRange::SetNumber( const RSCINST & rInst, INT32 nValue )
 |*    RscRange::GetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscRange::GetNumber( const RSCINST & rInst, INT32 * pN )
+ERRTYPE RscRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
 {
     *pN = ((RscRangeInst *)rInst.pData)->nValue + nMin;
     return( ERR_OK );
@@ -137,7 +137,7 @@ ERRTYPE RscRange::GetNumber( const RSCINST & rInst, INT32 * pN )
 |*
 *************************************************************************/
 RSCINST RscRange::Create( RSCINST * pInst, const RSCINST & rDflt,
-                            BOOL bOwnClass )
+                            sal_Bool bOwnClass )
 {
     RSCINST aInst;
 
@@ -160,7 +160,7 @@ RSCINST RscRange::Create( RSCINST * pInst, const RSCINST & rDflt,
             ((RscRangeInst *)aInst.pData)->nValue = (sal_uInt16)(0L - nMin);
         else
             ((RscRangeInst *)aInst.pData)->nValue = 0;
-        ((RscRangeInst *)aInst.pData)->bDflt = TRUE;
+        ((RscRangeInst *)aInst.pData)->bDflt = sal_True;
     }
 
     return( aInst );
@@ -183,7 +183,7 @@ void RscRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
-                           RscTypCont *, sal_uInt32, BOOL )
+                           RscTypCont *, sal_uInt32, sal_Bool )
 {
     if( nMin >= 0 )
     {
@@ -245,7 +245,7 @@ RSCCLASS_TYPE RscLongRange::GetClassType() const
 |*    RscLongRange::SetRange()
 |*
 *************************************************************************/
-ERRTYPE RscLongRange::SetRange( INT32 nMinimum, INT32 nMaximum )
+ERRTYPE RscLongRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
 {
     if( nMinimum > nMaximum )
     {
@@ -266,14 +266,14 @@ ERRTYPE RscLongRange::SetRange( INT32 nMinimum, INT32 nMaximum )
 |*    RscLongRange::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscLongRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
+sal_Bool RscLongRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 {
     if( pDef )
         return 0 == memcmp( &((RscLongRangeInst*)rInst.pData)->nValue,
                             &((RscLongRangeInst*)pDef)->nValue,
-                            sizeof( INT32 ) );
+                            sizeof( sal_Int32 ) );
 
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -281,13 +281,13 @@ BOOL RscLongRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 |*    RscLongRange::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscLongRange::SetNumber( const RSCINST & rInst, INT32 nValue )
+ERRTYPE RscLongRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
 {
     if( nMax < nValue || nMin > nValue )
         return( ERR_RSCRANGE_OUTDEFSET );
     void * pData = &((RscLongRangeInst*)rInst.pData)->nValue;
-    memmove( pData, &nValue, sizeof( INT32 ) );
-    ((RscLongRangeInst *)rInst.pData)->bDflt = FALSE;
+    memmove( pData, &nValue, sizeof( sal_Int32 ) );
+    ((RscLongRangeInst *)rInst.pData)->bDflt = sal_False;
     return( ERR_OK );
 }
 
@@ -296,10 +296,10 @@ ERRTYPE RscLongRange::SetNumber( const RSCINST & rInst, INT32 nValue )
 |*    RscLongRange::GetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscLongRange::GetNumber( const RSCINST & rInst, INT32 * pN )
+ERRTYPE RscLongRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
 {
     memmove( pN, &((RscLongRangeInst*)rInst.pData)->nValue,
-             sizeof( INT32 ) );
+             sizeof( sal_Int32 ) );
     return( ERR_OK );
 }
 
@@ -309,7 +309,7 @@ ERRTYPE RscLongRange::GetNumber( const RSCINST & rInst, INT32 * pN )
 |*
 *************************************************************************/
 RSCINST RscLongRange::Create( RSCINST * pInst, const RSCINST & rDflt,
-                              BOOL bOwnClass )
+                              sal_Bool bOwnClass )
 {
     RSCINST aInst;
 
@@ -328,14 +328,14 @@ RSCINST RscLongRange::Create( RSCINST * pInst, const RSCINST & rDflt,
         memmove( aInst.pData, rDflt.pData, sizeof( RscLongRangeInst ) );
     else
     {
-        INT32   lDflt;
+        sal_Int32   lDflt;
         if( 0L >= nMin && 0L <= nMax )
             lDflt = 0;
         else
             lDflt = nMin;
         void * pData = &((RscLongRangeInst*)aInst.pData)->nValue;
-        memmove( pData, &lDflt, sizeof( INT32 ) );
-        ((RscLongRangeInst *)aInst.pData)->bDflt = TRUE;
+        memmove( pData, &lDflt, sizeof( sal_Int32 ) );
+        ((RscLongRangeInst *)aInst.pData)->bDflt = sal_True;
     }
 
     return( aInst );
@@ -349,7 +349,7 @@ RSCINST RscLongRange::Create( RSCINST * pInst, const RSCINST & rDflt,
 void RscLongRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
                          RscTypCont *, sal_uInt32, const char * )
 {
-    INT32 lVal;
+    sal_Int32 lVal;
     GetNumber( rInst, &lVal );
     fprintf( fOutput, "%d", static_cast<int>(lVal) );
 }
@@ -360,12 +360,12 @@ void RscLongRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscLongRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
-                               RscTypCont *, sal_uInt32, BOOL )
+                               RscTypCont *, sal_uInt32, sal_Bool )
 {
-    INT32 lVal;
+    sal_Int32 lVal;
 
     GetNumber( rInst, &lVal );
-    aMem.Put( (INT32)lVal );
+    aMem.Put( (sal_Int32)lVal );
 
     return( ERR_OK );
 }
@@ -380,7 +380,7 @@ void RscLongRange::WriteRcAccess
 {
     fprintf( fOutput, "\t\tSet%s( ", pName );
     fprintf( fOutput, "GetLong( pResData+nOffset ) );\n" );
-    fprintf( fOutput, "\t\tnOffset += sizeof( INT32 );\n" );
+    fprintf( fOutput, "\t\tnOffset += sizeof( sal_Int32 );\n" );
 }
 
 /****************** R s c L o n g E n u m R a n g e *********************/
@@ -400,7 +400,7 @@ RscLongEnumRange::RscLongEnumRange( Atom nId, sal_uInt32 nTypeId )
 |*    Beschreibung
 *************************************************************************/
 ERRTYPE RscLongEnumRange::SetConst( const RSCINST & rInst, Atom /*nConst*/,
-                                    INT32 nValue )
+                                    sal_Int32 nValue )
 {
     return SetNumber( rInst, nValue );
 }
@@ -433,7 +433,7 @@ RSCCLASS_TYPE RscIdRange::GetClassType() const
 |*    RscIdRange::Create()
 |*
 *************************************************************************/
-RSCINST RscIdRange::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass ){
+RSCINST RscIdRange::Create( RSCINST * pInst, const RSCINST & rDflt, sal_Bool bOwnClass ){
     RSCINST aInst;
     RscId * pClassData;
 
@@ -456,11 +456,11 @@ RSCINST RscIdRange::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnCla
     else{
             *pClassData = RscId();
         if( 0 >= nMin && 0 <= nMax )
-            *pClassData = RscId( (INT32)0 );
+            *pClassData = RscId( (sal_Int32)0 );
         else
             *pClassData = RscId( nMin );
         //cUnused wird fuer Defaultkennung verwendet
-        ((RscId *)aInst.pData)->aExp.cUnused = TRUE;
+        ((RscId *)aInst.pData)->aExp.cUnused = sal_True;
     }
 
     return( aInst );
@@ -480,7 +480,7 @@ void RscIdRange :: Destroy( const RSCINST & rInst ){
 |*    RscIdRange::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
+sal_Bool RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
     if( pDef ){
         if( ((RscId*)rInst.pData)->aExp.IsNumber()
           && ((RscId*)pDef)->aExp.IsNumber() )
@@ -488,12 +488,12 @@ BOOL RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
             if( ((RscId*)rInst.pData)->GetNumber() ==
               ((RscId*)pDef)->GetNumber() )
             {
-                return TRUE;
+                return sal_True;
             }
         }
     }
 
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -501,13 +501,13 @@ BOOL RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
 |*    RscIdRange::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscIdRange::SetNumber( const RSCINST & rInst, INT32 nValue )
+ERRTYPE RscIdRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
 {
     if( nMax < nValue || nMin > nValue )
         return( ERR_RSCRANGE_OUTDEFSET );
 
     *(RscId *)rInst.pData = RscId( nValue );
-    ((RscId *)rInst.pData)->aExp.cUnused = FALSE;
+    ((RscId *)rInst.pData)->aExp.cUnused = sal_False;
     return( ERR_OK );
 }
 
@@ -516,7 +516,7 @@ ERRTYPE RscIdRange::SetNumber( const RSCINST & rInst, INT32 nValue )
 |*    RscIdRange::GetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscIdRange::GetNumber( const RSCINST & rInst, INT32 * plValue ){
+ERRTYPE RscIdRange::GetNumber( const RSCINST & rInst, sal_Int32 * plValue ){
     *plValue = ((RscId *)rInst.pData)->GetNumber();
     return( ERR_OK );
 }
@@ -532,7 +532,7 @@ ERRTYPE RscIdRange::SetRef( const RSCINST & rInst, const RscId & rRscId ){
         aError = SetNumber( rInst, rRscId );
         if( aError.IsOk() ){
             *(RscId *)rInst.pData = rRscId;
-            ((RscId *)rInst.pData)->aExp.cUnused = FALSE;
+            ((RscId *)rInst.pData)->aExp.cUnused = sal_False;
         }
     }
     else
@@ -569,11 +569,11 @@ void RscIdRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscIdRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
-                             RscTypCont *, sal_uInt32, BOOL )
+                             RscTypCont *, sal_uInt32, sal_Bool )
 {
-    INT32 lVal = ((RscId*)rInst.pData)->GetNumber();
+    sal_Int32 lVal = ((RscId*)rInst.pData)->GetNumber();
 
-    aMem.Put( (INT32)lVal );
+    aMem.Put( (sal_Int32)lVal );
 
     return( ERR_OK );
 }
@@ -588,7 +588,7 @@ void RscIdRange::WriteRcAccess
 {
     fprintf( fOutput, "\t\tSet%s( ", pName );
     fprintf( fOutput, "GetLong( pResData+nOffset ) );\n" );
-    fprintf( fOutput, "\t\tnOffset += sizeof( INT32 );\n" );
+    fprintf( fOutput, "\t\tnOffset += sizeof( sal_Int32 );\n" );
 }
 
 /*************************************************************************
@@ -596,13 +596,13 @@ void RscIdRange::WriteRcAccess
 |*    RscIdRange::IsConsistent()
 |*
 *************************************************************************/
-BOOL RscIdRange::IsConsistent( const RSCINST & rInst )
+sal_Bool RscIdRange::IsConsistent( const RSCINST & rInst )
 {
     long nValue = ((RscId *)rInst.pData)->GetNumber();
     if( (nMax >= nValue) && (nMin <= nValue) )
-        return TRUE;
+        return sal_True;
     else {
-        return FALSE;
+        return sal_False;
     }
 }
 
@@ -636,7 +636,7 @@ RSCCLASS_TYPE  RscBool::GetClassType() const
 void RscBool::WriteSrc( const RSCINST & rInst, FILE * fOutput,
                         RscTypCont *, sal_uInt32, const char * )
 {
-    INT32 l;
+    sal_Int32 l;
 
     GetNumber( rInst, &l );
     if( l )
@@ -654,7 +654,7 @@ void RscBool::WriteRcAccess
 )
 {
     fprintf( fOutput, "\t\tSet%s( ", pName );
-    fprintf( fOutput, "(BOOL)*(short *)(pResData+nOffset) );\n" );
+    fprintf( fOutput, "(sal_Bool)*(short *)(pResData+nOffset) );\n" );
     fprintf( fOutput, "\t\tnOffset += sizeof( short );\n" );
 }
 
@@ -675,7 +675,7 @@ RscBreakRange :: RscBreakRange( Atom nId, sal_uInt32 nTypeId )
 |*    RscBreakRange::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscBreakRange::SetNumber( const RSCINST & rInst, INT32 nValue ){
+ERRTYPE RscBreakRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue ){
     if( nValue == nOutRange )
         return( ERR_RSCRANGE_OUTDEFSET );
     else
@@ -688,10 +688,10 @@ ERRTYPE RscBreakRange::SetNumber( const RSCINST & rInst, INT32 nValue ){
 |*
 *************************************************************************/
 RSCINST RscBreakRange::Create( RSCINST * pInst, const RSCINST & rDflt,
-                               BOOL bOwnClass )
+                               sal_Bool bOwnClass )
 {
     RSCINST aInst;
-    INT32   l;
+    sal_Int32   l;
 
     aInst = RscRange::Create( pInst, rDflt, bOwnClass );
 
diff --git a/rsc/source/res/rscstr.cxx b/rsc/source/res/rscstr.cxx
index 94d69f860cc2..9126823b5f76 100644
--- a/rsc/source/res/rscstr.cxx
+++ b/rsc/source/res/rscstr.cxx
@@ -76,7 +76,7 @@ ERRTYPE RscString::SetString( const RSCINST & rInst, const char * pStr ){
     ERRTYPE aError;
 
     if( aError.IsOk() ){
-        ((RscStringInst *)rInst.pData)->bDflt = FALSE;
+        ((RscStringInst *)rInst.pData)->bDflt = sal_False;
 
         pTmp = ((RscStringInst *)rInst.pData)->pStr;
         if( pTmp ){
@@ -124,7 +124,7 @@ ERRTYPE RscString::GetRef( const RSCINST & rInst, RscId * pRscId ){
 ERRTYPE RscString::SetRef( const RSCINST & rInst, const RscId & rRefId ){
     if( pRefClass ){
         ((RscStringInst *)rInst.pData)->aRefId = rRefId;
-        ((RscStringInst *)rInst.pData)->bDflt  = FALSE;
+        ((RscStringInst *)rInst.pData)->bDflt  = sal_False;
     }
     else
         return( ERR_REFNOTALLOWED );
@@ -138,7 +138,7 @@ ERRTYPE RscString::SetRef( const RSCINST & rInst, const RscId & rRefId ){
 |*
 *************************************************************************/
 RSCINST RscString::Create( RSCINST * pInst, const RSCINST & rDflt,
-                           BOOL bOwnClass )
+                           sal_Bool bOwnClass )
 {
     RSCINST aInst;
 
@@ -154,7 +154,7 @@ RSCINST RscString::Create( RSCINST * pInst, const RSCINST & rDflt,
 
     ((RscStringInst *)aInst.pData)->aRefId.Create();
     ((RscStringInst *)aInst.pData)->pStr = NULL;
-    ((RscStringInst *)aInst.pData)->bDflt = TRUE;
+    ((RscStringInst *)aInst.pData)->bDflt = sal_True;
 
     if( bOwnClass ){
         ((RscStringInst *)aInst.pData)->aRefId =
@@ -183,7 +183,7 @@ void RscString::Destroy( const RSCINST & rInst ){
 |*    RscString::IsValueDefault()
 |*
 *************************************************************************/
-BOOL RscString::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
+sal_Bool RscString::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
     RscStringInst * pData    = (RscStringInst*)rInst.pData;
     RscStringInst * pDefData = (RscStringInst*)pDef;
 
@@ -196,34 +196,34 @@ BOOL RscString::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
                 // Sind die Referenzidentifier gleich
                 if( pData->aRefId.GetNumber() == pDefData->aRefId.GetNumber() )
                 {
-                    return TRUE;
+                    return sal_True;
                 }
             }
         }
         else {
-            BOOL bStrEmpty = FALSE;
-            BOOL bDefStrEmpty = FALSE;
+            sal_Bool bStrEmpty = sal_False;
+            sal_Bool bDefStrEmpty = sal_False;
 
             if( pData->pStr ){
                 bStrEmpty = ('\0' == *pData->pStr);
             }
             else
-                bStrEmpty = TRUE;
+                bStrEmpty = sal_True;
 
             if( pDefData->pStr ){
                 bDefStrEmpty = ('\0' == *pDefData->pStr);
             }
             else
-                bDefStrEmpty = TRUE;
+                bDefStrEmpty = sal_True;
 
             if( !bStrEmpty || !bDefStrEmpty ){
-                return FALSE;
+                return sal_False;
             }
-            return TRUE;
+            return sal_True;
         }
     }
 
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -276,7 +276,7 @@ void RscString::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 |*
 *************************************************************************/
 ERRTYPE RscString::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                            RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                            RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     ERRTYPE aError;
     ObjNode *       pObjNode = NULL;
diff --git a/rsc/source/res/rsctop.cxx b/rsc/source/res/rsctop.cxx
index a3305412da10..db9eb6fec470 100644
--- a/rsc/source/res/rsctop.cxx
+++ b/rsc/source/res/rsctop.cxx
@@ -145,12 +145,12 @@ ERRTYPE RscTop :: GetRef( const RSCINST & rInst, RscId * pRscId ){
 |*    RscTop::InHierarchy()
 |*
 *************************************************************************/
-BOOL RscTop::InHierarchy( RscTop * pClass ){
+sal_Bool RscTop::InHierarchy( RscTop * pClass ){
     if( this == pClass )
-        return( TRUE );
+        return( sal_True );
     if( pSuperClass )
         return( pSuperClass->InHierarchy( pClass ) );
-    return( FALSE );
+    return( sal_False );
 }
 
 /*************************************************************************
@@ -191,7 +191,7 @@ RSCINST RscTop::GetVariable
     const RSCINST & rInst,
     Atom nVarName,
     const RSCINST & rInitInst,
-    BOOL bInitDflt,
+    sal_Bool bInitDflt,
     RscTop * pCreateClass
 )
 {
@@ -275,7 +275,7 @@ ERRTYPE RscTop::GetArrayEle
 ERRTYPE RscTop::GetValueEle
 (
     const RSCINST & rInst,
-    INT32 lValue,
+    sal_Int32 lValue,
     RscTop * pCreateClass,
     RSCINST * pGetInst
 )
@@ -374,7 +374,7 @@ sal_uInt32  RscTop::GetCount( const RSCINST & rInst ){
 |*    RscTop::SetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscTop::SetNumber( const RSCINST & rInst, INT32 lValue ){
+ERRTYPE RscTop::SetNumber( const RSCINST & rInst, sal_Int32 lValue ){
     if( pSuperClass )
         return pSuperClass->
                     SetNumber( rInst, lValue );
@@ -387,7 +387,7 @@ ERRTYPE RscTop::SetNumber( const RSCINST & rInst, INT32 lValue ){
 |*    RscTop::SetBool()
 |*
 *************************************************************************/
-ERRTYPE RscTop::SetBool( const RSCINST & rInst, BOOL bValue ){
+ERRTYPE RscTop::SetBool( const RSCINST & rInst, sal_Bool bValue ){
     if( pSuperClass )
         return pSuperClass->
                     SetBool( rInst, bValue );
@@ -400,7 +400,7 @@ ERRTYPE RscTop::SetBool( const RSCINST & rInst, BOOL bValue ){
 |*    RscTop::SetConst()
 |*
 *************************************************************************/
-ERRTYPE RscTop::SetConst( const RSCINST & rInst, Atom nId, INT32 nVal )
+ERRTYPE RscTop::SetConst( const RSCINST & rInst, Atom nId, sal_Int32 nVal )
 {
     if( pSuperClass )
         return pSuperClass->SetConst( rInst, nId, nVal );
@@ -439,7 +439,7 @@ ERRTYPE RscTop::SetString( const RSCINST & rInst, const char * pStr ){
 |*    RscTop::GetNumber()
 |*
 *************************************************************************/
-ERRTYPE RscTop::GetNumber( const RSCINST & rInst, INT32 * pN ){
+ERRTYPE RscTop::GetNumber( const RSCINST & rInst, sal_Int32 * pN ){
     if( pSuperClass )
         return pSuperClass->
                     GetNumber( rInst, pN );
@@ -452,7 +452,7 @@ ERRTYPE RscTop::GetNumber( const RSCINST & rInst, INT32 * pN ){
 |*    RscTop::GetBool()
 |*
 *************************************************************************/
-ERRTYPE RscTop::GetBool( const RSCINST & rInst, BOOL * pB ){
+ERRTYPE RscTop::GetBool( const RSCINST & rInst, sal_Bool * pB ){
  if( pSuperClass )
         return pSuperClass->
                     GetBool( rInst, pB );
@@ -491,7 +491,7 @@ ERRTYPE RscTop::GetString( const RSCINST & rInst, char ** ppStr ){
 |*    RscTop::Create()
 |*
 *************************************************************************/
-RSCINST RscTop::Create( RSCINST * pInst, const RSCINST & rDefInst, BOOL bOwnRange )
+RSCINST RscTop::Create( RSCINST * pInst, const RSCINST & rDefInst, sal_Bool bOwnRange )
 {
     if( pSuperClass )
         return pSuperClass->
@@ -518,12 +518,12 @@ void    RscTop::Destroy( const RSCINST & rInst ){
 |*    RscTop::IsConsistent()
 |*
 *************************************************************************/
-BOOL    RscTop::IsConsistent( const RSCINST & rInst )
+sal_Bool RscTop::IsConsistent( const RSCINST & rInst )
 {
     if( pSuperClass )
         return pSuperClass->IsConsistent( rInst );
     else
-        return TRUE;
+        return sal_True;
 }
 
 /*************************************************************************
@@ -542,11 +542,11 @@ void    RscTop::SetToDefault( const RSCINST & rInst )
 |*    RscTop::IsDefault()
 |*
 *************************************************************************/
-BOOL    RscTop::IsDefault( const RSCINST & rInst ){
+sal_Bool    RscTop::IsDefault( const RSCINST & rInst ){
     if( pSuperClass )
         return pSuperClass->IsDefault( rInst );
     else
-        return TRUE;
+        return sal_True;
 }
 
 /*************************************************************************
@@ -554,11 +554,11 @@ BOOL    RscTop::IsDefault( const RSCINST & rInst ){
 |*    RscTop::IsValueDefault()
 |*
 *************************************************************************/
-BOOL    RscTop::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
+sal_Bool    RscTop::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
     if( pSuperClass )
         return pSuperClass->IsValueDefault( rInst, pDef );
     else
-        return TRUE;
+        return sal_True;
 }
 
 /*************************************************************************
@@ -707,7 +707,7 @@ void RscTop::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 *************************************************************************/
 ERRTYPE RscTop::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
                                RscTypCont * pTC, const RscId & rId,
-                               sal_uInt32 nDeep, BOOL bExtra )
+                               sal_uInt32 nDeep, sal_Bool bExtra )
 {
     if( pSuperClass )
         return( pSuperClass->
@@ -722,7 +722,7 @@ ERRTYPE RscTop::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
 |*
 *************************************************************************/
 ERRTYPE RscTop::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
-                         RscTypCont * pTC, sal_uInt32 nDeep, BOOL bExtra )
+                         RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
 {
     if( pSuperClass )
         return( pSuperClass->