#i112600#: clean up l10ntools, rsc, sot, svl, tools and unotools

3 files changed, 130 insertions, 130 deletions

diff --git a/tools/source/datetime/datetime.cxx b/tools/source/datetime/datetime.cxx
index 8b679478c535..ffdbd25789ac 100644
--- a/tools/source/datetime/datetime.cxx
+++ b/tools/source/datetime/datetime.cxx
@@ -41,13 +41,13 @@
 |*
 *************************************************************************/
 
-BOOL DateTime::IsBetween( const DateTime& rFrom,
+sal_Bool DateTime::IsBetween( const DateTime& rFrom,
                           const DateTime& rTo ) const
 {
     if ( (*this >= rFrom) && (*this <= rTo) )
-        return TRUE;
+        return sal_True;
     else
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -60,13 +60,13 @@ BOOL DateTime::IsBetween( const DateTime& rFrom,
 |*
 *************************************************************************/
 
-BOOL DateTime::operator >( const DateTime& rDateTime ) const
+sal_Bool DateTime::operator >( const DateTime& rDateTime ) const
 {
     if ( (Date::operator>( rDateTime )) ||
          (Date::operator==( rDateTime ) && Time::operator>( rDateTime )) )
-        return TRUE;
+        return sal_True;
     else
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -79,13 +79,13 @@ BOOL DateTime::operator >( const DateTime& rDateTime ) const
 |*
 *************************************************************************/
 
-BOOL DateTime::operator <( const DateTime& rDateTime ) const
+sal_Bool DateTime::operator <( const DateTime& rDateTime ) const
 {
     if ( (Date::operator<( rDateTime )) ||
          (Date::operator==( rDateTime ) && Time::operator<( rDateTime )) )
-        return TRUE;
+        return sal_True;
     else
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -98,13 +98,13 @@ BOOL DateTime::operator <( const DateTime& rDateTime ) const
 |*
 *************************************************************************/
 
-BOOL DateTime::operator >=( const DateTime& rDateTime ) const
+sal_Bool DateTime::operator >=( const DateTime& rDateTime ) const
 {
     if ( (Date::operator>( rDateTime )) ||
          (Date::operator==( rDateTime ) && Time::operator>=( rDateTime )) )
-        return TRUE;
+        return sal_True;
     else
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -117,13 +117,13 @@ BOOL DateTime::operator >=( const DateTime& rDateTime ) const
 |*
 *************************************************************************/
 
-BOOL DateTime::operator <=( const DateTime& rDateTime ) const
+sal_Bool DateTime::operator <=( const DateTime& rDateTime ) const
 {
     if ( (Date::operator<( rDateTime )) ||
          (Date::operator==( rDateTime ) && Time::operator<=( rDateTime )) )
-        return TRUE;
+        return sal_True;
     else
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -161,14 +161,14 @@ long DateTime::GetSecFromDateTime( const Date& rDate ) const
 |*
 *************************************************************************/
 
-void DateTime::MakeDateTimeFromSec( const Date& rDate, ULONG nSec )
+void DateTime::MakeDateTimeFromSec( const Date& rDate, sal_uIntPtr nSec )
 {
     long nDays = nSec / (24UL*60*60);
     ((Date*)this)->operator=( rDate );
     nSec -= nDays * (24UL*60*60);
-    USHORT nMin = (USHORT)(nSec / 60);
+    sal_uInt16 nMin = (sal_uInt16)(nSec / 60);
     nSec -= nMin * 60;
-    ((Time*)this)->operator=( Time( 0, nMin, (USHORT)nSec ) );
+    ((Time*)this)->operator=( Time( 0, nMin, (sal_uInt16)nSec ) );
     operator+=( nDays );
 }
 
@@ -186,7 +186,7 @@ DateTime& DateTime::operator +=( const Time& rTime )
 {
     Time aTime = *this;
     aTime += rTime;
-    USHORT nHours = aTime.GetHour();
+    sal_uInt16 nHours = aTime.GetHour();
     if ( aTime.GetTime() > 0 )
     {
         while ( nHours >= 24 )
@@ -225,7 +225,7 @@ DateTime& DateTime::operator -=( const Time& rTime )
 {
     Time aTime = *this;
     aTime -= rTime;
-    USHORT nHours = aTime.GetHour();
+    sal_uInt16 nHours = aTime.GetHour();
     if ( aTime.GetTime() > 0 )
     {
         while ( nHours >= 24 )
@@ -421,22 +421,22 @@ DateTime DateTime::CreateFromWin32FileDateTime( const sal_uInt32 & rLower, const
           ( nDays / ( 400 * 365 ) ) ) / 365;
     nDays -= nYears * 365 + nYears / 4 - nYears / 100 + nYears / 400;
 
-    USHORT nMonths = 0;
+    sal_uInt16 nMonths = 0;
     for( sal_Int64 nDaysCount = nDays; nDaysCount >= 0; )
     {
         nDays = nDaysCount;
         nMonths ++;
         nDaysCount -= Date(
-            1, nMonths, sal::static_int_cast< USHORT >(1601 + nYears) ).
+            1, nMonths, sal::static_int_cast< sal_uInt16 >(1601 + nYears) ).
             GetDaysInMonth();
     }
 
     Date _aDate(
-        (USHORT)( nDays + 1 ), nMonths,
-        sal::static_int_cast< USHORT >(nYears + 1601) );
-    Time _aTime( ULONG( ( aTime / ( a100nPerSecond * 60 * 60 ) ) % sal_Int64( 24 ) ),
-            ULONG( ( aTime / ( a100nPerSecond * 60 ) ) % sal_Int64( 60 ) ),
-            ULONG( ( aTime / ( a100nPerSecond ) ) % sal_Int64( 60 ) ) );
+        (sal_uInt16)( nDays + 1 ), nMonths,
+        sal::static_int_cast< sal_uInt16 >(nYears + 1601) );
+    Time _aTime( sal_uIntPtr( ( aTime / ( a100nPerSecond * 60 * 60 ) ) % sal_Int64( 24 ) ),
+            sal_uIntPtr( ( aTime / ( a100nPerSecond * 60 ) ) % sal_Int64( 60 ) ),
+            sal_uIntPtr( ( aTime / ( a100nPerSecond ) ) % sal_Int64( 60 ) ) );
 
     return DateTime( _aDate, _aTime );
 }
diff --git a/tools/source/datetime/tdate.cxx b/tools/source/datetime/tdate.cxx
index e6bb4345d9f9..2a3c36daf9ed 100644
--- a/tools/source/datetime/tdate.cxx
+++ b/tools/source/datetime/tdate.cxx
@@ -53,14 +53,14 @@ struct tm *localtime_r(const time_t *timep, struct tm *buffer);
 
 // =======================================================================
 
-static USHORT aDaysInMonth[12] = { 31, 28, 31, 30, 31, 30,
+static sal_uInt16 aDaysInMonth[12] = { 31, 28, 31, 30, 31, 30,
                                    31, 31, 30, 31, 30, 31 };
 
 #define MAX_DAYS    3636532
 
 // =======================================================================
 
-inline BOOL ImpIsLeapYear( USHORT nYear )
+inline sal_Bool ImpIsLeapYear( sal_uInt16 nYear )
 {
     return (
                  ( ((nYear % 4) == 0) && ((nYear % 100) != 0) ) ||
@@ -70,7 +70,7 @@ inline BOOL ImpIsLeapYear( USHORT nYear )
 
 // -----------------------------------------------------------------------
 
-inline USHORT DaysInMonth( USHORT nMonth, USHORT nYear )
+inline sal_uInt16 DaysInMonth( sal_uInt16 nMonth, sal_uInt16 nYear )
 {
     if ( nMonth != 2 )
         return aDaysInMonth[nMonth-1];
@@ -85,13 +85,13 @@ inline USHORT DaysInMonth( USHORT nMonth, USHORT nYear )
 
 // -----------------------------------------------------------------------
 
-long Date::DateToDays( USHORT nDay, USHORT nMonth, USHORT nYear )
+long Date::DateToDays( sal_uInt16 nDay, sal_uInt16 nMonth, sal_uInt16 nYear )
 {
     long nDays;
 
-    nDays = ((ULONG)nYear-1) * 365;
+    nDays = ((sal_uIntPtr)nYear-1) * 365;
     nDays += ((nYear-1) / 4) - ((nYear-1) / 100) + ((nYear-1) / 400);
-    for( USHORT i = 1; i < nMonth; i++ )
+    for( sal_uInt16 i = 1; i < nMonth; i++ )
         nDays += DaysInMonth(i,nYear);
     nDays += nDay;
     return nDays;
@@ -100,23 +100,23 @@ long Date::DateToDays( USHORT nDay, USHORT nMonth, USHORT nYear )
 // -----------------------------------------------------------------------
 
 static void DaysToDate( long nDays,
-                        USHORT& rDay, USHORT& rMonth, USHORT& rYear )
+                        sal_uInt16& rDay, sal_uInt16& rMonth, sal_uInt16& rYear )
 {
     long    nTempDays;
     long    i = 0;
-    BOOL    bCalc;
+    sal_Bool    bCalc;
 
     do
     {
         nTempDays = (long)nDays;
-        rYear = (USHORT)((nTempDays / 365) - i);
-        nTempDays -= ((ULONG)rYear-1) * 365;
+        rYear = (sal_uInt16)((nTempDays / 365) - i);
+        nTempDays -= ((sal_uIntPtr)rYear-1) * 365;
         nTempDays -= ((rYear-1) / 4) - ((rYear-1) / 100) + ((rYear-1) / 400);
-        bCalc = FALSE;
+        bCalc = sal_False;
         if ( nTempDays < 1 )
         {
             i++;
-            bCalc = TRUE;
+            bCalc = sal_True;
         }
         else
         {
@@ -125,7 +125,7 @@ static void DaysToDate( long nDays,
                 if ( (nTempDays != 366) || !ImpIsLeapYear( rYear ) )
                 {
                     i--;
-                    bCalc = TRUE;
+                    bCalc = sal_True;
                 }
             }
         }
@@ -133,12 +133,12 @@ static void DaysToDate( long nDays,
     while ( bCalc );
 
     rMonth = 1;
-    while ( (ULONG)nTempDays > DaysInMonth( rMonth, rYear ) )
+    while ( (sal_uIntPtr)nTempDays > DaysInMonth( rMonth, rYear ) )
     {
         nTempDays -= DaysInMonth( rMonth, rYear );
         rMonth++;
     }
-    rDay = (USHORT)nTempDays;
+    rDay = (sal_uInt16)nTempDays;
 }
 
 // =======================================================================
@@ -150,17 +150,17 @@ Date::Date()
     DosGetDateTime( &aDateTime );
 
     // Datum zusammenbauen
-    nDate = ((ULONG)aDateTime.day) +
-            (((ULONG)aDateTime.month)*100) +
-            (((ULONG)aDateTime.year)*10000);
+    nDate = ((sal_uIntPtr)aDateTime.day) +
+            (((sal_uIntPtr)aDateTime.month)*100) +
+            (((sal_uIntPtr)aDateTime.year)*10000);
 #elif defined WNT
     SYSTEMTIME aDateTime;
     GetLocalTime( &aDateTime );
 
     // Datum zusammenbauen
-    nDate = ((ULONG)aDateTime.wDay) +
-            (((ULONG)aDateTime.wMonth)*100) +
-            (((ULONG)aDateTime.wYear)*10000);
+    nDate = ((sal_uIntPtr)aDateTime.wDay) +
+            (((sal_uIntPtr)aDateTime.wMonth)*100) +
+            (((sal_uIntPtr)aDateTime.wYear)*10000);
 #else
     time_t     nTmpTime;
     struct tm aTime;
@@ -171,65 +171,65 @@ Date::Date()
     // Datum zusammenbauen
     if ( localtime_r( &nTmpTime, &aTime ) )
     {
-        nDate = ((ULONG)aTime.tm_mday) +
-                (((ULONG)(aTime.tm_mon+1))*100) +
-                (((ULONG)(aTime.tm_year+1900))*10000);
+        nDate = ((sal_uIntPtr)aTime.tm_mday) +
+                (((sal_uIntPtr)(aTime.tm_mon+1))*100) +
+                (((sal_uIntPtr)(aTime.tm_year+1900))*10000);
     }
     else
-        nDate = 1 + 100 + (((ULONG)1900)*10000);
+        nDate = 1 + 100 + (((sal_uIntPtr)1900)*10000);
 #endif
 }
 
 // -----------------------------------------------------------------------
 
-void Date::SetDay( USHORT nNewDay )
+void Date::SetDay( sal_uInt16 nNewDay )
 {
-    ULONG  nMonth  = GetMonth();
-    ULONG  nYear   = GetYear();
+    sal_uIntPtr  nMonth  = GetMonth();
+    sal_uIntPtr  nYear   = GetYear();
 
-    nDate = ((ULONG)(nNewDay%100)) + (nMonth*100) + (nYear*10000);
+    nDate = ((sal_uIntPtr)(nNewDay%100)) + (nMonth*100) + (nYear*10000);
 }
 
 // -----------------------------------------------------------------------
 
-void Date::SetMonth( USHORT nNewMonth )
+void Date::SetMonth( sal_uInt16 nNewMonth )
 {
-    ULONG  nDay      = GetDay();
-    ULONG  nYear     = GetYear();
+    sal_uIntPtr  nDay    = GetDay();
+    sal_uIntPtr  nYear   = GetYear();
 
-    nDate = nDay + (((ULONG)(nNewMonth%100))*100) + (nYear*10000);
+    nDate = nDay + (((sal_uIntPtr)(nNewMonth%100))*100) + (nYear*10000);
 }
 
 // -----------------------------------------------------------------------
 
-void Date::SetYear( USHORT nNewYear )
+void Date::SetYear( sal_uInt16 nNewYear )
 {
-    ULONG  nDay     = GetDay();
-    ULONG  nMonth   = GetMonth();
+    sal_uIntPtr  nDay   = GetDay();
+    sal_uIntPtr  nMonth = GetMonth();
 
-    nDate = nDay + (nMonth*100) + (((ULONG)(nNewYear%10000))*10000);
+    nDate = nDay + (nMonth*100) + (((sal_uIntPtr)(nNewYear%10000))*10000);
 }
 
 // -----------------------------------------------------------------------
 
 DayOfWeek Date::GetDayOfWeek() const
 {
-    return (DayOfWeek)((ULONG)(DateToDays( GetDay(), GetMonth(), GetYear() )-1) % 7);
+    return (DayOfWeek)((sal_uIntPtr)(DateToDays( GetDay(), GetMonth(), GetYear() )-1) % 7);
 }
 
 // -----------------------------------------------------------------------
 
-USHORT Date::GetDayOfYear() const
+sal_uInt16 Date::GetDayOfYear() const
 {
-    USHORT nDay = GetDay();
-    for( USHORT i = 1; i < GetMonth(); i++ )
+    sal_uInt16 nDay = GetDay();
+    for( sal_uInt16 i = 1; i < GetMonth(); i++ )
          nDay = nDay + ::DaysInMonth( i, GetYear() );   // += yields a warning on MSVC, so don't use it
     return nDay;
 }
 
 // -----------------------------------------------------------------------
 
-USHORT Date::GetWeekOfYear( DayOfWeek eStartDay,
+sal_uInt16 Date::GetWeekOfYear( DayOfWeek eStartDay,
                             sal_Int16 nMinimumNumberOfDaysInWeek ) const
 {
     short nWeek;
@@ -307,76 +307,76 @@ USHORT Date::GetWeekOfYear( DayOfWeek eStartDay,
                 //                     == noch gleiche Woche
                 long nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() );
                 nTempDays +=  6 - (GetDayOfWeek()+(7-(short)eStartDay)) % 7;
-                USHORT  nDay;
-                USHORT  nMonth;
-                USHORT  nYear;
+                sal_uInt16  nDay;
+                sal_uInt16  nMonth;
+                sal_uInt16  nYear;
                 DaysToDate( nTempDays, nDay, nMonth, nYear );
                 nWeek = Date( nDay, nMonth, nYear ).GetWeekOfYear( eStartDay, nMinimumNumberOfDaysInWeek );
             }
         }
     }
 
-    return (USHORT)nWeek;
+    return (sal_uInt16)nWeek;
 }
 
 // -----------------------------------------------------------------------
 
-USHORT Date::GetDaysInMonth() const
+sal_uInt16 Date::GetDaysInMonth() const
 {
     return DaysInMonth( GetMonth(), GetYear() );
 }
 
 // -----------------------------------------------------------------------
 
-BOOL Date::IsLeapYear() const
+sal_Bool Date::IsLeapYear() const
 {
-    USHORT nYear = GetYear();
+    sal_uInt16 nYear = GetYear();
     return ImpIsLeapYear( nYear );
 }
 
 // -----------------------------------------------------------------------
 
-BOOL Date::IsValid() const
+sal_Bool Date::IsValid() const
 {
-    USHORT nDay   = GetDay();
-    USHORT nMonth = GetMonth();
-    USHORT nYear  = GetYear();
+    sal_uInt16 nDay   = GetDay();
+    sal_uInt16 nMonth = GetMonth();
+    sal_uInt16 nYear  = GetYear();
 
     if ( !nMonth || (nMonth > 12) )
-        return FALSE;
+        return sal_False;
     if ( !nDay || (nDay > DaysInMonth( nMonth, nYear )) )
-        return FALSE;
+        return sal_False;
     else if ( nYear <= 1582 )
     {
         if ( nYear < 1582 )
-            return FALSE;
+            return sal_False;
         else if ( nMonth < 10 )
-            return FALSE;
+            return sal_False;
         else if ( (nMonth == 10) && (nDay < 15) )
-            return FALSE;
+            return sal_False;
     }
 
-    return TRUE;
+    return sal_True;
 }
 
 // -----------------------------------------------------------------------
 
 Date& Date::operator +=( long nDays )
 {
-    USHORT  nDay;
-    USHORT  nMonth;
-    USHORT  nYear;
+    sal_uInt16  nDay;
+    sal_uInt16  nMonth;
+    sal_uInt16  nYear;
     long    nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() );
 
     nTempDays += nDays;
     if ( nTempDays > MAX_DAYS )
-        nDate = 31 + (12*100) + (((ULONG)9999)*10000);
+        nDate = 31 + (12*100) + (((sal_uIntPtr)9999)*10000);
     else if ( nTempDays <= 0 )
         nDate = 1 + 100;
     else
     {
         DaysToDate( nTempDays, nDay, nMonth, nYear );
-        nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000);
+        nDate = ((sal_uIntPtr)nDay) + (((sal_uIntPtr)nMonth)*100) + (((sal_uIntPtr)nYear)*10000);
     }
 
     return *this;
@@ -386,20 +386,20 @@ Date& Date::operator +=( long nDays )
 
 Date& Date::operator -=( long nDays )
 {
-    USHORT  nDay;
-    USHORT  nMonth;
-    USHORT  nYear;
+    sal_uInt16  nDay;
+    sal_uInt16  nMonth;
+    sal_uInt16  nYear;
     long    nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() );
 
     nTempDays -= nDays;
     if ( nTempDays > MAX_DAYS )
-        nDate = 31 + (12*100) + (((ULONG)9999)*10000);
+        nDate = 31 + (12*100) + (((sal_uIntPtr)9999)*10000);
     else if ( nTempDays <= 0 )
         nDate = 1 + 100;
     else
     {
         DaysToDate( nTempDays, nDay, nMonth, nYear );
-        nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000);
+        nDate = ((sal_uIntPtr)nDay) + (((sal_uIntPtr)nMonth)*100) + (((sal_uIntPtr)nYear)*10000);
     }
 
     return *this;
@@ -409,16 +409,16 @@ Date& Date::operator -=( long nDays )
 
 Date& Date::operator ++()
 {
-    USHORT  nDay;
-    USHORT  nMonth;
-    USHORT  nYear;
+    sal_uInt16  nDay;
+    sal_uInt16  nMonth;
+    sal_uInt16  nYear;
     long    nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() );
 
     if ( nTempDays < MAX_DAYS )
     {
         nTempDays++;
         DaysToDate( nTempDays, nDay, nMonth, nYear );
-        nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000);
+        nDate = ((sal_uIntPtr)nDay) + (((sal_uIntPtr)nMonth)*100) + (((sal_uIntPtr)nYear)*10000);
     }
 
     return *this;
@@ -428,16 +428,16 @@ Date& Date::operator ++()
 
 Date& Date::operator --()
 {
-    USHORT  nDay;
-    USHORT  nMonth;
-    USHORT  nYear;
+    sal_uInt16  nDay;
+    sal_uInt16  nMonth;
+    sal_uInt16  nYear;
     long    nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() );
 
     if ( nTempDays > 1 )
     {
         nTempDays--;
         DaysToDate( nTempDays, nDay, nMonth, nYear );
-        nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000);
+        nDate = ((sal_uIntPtr)nDay) + (((sal_uIntPtr)nMonth)*100) + (((sal_uIntPtr)nYear)*10000);
     }
     return *this;
 }
@@ -486,9 +486,9 @@ Date operator -( const Date& rDate, long nDays )
 
 long operator -( const Date& rDate1, const Date& rDate2 )
 {
-    ULONG  nTempDays1 = Date::DateToDays( rDate1.GetDay(), rDate1.GetMonth(),
+    sal_uIntPtr  nTempDays1 = Date::DateToDays( rDate1.GetDay(), rDate1.GetMonth(),
                                     rDate1.GetYear() );
-    ULONG  nTempDays2 = Date::DateToDays( rDate2.GetDay(), rDate2.GetMonth(),
+    sal_uIntPtr  nTempDays2 = Date::DateToDays( rDate2.GetDay(), rDate2.GetMonth(),
                                     rDate2.GetYear() );
     return nTempDays1 - nTempDays2;
 }
diff --git a/tools/source/datetime/ttime.cxx b/tools/source/datetime/ttime.cxx
index 9483cc10065e..fee1c159df44 100644
--- a/tools/source/datetime/ttime.cxx
+++ b/tools/source/datetime/ttime.cxx
@@ -145,7 +145,7 @@ Time::Time( const Time& rTime )
 
 // -----------------------------------------------------------------------
 
-Time::Time( ULONG nHour, ULONG nMin, ULONG nSec, ULONG n100Sec )
+Time::Time( sal_uIntPtr nHour, sal_uIntPtr nMin, sal_uIntPtr nSec, sal_uIntPtr n100Sec )
 {
     // Zeit normalisieren
     nSec    += n100Sec / 100;
@@ -161,7 +161,7 @@ Time::Time( ULONG nHour, ULONG nMin, ULONG nSec, ULONG n100Sec )
 
 // -----------------------------------------------------------------------
 
-void Time::SetHour( USHORT nNewHour )
+void Time::SetHour( sal_uInt16 nNewHour )
 {
     short  nSign      = (nTime >= 0) ? +1 : -1;
     sal_Int32   nMin      = GetMin();
@@ -174,7 +174,7 @@ void Time::SetHour( USHORT nNewHour )
 
 // -----------------------------------------------------------------------
 
-void Time::SetMin( USHORT nNewMin )
+void Time::SetMin( sal_uInt16 nNewMin )
 {
     short  nSign      = (nTime >= 0) ? +1 : -1;
     sal_Int32   nHour     = GetHour();
@@ -190,7 +190,7 @@ void Time::SetMin( USHORT nNewMin )
 
 // -----------------------------------------------------------------------
 
-void Time::SetSec( USHORT nNewSec )
+void Time::SetSec( sal_uInt16 nNewSec )
 {
     short       nSign     = (nTime >= 0) ? +1 : -1;
     sal_Int32   nHour     = GetHour();
@@ -206,7 +206,7 @@ void Time::SetSec( USHORT nNewSec )
 
 // -----------------------------------------------------------------------
 
-void Time::Set100Sec( USHORT nNew100Sec )
+void Time::Set100Sec( sal_uInt16 nNew100Sec )
 {
     short       nSign     = (nTime >= 0) ? +1 : -1;
     sal_Int32   nHour     = GetHour();
@@ -307,7 +307,7 @@ Time operator -( const Time& rTime1, const Time& rTime2 )
 
 // -----------------------------------------------------------------------
 
-BOOL Time::IsEqualIgnore100Sec( const Time& rTime ) const
+sal_Bool Time::IsEqualIgnore100Sec( const Time& rTime ) const
 {
     sal_Int32 n1 = (nTime < 0 ? -Get100Sec() : Get100Sec() );
     sal_Int32 n2 = (rTime.nTime < 0 ? -rTime.Get100Sec() : rTime.Get100Sec() );
@@ -327,7 +327,7 @@ Time Time::GetUTCOffset()
     if ( aDateTime.timezone != -1  )
     {
         short nTempTime = (short)Abs( aDateTime.timezone );
-        Time aTime( 0, (USHORT)nTempTime );
+        Time aTime( 0, (sal_uInt16)nTempTime );
         if ( aDateTime.timezone > 0 )
             aTime = -aTime;
         return aTime;
@@ -343,14 +343,14 @@ Time Time::GetUTCOffset()
         nTempTime += aTimeZone.StandardBias;
     else if ( nTimeZoneRet == TIME_ZONE_ID_DAYLIGHT )
         nTempTime += aTimeZone.DaylightBias;
-    Time aTime( 0, (USHORT)Abs( nTempTime ) );
+    Time aTime( 0, (sal_uInt16)Abs( nTempTime ) );
     if ( nTempTime > 0 )
         aTime = -aTime;
     return aTime;
 #else
-    static ULONG    nCacheTicks = 0;
+    static sal_uIntPtr  nCacheTicks = 0;
     static sal_Int32    nCacheSecOffset = -1;
-    ULONG           nTicks = Time::GetSystemTicks();
+    sal_uIntPtr         nTicks = Time::GetSystemTicks();
     time_t          nTime;
     tm              aTM;
     sal_Int32           nLocalTime;
@@ -382,7 +382,7 @@ Time Time::GetUTCOffset()
     }
 
     nTempTime = (short)Abs( nCacheSecOffset );
-    Time aTime( 0, (USHORT)nTempTime );
+    Time aTime( 0, (sal_uInt16)nTempTime );
     if ( nCacheSecOffset < 0 )
         aTime = -aTime;
     return aTime;
@@ -392,14 +392,14 @@ Time Time::GetUTCOffset()
 
 // -----------------------------------------------------------------------
 
-ULONG Time::GetSystemTicks()
+sal_uIntPtr Time::GetSystemTicks()
 {
 #if defined WNT
-    return (ULONG)GetTickCount();
+    return (sal_uIntPtr)GetTickCount();
 #elif defined( OS2 )
-    ULONG nClock;
+    sal_uIntPtr nClock;
     DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, &nClock, sizeof( nClock ) );
-    return (ULONG)nClock;
+    return (sal_uIntPtr)nClock;
 #else
     timeval tv;
     gettimeofday (&tv, 0);
@@ -409,37 +409,37 @@ ULONG Time::GetSystemTicks()
     fTicks += ((tv.tv_usec + 500) / 1000);
 
     fTicks = fmod (fTicks, double(ULONG_MAX));
-    return ULONG(fTicks);
+    return sal_uIntPtr(fTicks);
 #endif
 }
 
 // -----------------------------------------------------------------------
 
-ULONG Time::GetProcessTicks()
+sal_uIntPtr Time::GetProcessTicks()
 {
 #if defined WNT
-    return (ULONG)GetTickCount();
+    return (sal_uIntPtr)GetTickCount();
 #elif defined( OS2 )
-    ULONG nClock;
+    sal_uIntPtr nClock;
     DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, &nClock, sizeof( nClock ) );
-    return (ULONG)nClock;
+    return (sal_uIntPtr)nClock;
 #else
-    static ULONG    nImplTicksPerSecond = 0;
+    static sal_uIntPtr  nImplTicksPerSecond = 0;
     static double   dImplTicksPerSecond;
     static double   dImplTicksULONGMAX;
-    ULONG           nTicks = (ULONG)clock();
+    sal_uIntPtr         nTicks = (sal_uIntPtr)clock();
 
     if ( !nImplTicksPerSecond )
     {
         nImplTicksPerSecond = CLOCKS_PER_SEC;
         dImplTicksPerSecond = nImplTicksPerSecond;
-        dImplTicksULONGMAX  = (double)(ULONG)ULONG_MAX;
+        dImplTicksULONGMAX  = (double)(sal_uIntPtr)ULONG_MAX;
     }
 
     double fTicks = nTicks;
     fTicks *= 1000;
     fTicks /= dImplTicksPerSecond;
     fTicks = fmod (fTicks, dImplTicksULONGMAX);
-    return (ULONG)fTicks;
+    return (sal_uIntPtr)fTicks;
 #endif
 }