rebase to DEV300_m100

1 files changed, 265 insertions, 265 deletions

diff --git a/editeng/source/items/textitem.cxx b/editeng/source/items/textitem.cxx
index d0ecd225755d..f1dc1f6c6f85 100644
--- a/editeng/source/items/textitem.cxx
+++ b/editeng/source/items/textitem.cxx
@@ -124,7 +124,7 @@ using namespace ::com::sun::star::text;
 #define TWIP_TO_MM100_UNSIGNED(TWIP)     ((((TWIP)*127L+36L)/72L))
 #define MM100_TO_TWIP_UNSIGNED(MM100)    ((((MM100)*72L+63L)/127L))
 
-BOOL SvxFontItem::bEnableStoreUnicodeNames = FALSE;
+sal_Bool SvxFontItem::bEnableStoreUnicodeNames = sal_False;
 
 // STATIC DATA -----------------------------------------------------------
 
@@ -169,7 +169,7 @@ TYPEINIT1(SvxScriptSetItem, SfxSetItem );
 // class SvxFontListItem -------------------------------------------------
 
 SvxFontListItem::SvxFontListItem( const FontList* pFontLst,
-                                  const USHORT nId ) :
+                                  const sal_uInt16 nId ) :
     SfxPoolItem( nId ),
     pFontList( pFontLst )
 {
@@ -178,7 +178,7 @@ SvxFontListItem::SvxFontListItem( const FontList* pFontLst,
         sal_Int32 nCount = pFontList->GetFontNameCount();
         aFontNameSeq.realloc( nCount );
 
-        for ( USHORT i = 0; i < nCount; i++ )
+        for ( sal_uInt16 i = 0; i < nCount; i++ )
             aFontNameSeq[i] = pFontList->GetFontName(i).GetName();
     }
 }
@@ -209,7 +209,7 @@ int SvxFontListItem::operator==( const SfxPoolItem& rAttr ) const
     return( pFontList == ((SvxFontListItem&)rAttr).pFontList );
 }
 
-sal_Bool SvxFontListItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
+sal_Bool SvxFontListItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 {
     rVal <<= aFontNameSeq;
     return sal_True;
@@ -231,7 +231,7 @@ SfxItemPresentation SvxFontListItem::GetPresentation
 
 // class SvxFontItem -----------------------------------------------------
 
-SvxFontItem::SvxFontItem( const USHORT nId ) :
+SvxFontItem::SvxFontItem( const sal_uInt16 nId ) :
     SfxPoolItem( nId )
 {
     eFamily = FAMILY_SWISS;
@@ -243,7 +243,7 @@ SvxFontItem::SvxFontItem( const USHORT nId ) :
 
 SvxFontItem::SvxFontItem( const FontFamily eFam, const XubString& aName,
                   const XubString& aStName, const FontPitch eFontPitch,
-                  const rtl_TextEncoding eFontTextEncoding, const USHORT nId ) :
+                  const rtl_TextEncoding eFontTextEncoding, const sal_uInt16 nId ) :
 
     SfxPoolItem( nId ),
 
@@ -257,7 +257,7 @@ SvxFontItem::SvxFontItem( const FontFamily eFam, const XubString& aName,
 
 // -----------------------------------------------------------------------
 
-sal_Bool SvxFontItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxFontItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -287,7 +287,7 @@ sal_Bool SvxFontItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
     return sal_True;
 }
 // -----------------------------------------------------------------------
-sal_Bool SvxFontItem::PutValue( const uno::Any& rVal, BYTE nMemberId)
+sal_Bool SvxFontItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -382,17 +382,17 @@ SfxPoolItem* SvxFontItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxFontItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxFontItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    BOOL bToBats =
+    sal_Bool bToBats =
         GetFamilyName().EqualsAscii( "StarSymbol", 0, sizeof("StarSymbol")-1 ) ||
         GetFamilyName().EqualsAscii( "OpenSymbol", 0, sizeof("OpenSymbol")-1 );
 
-    // #90477# rStrm << (BYTE) GetFamily()
-    //    << (BYTE) GetPitch()
-    //    << (BYTE)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetStoreCharSet( GetCharSet(), (USHORT)rStrm.GetVersion() ) );
-    rStrm << (BYTE) GetFamily() << (BYTE) GetPitch()
-          << (BYTE)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion()));
+    // #90477# rStrm << (sal_uInt8) GetFamily()
+    //    << (sal_uInt8) GetPitch()
+    //    << (sal_uInt8)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetStoreCharSet( GetCharSet(), (sal_uInt16)rStrm.GetVersion() ) );
+    rStrm << (sal_uInt8) GetFamily() << (sal_uInt8) GetPitch()
+          << (sal_uInt8)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion()));
 
     String aStoreFamilyName( GetFamilyName() );
     if( bToBats )
@@ -414,9 +414,9 @@ SvStream& SvxFontItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE _eFamily, eFontPitch, eFontTextEncoding;
+    sal_uInt8 _eFamily, eFontPitch, eFontTextEncoding;
     String aName, aStyle;
     rStrm >> _eFamily;
     rStrm >> eFontPitch;
@@ -429,7 +429,7 @@ SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, USHORT) const
     rStrm.ReadByteString(aStyle);
 
     // Task 91008/90471: set the "correct" textencoding
-    eFontTextEncoding = (BYTE)GetSOLoadTextEncoding( eFontTextEncoding, (USHORT)rStrm.GetVersion() );
+    eFontTextEncoding = (sal_uInt8)GetSOLoadTextEncoding( eFontTextEncoding, (sal_uInt16)rStrm.GetVersion() );
 
     // irgendwann wandelte sich der StarBats vom ANSI- zum SYMBOL-Font
     if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName.EqualsAscii("StarBats") )
@@ -481,15 +481,15 @@ SfxItemPresentation SvxFontItem::GetPresentation
 
 //------------------------------------------------------------------------
 
-void SvxFontItem::EnableStoreUnicodeNames( BOOL bEnable )
+void SvxFontItem::EnableStoreUnicodeNames( sal_Bool bEnable )
 {
     bEnableStoreUnicodeNames = bEnable;
 }
 
 // class SvxPostureItem --------------------------------------------------
 
-SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const USHORT nId ) :
-    SfxEnumItem( nId, (USHORT)ePosture )
+SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const sal_uInt16 nId ) :
+    SfxEnumItem( nId, (sal_uInt16)ePosture )
 {
 }
 
@@ -502,24 +502,24 @@ SfxPoolItem* SvxPostureItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-USHORT SvxPostureItem::GetValueCount() const
+sal_uInt16 SvxPostureItem::GetValueCount() const
 {
     return ITALIC_NORMAL + 1;   // auch ITALIC_NONE geh"ort dazu
 }
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxPostureItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxPostureItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE)GetValue();
+    rStrm << (sal_uInt8)GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxPostureItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxPostureItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nPosture;
+    sal_uInt8 nPosture;
     rStrm >> nPosture;
     return new SvxPostureItem( (const FontItalic)nPosture, Which() );
 }
@@ -550,13 +550,13 @@ SfxItemPresentation SvxPostureItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-XubString SvxPostureItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxPostureItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos <= (USHORT)ITALIC_NORMAL, "enum overflow!" );
+    DBG_ASSERT( nPos <= (sal_uInt16)ITALIC_NORMAL, "enum overflow!" );
 
     XubString sTxt;
     FontItalic eItalic = (FontItalic)nPos;
-    USHORT nId = 0;
+    sal_uInt16 nId = 0;
 
     switch ( eItalic )
     {
@@ -575,7 +575,7 @@ XubString SvxPostureItem::GetValueTextByPos( USHORT nPos ) const
 /*-----------------13.03.98 14:28-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxPostureItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxPostureItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -593,7 +593,7 @@ sal_Bool SvxPostureItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------13.03.98 14:28-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxPostureItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxPostureItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -613,7 +613,7 @@ sal_Bool SvxPostureItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
 
                 eSlant = (awt::FontSlant)nValue;
             }
-            SetValue((USHORT)eSlant);
+            SetValue((sal_uInt16)eSlant);
         }
     }
     return sal_True;
@@ -636,13 +636,13 @@ sal_Bool SvxPostureItem::GetBoolValue() const
 
 void SvxPostureItem::SetBoolValue( sal_Bool bVal )
 {
-    SetValue( (USHORT)(bVal ? ITALIC_NORMAL : ITALIC_NONE) );
+    SetValue( (sal_uInt16)(bVal ? ITALIC_NORMAL : ITALIC_NONE) );
 }
 
 // class SvxWeightItem ---------------------------------------------------
 
-SvxWeightItem::SvxWeightItem( const FontWeight eWght, const USHORT nId ) :
-    SfxEnumItem( nId, (USHORT)eWght )
+SvxWeightItem::SvxWeightItem( const FontWeight eWght, const sal_uInt16 nId ) :
+    SfxEnumItem( nId, (sal_uInt16)eWght )
 {
 }
 
@@ -666,12 +666,12 @@ sal_Bool SvxWeightItem::GetBoolValue() const
 
 void SvxWeightItem::SetBoolValue( sal_Bool bVal )
 {
-    SetValue( (USHORT)(bVal ? WEIGHT_BOLD : WEIGHT_NORMAL) );
+    SetValue( (sal_uInt16)(bVal ? WEIGHT_BOLD : WEIGHT_NORMAL) );
 }
 
 // -----------------------------------------------------------------------
 
-USHORT SvxWeightItem::GetValueCount() const
+sal_uInt16 SvxWeightItem::GetValueCount() const
 {
     return WEIGHT_BLACK;    // WEIGHT_DONTKNOW geh"ort nicht dazu
 }
@@ -685,17 +685,17 @@ SfxPoolItem* SvxWeightItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxWeightItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxWeightItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE)GetValue();
+    rStrm << (sal_uInt8)GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxWeightItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxWeightItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nWeight;
+    sal_uInt8 nWeight;
     rStrm >> nWeight;
     return new SvxWeightItem( (FontWeight)nWeight, Which() );
 }
@@ -726,16 +726,16 @@ SfxItemPresentation SvxWeightItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-XubString SvxWeightItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxWeightItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos <= (USHORT)WEIGHT_BLACK, "enum overflow!" );
+    DBG_ASSERT( nPos <= (sal_uInt16)WEIGHT_BLACK, "enum overflow!" );
     return EE_RESSTR( RID_SVXITEMS_WEIGHT_BEGIN + nPos );
 }
 
 /*-----------------13.03.98 14:18-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxWeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxWeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -755,7 +755,7 @@ sal_Bool SvxWeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------13.03.98 14:18-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxWeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxWeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -774,7 +774,7 @@ sal_Bool SvxWeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
                     return sal_False;
                 fValue = (float)nValue;
             }
-            SetValue( (USHORT)VCLUnoHelper::ConvertFontWeight((float)fValue) );
+            SetValue( (sal_uInt16)VCLUnoHelper::ConvertFontWeight((float)fValue) );
         }
         break;
     }
@@ -783,9 +783,9 @@ sal_Bool SvxWeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
 
 // class SvxFontHeightItem -----------------------------------------------
 
-SvxFontHeightItem::SvxFontHeightItem( const ULONG nSz,
-                                      const USHORT nPrp,
-                                      const USHORT nId ) :
+SvxFontHeightItem::SvxFontHeightItem( const sal_uLong nSz,
+                                      const sal_uInt16 nPrp,
+                                      const sal_uInt16 nId ) :
     SfxPoolItem( nId )
 {
     SetHeight( nSz,nPrp );  // mit den Prozenten rechnen
@@ -800,17 +800,17 @@ SfxPoolItem* SvxFontHeightItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxFontHeightItem::Store( SvStream& rStrm , USHORT nItemVersion ) const
+SvStream& SvxFontHeightItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
 {
-    rStrm << (USHORT)GetHeight();
+    rStrm << (sal_uInt16)GetHeight();
 
     if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
-        rStrm << GetProp() << (USHORT)GetPropUnit();
+        rStrm << GetProp() << (sal_uInt16)GetPropUnit();
     else
     {
         // JP 30.06.98: beim Export in alte Versionen geht die relative
         // Angabe verloren, wenn es keine Prozentuale ist
-        USHORT _nProp = GetProp();
+        sal_uInt16 _nProp = GetProp();
         if( SFX_MAPUNIT_RELATIVE != GetPropUnit() )
             _nProp = 100;
         rStrm << _nProp;
@@ -821,9 +821,9 @@ SvStream& SvxFontHeightItem::Store( SvStream& rStrm , USHORT nItemVersion ) cons
 // -----------------------------------------------------------------------
 
 SfxPoolItem* SvxFontHeightItem::Create( SvStream& rStrm,
-                                                 USHORT nVersion ) const
+                                                 sal_uInt16 nVersion ) const
 {
-    USHORT nsize, nprop = 0, nPropUnit = SFX_MAPUNIT_RELATIVE;
+    sal_uInt16 nsize, nprop = 0, nPropUnit = SFX_MAPUNIT_RELATIVE;
 
     rStrm >> nsize;
 
@@ -831,9 +831,9 @@ SfxPoolItem* SvxFontHeightItem::Create( SvStream& rStrm,
         rStrm >> nprop;
     else
     {
-        BYTE nP;
+        sal_uInt8 nP;
         rStrm  >> nP;
-        nprop = (USHORT)nP;
+        nprop = (sal_uInt16)nP;
     }
 
     if( FONTHEIGHT_UNIT_VERSION <= nVersion )
@@ -857,7 +857,7 @@ int SvxFontHeightItem::operator==( const SfxPoolItem& rItem ) const
 /*-----------------13.03.98 14:53-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxFontHeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxFontHeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
     //  In StarOne sind im uno::Any immer 1/100mm. Ueber die MemberId wird
     //  gesteuert, ob der Wert im Item 1/100mm oder Twips sind.
@@ -995,7 +995,7 @@ sal_uInt32 lcl_GetRealHeight_Impl(sal_uInt32 nHeight, sal_uInt16 nProp, SfxMapUn
 /*-----------------13.03.98 14:53-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxFontHeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxFontHeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
     sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1122,7 +1122,7 @@ SfxItemPresentation SvxFontHeightItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-USHORT SvxFontHeightItem::GetVersion(USHORT nFileVersion) const
+sal_uInt16 SvxFontHeightItem::GetVersion(sal_uInt16 nFileVersion) const
 {
     return (nFileVersion <= SOFFICE_FILEFORMAT_40)
                ? FONTHEIGHT_16_VERSION
@@ -1144,7 +1144,7 @@ int SvxFontHeightItem::HasMetrics() const
     return 1;
 }
 
-void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const USHORT nNewProp,
+void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const sal_uInt16 nNewProp,
                                     SfxMapUnit eUnit )
 {
     DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
@@ -1164,7 +1164,7 @@ void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const USHORT nNewProp,
     ePropUnit = eUnit;
 }
 
-void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, USHORT nNewProp,
+void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, sal_uInt16 nNewProp,
                                  SfxMapUnit eMetric, SfxMapUnit eCoreMetric )
 {
     DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
@@ -1188,7 +1188,7 @@ void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, USHORT nNewProp,
 
 // class SvxFontWidthItem -----------------------------------------------
 
-SvxFontWidthItem::SvxFontWidthItem( const USHORT nSz, const USHORT nPrp, const USHORT nId ) :
+SvxFontWidthItem::SvxFontWidthItem( const sal_uInt16 nSz, const sal_uInt16 nPrp, const sal_uInt16 nId ) :
     SfxPoolItem( nId )
 {
     nWidth = nSz;
@@ -1204,7 +1204,7 @@ SfxPoolItem* SvxFontWidthItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxFontWidthItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxFontWidthItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << GetWidth() << GetProp();
     return rStrm;
@@ -1214,7 +1214,7 @@ SvStream& SvxFontWidthItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) c
 
 int SvxFontWidthItem::ScaleMetrics( long nMult, long nDiv )
 {
-    nWidth = (USHORT)Scale( nWidth, nMult, nDiv );
+    nWidth = (sal_uInt16)Scale( nWidth, nMult, nDiv );
     return 1;
 }
 
@@ -1228,10 +1228,10 @@ int SvxFontWidthItem::HasMetrics() const
 // -----------------------------------------------------------------------
 
 SfxPoolItem* SvxFontWidthItem::Create( SvStream& rStrm,
-                                                 USHORT /*nVersion*/ ) const
+                                                 sal_uInt16 /*nVersion*/ ) const
 {
-    USHORT nS;
-    USHORT nP;
+    sal_uInt16 nS;
+    sal_uInt16 nP;
 
     rStrm >> nS;
     rStrm >> nP;
@@ -1252,7 +1252,7 @@ int SvxFontWidthItem::operator==( const SfxPoolItem& rItem ) const
 /*-----------------13.03.98 16:03-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxFontWidthItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxFontWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1270,7 +1270,7 @@ sal_Bool SvxFontWidthItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------13.03.98 16:03-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxFontWidthItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxFontWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1327,8 +1327,8 @@ SfxItemPresentation SvxFontWidthItem::GetPresentation
 
 // class SvxTextLineItem ------------------------------------------------
 
-SvxTextLineItem::SvxTextLineItem( const FontUnderline eSt, const USHORT nId )
-    : SfxEnumItem( nId, (USHORT)eSt ), mColor( COL_TRANSPARENT )
+SvxTextLineItem::SvxTextLineItem( const FontUnderline eSt, const sal_uInt16 nId )
+    : SfxEnumItem( nId, (sal_uInt16)eSt ), mColor( COL_TRANSPARENT )
 {
 }
 
@@ -1350,7 +1350,7 @@ sal_Bool SvxTextLineItem::GetBoolValue() const
 
 void SvxTextLineItem::SetBoolValue( sal_Bool bVal )
 {
-    SetValue( (USHORT)(bVal ? UNDERLINE_SINGLE : UNDERLINE_NONE) );
+    SetValue( (sal_uInt16)(bVal ? UNDERLINE_SINGLE : UNDERLINE_NONE) );
 }
 
 // -----------------------------------------------------------------------
@@ -1364,24 +1364,24 @@ SfxPoolItem* SvxTextLineItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-USHORT SvxTextLineItem::GetValueCount() const
+sal_uInt16 SvxTextLineItem::GetValueCount() const
 {
     return UNDERLINE_DOTTED + 1;    // auch UNDERLINE_NONE geh"ort dazu
 }
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxTextLineItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxTextLineItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE)GetValue();
+    rStrm << (sal_uInt8)GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxTextLineItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxTextLineItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nState;
+    sal_uInt8 nState;
     rStrm >> nState;
     return new SvxTextLineItem(  (FontUnderline)nState, Which() );
 }
@@ -1416,7 +1416,7 @@ SfxItemPresentation SvxTextLineItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-XubString SvxTextLineItem::GetValueTextByPos( USHORT /*nPos*/ ) const
+XubString SvxTextLineItem::GetValueTextByPos( sal_uInt16 /*nPos*/ ) const
 {
     DBG_ERROR("SvxTextLineItem::GetValueTextByPos: Pure virtual method");
     return XubString();
@@ -1425,7 +1425,7 @@ XubString SvxTextLineItem::GetValueTextByPos( USHORT /*nPos*/ ) const
 /*-----------------13.03.98 16:25-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxTextLineItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxTextLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1450,7 +1450,7 @@ sal_Bool SvxTextLineItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------13.03.98 16:28-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxTextLineItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxTextLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1500,7 +1500,7 @@ int SvxTextLineItem::operator==( const SfxPoolItem& rItem ) const
 
 // class SvxUnderlineItem ------------------------------------------------
 
-SvxUnderlineItem::SvxUnderlineItem( const FontUnderline eSt, const USHORT nId )
+SvxUnderlineItem::SvxUnderlineItem( const FontUnderline eSt, const sal_uInt16 nId )
     : SvxTextLineItem( eSt, nId )
 {
 }
@@ -1516,24 +1516,24 @@ SfxPoolItem* SvxUnderlineItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxUnderlineItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxUnderlineItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nState;
+    sal_uInt8 nState;
     rStrm >> nState;
     return new SvxUnderlineItem(  (FontUnderline)nState, Which() );
 }
 
 // -----------------------------------------------------------------------
 
-XubString SvxUnderlineItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxUnderlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos <= (USHORT)UNDERLINE_BOLDWAVE, "enum overflow!" );
+    DBG_ASSERT( nPos <= (sal_uInt16)UNDERLINE_BOLDWAVE, "enum overflow!" );
     return EE_RESSTR( RID_SVXITEMS_UL_BEGIN + nPos );
 }
 
 // class SvxOverlineItem ------------------------------------------------
 
-SvxOverlineItem::SvxOverlineItem( const FontUnderline eSt, const USHORT nId )
+SvxOverlineItem::SvxOverlineItem( const FontUnderline eSt, const sal_uInt16 nId )
     : SvxTextLineItem( eSt, nId )
 {
 }
@@ -1549,25 +1549,25 @@ SfxPoolItem* SvxOverlineItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxOverlineItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxOverlineItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nState;
+    sal_uInt8 nState;
     rStrm >> nState;
     return new SvxOverlineItem(  (FontUnderline)nState, Which() );
 }
 
 // -----------------------------------------------------------------------
 
-XubString SvxOverlineItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxOverlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos <= (USHORT)UNDERLINE_BOLDWAVE, "enum overflow!" );
+    DBG_ASSERT( nPos <= (sal_uInt16)UNDERLINE_BOLDWAVE, "enum overflow!" );
     return EE_RESSTR( RID_SVXITEMS_OL_BEGIN + nPos );
 }
 
 // class SvxCrossedOutItem -----------------------------------------------
 
-SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const USHORT nId )
-    : SfxEnumItem( nId, (USHORT)eSt )
+SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const sal_uInt16 nId )
+    : SfxEnumItem( nId, (sal_uInt16)eSt )
 {
 }
 
@@ -1589,12 +1589,12 @@ sal_Bool SvxCrossedOutItem::GetBoolValue() const
 
 void SvxCrossedOutItem::SetBoolValue( sal_Bool bVal )
 {
-    SetValue( (USHORT)(bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE) );
+    SetValue( (sal_uInt16)(bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE) );
 }
 
 // -----------------------------------------------------------------------
 
-USHORT SvxCrossedOutItem::GetValueCount() const
+sal_uInt16 SvxCrossedOutItem::GetValueCount() const
 {
     return STRIKEOUT_DOUBLE + 1;    // auch STRIKEOUT_NONE geh"ort dazu
 }
@@ -1608,17 +1608,17 @@ SfxPoolItem* SvxCrossedOutItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxCrossedOutItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxCrossedOutItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE)GetValue();
+    rStrm << (sal_uInt8)GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxCrossedOutItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxCrossedOutItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE eCross;
+    sal_uInt8 eCross;
     rStrm >> eCross;
     return new SvxCrossedOutItem(  (FontStrikeout)eCross, Which() );
 }
@@ -1649,16 +1649,16 @@ SfxItemPresentation SvxCrossedOutItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-XubString SvxCrossedOutItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxCrossedOutItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos <= (USHORT)STRIKEOUT_X, "enum overflow!" );
+    DBG_ASSERT( nPos <= (sal_uInt16)STRIKEOUT_X, "enum overflow!" );
     return EE_RESSTR( RID_SVXITEMS_STRIKEOUT_BEGIN + nPos );
 }
 
 /*-----------------13.03.98 16:28-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1676,7 +1676,7 @@ sal_Bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------13.03.98 16:29-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -1698,7 +1698,7 @@ sal_Bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
 }
 // class SvxShadowedItem -------------------------------------------------
 
-SvxShadowedItem::SvxShadowedItem( const sal_Bool bShadowed, const USHORT nId ) :
+SvxShadowedItem::SvxShadowedItem( const sal_Bool bShadowed, const sal_uInt16 nId ) :
     SfxBoolItem( nId, bShadowed )
 {
 }
@@ -1712,17 +1712,17 @@ SfxPoolItem* SvxShadowedItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxShadowedItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxShadowedItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE) GetValue();
+    rStrm << (sal_uInt8) GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxShadowedItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxShadowedItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nState;
+    sal_uInt8 nState;
     rStrm >> nState;
     return new SvxShadowedItem( nState, Which() );
 }
@@ -1745,7 +1745,7 @@ SfxItemPresentation SvxShadowedItem::GetPresentation
         case SFX_ITEM_PRESENTATION_NAMELESS:
         case SFX_ITEM_PRESENTATION_COMPLETE:
         {
-            USHORT nId = RID_SVXITEMS_SHADOWED_FALSE;
+            sal_uInt16 nId = RID_SVXITEMS_SHADOWED_FALSE;
 
             if ( GetValue() )
                 nId = RID_SVXITEMS_SHADOWED_TRUE;
@@ -1759,7 +1759,7 @@ SfxItemPresentation SvxShadowedItem::GetPresentation
 
 // class SvxAutoKernItem -------------------------------------------------
 
-SvxAutoKernItem::SvxAutoKernItem( const sal_Bool bAutoKern, const USHORT nId ) :
+SvxAutoKernItem::SvxAutoKernItem( const sal_Bool bAutoKern, const sal_uInt16 nId ) :
     SfxBoolItem( nId, bAutoKern )
 {
 }
@@ -1773,17 +1773,17 @@ SfxPoolItem* SvxAutoKernItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxAutoKernItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxAutoKernItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE) GetValue();
+    rStrm << (sal_uInt8) GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxAutoKernItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxAutoKernItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nState;
+    sal_uInt8 nState;
     rStrm >> nState;
     return new SvxAutoKernItem( nState, Which() );
 }
@@ -1806,7 +1806,7 @@ SfxItemPresentation SvxAutoKernItem::GetPresentation
         case SFX_ITEM_PRESENTATION_NAMELESS:
         case SFX_ITEM_PRESENTATION_COMPLETE:
         {
-            USHORT nId = RID_SVXITEMS_AUTOKERN_FALSE;
+            sal_uInt16 nId = RID_SVXITEMS_AUTOKERN_FALSE;
 
             if ( GetValue() )
                 nId = RID_SVXITEMS_AUTOKERN_TRUE;
@@ -1821,7 +1821,7 @@ SfxItemPresentation SvxAutoKernItem::GetPresentation
 // class SvxWordLineModeItem ---------------------------------------------
 
 SvxWordLineModeItem::SvxWordLineModeItem( const sal_Bool bWordLineMode,
-                                          const USHORT nId ) :
+                                          const sal_uInt16 nId ) :
     SfxBoolItem( nId, bWordLineMode )
 {
 }
@@ -1835,7 +1835,7 @@ SfxPoolItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << (sal_Bool) GetValue();
     return rStrm;
@@ -1843,7 +1843,7 @@ SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxWordLineModeItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxWordLineModeItem::Create(SvStream& rStrm, sal_uInt16) const
 {
     sal_Bool bValue;
     rStrm >> bValue;
@@ -1868,7 +1868,7 @@ SfxItemPresentation SvxWordLineModeItem::GetPresentation
         case SFX_ITEM_PRESENTATION_NAMELESS:
         case SFX_ITEM_PRESENTATION_COMPLETE:
         {
-            USHORT nId = RID_SVXITEMS_WORDLINE_FALSE;
+            sal_uInt16 nId = RID_SVXITEMS_WORDLINE_FALSE;
 
             if ( GetValue() )
                 nId = RID_SVXITEMS_WORDLINE_TRUE;
@@ -1882,7 +1882,7 @@ SfxItemPresentation SvxWordLineModeItem::GetPresentation
 
 // class SvxContourItem --------------------------------------------------
 
-SvxContourItem::SvxContourItem( const sal_Bool bContoured, const USHORT nId ) :
+SvxContourItem::SvxContourItem( const sal_Bool bContoured, const sal_uInt16 nId ) :
     SfxBoolItem( nId, bContoured )
 {
 }
@@ -1896,7 +1896,7 @@ SfxPoolItem* SvxContourItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxContourItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxContourItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << (sal_Bool) GetValue();
     return rStrm;
@@ -1904,7 +1904,7 @@ SvStream& SvxContourItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) con
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxContourItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxContourItem::Create(SvStream& rStrm, sal_uInt16) const
 {
     sal_Bool bValue;
     rStrm >> bValue;
@@ -1929,7 +1929,7 @@ SfxItemPresentation SvxContourItem::GetPresentation
         case SFX_ITEM_PRESENTATION_NAMELESS:
         case SFX_ITEM_PRESENTATION_COMPLETE:
         {
-            USHORT nId = RID_SVXITEMS_CONTOUR_FALSE;
+            sal_uInt16 nId = RID_SVXITEMS_CONTOUR_FALSE;
 
             if ( GetValue() )
                 nId = RID_SVXITEMS_CONTOUR_TRUE;
@@ -1943,7 +1943,7 @@ SfxItemPresentation SvxContourItem::GetPresentation
 
 // class SvxPropSizeItem -------------------------------------------------
 
-SvxPropSizeItem::SvxPropSizeItem( const USHORT nPercent, const USHORT nId ) :
+SvxPropSizeItem::SvxPropSizeItem( const sal_uInt16 nPercent, const sal_uInt16 nId ) :
     SfxUInt16Item( nId, nPercent )
 {
 }
@@ -1957,17 +1957,17 @@ SfxPoolItem* SvxPropSizeItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxPropSizeItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxPropSizeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (USHORT) GetValue();
+    rStrm << (sal_uInt16) GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxPropSizeItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxPropSizeItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    USHORT nSize;
+    sal_uInt16 nSize;
     rStrm >> nSize;
     return new SvxPropSizeItem( nSize, Which() );
 }
@@ -1988,7 +1988,7 @@ SfxItemPresentation SvxPropSizeItem::GetPresentation
 
 // class SvxColorItem ----------------------------------------------------
 
-SvxColorItem::SvxColorItem( const USHORT nId ) :
+SvxColorItem::SvxColorItem( const sal_uInt16 nId ) :
     SfxPoolItem( nId ),
     mColor( COL_BLACK )
 {
@@ -1996,7 +1996,7 @@ SvxColorItem::SvxColorItem( const USHORT nId ) :
 
 // -----------------------------------------------------------------------
 
-SvxColorItem::SvxColorItem( const Color& rCol, const USHORT nId ) :
+SvxColorItem::SvxColorItem( const Color& rCol, const sal_uInt16 nId ) :
     SfxPoolItem( nId ),
     mColor( rCol )
 {
@@ -2004,7 +2004,7 @@ SvxColorItem::SvxColorItem( const Color& rCol, const USHORT nId ) :
 
 // -----------------------------------------------------------------------
 
-SvxColorItem::SvxColorItem( SvStream &rStrm, const USHORT nId ) :
+SvxColorItem::SvxColorItem( SvStream &rStrm, const sal_uInt16 nId ) :
     SfxPoolItem( nId )
 {
     Color aColor;
@@ -2027,7 +2027,7 @@ SvxColorItem::~SvxColorItem()
 }
 
 // -----------------------------------------------------------------------
-USHORT SvxColorItem::GetVersion( USHORT nFFVer ) const
+sal_uInt16 SvxColorItem::GetVersion( sal_uInt16 nFFVer ) const
 {
     DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
             SOFFICE_FILEFORMAT_40==nFFVer ||
@@ -2047,7 +2047,7 @@ int SvxColorItem::operator==( const SfxPoolItem& rAttr ) const
 
 // -----------------------------------------------------------------------
 
-sal_Bool SvxColorItem::QueryValue( uno::Any& rVal, BYTE /*nMemberId*/ ) const
+sal_Bool SvxColorItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 {
     rVal <<= (sal_Int32)(mColor.GetColor());
     return sal_True;
@@ -2055,7 +2055,7 @@ sal_Bool SvxColorItem::QueryValue( uno::Any& rVal, BYTE /*nMemberId*/ ) const
 
 // -----------------------------------------------------------------------
 
-sal_Bool SvxColorItem::PutValue( const uno::Any& rVal, BYTE /*nMemberId*/ )
+sal_Bool SvxColorItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 {
     sal_Int32 nColor = 0;
     if(!(rVal >>= nColor))
@@ -2074,7 +2074,7 @@ SfxPoolItem* SvxColorItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxColorItem::Store( SvStream& rStrm , USHORT nItemVersion ) const
+SvStream& SvxColorItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
 {
     if( VERSION_USEAUTOCOLOR == nItemVersion &&
         COL_AUTO == mColor.GetColor() )
@@ -2086,7 +2086,7 @@ SvStream& SvxColorItem::Store( SvStream& rStrm , USHORT nItemVersion ) const
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxColorItem::Create(SvStream& rStrm, USHORT /*nVer*/ ) const
+SfxPoolItem* SvxColorItem::Create(SvStream& rStrm, sal_uInt16 /*nVer*/ ) const
 {
     return new SvxColorItem( rStrm, Which() );
 }
@@ -2126,7 +2126,7 @@ void SvxColorItem::SetValue( const Color& rNewCol )
 
 // class SvxCharSetColorItem ---------------------------------------------
 
-SvxCharSetColorItem::SvxCharSetColorItem( const USHORT nId ) :
+SvxCharSetColorItem::SvxCharSetColorItem( const sal_uInt16 nId ) :
     SvxColorItem( nId ),
 
     eFrom( RTL_TEXTENCODING_DONTKNOW )
@@ -2137,7 +2137,7 @@ SvxCharSetColorItem::SvxCharSetColorItem( const USHORT nId ) :
 
 SvxCharSetColorItem::SvxCharSetColorItem( const Color& rCol,
                                           const rtl_TextEncoding _eFrom,
-                                          const USHORT nId ) :
+                                          const sal_uInt16 nId ) :
     SvxColorItem( rCol, nId ),
 
     eFrom( _eFrom )
@@ -2154,20 +2154,20 @@ SfxPoolItem* SvxCharSetColorItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxCharSetColorItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxCharSetColorItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    // #90477# rStrm << (BYTE) GetStoreCharSet( GetCharSet(), (USHORT)rStrm.GetVersion() )
+    // #90477# rStrm << (sal_uInt8) GetStoreCharSet( GetCharSet(), (sal_uInt16)rStrm.GetVersion() )
     //    << GetValue();
-    rStrm << (BYTE)GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion())
+    rStrm << (sal_uInt8)GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion())
           << GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxCharSetColorItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxCharSetColorItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE cSet;
+    sal_uInt8 cSet;
     Color aColor;
     rStrm >> cSet >> aColor;
     return new SvxCharSetColorItem( aColor,  (rtl_TextEncoding)cSet, Which() );
@@ -2189,7 +2189,7 @@ SfxItemPresentation SvxCharSetColorItem::GetPresentation
 
 // class SvxKerningItem --------------------------------------------------
 
-SvxKerningItem::SvxKerningItem( const short nKern, const USHORT nId ) :
+SvxKerningItem::SvxKerningItem( const short nKern, const sal_uInt16 nId ) :
     SfxInt16Item( nId, nKern )
 {
 }
@@ -2203,7 +2203,7 @@ SfxPoolItem* SvxKerningItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxKerningItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxKerningItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << (short) GetValue();
     return rStrm;
@@ -2226,7 +2226,7 @@ int SvxKerningItem::HasMetrics() const
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxKerningItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxKerningItem::Create(SvStream& rStrm, sal_uInt16) const
 {
     short nValue;
     rStrm >> nValue;
@@ -2256,7 +2256,7 @@ SfxItemPresentation SvxKerningItem::GetPresentation
         case SFX_ITEM_PRESENTATION_COMPLETE:
         {
             rText = EE_RESSTR(RID_SVXITEMS_KERNING_COMPLETE);
-            USHORT nId = 0;
+            sal_uInt16 nId = 0;
 
             if ( GetValue() > 0 )
                 nId = RID_SVXITEMS_KERNING_EXPANDED;
@@ -2277,7 +2277,7 @@ SfxItemPresentation SvxKerningItem::GetPresentation
 /* -----------------------------19.02.01 12:21--------------------------------
 
  ---------------------------------------------------------------------------*/
-sal_Bool SvxKerningItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxKerningItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
     sal_Int16 nVal = GetValue();
     if(nMemberId & CONVERT_TWIPS)
@@ -2286,7 +2286,7 @@ sal_Bool SvxKerningItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
     return sal_True;
 }
 // -----------------------------------------------------------------------
-sal_Bool SvxKerningItem::PutValue( const uno::Any& rVal, BYTE nMemberId)
+sal_Bool SvxKerningItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
 {
     sal_Int16 nVal = sal_Int16();
     if(!(rVal >>= nVal))
@@ -2299,14 +2299,14 @@ sal_Bool SvxKerningItem::PutValue( const uno::Any& rVal, BYTE nMemberId)
 
 // class SvxCaseMapItem --------------------------------------------------
 
-SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const USHORT nId ) :
-    SfxEnumItem( nId, (USHORT)eMap )
+SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const sal_uInt16 nId ) :
+    SfxEnumItem( nId, (sal_uInt16)eMap )
 {
 }
 
 // -----------------------------------------------------------------------
 
-USHORT SvxCaseMapItem::GetValueCount() const
+sal_uInt16 SvxCaseMapItem::GetValueCount() const
 {
     return SVX_CASEMAP_END; // SVX_CASEMAP_KAPITAELCHEN + 1
 }
@@ -2320,17 +2320,17 @@ SfxPoolItem* SvxCaseMapItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxCaseMapItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxCaseMapItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE) GetValue();
+    rStrm << (sal_uInt8) GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxCaseMapItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxCaseMapItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE cMap;
+    sal_uInt8 cMap;
     rStrm >> cMap;
     return new SvxCaseMapItem( (const SvxCaseMap)cMap, Which() );
 }
@@ -2361,16 +2361,16 @@ SfxItemPresentation SvxCaseMapItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-XubString SvxCaseMapItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxCaseMapItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos < (USHORT)SVX_CASEMAP_END, "enum overflow!" );
+    DBG_ASSERT( nPos < (sal_uInt16)SVX_CASEMAP_END, "enum overflow!" );
     return EE_RESSTR( RID_SVXITEMS_CASEMAP_BEGIN + nPos );
 }
 
 /*-----------------13.03.98 16:29-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxCaseMapItem::QueryValue( uno::Any& rVal, BYTE /*nMemberId*/ ) const
+sal_Bool SvxCaseMapItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 {
     sal_Int16 nRet = style::CaseMap::NONE;
     switch( GetValue() )
@@ -2387,7 +2387,7 @@ sal_Bool SvxCaseMapItem::QueryValue( uno::Any& rVal, BYTE /*nMemberId*/ ) const
 /*-----------------13.03.98 16:29-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxCaseMapItem::PutValue( const uno::Any& rVal, BYTE /*nMemberId*/ )
+sal_Bool SvxCaseMapItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 {
     sal_uInt16 nVal = sal_uInt16();
     if(!(rVal >>= nVal))
@@ -2407,7 +2407,7 @@ sal_Bool SvxCaseMapItem::PutValue( const uno::Any& rVal, BYTE /*nMemberId*/ )
 
 // class SvxEscapementItem -----------------------------------------------
 
-SvxEscapementItem::SvxEscapementItem( const USHORT nId ) :
+SvxEscapementItem::SvxEscapementItem( const sal_uInt16 nId ) :
     SfxEnumItemInterface( nId ),
 
     nEsc    ( 0 ),
@@ -2418,7 +2418,7 @@ SvxEscapementItem::SvxEscapementItem( const USHORT nId ) :
 // -----------------------------------------------------------------------
 
 SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape,
-                                      const USHORT nId ) :
+                                      const sal_uInt16 nId ) :
     SfxEnumItemInterface( nId ),
     nProp( 100 )
 {
@@ -2430,8 +2430,8 @@ SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape,
 // -----------------------------------------------------------------------
 
 SvxEscapementItem::SvxEscapementItem( const short _nEsc,
-                                      const BYTE _nProp,
-                                      const USHORT nId ) :
+                                      const sal_uInt8 _nProp,
+                                      const sal_uInt16 nId ) :
     SfxEnumItemInterface( nId ),
     nEsc    ( _nEsc ),
     nProp   ( _nProp )
@@ -2457,7 +2457,7 @@ SfxPoolItem* SvxEscapementItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxEscapementItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxEscapementItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     short _nEsc = GetEsc();
     if( SOFFICE_FILEFORMAT_31 == rStrm.GetVersion() )
@@ -2467,16 +2467,16 @@ SvStream& SvxEscapementItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ )
         else if( DFLT_ESC_AUTO_SUB == _nEsc )
             _nEsc = DFLT_ESC_SUB;
     }
-    rStrm << (BYTE) GetProp()
+    rStrm << (sal_uInt8) GetProp()
           << (short) _nEsc;
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE _nProp;
+    sal_uInt8 _nProp;
     short _nEsc;
     rStrm >> _nProp >> _nEsc;
     return new SvxEscapementItem( _nEsc, _nProp, Which() );
@@ -2484,7 +2484,7 @@ SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, USHORT) const
 
 // -----------------------------------------------------------------------
 
-USHORT SvxEscapementItem::GetValueCount() const
+sal_uInt16 SvxEscapementItem::GetValueCount() const
 {
     return SVX_ESCAPEMENT_END;  // SVX_ESCAPEMENT_SUBSCRIPT + 1
 }
@@ -2525,15 +2525,15 @@ SfxItemPresentation SvxEscapementItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-XubString SvxEscapementItem::GetValueTextByPos( USHORT nPos ) const
+XubString SvxEscapementItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
-    DBG_ASSERT( nPos < (USHORT)SVX_ESCAPEMENT_END, "enum overflow!" );
+    DBG_ASSERT( nPos < (sal_uInt16)SVX_ESCAPEMENT_END, "enum overflow!" );
     return EE_RESSTR(RID_SVXITEMS_ESCAPEMENT_BEGIN + nPos);
 }
 
 // -----------------------------------------------------------------------
 
-USHORT SvxEscapementItem::GetEnumValue() const
+sal_uInt16 SvxEscapementItem::GetEnumValue() const
 {
     if ( nEsc < 0 )
         return SVX_ESCAPEMENT_SUBSCRIPT;
@@ -2544,7 +2544,7 @@ USHORT SvxEscapementItem::GetEnumValue() const
 
 // -----------------------------------------------------------------------
 
-void SvxEscapementItem::SetEnumValue( USHORT nVal )
+void SvxEscapementItem::SetEnumValue( sal_uInt16 nVal )
 {
     SetEscapement( (const SvxEscapement)nVal );
 }
@@ -2552,7 +2552,7 @@ void SvxEscapementItem::SetEnumValue( USHORT nVal )
 /*-----------------13.03.98 17:05-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxEscapementItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxEscapementItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -2573,7 +2573,7 @@ sal_Bool SvxEscapementItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------13.03.98 17:05-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxEscapementItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxEscapementItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -2599,7 +2599,7 @@ sal_Bool SvxEscapementItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
         break;
         case MID_AUTO_ESC:
         {
-            BOOL bVal = Any2Bool(rVal);
+            sal_Bool bVal = Any2Bool(rVal);
             if(bVal)
             {
                 if(nEsc < 0)
@@ -2620,14 +2620,14 @@ sal_Bool SvxEscapementItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
 
 // class SvxLanguageItem -------------------------------------------------
 
-SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const USHORT nId )
+SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const sal_uInt16 nId )
     : SfxEnumItem( nId , eLang )
 {
 }
 
 // -----------------------------------------------------------------------
 
-USHORT SvxLanguageItem::GetValueCount() const
+sal_uInt16 SvxLanguageItem::GetValueCount() const
 {
     // #i50205# got rid of class International
     DBG_ERRORFILE("SvxLanguageItem::GetValueCount: supposed to return a count of what?");
@@ -2646,17 +2646,17 @@ SfxPoolItem* SvxLanguageItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxLanguageItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxLanguageItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (USHORT) GetValue();
+    rStrm << (sal_uInt16) GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxLanguageItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxLanguageItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    USHORT nValue;
+    sal_uInt16 nValue;
     rStrm >> nValue;
     return new SvxLanguageItem( (LanguageType)nValue, Which() );
 }
@@ -2693,7 +2693,7 @@ SfxItemPresentation SvxLanguageItem::GetPresentation
 /*-----------------14.03.98 14:13-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxLanguageItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxLanguageItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -2712,7 +2712,7 @@ sal_Bool SvxLanguageItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
 /*-----------------14.03.98 14:13-------------------
 
 --------------------------------------------------*/
-sal_Bool SvxLanguageItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxLanguageItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -2744,7 +2744,7 @@ sal_Bool SvxLanguageItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
 }
 
 // class SvxNoLinebreakItem ----------------------------------------------
-SvxNoLinebreakItem::SvxNoLinebreakItem( const sal_Bool bBreak, const USHORT nId ) :
+SvxNoLinebreakItem::SvxNoLinebreakItem( const sal_Bool bBreak, const sal_uInt16 nId ) :
       SfxBoolItem( nId, bBreak )
 {
 }
@@ -2758,7 +2758,7 @@ SfxPoolItem* SvxNoLinebreakItem::Clone( SfxItemPool* ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxNoLinebreakItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxNoLinebreakItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << (sal_Bool)GetValue();
     return rStrm;
@@ -2766,7 +2766,7 @@ SvStream& SvxNoLinebreakItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ )
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxNoLinebreakItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxNoLinebreakItem::Create(SvStream& rStrm, sal_uInt16) const
 {
     sal_Bool bValue;
     rStrm >> bValue;
@@ -2789,7 +2789,7 @@ SfxItemPresentation SvxNoLinebreakItem::GetPresentation
 
 // class SvxNoHyphenItem -------------------------------------------------
 
-SvxNoHyphenItem::SvxNoHyphenItem( const sal_Bool bHyphen, const USHORT nId ) :
+SvxNoHyphenItem::SvxNoHyphenItem( const sal_Bool bHyphen, const sal_uInt16 nId ) :
     SfxBoolItem( nId , bHyphen )
 {
 }
@@ -2803,7 +2803,7 @@ SfxPoolItem* SvxNoHyphenItem::Clone( SfxItemPool* ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxNoHyphenItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxNoHyphenItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << (sal_Bool) GetValue();
     return rStrm;
@@ -2811,7 +2811,7 @@ SvStream& SvxNoHyphenItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) co
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxNoHyphenItem::Create( SvStream& rStrm, USHORT ) const
+SfxPoolItem* SvxNoHyphenItem::Create( SvStream& rStrm, sal_uInt16 ) const
 {
     sal_Bool bValue;
     rStrm >> bValue;
@@ -2841,21 +2841,21 @@ SfxItemPresentation SvxNoHyphenItem::GetPresentation
 // class SvxLineColorItem (== SvxColorItem)
 // -----------------------------------------------------------------------
 
-SvxLineColorItem::SvxLineColorItem( const USHORT nId ) :
+SvxLineColorItem::SvxLineColorItem( const sal_uInt16 nId ) :
     SvxColorItem( nId )
 {
 }
 
 // -----------------------------------------------------------------------
 
-SvxLineColorItem::SvxLineColorItem( const Color& rCol, const USHORT nId ) :
+SvxLineColorItem::SvxLineColorItem( const Color& rCol, const sal_uInt16 nId ) :
     SvxColorItem( rCol, nId )
 {
 }
 
 // -----------------------------------------------------------------------
 
-SvxLineColorItem::SvxLineColorItem( SvStream &rStrm, const USHORT nId ) :
+SvxLineColorItem::SvxLineColorItem( SvStream &rStrm, const sal_uInt16 nId ) :
     SvxColorItem( rStrm, nId )
 {
 }
@@ -2891,7 +2891,7 @@ SfxItemPresentation SvxLineColorItem::GetPresentation
 // class SvxBlinkItem -------------------------------------------------
 
 
-SvxBlinkItem::SvxBlinkItem( const sal_Bool bBlink, const USHORT nId ) :
+SvxBlinkItem::SvxBlinkItem( const sal_Bool bBlink, const sal_uInt16 nId ) :
     SfxBoolItem( nId, bBlink )
 {
 }
@@ -2905,17 +2905,17 @@ SfxPoolItem* SvxBlinkItem::Clone( SfxItemPool * ) const
 
 // -----------------------------------------------------------------------
 
-SvStream& SvxBlinkItem::Store( SvStream& rStrm , USHORT /*nItemVersion*/ ) const
+SvStream& SvxBlinkItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
 {
-    rStrm << (BYTE) GetValue();
+    rStrm << (sal_uInt8) GetValue();
     return rStrm;
 }
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxBlinkItem::Create(SvStream& rStrm, USHORT) const
+SfxPoolItem* SvxBlinkItem::Create(SvStream& rStrm, sal_uInt16) const
 {
-    BYTE nState;
+    sal_uInt8 nState;
     rStrm >> nState;
     return new SvxBlinkItem( nState, Which() );
 }
@@ -2938,7 +2938,7 @@ SfxItemPresentation SvxBlinkItem::GetPresentation
         case SFX_ITEM_PRESENTATION_NAMELESS:
         case SFX_ITEM_PRESENTATION_COMPLETE:
         {
-            USHORT nId = RID_SVXITEMS_BLINK_FALSE;
+            sal_uInt16 nId = RID_SVXITEMS_BLINK_FALSE;
 
             if ( GetValue() )
                 nId = RID_SVXITEMS_BLINK_TRUE;
@@ -2953,7 +2953,7 @@ SfxItemPresentation SvxBlinkItem::GetPresentation
 // class SvxEmphaisMarkItem ---------------------------------------------------
 
 SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue,
-                                        const USHORT nId )
+                                        const sal_uInt16 nId )
     : SfxUInt16Item( nId, nValue )
 {
 }
@@ -2968,7 +2968,7 @@ SfxPoolItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const
 // -----------------------------------------------------------------------
 
 SvStream& SvxEmphasisMarkItem::Store( SvStream& rStrm,
-                                     USHORT /*nItemVersion*/ ) const
+                                     sal_uInt16 /*nItemVersion*/ ) const
 {
     rStrm << (sal_uInt16)GetValue();
     return rStrm;
@@ -2976,7 +2976,7 @@ SvStream& SvxEmphasisMarkItem::Store( SvStream& rStrm,
 
 // -----------------------------------------------------------------------
 
-SfxPoolItem* SvxEmphasisMarkItem::Create( SvStream& rStrm, USHORT ) const
+SfxPoolItem* SvxEmphasisMarkItem::Create( SvStream& rStrm, sal_uInt16 ) const
 {
     sal_uInt16 nValue;
     rStrm >> nValue;
@@ -3005,7 +3005,7 @@ SfxItemPresentation SvxEmphasisMarkItem::GetPresentation
                 sal_uInt16 nVal = GetValue();
                 rText = EE_RESSTR( RID_SVXITEMS_EMPHASIS_BEGIN_STYLE +
                                         ( EMPHASISMARK_STYLE & nVal ));
-                USHORT nId = ( EMPHASISMARK_POS_ABOVE & nVal )
+                sal_uInt16 nId = ( EMPHASISMARK_POS_ABOVE & nVal )
                                 ? RID_SVXITEMS_EMPHASIS_ABOVE_POS
                                 : ( EMPHASISMARK_POS_BELOW & nVal )
                                     ? RID_SVXITEMS_EMPHASIS_BELOW_POS
@@ -3021,7 +3021,7 @@ SfxItemPresentation SvxEmphasisMarkItem::GetPresentation
 
 // -----------------------------------------------------------------------
 
-sal_Bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
+sal_Bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3048,7 +3048,7 @@ sal_Bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const
     return sal_True;
 }
 
-sal_Bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
+sal_Bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3079,7 +3079,7 @@ sal_Bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, BYTE nMemberId )
     return bRet;
 }
 
-USHORT SvxEmphasisMarkItem::GetVersion( USHORT nFFVer ) const
+sal_uInt16 SvxEmphasisMarkItem::GetVersion( sal_uInt16 nFFVer ) const
 {
     DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
             SOFFICE_FILEFORMAT_40==nFFVer ||
@@ -3127,7 +3127,7 @@ SfxPoolItem* SvxTwoLinesItem::Clone( SfxItemPool* ) const
 }
 
 sal_Bool SvxTwoLinesItem::QueryValue( com::sun::star::uno::Any& rVal,
-                                BYTE nMemberId ) const
+                                sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3161,7 +3161,7 @@ sal_Bool SvxTwoLinesItem::QueryValue( com::sun::star::uno::Any& rVal,
 }
 
 sal_Bool SvxTwoLinesItem::PutValue( const com::sun::star::uno::Any& rVal,
-                                    BYTE nMemberId )
+                                    sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3221,7 +3221,7 @@ SfxItemPresentation SvxTwoLinesItem::GetPresentation( SfxItemPresentation ePres,
 }
 
 
-SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, USHORT /*nVer*/) const
+SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, sal_uInt16 /*nVer*/) const
 {
     sal_Bool _bOn;
     sal_Unicode cStart, cEnd;
@@ -3229,13 +3229,13 @@ SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, USHORT /*nVer*/) const
     return new SvxTwoLinesItem( _bOn, cStart, cEnd, Which() );
 }
 
-SvStream& SvxTwoLinesItem::Store(SvStream & rStrm, USHORT /*nIVer*/) const
+SvStream& SvxTwoLinesItem::Store(SvStream & rStrm, sal_uInt16 /*nIVer*/) const
 {
     rStrm << GetValue() << GetStartBracket() << GetEndBracket();
     return rStrm;
 }
 
-USHORT SvxTwoLinesItem::GetVersion( USHORT nFFVer ) const
+sal_uInt16 SvxTwoLinesItem::GetVersion( sal_uInt16 nFFVer ) const
 {
     DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
             SOFFICE_FILEFORMAT_40==nFFVer ||
@@ -3262,7 +3262,7 @@ SfxPoolItem* SvxCharRotateItem::Clone( SfxItemPool* ) const
     return new SvxCharRotateItem( GetValue(), IsFitToLine(), Which() );
 }
 
-SfxPoolItem* SvxCharRotateItem::Create( SvStream& rStrm, USHORT ) const
+SfxPoolItem* SvxCharRotateItem::Create( SvStream& rStrm, sal_uInt16 ) const
 {
     sal_uInt16 nVal;
     sal_Bool b;
@@ -3270,14 +3270,14 @@ SfxPoolItem* SvxCharRotateItem::Create( SvStream& rStrm, USHORT ) const
     return new SvxCharRotateItem( nVal, b, Which() );
 }
 
-SvStream& SvxCharRotateItem::Store( SvStream & rStrm, USHORT ) const
+SvStream& SvxCharRotateItem::Store( SvStream & rStrm, sal_uInt16 ) const
 {
     sal_Bool bFlag = IsFitToLine();
     rStrm << GetValue() << bFlag;
     return rStrm;
 }
 
-USHORT SvxCharRotateItem::GetVersion( USHORT nFFVer ) const
+sal_uInt16 SvxCharRotateItem::GetVersion( sal_uInt16 nFFVer ) const
 {
     return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
 }
@@ -3313,7 +3313,7 @@ SfxItemPresentation SvxCharRotateItem::GetPresentation(
 }
 
 sal_Bool SvxCharRotateItem::QueryValue( com::sun::star::uno::Any& rVal,
-                                BYTE nMemberId ) const
+                                sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3334,7 +3334,7 @@ sal_Bool SvxCharRotateItem::QueryValue( com::sun::star::uno::Any& rVal,
 }
 
 sal_Bool SvxCharRotateItem::PutValue( const com::sun::star::uno::Any& rVal,
-                                    BYTE nMemberId )
+                                    sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3345,7 +3345,7 @@ sal_Bool SvxCharRotateItem::PutValue( const com::sun::star::uno::Any& rVal,
         {
             sal_Int16 nVal = 0;
             if((rVal >>= nVal) && (0 == nVal || 900 == nVal || 2700 == nVal))
-                SetValue( (USHORT)nVal );
+                SetValue( (sal_uInt16)nVal );
             else
                 bRet = sal_False;
             break;
@@ -3383,7 +3383,7 @@ SfxPoolItem* SvxCharScaleWidthItem::Clone( SfxItemPool* ) const
     return new SvxCharScaleWidthItem( GetValue(), Which() );
 }
 
-SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, USHORT ) const
+SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, sal_uInt16 ) const
 {
     sal_uInt16 nVal;
     rStrm >> nVal;
@@ -3392,10 +3392,10 @@ SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, USHORT ) const
     if ( Which() == EE_CHAR_FONTWIDTH )
     {
         // #87271#: Was a SvxFontWidthItem in 5.2
-        // USHORT nFixWidth, USHORT nPropWidth.
+        // sal_uInt16 nFixWidth, sal_uInt16 nPropWidth.
         // nFixWidth has never been used...
         rStrm >> nVal;
-        USHORT nTest;
+        sal_uInt16 nTest;
         rStrm >> nTest;
         if ( nTest == 0x1234 )
             pItem->SetValue( nVal );
@@ -3406,23 +3406,23 @@ SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, USHORT ) const
     return pItem;
 }
 
-SvStream& SvxCharScaleWidthItem::Store( SvStream& rStream, USHORT nVer ) const
+SvStream& SvxCharScaleWidthItem::Store( SvStream& rStream, sal_uInt16 nVer ) const
 {
     SvStream& rRet = SfxUInt16Item::Store( rStream, nVer );
     if ( Which() == EE_CHAR_FONTWIDTH )
     {
         // see comment in Create()....
-        rRet.SeekRel( -1*(long)sizeof(USHORT) );
-        rRet << (USHORT)0;
+        rRet.SeekRel( -1*(long)sizeof(sal_uInt16) );
+        rRet << (sal_uInt16)0;
         rRet << GetValue();
         // Really ugly, but not a problem for reading the doc in 5.2
-        rRet << (USHORT)0x1234;
+        rRet << (sal_uInt16)0x1234;
     }
     return rRet;
 }
 
 
-USHORT SvxCharScaleWidthItem::GetVersion( USHORT nFFVer ) const
+sal_uInt16 SvxCharScaleWidthItem::GetVersion( sal_uInt16 nFFVer ) const
 {
     return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
 }
@@ -3455,27 +3455,27 @@ SfxItemPresentation SvxCharScaleWidthItem::GetPresentation(
     return SFX_ITEM_PRESENTATION_NONE;
 }
 
-sal_Bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, BYTE /*nMemberId*/ )
+sal_Bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 {
     // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
     // where we still want this to be a sal_Int16
     sal_Int16 nValue = sal_Int16();
     if (rVal >>= nValue)
     {
-        SetValue( (UINT16) nValue );
-        return TRUE;
+        SetValue( (sal_uInt16) nValue );
+        return sal_True;
     }
 
     DBG_ERROR( "SvxCharScaleWidthItem::PutValue - Wrong type!" );
-    return FALSE;
+    return sal_False;
 }
 
-sal_Bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, BYTE /*nMemberId*/ ) const
+sal_Bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 {
     // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
     // where we still want this to be a sal_Int16
     rVal <<= (sal_Int16)GetValue();
-    return TRUE;
+    return sal_True;
 }
 
 /*************************************************************************
@@ -3484,7 +3484,7 @@ sal_Bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, BYTE /*nMemberId*/ )
 
 SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue,
                                          const sal_uInt16 nId )
-    : SfxEnumItem( nId, (USHORT)eValue )
+    : SfxEnumItem( nId, (sal_uInt16)eValue )
 {
 }
 
@@ -3493,33 +3493,33 @@ SfxPoolItem* SvxCharReliefItem::Clone( SfxItemPool * ) const
     return new SvxCharReliefItem( *this );
 }
 
-SfxPoolItem* SvxCharReliefItem::Create(SvStream & rStrm, USHORT) const
+SfxPoolItem* SvxCharReliefItem::Create(SvStream & rStrm, sal_uInt16) const
 {
     sal_uInt16 nVal;
     rStrm >> nVal;
     return new SvxCharReliefItem( (FontRelief)nVal, Which() );
 }
 
-SvStream& SvxCharReliefItem::Store(SvStream & rStrm, USHORT /*nIVer*/) const
+SvStream& SvxCharReliefItem::Store(SvStream & rStrm, sal_uInt16 /*nIVer*/) const
 {
     sal_uInt16 nVal = GetValue();
     rStrm << nVal;
     return rStrm;
 }
 
-USHORT SvxCharReliefItem::GetVersion( USHORT nFFVer ) const
+sal_uInt16 SvxCharReliefItem::GetVersion( sal_uInt16 nFFVer ) const
 {
     return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
 }
 
-String SvxCharReliefItem::GetValueTextByPos( USHORT nPos ) const
+String SvxCharReliefItem::GetValueTextByPos( sal_uInt16 nPos ) const
 {
     DBG_ASSERT( RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE,
                     "enum overflow" );
     return String( EditResId( RID_SVXITEMS_RELIEF_BEGIN + nPos ));
 }
 
-USHORT SvxCharReliefItem::GetValueCount() const
+sal_uInt16 SvxCharReliefItem::GetValueCount() const
 {
     return RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE;
 }
@@ -3551,7 +3551,7 @@ SfxItemPresentation SvxCharReliefItem::GetPresentation
 }
 
 sal_Bool SvxCharReliefItem::PutValue( const com::sun::star::uno::Any& rVal,
-                                        BYTE nMemberId )
+                                        sal_uInt8 nMemberId )
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3563,7 +3563,7 @@ sal_Bool SvxCharReliefItem::PutValue( const com::sun::star::uno::Any& rVal,
             sal_Int16 nVal = -1;
             rVal >>= nVal;
             if(nVal >= 0 && nVal <= RELIEF_ENGRAVED)
-                SetValue( (USHORT)nVal );
+                SetValue( (sal_uInt16)nVal );
             else
                 bRet = sal_False;
         }
@@ -3576,7 +3576,7 @@ sal_Bool SvxCharReliefItem::PutValue( const com::sun::star::uno::Any& rVal,
 }
 
 sal_Bool SvxCharReliefItem::QueryValue( com::sun::star::uno::Any& rVal,
-                                        BYTE nMemberId ) const
+                                        sal_uInt8 nMemberId ) const
 {
 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     nMemberId &= ~CONVERT_TWIPS;
@@ -3610,14 +3610,14 @@ SfxPoolItem* SvxScriptTypeItem::Clone( SfxItemPool * ) const
 |*    class SvxScriptSetItem
 *************************************************************************/
 
-SvxScriptSetItem::SvxScriptSetItem( USHORT nSlotId, SfxItemPool& rPool )
+SvxScriptSetItem::SvxScriptSetItem( sal_uInt16 nSlotId, SfxItemPool& rPool )
     : SfxSetItem( nSlotId, new SfxItemSet( rPool,
                         SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONT ))
 {
-    USHORT nLatin, nAsian, nComplex;
+    sal_uInt16 nLatin, nAsian, nComplex;
     GetWhichIds( nLatin, nAsian, nComplex );
 
-    USHORT aIds[ 9 ] = { 0 };
+    sal_uInt16 aIds[ 9 ] = { 0 };
     aIds[ 0 ] = aIds[ 1 ] = nLatin;
     aIds[ 2 ] = aIds[ 3 ] = nAsian;
     aIds[ 4 ] = aIds[ 5 ] = nComplex;
@@ -3630,28 +3630,28 @@ SvxScriptSetItem::SvxScriptSetItem( USHORT nSlotId, SfxItemPool& rPool )
 SfxPoolItem* SvxScriptSetItem::Clone( SfxItemPool * ) const
 {
     SvxScriptSetItem* p = new SvxScriptSetItem( Which(), *GetItemSet().GetPool() );
-    p->GetItemSet().Put( GetItemSet(), FALSE );
+    p->GetItemSet().Put( GetItemSet(), sal_False );
     return p;
 }
 
-SfxPoolItem* SvxScriptSetItem::Create( SvStream &, USHORT ) const
+SfxPoolItem* SvxScriptSetItem::Create( SvStream &, sal_uInt16 ) const
 {
     return 0;
 }
 
 const SfxPoolItem* SvxScriptSetItem::GetItemOfScriptSet(
-                            const SfxItemSet& rSet, USHORT nId )
+                            const SfxItemSet& rSet, sal_uInt16 nId )
 {
     const SfxPoolItem* pI;
-    SfxItemState eSt = rSet.GetItemState( nId, FALSE, &pI );
+    SfxItemState eSt = rSet.GetItemState( nId, sal_False, &pI );
     if( SFX_ITEM_SET != eSt )
         pI = SFX_ITEM_DEFAULT == eSt ? &rSet.Get( nId ) : 0;
     return pI;
 }
 
-const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( USHORT nSlotId, const SfxItemSet& rSet, USHORT nScript )
+const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16 nScript )
 {
-    USHORT nLatin, nAsian, nComplex;
+    sal_uInt16 nLatin, nAsian, nComplex;
     GetWhichIds( nSlotId, rSet, nLatin, nAsian, nComplex );
 
     const SfxPoolItem *pRet, *pAsn, *pCmplx;
@@ -3700,15 +3700,15 @@ const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( USHORT nSlotId, const SfxI
     return pRet;
 }
 
-const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( USHORT nScript ) const
+const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nScript ) const
 {
     return GetItemOfScript( Which(), GetItemSet(), nScript );
 }
 
-void SvxScriptSetItem::PutItemForScriptType( USHORT nScriptType,
+void SvxScriptSetItem::PutItemForScriptType( sal_uInt16 nScriptType,
                                              const SfxPoolItem& rItem )
 {
-    USHORT nLatin, nAsian, nComplex;
+    sal_uInt16 nLatin, nAsian, nComplex;
     GetWhichIds( nLatin, nAsian, nComplex );
 
     SfxPoolItem* pCpy = rItem.Clone();
@@ -3730,7 +3730,7 @@ void SvxScriptSetItem::PutItemForScriptType( USHORT nScriptType,
     delete pCpy;
 }
 
-void SvxScriptSetItem::GetWhichIds( USHORT nSlotId, const SfxItemSet& rSet, USHORT& rLatin, USHORT& rAsian, USHORT& rComplex )
+void SvxScriptSetItem::GetWhichIds( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16& rLatin, sal_uInt16& rAsian, sal_uInt16& rComplex )
 {
     const SfxItemPool& rPool = *rSet.GetPool();
     GetSlotIds( nSlotId, rLatin, rAsian, rComplex );
@@ -3739,19 +3739,19 @@ void SvxScriptSetItem::GetWhichIds( USHORT nSlotId, const SfxItemSet& rSet, USHO
     rComplex = rPool.GetWhich( rComplex );
 }
 
-void SvxScriptSetItem::GetWhichIds( USHORT& rLatin, USHORT& rAsian,
-                                    USHORT& rComplex ) const
+void SvxScriptSetItem::GetWhichIds( sal_uInt16& rLatin, sal_uInt16& rAsian,
+                                    sal_uInt16& rComplex ) const
 {
     GetWhichIds( Which(), GetItemSet(), rLatin, rAsian, rComplex );
 }
 
-void SvxScriptSetItem::GetSlotIds( USHORT nSlotId, USHORT& rLatin,
-                                    USHORT& rAsian, USHORT& rComplex )
+void SvxScriptSetItem::GetSlotIds( sal_uInt16 nSlotId, sal_uInt16& rLatin,
+                                    sal_uInt16& rAsian, sal_uInt16& rComplex )
 {
     switch( nSlotId )
     {
     default:
-        DBG_ASSERT( FALSE, "wrong SlotId for class SvxScriptSetItem" );
+        DBG_ASSERT( sal_False, "wrong SlotId for class SvxScriptSetItem" );
         // no break - default to font - Id Range !!
 
     case SID_ATTR_CHAR_FONT:
@@ -3784,12 +3784,12 @@ void SvxScriptSetItem::GetSlotIds( USHORT nSlotId, USHORT& rLatin,
 
 void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex )
 {
-    const USHORT nItemCnt = 3;
+    const sal_uInt16 nItemCnt = 3;
 
     static struct
     {
-        USHORT nFontType;
-        USHORT nLanguage;
+        sal_uInt16 nFontType;
+        sal_uInt16 nLanguage;
     }
     aOutTypeArr[ nItemCnt ] =
     {
@@ -3800,7 +3800,7 @@ void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rCo
 
     SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex };
 
-    for ( USHORT n = 0; n < nItemCnt; ++n )
+    for ( sal_uInt16 n = 0; n < nItemCnt; ++n )
     {
         Font aFont( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFontType,
                                                   aOutTypeArr[ n ].nLanguage,
@@ -3815,12 +3815,12 @@ void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rCo
 }
 
 
-USHORT GetI18NScriptTypeOfLanguage( USHORT nLang )
+sal_uInt16 GetI18NScriptTypeOfLanguage( sal_uInt16 nLang )
 {
     return GetI18NScriptType( SvtLanguageOptions::GetScriptTypeOfLanguage( nLang ) );
 }
 
-USHORT GetItemScriptType( short nI18NType )
+sal_uInt16 GetItemScriptType( short nI18NType )
 {
     switch ( nI18NType )
     {
@@ -3831,7 +3831,7 @@ USHORT GetItemScriptType( short nI18NType )
     return 0;
 }
 
-short GetI18NScriptType( USHORT nItemType )
+short GetI18NScriptType( sal_uInt16 nItemType )
 {
     switch ( nItemType )
     {