removetooltypes: #i112600# remove tooltypes

27 files changed, 868 insertions, 868 deletions

diff --git a/soldep/bootstrp/dep.cxx b/soldep/bootstrp/dep.cxx
index fb4edcc998bc..1178e1d09475 100644
--- a/soldep/bootstrp/dep.cxx
+++ b/soldep/bootstrp/dep.cxx
@@ -35,8 +35,8 @@ SByteExtStringList::~SByteExtStringList()
 {
     if (bDeleteStrings)
         while( Count()) {
-            delete GetObject((ULONG)0);
-            Remove((ULONG)0);
+            delete GetObject((sal_uIntPtr)0);
+            Remove((sal_uIntPtr)0);
         }
 }
 
@@ -55,8 +55,8 @@ void VersionDepInfo::Clear()
 /*****************************************************************************/
 {
     while( Count()) {
-        delete GetObject((ULONG)0);
-        Remove((ULONG)0);
+        delete GetObject((sal_uIntPtr)0);
+        Remove((sal_uIntPtr)0);
     }
 }
 
diff --git a/soldep/bootstrp/hashtbl.cxx b/soldep/bootstrp/hashtbl.cxx
index b6f9b0b7826a..e9455e75f454 100644
--- a/soldep/bootstrp/hashtbl.cxx
+++ b/soldep/bootstrp/hashtbl.cxx
@@ -43,16 +43,16 @@ class HashItem
 public:
     HashItem() { m_Tag = TAG_EMPTY; m_pObject = NULL; }
 
-    BOOL IsDeleted() const
+    sal_Bool IsDeleted() const
     {   return m_Tag == TAG_DELETED; }
 
-    BOOL IsEmpty() const
+    sal_Bool IsEmpty() const
     {   return m_Tag == TAG_DELETED || m_Tag == TAG_EMPTY; }
 
-    BOOL IsFree() const
+    sal_Bool IsFree() const
     {   return m_Tag == TAG_EMPTY; }
 
-    BOOL IsUsed() const
+    sal_Bool IsUsed() const
     {   return m_Tag == TAG_USED; }
 
     void Delete()
@@ -78,7 +78,7 @@ public:
 /*static*/ double HashTable::m_defMaxLoadFactor = 0.8;
 /*static*/ double HashTable::m_defDefGrowFactor = 2.0;
 
-HashTable::HashTable(ULONG lSize, BOOL bOwner, double dMaxLoadFactor, double dGrowFactor)
+HashTable::HashTable(sal_uIntPtr lSize, sal_Bool bOwner, double dMaxLoadFactor, double dGrowFactor)
 {
     m_lSize          = lSize;
     m_bOwner         = bOwner;
@@ -107,7 +107,7 @@ HashTable::~HashTable()
     /*
     if (m_bOwner)
     {
-        for (ULONG i=0; i<GetSize(); i++)
+        for (sal_uIntPtr i=0; i<GetSize(); i++)
         {
             void *pObject = GetObjectAt(i);
 
@@ -121,7 +121,7 @@ HashTable::~HashTable()
     delete [] m_pData;
 }
 
-void* HashTable::GetObjectAt(ULONG lPos) const
+void* HashTable::GetObjectAt(sal_uIntPtr lPos) const
 // Gibt Objekt zurück, wenn es eines gibt, sonst NULL;
 {
     DBG_ASSERT(lPos<m_lSize, "HashTable::GetObjectAt()");
@@ -136,16 +136,16 @@ void HashTable::OnDeleteObject(void*)
     DBG_ERROR("HashTable::OnDeleteObject(void*) nicht überladen");
 }
 
-ULONG HashTable::Hash(ByteString const& Key) const
+sal_uIntPtr HashTable::Hash(ByteString const& Key) const
 {
     /*
-    ULONG lHash = 0;
-    ULONG i,n;
+    sal_uIntPtr lHash = 0;
+    sal_uIntPtr i,n;
 
     for (i=0,n=Key.Len(); i<n; i++)
     {
         lHash *= 256L;
-        lHash += (ULONG)(USHORT)Key.GetStr()[i];
+        lHash += (sal_uIntPtr)(sal_uInt16)Key.GetStr()[i];
         lHash %= m_lSize;
     }
     return lHash;
@@ -153,13 +153,13 @@ ULONG HashTable::Hash(ByteString const& Key) const
 
     // Hashfunktion von P.J. Weinberger
     // aus dem "Drachenbuch" von Aho/Sethi/Ullman
-    ULONG i,n;
-    ULONG h = 0;
-    ULONG g = 0;
+    sal_uIntPtr i,n;
+    sal_uIntPtr h = 0;
+    sal_uIntPtr g = 0;
 
     for (i=0,n=Key.Len(); i<n; i++)
     {
-        h = (h<<4) + (ULONG)(USHORT)Key.GetBuffer()[i];
+        h = (h<<4) + (sal_uIntPtr)(sal_uInt16)Key.GetBuffer()[i];
         g = h & 0xf0000000;
 
         if (g != 0)
@@ -172,15 +172,15 @@ ULONG HashTable::Hash(ByteString const& Key) const
     return h % m_lSize;
 }
 
-ULONG HashTable::DHash(ByteString const& Key, ULONG lOldHash) const
+sal_uIntPtr HashTable::DHash(ByteString const& Key, sal_uIntPtr lOldHash) const
 {
-    ULONG lHash = lOldHash;
-    ULONG i,n;
+    sal_uIntPtr lHash = lOldHash;
+    sal_uIntPtr i,n;
 
     for (i=0,n=Key.Len(); i<n; i++)
     {
         lHash *= 256L;
-        lHash += (ULONG)(USHORT)Key.GetBuffer()[i];
+        lHash += (sal_uIntPtr)(sal_uInt16)Key.GetBuffer()[i];
         lHash %= m_lSize;
     }
     return lHash;
@@ -196,19 +196,19 @@ ULONG HashTable::DHash(ByteString const& Key, ULONG lOldHash) const
 */
 }
 
-ULONG HashTable::Probe(ULONG lPos) const
+sal_uIntPtr HashTable::Probe(sal_uIntPtr lPos) const
 // gibt den Folgewert von lPos zurück
 {
     lPos++; if (lPos==m_lSize) lPos=0;
     return lPos;
 }
 
-BOOL HashTable::IsFull() const
+sal_Bool HashTable::IsFull() const
 {
     return m_lElem>=m_lSize;
 }
 
-BOOL HashTable::Insert(ByteString const& Key, void* pObject)
+sal_Bool HashTable::Insert(ByteString const& Key, void* pObject)
 // pre:  Key ist nicht im Dictionary enthalten, sonst return FALSE
 //       Dictionary ist nicht voll, sonst return FALSE
 // post: pObject ist unter Key im Dictionary; m_nElem wurde erhöht
@@ -218,13 +218,13 @@ BOOL HashTable::Insert(ByteString const& Key, void* pObject)
     if (IsFull())
     {
         DBG_ERROR("HashTable::Insert() is full");
-        return FALSE;
+        return sal_False;
     }
 
     if (FindPos(Key) != NULL )
-        return FALSE;
+        return sal_False;
 
-    ULONG     lPos  = Hash(Key);
+    sal_uIntPtr     lPos  = Hash(Key);
     HashItem *pItem = &m_pData[lPos];
 
     // first hashing
@@ -238,7 +238,7 @@ BOOL HashTable::Insert(ByteString const& Key, void* pObject)
         m_aStatistic.m_lSingleHash++;
         #endif
 
-        return TRUE;
+        return sal_True;
     }
 
     // double hashing
@@ -255,7 +255,7 @@ BOOL HashTable::Insert(ByteString const& Key, void* pObject)
         m_aStatistic.m_lDoubleHash++;
         #endif
 
-        return TRUE;
+        return sal_True;
     }
 
     // linear probing
@@ -273,7 +273,7 @@ BOOL HashTable::Insert(ByteString const& Key, void* pObject)
 
     pItem->SetObject(Key, pObject);
     m_lElem++;
-    return TRUE;
+    return sal_True;
 }
 
 HashItem* HashTable::FindPos(ByteString const& Key) const
@@ -285,7 +285,7 @@ HashItem* HashTable::FindPos(ByteString const& Key) const
 {
     // first hashing
     //
-    ULONG     lPos  = Hash(Key);
+    sal_uIntPtr     lPos  = Hash(Key);
     HashItem *pItem = &m_pData[lPos];
 
     if (pItem->IsUsed()
@@ -311,9 +311,9 @@ HashItem* HashTable::FindPos(ByteString const& Key) const
         //
         if (pItem->IsDeleted() || pItem->IsUsed())
         {
-            ULONG n      = 0;
-            BOOL  bFound = FALSE;
-            BOOL  bEnd   = FALSE;
+            sal_uIntPtr n      = 0;
+            sal_Bool  bFound = sal_False;
+            sal_Bool  bEnd   = sal_False;
 
             do
             {
@@ -397,10 +397,10 @@ void HashTable::SmartGrow()
     if (dLoadFactor <= m_dMaxLoadFactor)
         return; // nothing to grow
 
-    ULONG     lOldSize = m_lSize;              // alte Daten sichern
+    sal_uIntPtr     lOldSize = m_lSize;              // alte Daten sichern
     HashItem* pOldData = m_pData;
 
-    m_lSize = ULONG (m_dGrowFactor * m_lSize); // neue Größe
+    m_lSize = sal_uIntPtr (m_dGrowFactor * m_lSize); // neue Größe
     m_pData = new HashItem[m_lSize];           // neue Daten holen
 
     // kein Speicher:
@@ -417,7 +417,7 @@ void HashTable::SmartGrow()
 
     // Umkopieren der Daten
     //
-    for (ULONG i=0; i<lOldSize; i++)
+    for (sal_uIntPtr i=0; i<lOldSize; i++)
     {
         HashItem *pItem = &pOldData[i];
 
@@ -440,13 +440,13 @@ HashTableIterator::HashTableIterator(HashTable const& aTable)
 void* HashTableIterator::GetFirst()
 {
     m_lAt = 0;
-    return FindValidObject(TRUE /* forward */);
+    return FindValidObject(sal_True /* forward */);
 }
 
 void* HashTableIterator::GetLast()
 {
     m_lAt = m_aTable.GetSize() -1;
-    return FindValidObject(FALSE /* backward */);
+    return FindValidObject(sal_False /* backward */);
 }
 
 void* HashTableIterator::GetNext()
@@ -455,7 +455,7 @@ void* HashTableIterator::GetNext()
         return NULL;
 
     m_lAt++;
-    return FindValidObject(TRUE /* forward */);
+    return FindValidObject(sal_True /* forward */);
 }
 
 void* HashTableIterator::GetPrev()
@@ -464,16 +464,16 @@ void* HashTableIterator::GetPrev()
         return NULL;
 
     m_lAt--;
-    return FindValidObject(FALSE /* backward */);
+    return FindValidObject(sal_False /* backward */);
 }
 
-void* HashTableIterator::FindValidObject(BOOL bForward)
+void* HashTableIterator::FindValidObject(sal_Bool bForward)
 // Sucht nach einem vorhandenen Objekt ab der aktuellen
 // Position.
 //
 // pre:  ab inkl. m_lAt soll die Suche beginnen
 // post: if not found then
-//          if bForward == TRUE then
+//          if bForward == sal_True then
 //              m_lAt == m_aTable.GetSize() -1
 //          else
 //              m_lAt == 0
diff --git a/soldep/bootstrp/minormk.cxx b/soldep/bootstrp/minormk.cxx
index acd8478cf11a..489472b9f87a 100644
--- a/soldep/bootstrp/minormk.cxx
+++ b/soldep/bootstrp/minormk.cxx
@@ -108,16 +108,16 @@ MinorMk::MinorMk( GenericInformationList *pList, const ByteString rVersion )
 /*****************************************************************************/
 MinorMk::MinorMk( const ByteString &rMinor, const ByteString &rEnvironment )
 /*****************************************************************************/
-                : bExists( FALSE )
+                : bExists( sal_False )
 {
     ByteString sDelimiter( DirEntry::GetAccessDelimiter(), RTL_TEXTENCODING_ASCII_US );
 
 
     ByteString sSolver( GetEnv( "SOLARVERSION" ));
-    BOOL bNewEnv = TRUE;
+    sal_Bool bNewEnv = sal_True;
     if ( !sSolver.Len()) {
         sSolver = GetEnv( "SOLARVER" );
-        bNewEnv = FALSE;
+        bNewEnv = sal_False;
     }
     ByteString sUPD( GetEnv( "UPD" ));
 
@@ -152,7 +152,7 @@ void MinorMk::ReadMinorMk( const String &rFileName )
 /*****************************************************************************/
 {
     if ( DirEntry( rFileName ).Exists()) {
-        bExists = TRUE;
+        bExists = sal_True;
         SvFileStream aStream( rFileName, STREAM_STD_READ );
         while ( !aStream.IsOpen())
             aStream.Open( rFileName, STREAM_STD_READ );
diff --git a/soldep/bootstrp/prj.cxx b/soldep/bootstrp/prj.cxx
index 746fa091e4b6..793f50e860aa 100644
--- a/soldep/bootstrp/prj.cxx
+++ b/soldep/bootstrp/prj.cxx
@@ -115,7 +115,7 @@ ByteString  SimpleConfig::GetNextLine()
 {
     ByteString aSecStr;
     sal_Bool bStreamOk;
-//  USHORT iret = 0;
+//  sal_uInt16 iret = 0;
     nLine++;
 
     bStreamOk = aFileStream.ReadLine ( aTmpStr );
@@ -127,10 +127,10 @@ ByteString  SimpleConfig::GetNextLine()
     int nLength = aTmpStr.Len();
     if ( bStreamOk && (nLength == 0) )
         return "\t";
-//  USHORT nPos = 0;
-    BOOL bFound = FALSE;
+//  sal_uInt16 nPos = 0;
+    sal_Bool bFound = sal_False;
     ByteString aEraseString;
-    for ( USHORT i = 0; i<= nLength; i++)
+    for ( sal_uInt16 i = 0; i<= nLength; i++)
     {
         if ( aTmpStr.GetChar( i ) == 0x20  && !bFound )
             aTmpStr.SetChar( i, 0x09 );
@@ -139,7 +139,7 @@ ByteString  SimpleConfig::GetNextLine()
 }
 
 /*****************************************************************************/
-ByteString SimpleConfig::GetCleanedNextLine( BOOL bReadComments )
+ByteString SimpleConfig::GetCleanedNextLine( sal_Bool bReadComments )
 /*****************************************************************************/
 {
     sal_Bool bStreamOk;
@@ -348,7 +348,7 @@ CommandData& CommandData::operator<<  ( SvStream& rStream )
     rStream >> nCommand;
     rStream >> nDepth;
 
-    BOOL bDepList;
+    sal_Bool bDepList;
     rStream >> bDepList;
     if (pDepList)
         pDepList->CleanUp();
@@ -364,7 +364,7 @@ CommandData& CommandData::operator<<  ( SvStream& rStream )
         DELETEZ (pDepList);
     }
 
-    BOOL bCommandList;
+    sal_Bool bCommandList;
     rStream >> bCommandList;
     if (pCommandList)
         pCommandList->CleanUp();
@@ -436,7 +436,7 @@ DepInfo& DepInfo::operator<<  ( SvStream& rStream )
     pProject = new ByteString();
     rStream >> *pProject;
 
-    BOOL bModeList;
+    sal_Bool bModeList;
     rStream >> bModeList;
     if (pModeList)
         pModeList->CleanUp();
@@ -490,10 +490,10 @@ SDepInfoList::~SDepInfoList()
 }
 
 /*****************************************************************************/
-ULONG SDepInfoList::IsString( ByteString* pStr )
+sal_uIntPtr SDepInfoList::IsString( ByteString* pStr )
 /*****************************************************************************/
 {
-    ULONG nRet = NOT_THERE;
+    sal_uIntPtr nRet = NOT_THERE;
     if ( (nRet = GetPrevString( pStr )) != 0 )
     {
         ByteString* pString = GetObject( nRet )->GetProject();
@@ -514,16 +514,16 @@ ULONG SDepInfoList::IsString( ByteString* pStr )
 }
 
 /*****************************************************************************/
-ULONG SDepInfoList::GetPrevString( ByteString* pStr )
+sal_uIntPtr SDepInfoList::GetPrevString( ByteString* pStr )
 /*****************************************************************************/
 {
-    ULONG nRet = 0;
-    BOOL bFound = FALSE;
-    ULONG nCount_l = Count();
-    ULONG nUpper = nCount_l;
-    ULONG nLower = 0;
-    ULONG nCurrent = nUpper / 2;
-    ULONG nRem = 0;
+    sal_uIntPtr nRet = 0;
+    sal_Bool bFound = sal_False;
+    sal_uIntPtr nCount_l = Count();
+    sal_uIntPtr nUpper = nCount_l;
+    sal_uIntPtr nLower = 0;
+    sal_uIntPtr nCurrent = nUpper / 2;
+    sal_uIntPtr nRem = 0;
     ByteString* pString;
 
     do
@@ -584,7 +584,7 @@ void SDepInfoList::PutModeString( DepInfo* pInfoList, ByteString* pStr )
 }
 
 /*****************************************************************************/
-ULONG SDepInfoList::PutString( ByteString* pStr)
+sal_uIntPtr SDepInfoList::PutString( ByteString* pStr)
 /*****************************************************************************/
 {
     return PutString( pStr, NULL);
@@ -597,7 +597,7 @@ ULONG SDepInfoList::PutString( ByteString* pStr)
 *
 **************************************************************************/
 
-ULONG SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
+sal_uIntPtr SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
 {
     if (pAllModeList)
     {
@@ -605,7 +605,7 @@ ULONG SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
         pAllModeList = NULL;
     }
 
-    ULONG nPos = GetPrevString ( pStr );
+    sal_uIntPtr nPos = GetPrevString ( pStr );
     if ( Count() )
     {
         {
@@ -621,9 +621,9 @@ ULONG SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
                         PutModeString(pInfo, pModeStr);
                     else
                         pInfo->SetAllModes();
-                    Insert( pInfo, (ULONG)0 );
+                    Insert( pInfo, (sal_uIntPtr)0 );
                 }
-                return (ULONG)0;
+                return (sal_uIntPtr)0;
             }
         }
         ByteString* pString = GetObject( nPos )->GetProject();
@@ -663,7 +663,7 @@ ULONG SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
             else
                 pInfo->SetAllModes();
             Insert( pInfo);
-            return (ULONG)0;
+            return (sal_uIntPtr)0;
         }
     }
 
@@ -677,7 +677,7 @@ ULONG SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
 ByteString* SDepInfoList::RemoveString( const ByteString& rName )
 /*****************************************************************************/
 {
-    ULONG i;
+    sal_uIntPtr i;
     ByteString* pReturn;
     if (pAllModeList)
     {
@@ -732,9 +732,9 @@ SByteStringList* SDepInfoList::GetAllDepModes()
 SDepInfoList& SDepInfoList::operator<< ( SvStream& rStream )
 /*****************************************************************************/
 {
-    ULONG nCount_l;
+    sal_uIntPtr nCount_l;
     rStream >> nCount_l;
-    for ( USHORT i = 0; i < nCount_l; i++ ) {
+    for ( sal_uInt16 i = 0; i < nCount_l; i++ ) {
         DepInfo* pDepInfo = new DepInfo();
         *pDepInfo << rStream;
         Insert (pDepInfo, LIST_APPEND);
@@ -746,7 +746,7 @@ SDepInfoList& SDepInfoList::operator<< ( SvStream& rStream )
 SDepInfoList& SDepInfoList::operator>> ( SvStream& rStream )
 /*****************************************************************************/
 {
-    ULONG nCount_l = Count();
+    sal_uIntPtr nCount_l = Count();
     rStream << nCount_l;
     DepInfo* pDepInfo = First();
     while (pDepInfo) {
@@ -758,7 +758,7 @@ SDepInfoList& SDepInfoList::operator>> ( SvStream& rStream )
 }
 
 /*****************************************************************************/
-CommandData* Prj::GetDirectoryList ( USHORT nWhatOS, USHORT nCommand )
+CommandData* Prj::GetDirectoryList ( sal_uInt16 nWhatOS, sal_uInt16 nCommand )
 /*****************************************************************************/
 {
     return (CommandData *)NULL;
@@ -770,8 +770,8 @@ CommandData* Prj::GetDirectoryData( ByteString aLogFileName )
 {
     PrjList* pPrjList = GetCommandDataList ();
     CommandData *pData = NULL;
-    ULONG nCount_l = pPrjList->Count();
-    for ( ULONG i=0; i<nCount_l; i++ )
+    sal_uIntPtr nCount_l = pPrjList->Count();
+    for ( sal_uIntPtr i=0; i<nCount_l; i++ )
     {
         pData = pPrjList->GetObject(i);
         if ( pData->GetLogFile() == aLogFileName )
@@ -789,14 +789,14 @@ Prj::Prj() :
     pPrjInitialDepList(0),
     pPrjDepList(0),
     pPrjDepInfoList(0),
-    bSorted( FALSE ),
-    bHardDependencies( FALSE ),
-    bFixedDependencies( FALSE ),
-    bVisited( FALSE ),
-    bIsAvailable( TRUE ),
+    bSorted( sal_False ),
+    bHardDependencies( sal_False ),
+    bFixedDependencies( sal_False ),
+    bVisited( sal_False ),
+    bIsAvailable( sal_True ),
     pTempCommandDataList (0),
-    bTempCommandDataListPermanent (FALSE),
-    bError (FALSE)
+    bTempCommandDataListPermanent (sal_False),
+    bError (sal_False)
 /*****************************************************************************/
 {
 }
@@ -807,14 +807,14 @@ Prj::Prj( ByteString aName ) :
     pPrjInitialDepList(0),
     pPrjDepList(0),
     pPrjDepInfoList(0),
-    bSorted( FALSE ),
-    bHardDependencies( FALSE ),
-    bFixedDependencies( FALSE ),
-    bVisited( FALSE ),
-    bIsAvailable( TRUE ),
+    bSorted( sal_False ),
+    bHardDependencies( sal_False ),
+    bFixedDependencies( sal_False ),
+    bVisited( sal_False ),
+    bIsAvailable( sal_True ),
     pTempCommandDataList (0),
-    bTempCommandDataListPermanent (FALSE),
-    bError (FALSE)
+    bTempCommandDataListPermanent (sal_False),
+    bError (sal_False)
 /*****************************************************************************/
 {
 }
@@ -892,7 +892,7 @@ void Prj::AddDependencies( ByteString aStr, ByteString aModeStr )
 }
 
 /*****************************************************************************/
-SByteStringList* Prj::GetDependencies( BOOL bExpanded )
+SByteStringList* Prj::GetDependencies( sal_Bool bExpanded )
 /*****************************************************************************/
 {
     if ( bExpanded )
@@ -934,7 +934,7 @@ void Prj::SetMode(SByteStringList* pModList)
         }
         else
         {
-            BOOL bStringFound = FALSE;
+            sal_Bool bStringFound = sal_False;
             SByteStringList * pDepList = pInfo->GetModeList();
             ByteString *pModString = pDepList->First();
             while ( pModString )
@@ -948,7 +948,7 @@ void Prj::SetMode(SByteStringList* pModList)
                         pPrjInitialDepList->PutString( new ByteString((ByteString) *(pInfo->GetProject())));
                         //pPrjDepList->PutString( pInfo->GetProject());
                         //pPrjInitialDepList->PutString( pInfo->GetProject());
-                        bStringFound = TRUE;
+                        bStringFound = sal_True;
                         break;
                     }
                     pDefModString = pModList->Next();
@@ -965,8 +965,8 @@ void Prj::SetMode(SByteStringList* pModList)
 }
 
 /*****************************************************************************/
-BOOL Prj::InsertDirectory ( ByteString aDirName, USHORT aWhat,
-                                USHORT aWhatOS, ByteString aLogFileName,
+sal_Bool Prj::InsertDirectory ( ByteString aDirName, sal_uInt16 aWhat,
+                                sal_uInt16 aWhatOS, ByteString aLogFileName,
                                 const ByteString &rClientRestriction )
 /*****************************************************************************/
 {
@@ -981,7 +981,7 @@ BOOL Prj::InsertDirectory ( ByteString aDirName, USHORT aWhat,
     PrjList* pPrjList = GetCommandDataList ();
     pPrjList->Insert( pData );
 
-    return FALSE;
+    return sal_False;
 }
 
 /*****************************************************************************/
@@ -992,12 +992,12 @@ CommandData* Prj::RemoveDirectory ( ByteString aLogFileName )
 /*****************************************************************************/
 {
     PrjList* pPrjList = GetCommandDataList ();
-    ULONG nCount_l = pPrjList->Count();
+    sal_uIntPtr nCount_l = pPrjList->Count();
     CommandData* pData;
     CommandData* pDataFound = NULL;
     SByteStringList* pDataDeps;
 
-    for ( USHORT i = 0; i < nCount_l; i++ )
+    for ( sal_uInt16 i = 0; i < nCount_l; i++ )
     {
         pData = pPrjList->GetObject( i );
         if ( pData->GetLogFile() == aLogFileName )
@@ -1008,8 +1008,8 @@ CommandData* Prj::RemoveDirectory ( ByteString aLogFileName )
             if ( pDataDeps )
             {
                 ByteString* pString;
-                ULONG nDataDepsCount = pDataDeps->Count();
-                for ( ULONG j = nDataDepsCount; j > 0; j-- )
+                sal_uIntPtr nDataDepsCount = pDataDeps->Count();
+                for ( sal_uIntPtr j = nDataDepsCount; j > 0; j-- )
                 {
                     pString = pDataDeps->GetObject( j - 1 );
                     if ( pString->GetToken( 0, '.') == aLogFileName )
@@ -1028,7 +1028,7 @@ CommandData* Prj::RemoveDirectory ( ByteString aLogFileName )
 void Prj::ExtractDependencies()
 /*****************************************************************************/
 {
-    ULONG nPos = 0;
+    sal_uIntPtr nPos = 0;
     CommandData* pData = GetObject(nPos);
     while (pData)
     {
@@ -1129,7 +1129,7 @@ Prj& Prj::operator>>  ( SvStream& rStream )
     else
         rStream << sal_False;
 
-    ULONG nCount_l = Count();
+    sal_uIntPtr nCount_l = Count();
     rStream << nCount_l;
 
     CommandData* pData = First();
@@ -1154,7 +1154,7 @@ Prj& Prj::operator<<  ( SvStream& rStream )
     rStream >> bIsAvailable;
     rStream >> bError;
 
-    BOOL bDepList;
+    sal_Bool bDepList;
     rStream >> bDepList;
     DELETEZ (pPrjDepInfoList);
     if (bDepList)
@@ -1163,10 +1163,10 @@ Prj& Prj::operator<<  ( SvStream& rStream )
         *pPrjDepInfoList << rStream;
     }
 
-    ULONG nCount_l;
+    sal_uIntPtr nCount_l;
     rStream >> nCount_l;
 
-    for ( USHORT i = 0; i < nCount_l; i++ ) {
+    for ( sal_uInt16 i = 0; i < nCount_l; i++ ) {
         CommandData* pData = new CommandData();
         *pData << rStream;
         Insert (pData, LIST_APPEND);
@@ -1190,7 +1190,7 @@ Star::Star()
 }
 
 /*****************************************************************************/
-Star::Star(String aFileName, USHORT nMode )
+Star::Star(String aFileName, sal_uInt16 nMode )
 /*****************************************************************************/
                 : nStarMode( nMode ),
                 sFileName( aFileName ),
@@ -1217,12 +1217,12 @@ Star::Star(GenericInformationList *pStandLst, ByteString &rVersion )
                 : pDepMode (NULL),
                 pAllDepMode (NULL)
 {
-    UpdateFileList (pStandLst, rVersion, TRUE );
+    UpdateFileList (pStandLst, rVersion, sal_True );
 }
 
 /*****************************************************************************/
 void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion,
-    BOOL bRead )
+    sal_Bool bRead )
 /*****************************************************************************/
 {
     sSourceRoot=String::CreateFromAscii(""); // clear old SourceRoot
@@ -1233,7 +1233,7 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
 #else
     sPath += "/settings/SOLARLIST";
 #endif
-    GenericInformation *pInfo = pStandLst->GetInfo( sPath, TRUE );
+    GenericInformation *pInfo = pStandLst->GetInfo( sPath, sal_True );
 
     if( pInfo && pInfo->GetValue().Len()) {
         ByteString sFile( pInfo->GetValue());
@@ -1248,17 +1248,17 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
         sPath = rVersion;
         sPath += "/drives";
 
-        GenericInformation *pInfo_l = pStandLst->GetInfo( sPath, TRUE );
+        GenericInformation *pInfo_l = pStandLst->GetInfo( sPath, sal_True );
         if ( pInfo_l && pInfo_l->GetSubList())  {
             GenericInformationList *pDrives = pInfo_l->GetSubList();
-            for ( ULONG i = 0; i < pDrives->Count(); i++ ) {
+            for ( sal_uIntPtr i = 0; i < pDrives->Count(); i++ ) {
                 GenericInformation *pDrive = pDrives->GetObject( i );
                 if ( pDrive ) {
                     DirEntry aEntry;
-                    BOOL bOk = FALSE;
+                    sal_Bool bOk = sal_False;
                     if ( sSourceRoot.Len()) {
                         aEntry = DirEntry( sSourceRoot );
-                        bOk = TRUE;
+                        bOk = sal_True;
                     }
                     else {
 #ifdef UNX
@@ -1267,10 +1267,10 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
                         if ( pUnixVolume ) {
                             String sRoot( pUnixVolume->GetValue(), RTL_TEXTENCODING_ASCII_US );
                             aEntry = DirEntry( sRoot );
-                            bOk = TRUE;
+                            bOk = sal_True;
                          }
 #else
-                        bOk = TRUE;
+                        bOk = sal_True;
                         String sRoot( *pDrive, RTL_TEXTENCODING_ASCII_US );
                         sRoot += String::CreateFromAscii( "\\" );
                         aEntry = DirEntry( sRoot );
@@ -1278,12 +1278,12 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
                     }
                     if ( bOk ) {
                         sPath = "projects";
-                        GenericInformation *pProjectsKey = pDrive->GetSubInfo( sPath, TRUE );
+                        GenericInformation *pProjectsKey = pDrive->GetSubInfo( sPath, sal_True );
                         if ( pProjectsKey ) {
                             if ( !sSourceRoot.Len()) {
                                 sPath = rVersion;
                                 sPath += "/settings/PATH";
-                                GenericInformation *pPath = pStandLst->GetInfo( sPath, TRUE );
+                                GenericInformation *pPath = pStandLst->GetInfo( sPath, sal_True );
                                 if( pPath ) {
                                     ByteString sAddPath( pPath->GetValue());
 #ifdef UNX
@@ -1297,10 +1297,10 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
                             }
                             sPath = rVersion;
                             sPath += "/settings/SHORTPATH";
-                            GenericInformation *pShortPath = pStandLst->GetInfo( sPath, TRUE );
-                            BOOL bShortPath = FALSE;
+                            GenericInformation *pShortPath = pStandLst->GetInfo( sPath, sal_True );
+                            sal_Bool bShortPath = sal_False;
                             if (pShortPath && (pShortPath->GetValue() == "_TRUE"))
-                                bShortPath = TRUE;
+                                bShortPath = sal_True;
                             sSourceRoot = aEntry.GetFull();
                             GenericInformationList *pProjects = pProjectsKey->GetSubList();
                             if ( pProjects ) {
@@ -1341,7 +1341,7 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
             ClearCurrentDeps();
             ClearLoadedFilesList();
             RemoveAllPrj();
-            bRead = TRUE; // read new list because old list is deleted
+            bRead = sal_True; // read new list because old list is deleted
         }
 
         if (bRead)
@@ -1353,7 +1353,7 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
 
 /*****************************************************************************/
 void Star::FullReload( GenericInformationList *pStandLst, ByteString &rVersion,
-    BOOL bRead )
+    sal_Bool bRead )
 /*****************************************************************************/
 {
     ClearAvailableDeps();
@@ -1364,29 +1364,29 @@ void Star::FullReload( GenericInformationList *pStandLst, ByteString &rVersion,
 }
 
 /*****************************************************************************/
-BOOL Star::CheckFileLoadList(SolarFileList *pSolarFiles)
+sal_Bool Star::CheckFileLoadList(SolarFileList *pSolarFiles)
 /*****************************************************************************/
 {
-    BOOL bRet = TRUE;
+    sal_Bool bRet = sal_True;
     if (aLoadedFilesList.Count() == 0)
         return bRet;
     StarFile * pLoadFile = aLoadedFilesList.First();
     while (pLoadFile)
     {
-        BOOL bIsAvailable = FALSE;
+        sal_Bool bIsAvailable = sal_False;
         String * pFile = pSolarFiles->First();
         while (pFile)
         {
             if (*pFile == pLoadFile->GetName())
             {
-                bIsAvailable = TRUE;
+                bIsAvailable = sal_True;
                 break;
             }
             pFile = pSolarFiles->Next();
         }
         if (!bIsAvailable)
         {
-            bRet = FALSE;
+            bRet = sal_False;
             break;
         }
         pLoadFile = aLoadedFilesList.Next();
@@ -1410,9 +1410,9 @@ void Star::GenerateFileLoadList( SolarFileList *pSolarFiles )
 {
     SolarFileList* pNewSolarFiles = NULL;
     while(  pSolarFiles->Count()) {
-        StarFile *pFile = new StarFile( *pSolarFiles->GetObject(( ULONG ) 0 ));
+        StarFile *pFile = new StarFile( *pSolarFiles->GetObject(( sal_uIntPtr ) 0 ));
         aMutex.acquire();
-        ULONG nPos = SearchFileEntry(&aLoadedFilesList, pFile);
+        sal_uIntPtr nPos = SearchFileEntry(&aLoadedFilesList, pFile);
         if ( nPos == LIST_ENTRY_NOTFOUND )
         {
             if (!pNewSolarFiles)
@@ -1421,7 +1421,7 @@ void Star::GenerateFileLoadList( SolarFileList *pSolarFiles )
             pNewSolarFiles->Insert(new String(pFile->GetName()), LIST_APPEND );
         }
         aMutex.release();
-        delete pSolarFiles->Remove(( ULONG ) 0 );
+        delete pSolarFiles->Remove(( sal_uIntPtr ) 0 );
         delete pFile;
     }
     delete pSolarFiles;
@@ -1435,7 +1435,7 @@ SolarFileList* Star::NeedsFilesForUpdate()
 {
     aMutex.acquire();
     SolarFileList* pPrjList = NULL;
-    for ( ULONG i = 0; i < aLoadedFilesList.Count(); i++ )
+    for ( sal_uIntPtr i = 0; i < aLoadedFilesList.Count(); i++ )
         if ( aLoadedFilesList.GetObject( i )->NeedsUpdate()) {
             if (!pPrjList)
                 pPrjList = new SolarFileList();
@@ -1448,18 +1448,18 @@ SolarFileList* Star::NeedsFilesForUpdate()
 }
 
 /*****************************************************************************/
-BOOL Star::NeedsUpdate()
+sal_Bool Star::NeedsUpdate()
 /*****************************************************************************/
 {
     aMutex.acquire();
-    for ( ULONG i = 0; i < aLoadedFilesList.Count(); i++ )
+    for ( sal_uIntPtr i = 0; i < aLoadedFilesList.Count(); i++ )
         if ( aLoadedFilesList.GetObject( i )->NeedsUpdate()) {
             aMutex.release();
-            return TRUE;
+            return sal_True;
         }
 
     aMutex.release();
-    return FALSE;
+    return sal_False;
 }
 
 /*****************************************************************************/
@@ -1476,28 +1476,28 @@ void Star::Read( String &rFileName )
     sSourceRoot = aEntry.GetFull();
 
     while( aFileList.Count()) {
-        String ssFileName = *aFileList.GetObject(( ULONG ) 0 );
+        String ssFileName = *aFileList.GetObject(( sal_uIntPtr ) 0 );
         StarFile* pFile = ReadBuildlist (ssFileName);
         aMutex.acquire();
         ReplaceFileEntry (&aLoadedFilesList, pFile);
         //aLoadedFilesList.Insert( pFile, LIST_APPEND );
         aMutex.release();
-        aFileList.Remove(( ULONG ) 0 );
+        aFileList.Remove(( sal_uIntPtr ) 0 );
     }
     // resolve all dependencies recursive
     Expand_Impl();
 }
 
 /*****************************************************************************/
-ULONG Star::SearchFileEntry( StarFileList *pStarFiles, StarFile* pFile )
+sal_uIntPtr Star::SearchFileEntry( StarFileList *pStarFiles, StarFile* pFile )
 /*****************************************************************************/
 {
     StarFile *pSearchFile;
-    ULONG nCount_l;
+    sal_uIntPtr nCount_l;
 
     nCount_l = pStarFiles->Count();
 
-    for ( ULONG i=0; i<nCount_l; i++)
+    for ( sal_uIntPtr i=0; i<nCount_l; i++)
     {
         pSearchFile = pStarFiles->GetObject(i);
         if ( pSearchFile->GetName() == pFile->GetName() )
@@ -1512,7 +1512,7 @@ ULONG Star::SearchFileEntry( StarFileList *pStarFiles, StarFile* pFile )
 void Star::ReplaceFileEntry( StarFileList *pStarFiles, StarFile* pFile )
 /*****************************************************************************/
 {
-    ULONG nPos = SearchFileEntry(pStarFiles, pFile);
+    sal_uIntPtr nPos = SearchFileEntry(pStarFiles, pFile);
     if ( nPos != LIST_ENTRY_NOTFOUND )
     {
         StarFile* pTmpStarFile = pStarFiles->GetObject(nPos);
@@ -1531,7 +1531,7 @@ void Star::Read( SolarFileList *pSolarFiles )
     while(  pSolarFiles->Count()) {
         ByteString aString;
 
-        String ssFileName = *pSolarFiles->GetObject(( ULONG ) 0 );
+        String ssFileName = *pSolarFiles->GetObject(( sal_uIntPtr ) 0 );
         StarFile *pFile = ReadBuildlist ( ssFileName);
 
         if ( pFile->Exists()) {
@@ -1543,7 +1543,7 @@ void Star::Read( SolarFileList *pSolarFiles )
                 ByteString aPrjName = ByteString( aEntryPrj.GetName(), gsl_getSystemTextEncoding());
                 Prj* pPrj = GetPrj(aPrjName);
                 if (pPrj)
-                    pPrj->IsAvailable (FALSE);
+                    pPrj->IsAvailable (sal_False);
             }
 
         }
@@ -1552,7 +1552,7 @@ void Star::Read( SolarFileList *pSolarFiles )
         ReplaceFileEntry (&aLoadedFilesList, pFile);
         //aLoadedFilesList.Insert( pFile,   LIST_APPEND );
         aMutex.release();
-        delete pSolarFiles->Remove(( ULONG ) 0 );
+        delete pSolarFiles->Remove(( sal_uIntPtr ) 0 );
     }
     delete pSolarFiles;
 
@@ -1607,7 +1607,7 @@ void Star::InsertSolarList( String sProject )
     // inserts a new solarlist part of another project
     String sFileName_l( CreateFileName( sProject, sSourceRoot ));
 
-    for ( ULONG i = 0; i < aFileList.Count(); i++ ) {
+    for ( sal_uIntPtr i = 0; i < aFileList.Count(); i++ ) {
         if (( *aFileList.GetObject( i )) == sFileName_l )
             return;
     }
@@ -1626,14 +1626,14 @@ void Star::ExpandPrj_Impl( Prj *pPrj, Prj *pDepPrj )
     if ( pDepPrj->bVisited )
         return;
 
-    pDepPrj->bVisited = TRUE;
+    pDepPrj->bVisited = sal_True;
 
     SByteStringList* pPrjLst = pPrj->GetDependencies();
     SByteStringList* pDepLst = NULL;
     ByteString* pDepend;
     ByteString* pPutStr;
     Prj *pNextPrj = NULL;
-    ULONG i, nRetPos;
+    sal_uIntPtr i, nRetPos;
 
     if ( pPrjLst ) {
         pDepLst = pDepPrj->GetDependencies();
@@ -1657,9 +1657,9 @@ void Star::ExpandPrj_Impl( Prj *pPrj, Prj *pDepPrj )
 void Star::Expand_Impl()
 /*****************************************************************************/
 {
-    for ( ULONG i = 0; i < Count(); i++ ) {
-        for ( ULONG j = 0; j < Count(); j++ )
-            GetObject( j )->bVisited = FALSE;
+    for ( sal_uIntPtr i = 0; i < Count(); i++ ) {
+        for ( sal_uIntPtr j = 0; j < Count(); j++ )
+            GetObject( j )->bVisited = sal_False;
 
         Prj* pPrj = GetObject( i );
         pPrj->SetMode(pDepMode); // DepList für Mode initialisieren
@@ -1668,7 +1668,7 @@ void Star::Expand_Impl()
 }
 
 /*****************************************************************************/
-StarFile* Star::ReadBuildlist (const String& rFilename, BOOL bReadComments, BOOL bExtendAlias)
+StarFile* Star::ReadBuildlist (const String& rFilename, sal_Bool bReadComments, sal_Bool bExtendAlias)
 /*****************************************************************************/
 {
     ByteString sFileName_l(rFilename, RTL_TEXTENCODING_ASCII_US);
@@ -1698,10 +1698,10 @@ void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const By
     ByteString aWhat, aWhatOS,
         sClientRestriction, aLogFileName, aProjectName, aPrefix, aCommandPara;
     ByteString aDirName;
-    BOOL bPrjDep = FALSE;
-    BOOL bHardDep = FALSE;
-    BOOL bFixedDep = FALSE;
-    BOOL bNewProject = FALSE;
+    sal_Bool bPrjDep = sal_False;
+    sal_Bool bHardDep = sal_False;
+    sal_Bool bFixedDep = sal_False;
+    sal_Bool bNewProject = sal_False;
     int nCommandType=0, nOSType=0;
     Prj* pPrj = *ppPrj;
     CommandData* pCmdData;
@@ -1741,30 +1741,30 @@ void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const By
             case 2:
                     if ( sToken.CompareTo(":") == COMPARE_EQUAL )
                     {
-                        bPrjDep = TRUE;
-                        bHardDep = FALSE;
-                        bFixedDep = FALSE;
+                        bPrjDep = sal_True;
+                        bHardDep = sal_False;
+                        bFixedDep = sal_False;
                         i = 9;
                     }
                     else if ( sToken.CompareTo("::") == COMPARE_EQUAL )
                     {
-                        bPrjDep = TRUE;
-                        bHardDep = TRUE;
-                        bFixedDep = FALSE;
+                        bPrjDep = sal_True;
+                        bHardDep = sal_True;
+                        bFixedDep = sal_False;
                         i = 9;
                     }
                     else if ( sToken.CompareTo(":::") == COMPARE_EQUAL )
                     {
-                        bPrjDep = TRUE;
-                        bHardDep = TRUE;
-                        bFixedDep = TRUE;
+                        bPrjDep = sal_True;
+                        bHardDep = sal_True;
+                        bFixedDep = sal_True;
                         i = 9;
                     }
                     else
                     {
-                        bPrjDep = FALSE;
-                        bHardDep = FALSE;
-                        bFixedDep = FALSE;
+                        bPrjDep = sal_False;
+                        bHardDep = sal_False;
+                        bFixedDep = sal_False;
 
                         aWhat = sToken;
                         nCommandType = GetJobType(aWhat);
@@ -1837,24 +1837,24 @@ void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const By
                         {
                             // Liste zu Ende
                             i = -1;
-                            bPrjDep= FALSE;
+                            bPrjDep= sal_False;
                         }
                         else
                         {
                             ByteString sMode;
-                            BOOL bHasModes = FALSE;
+                            sal_Bool bHasModes = sal_False;
                             if (aItem.Search(":") != STRING_NOTFOUND)
                             {
                                 sMode = aItem.GetToken ( 0, ':');
                                 aItem = aItem.GetToken ( 1, ':');
-                                bHasModes = TRUE;
+                                bHasModes = sal_True;
                             }
                             if (!pPrj)
                             {
                                 // neues Project anlegen
                                 pPrj = new Prj ( aProjectName );
                                 pPrj->SetPreFix( aPrefix );
-                                bNewProject = TRUE;
+                                bNewProject = sal_True;
                             }
                             if (bHasModes)
                                 pPrj->AddDependencies( aItem, sMode );
@@ -1879,7 +1879,7 @@ void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const By
             // neues Project anlegen
             pPrj = new Prj ( aProjectName );
             pPrj->SetPreFix( aPrefix );
-            bNewProject = TRUE;
+            bNewProject = sal_True;
         }
 
         if (bNewProject)
@@ -1909,7 +1909,7 @@ void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const By
             // new project to set the error flag
             pPrj = new Prj ( rProjectName );
             pPrj->SetPreFix( aPrefix );
-            bNewProject = TRUE;
+            bNewProject = sal_True;
         }
         if (pPrj)
         {
@@ -1924,7 +1924,7 @@ void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const By
 }
 
 /*****************************************************************************/
-BOOL Star::HasProject ( ByteString aProjectName )
+sal_Bool Star::HasProject ( ByteString aProjectName )
 /*****************************************************************************/
 {
     Prj *pPrj;
@@ -1936,9 +1936,9 @@ BOOL Star::HasProject ( ByteString aProjectName )
     {
         pPrj = GetObject(i);
         if ( pPrj->GetProjectName().ToLowerAscii() == aProjectName.ToLowerAscii() )
-            return TRUE;
+            return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
 /*****************************************************************************/
@@ -1958,16 +1958,16 @@ Prj* Star::GetPrj ( ByteString aProjectName )
 }
 
 /*****************************************************************************/
-BOOL Star::RemovePrj ( Prj* pPrj )
+sal_Bool Star::RemovePrj ( Prj* pPrj )
 /*****************************************************************************/
 {
-    ULONG nPos = GetPos(pPrj);
+    sal_uIntPtr nPos = GetPos(pPrj);
     if (nPos != LIST_ENTRY_NOTFOUND) {
         delete pPrj;
         Remove(nPos);
-        return TRUE;
+        return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
 /*****************************************************************************/
@@ -1990,7 +1990,7 @@ ByteString Star::GetPrjName( DirEntry &aPath )
     ByteString aRetPrj, aDirName;
     ByteString aFullPathName = ByteString( aPath.GetFull(), gsl_getSystemTextEncoding());
 
-    USHORT nToken = aFullPathName.GetTokenCount(PATH_DELIMETER);
+    sal_uInt16 nToken = aFullPathName.GetTokenCount(PATH_DELIMETER);
     for ( int i=0; i< nToken; i++ )
     {
         aDirName = aFullPathName.GetToken( i, PATH_DELIMETER );
@@ -2144,13 +2144,13 @@ void Star::SetCurrentDeps (SByteStringList* pDepList)
 //          FullByteStringListWrapper aProducts = mpXmlBuildList->getProducts();
 //          ByteString aDepType = ByteString(DEP_MD_ALWAYS_STR);
 //          if (mpXmlBuildList->hasModuleDepType(aProducts, aDepType))
-//              pPrj->HasHardDependencies( TRUE );
+//              pPrj->HasHardDependencies( sal_True );
 //
 //          aDepType = ByteString(DEP_MD_FORCE_STR);
 //          if (mpXmlBuildList->hasModuleDepType(aProducts, aDepType))
 //          {
-//              pPrj->HasHardDependencies( TRUE );
-//              pPrj->HasFixedDependencies( TRUE );
+//              pPrj->HasHardDependencies( sal_True );
+//              pPrj->HasFixedDependencies( sal_True );
 //          }
 //
 //          // modul dependencies
@@ -2293,7 +2293,7 @@ int Star::GetJobType ( ByteString& JobType ) {
     else if ( JobType == "get" )
         nCommandType = COMMAND_GET;
     else {
-        ULONG nOffset = JobType.Copy( 3 ).ToInt32();
+        sal_uIntPtr nOffset = JobType.Copy( 3 ).ToInt32();
         nCommandType = COMMAND_USER_START + nOffset - 1;
     }
     return nCommandType;
@@ -2306,7 +2306,7 @@ void Star::PutPrjIntoStream (SByteStringList* pPrjNameList, SvStream* pStream)
     aMutex.acquire();
     *pStream << sal_False; // not full Star / only some Projects
 
-    ULONG nCount_l = pPrjNameList->Count();
+    sal_uIntPtr nCount_l = pPrjNameList->Count();
     *pStream << nCount_l;
     ByteString* pStr = pPrjNameList->First();
     while (pStr) {
@@ -2332,7 +2332,7 @@ Star& Star::operator>>  ( SvStream& rStream )
     else
         rStream << sal_False;
 
-    ULONG nCount_l = Count();
+    sal_uIntPtr nCount_l = Count();
     rStream << nCount_l;
     Prj* pPrj = First();
     while (pPrj) {
@@ -2349,12 +2349,12 @@ Star& Star::operator<<  ( SvStream& rStream )
 /*****************************************************************************/
 {
     aMutex.acquire();
-    BOOL bFullList;
+    sal_Bool bFullList;
     rStream >> bFullList;
     if (bFullList)
     {
         rStream >> nStarMode;
-        BOOL bDepMode;
+        sal_Bool bDepMode;
         rStream >> bDepMode;
         if (pDepMode)
             pDepMode->CleanUp();
@@ -2368,9 +2368,9 @@ Star& Star::operator<<  ( SvStream& rStream )
             DELETEZ (pDepMode);
 
     }
-    ULONG nCount_l;
+    sal_uIntPtr nCount_l;
     rStream >> nCount_l;
-    for ( USHORT i = 0; i < nCount_l; i++ ) {
+    for ( sal_uInt16 i = 0; i < nCount_l; i++ ) {
         Prj* pPrj = new Prj();
         *pPrj << rStream;
         pPrj->SetMode(pDepMode);
@@ -2394,7 +2394,7 @@ Star& Star::operator<<  ( SvStream& rStream )
 //
 
 /*****************************************************************************/
-StarWriter::StarWriter( String aFileName, BOOL bReadComments, USHORT nMode )
+StarWriter::StarWriter( String aFileName, sal_Bool bReadComments, sal_uInt16 nMode )
 /*****************************************************************************/
                 : Star ()
 {
@@ -2403,7 +2403,7 @@ StarWriter::StarWriter( String aFileName, BOOL bReadComments, USHORT nMode )
 }
 
 /*****************************************************************************/
-StarWriter::StarWriter( SolarFileList *pSolarFiles, BOOL bReadComments )
+StarWriter::StarWriter( SolarFileList *pSolarFiles, sal_Bool bReadComments )
 /*****************************************************************************/
                 : Star ()
 {
@@ -2412,7 +2412,7 @@ StarWriter::StarWriter( SolarFileList *pSolarFiles, BOOL bReadComments )
 
 /*****************************************************************************/
 StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
-    ByteString &rMinor, BOOL bReadComments )
+    ByteString &rMinor, sal_Bool bReadComments )
 /*****************************************************************************/
                 : Star ()
 {
@@ -2423,7 +2423,7 @@ StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
 #else
     sPath += "/settings/SOLARLIST";
 #endif
-    GenericInformation *pInfo_l = pStandLst->GetInfo( sPath, TRUE );
+    GenericInformation *pInfo_l = pStandLst->GetInfo( sPath, sal_True );
 
     if( pInfo_l && pInfo_l->GetValue().Len()) {
         ByteString sFile( pInfo_l->GetValue());
@@ -2437,17 +2437,17 @@ StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
         sPath = rVersion;
         sPath += "/drives";
 
-        GenericInformation *pInfo_k = pStandLst->GetInfo( sPath, TRUE );
+        GenericInformation *pInfo_k = pStandLst->GetInfo( sPath, sal_True );
         if ( pInfo_k && pInfo_k->GetSubList())  {
             GenericInformationList *pDrives = pInfo_k->GetSubList();
-            for ( ULONG i = 0; i < pDrives->Count(); i++ ) {
+            for ( sal_uIntPtr i = 0; i < pDrives->Count(); i++ ) {
                 GenericInformation *pDrive = pDrives->GetObject( i );
                 if ( pDrive ) {
                     DirEntry aEntry;
-                    BOOL bOk = FALSE;
+                    sal_Bool bOk = sal_False;
                     if ( sSourceRoot.Len()) {
                         aEntry = DirEntry( sSourceRoot );
-                        bOk = TRUE;
+                        bOk = sal_True;
                     }
                     else {
 #ifdef UNX
@@ -2456,10 +2456,10 @@ StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
                         if ( pUnixVolume ) {
                             String sRoot( pUnixVolume->GetValue(), RTL_TEXTENCODING_ASCII_US );
                             aEntry = DirEntry( sRoot );
-                            bOk = TRUE;
+                            bOk = sal_True;
                          }
 #else
-                        bOk = TRUE;
+                        bOk = sal_True;
                         String sRoot( *pDrive, RTL_TEXTENCODING_ASCII_US );
                         sRoot += String::CreateFromAscii( "\\" );
                         aEntry = DirEntry( sRoot );
@@ -2467,12 +2467,12 @@ StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
                     }
                     if ( bOk ) {
                         sPath = "projects";
-                        GenericInformation *pProjectsKey = pDrive->GetSubInfo( sPath, TRUE );
+                        GenericInformation *pProjectsKey = pDrive->GetSubInfo( sPath, sal_True );
                         if ( pProjectsKey ) {
                             if ( !sSourceRoot.Len()) {
                                 sPath = rVersion;
                                 sPath += "/settings/PATH";
-                                GenericInformation *pPath = pStandLst->GetInfo( sPath, TRUE );
+                                GenericInformation *pPath = pStandLst->GetInfo( sPath, sal_True );
                                 if( pPath ) {
                                     ByteString sAddPath( pPath->GetValue());
 #ifdef UNX
@@ -2492,10 +2492,10 @@ StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
                             }
                             sPath = rVersion;
                             sPath += "/settings/SHORTPATH";
-                            GenericInformation *pShortPath = pStandLst->GetInfo( sPath, TRUE );
-                            BOOL bShortPath = FALSE;
+                            GenericInformation *pShortPath = pStandLst->GetInfo( sPath, sal_True );
+                            sal_Bool bShortPath = sal_False;
                             if (pShortPath && (pShortPath->GetValue() == "_TRUE"))
-                                bShortPath = TRUE;
+                                bShortPath = sal_True;
                             sSourceRoot = aEntry.GetFull();
                             GenericInformationList *pProjects = pProjectsKey->GetSubList();
                             if ( pProjects ) {
@@ -2548,7 +2548,7 @@ void StarWriter::CleanUp()
 }
 
 /*****************************************************************************/
-USHORT StarWriter::Read( String aFileName, BOOL bReadComments, USHORT nMode  )
+sal_uInt16 StarWriter::Read( String aFileName, sal_Bool bReadComments, sal_uInt16 nMode  )
 /*****************************************************************************/
 {
     sFileName = aFileName;
@@ -2564,12 +2564,12 @@ USHORT StarWriter::Read( String aFileName, BOOL bReadComments, USHORT nMode  )
     sSourceRoot = aEntry.GetFull();
 
     while( aFileList.Count()) {
-        String ssFileName = *aFileList.GetObject(( ULONG ) 0 );
-        StarFile* pFile = ReadBuildlist (ssFileName, bReadComments, FALSE);
+        String ssFileName = *aFileList.GetObject(( sal_uIntPtr ) 0 );
+        StarFile* pFile = ReadBuildlist (ssFileName, bReadComments, sal_False);
         aMutex.acquire();
         aLoadedFilesList.Insert( pFile, LIST_APPEND );
         aMutex.release();
-        delete aFileList.Remove(( ULONG ) 0 );
+        delete aFileList.Remove(( sal_uIntPtr ) 0 );
     }
     // resolve all dependencies recursive
     Expand_Impl();
@@ -2580,7 +2580,7 @@ USHORT StarWriter::Read( String aFileName, BOOL bReadComments, USHORT nMode  )
 }
 
 /*****************************************************************************/
-USHORT StarWriter::Read( SolarFileList *pSolarFiles, BOOL bReadComments )
+sal_uInt16 StarWriter::Read( SolarFileList *pSolarFiles, sal_Bool bReadComments )
 /*****************************************************************************/
 {
     nStarMode = STAR_MODE_MULTIPLE_PARSE;
@@ -2588,12 +2588,12 @@ USHORT StarWriter::Read( SolarFileList *pSolarFiles, BOOL bReadComments )
     // this ctor is used by StarBuilder to get the information for the whole workspace
     while(  pSolarFiles->Count()) {
         ByteString aString;
-        String ssFileName = *pSolarFiles->GetObject(( ULONG ) 0 );
-        StarFile* pFile = ReadBuildlist(ssFileName, bReadComments, FALSE);
+        String ssFileName = *pSolarFiles->GetObject(( sal_uIntPtr ) 0 );
+        StarFile* pFile = ReadBuildlist(ssFileName, bReadComments, sal_False);
         aMutex.acquire();
         aLoadedFilesList.Insert( pFile, LIST_APPEND );
         aMutex.release();
-        delete pSolarFiles->Remove(( ULONG ) 0 );
+        delete pSolarFiles->Remove(( sal_uIntPtr ) 0 );
     }
     delete pSolarFiles;
 
@@ -2602,7 +2602,7 @@ USHORT StarWriter::Read( SolarFileList *pSolarFiles, BOOL bReadComments )
 }
 
 /*****************************************************************************/
-USHORT StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
+sal_uInt16 StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
 /*****************************************************************************/
 {
     ByteString aDataString;
@@ -2616,7 +2616,7 @@ USHORT StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
     if ( pPrj->Count() > 0 )
     {
         pCmdData = pPrj->First();
-        if ( (pPrjDepList = pPrj->GetDependencies( FALSE )) )
+        if ( (pPrjDepList = pPrj->GetDependencies( sal_False )) )
         {
             aDataString = pPrj->GetPreFix();
             aDataString += aTab;
@@ -2629,7 +2629,7 @@ USHORT StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
             else
                 aDataString+= ByteString(":");
             aDataString += aTab;
-            for ( USHORT i = 0; i< pPrjDepList->Count(); i++ ) {
+            for ( sal_uInt16 i = 0; i< pPrjDepList->Count(); i++ ) {
                 aDataString += *pPrjDepList->GetObject( i );
                 aDataString += aSpace;
             }
@@ -2649,7 +2649,7 @@ USHORT StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
 
                     aDataString+= pCmdData->GetPath();
                     aDataString += aTab;
-                    USHORT nPathLen = pCmdData->GetPath().Len();
+                    sal_uInt16 nPathLen = pCmdData->GetPath().Len();
                     if ( nPathLen < 40 )
                         for ( int i = 0; i < 9 - pCmdData->GetPath().Len() / 4 ; i++ )
                             aDataString += aTab;
@@ -2676,7 +2676,7 @@ USHORT StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
 
                     pCmdDepList = pCmdData->GetDependencies();
                     if ( pCmdDepList )
-                        for ( USHORT i = 0; i< pCmdDepList->Count(); i++ ) {
+                        for ( sal_uInt16 i = 0; i< pCmdDepList->Count(); i++ ) {
                             aDataString += *pCmdDepList->GetObject( i );
                             aDataString += aSpace;
                     }
@@ -2693,12 +2693,12 @@ USHORT StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
 }
 
 /*****************************************************************************/
-USHORT StarWriter::Write( String aFileName )
+sal_uInt16 StarWriter::Write( String aFileName )
 /*****************************************************************************/
 {
     sFileName = aFileName;
 
-    FileStat::SetReadOnlyFlag( DirEntry( aFileName ), FALSE );
+    FileStat::SetReadOnlyFlag( DirEntry( aFileName ), sal_False );
 
     SvFileStream aFileStream;
 
@@ -2726,7 +2726,7 @@ USHORT StarWriter::Write( String aFileName )
 }
 
 /*****************************************************************************/
-USHORT StarWriter::WriteMultiple( String rSourceRoot )
+sal_uInt16 StarWriter::WriteMultiple( String rSourceRoot )
 /*****************************************************************************/
 {
     sSourceRoot = rSourceRoot;
@@ -2746,7 +2746,7 @@ USHORT StarWriter::WriteMultiple( String rSourceRoot )
             aEntry += DirEntry( sPrjDir );
             aEntry += DirEntry( sSolarFile );
 
-            FileStat::SetReadOnlyFlag( aEntry, FALSE );
+            FileStat::SetReadOnlyFlag( aEntry, sal_False );
 
             SvFileStream aFileStream;
             aFileStream.Open( aEntry.GetFull(), STREAM_WRITE | STREAM_TRUNC);
@@ -2779,34 +2779,34 @@ void StarWriter::InsertTokenLine ( const ByteString& rTokenLine )
 }
 
 /*****************************************************************************/
-BOOL StarWriter::InsertProject ( Prj* /*pNewPrj*/ )
+sal_Bool StarWriter::InsertProject ( Prj* /*pNewPrj*/ )
 /*****************************************************************************/
 {
-    return FALSE;
+    return sal_False;
 }
 
 /*****************************************************************************/
 Prj* StarWriter::RemoveProject ( ByteString aProjectName )
 /*****************************************************************************/
 {
-    ULONG nCount_l = Count();
+    sal_uIntPtr nCount_l = Count();
     Prj* pPrj;
     Prj* pPrjFound = NULL;
     SByteStringList* pPrjDeps;
 
-    for ( USHORT i = 0; i < nCount_l; i++ )
+    for ( sal_uInt16 i = 0; i < nCount_l; i++ )
     {
         pPrj = GetObject( i );
         if ( pPrj->GetProjectName() == aProjectName )
             pPrjFound = pPrj;
         else
         {
-            pPrjDeps = pPrj->GetDependencies( FALSE );
+            pPrjDeps = pPrj->GetDependencies( sal_False );
             if ( pPrjDeps )
             {
                 ByteString* pString;
-                ULONG nPrjDepsCount = pPrjDeps->Count();
-                for ( ULONG j = nPrjDepsCount; j > 0; j-- )
+                sal_uIntPtr nPrjDepsCount = pPrjDeps->Count();
+                for ( sal_uIntPtr j = nPrjDepsCount; j > 0; j-- )
                 {
                     pString = pPrjDeps->GetObject( j - 1 );
                     if ( pString->GetToken( 0, '.') == aProjectName )
@@ -2832,7 +2832,7 @@ StarFile::StarFile( const String &rFile )
 {
     DirEntry aEntry( aFileName );
     if ( aEntry.Exists()) {
-        bExists = TRUE;
+        bExists = sal_True;
         FileStat aStat( aEntry );
         aDate = aStat.DateModified();
         aTime = aStat.TimeModified();
@@ -2840,23 +2840,23 @@ StarFile::StarFile( const String &rFile )
         aTimeCreated = aStat.TimeCreated();
     }
     else
-        bExists = FALSE;
+        bExists = sal_False;
 }
 
 /*****************************************************************************/
-BOOL StarFile::NeedsUpdate()
+sal_Bool StarFile::NeedsUpdate()
 /*****************************************************************************/
 {
     DirEntry aEntry( aFileName );
     if ( aEntry.Exists()) {
         if ( !bExists ) {
-            bExists = TRUE;
-            return TRUE;
+            bExists = sal_True;
+            return sal_True;
         }
         FileStat aStat( aEntry );
         if (( aStat.DateModified() != aDate ) || ( aStat.TimeModified() != aTime )
             || ( aStat.DateCreated() != aDateCreated ) || ( aStat.TimeCreated() != aTimeCreated ))
-            return TRUE;
+            return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
diff --git a/soldep/bootstrp/prodmap.cxx b/soldep/bootstrp/prodmap.cxx
index 166d111b563b..0c5ce1e66f14 100644
--- a/soldep/bootstrp/prodmap.cxx
+++ b/soldep/bootstrp/prodmap.cxx
@@ -99,44 +99,44 @@ void ProductMapper::CreateProductList( GenericInformationList *pVerList )
         ByteString sDependsOnKey( DEPENDS_ON_KEY );
         ByteString sBasedOnKey( BASED_ON_KEY );
 
-        for ( ULONG i = 0; i < pVersionList->Count(); i++ ) {
+        for ( sal_uIntPtr i = 0; i < pVersionList->Count(); i++ ) {
             GenericInformation *pVersion = pVersionList->GetObject( i );
 
-            GenericInformation *pProducts = pVersion->GetSubInfo( sProductKey, TRUE );
+            GenericInformation *pProducts = pVersion->GetSubInfo( sProductKey, sal_True );
             if ( pProducts ) {
                 ByteString sProducts = pProducts->GetValue();
 
                 ByteString sDependsOn;
-                GenericInformation *pDependsOn = pVersion->GetSubInfo( sDependsOnKey, TRUE );
+                GenericInformation *pDependsOn = pVersion->GetSubInfo( sDependsOnKey, sal_True );
                 if ( pDependsOn )
                     sDependsOn = pDependsOn->GetValue();
 
                 ByteString sBasedOn;
-                GenericInformation *pBasedOn = pVersion->GetSubInfo( sBasedOnKey, TRUE );
+                GenericInformation *pBasedOn = pVersion->GetSubInfo( sBasedOnKey, sal_True );
                 if ( pBasedOn )
                     sBasedOn = pBasedOn->GetValue();
 
-                for ( USHORT x = 0; x < sProducts.GetTokenCount( ';' ); x++ ) {
+                for ( sal_uInt16 x = 0; x < sProducts.GetTokenCount( ';' ); x++ ) {
                     ByteString sProduct( sProducts.GetToken( x, ';' ));
                     if( sProduct.Len()) {
                         if ( !pProductList )
                             pProductList = new GenericInformationList();
 
-                        pProductList->InsertInfo( sProduct, *pVersion, TRUE, TRUE );
+                        pProductList->InsertInfo( sProduct, *pVersion, sal_True, sal_True );
 
-                        for ( USHORT y = 0; y < sDependsOn.GetTokenCount( ';' ); y++ ) {
+                        for ( sal_uInt16 y = 0; y < sDependsOn.GetTokenCount( ';' ); y++ ) {
                             ByteString sDependsOnKey_l = sProduct;
                             sDependsOnKey_l += "/DependsOn/";
                             sDependsOnKey_l += sDependsOn.GetToken( y, ';' );
 
-                            pProductList->InsertInfo( sDependsOnKey_l, "", TRUE, TRUE );
+                            pProductList->InsertInfo( sDependsOnKey_l, "", sal_True, sal_True );
                         }
-                        for ( USHORT z = 0; z < sBasedOn.GetTokenCount( ';' ); z++ ) {
+                        for ( sal_uInt16 z = 0; z < sBasedOn.GetTokenCount( ';' ); z++ ) {
                             ByteString sBasedOnKey_l = sProduct;
                             sBasedOnKey_l += "/BasedOn/";
                             sBasedOnKey_l += sBasedOn.GetToken( z, ';' );
 
-                            pProductList->InsertInfo( sBasedOnKey_l, "", TRUE, TRUE );
+                            pProductList->InsertInfo( sBasedOnKey_l, "", sal_True, sal_True );
                         }
                     }
                 }
@@ -146,7 +146,7 @@ void ProductMapper::CreateProductList( GenericInformationList *pVerList )
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::GetProductInformation(
+sal_uInt16 ProductMapper::GetProductInformation(
     const ByteString &rProduct, GenericInformation *& pProductInfo )
 /*****************************************************************************/
 {
@@ -159,7 +159,7 @@ USHORT ProductMapper::GetProductInformation(
         return PRODUCT_MAPPER_NO_PRODUCT;
 
     ByteString sProductKey( rProduct );
-    pProductInfo = pProductList->GetInfo( sProductKey, TRUE );
+    pProductInfo = pProductList->GetInfo( sProductKey, sal_True );
 
     if ( !pProductInfo )
         return PRODUCT_MAPPER_NO_PRODUCT;
@@ -168,26 +168,26 @@ USHORT ProductMapper::GetProductInformation(
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::PrintDependentTargets(
-    const ByteString &rProduct, USHORT nLevel )
+sal_uInt16 ProductMapper::PrintDependentTargets(
+    const ByteString &rProduct, sal_uInt16 nLevel )
 /*****************************************************************************/
 {
     GenericInformation *pProductInfo;
 
-    USHORT nReturn = GetProductInformation( rProduct, pProductInfo );
+    sal_uInt16 nReturn = GetProductInformation( rProduct, pProductInfo );
 
     if ( nReturn == PRODUCT_MAPPER_OK ) {
-        for ( USHORT i = 0; i < nLevel; i++ )
+        for ( sal_uInt16 i = 0; i < nLevel; i++ )
             fprintf( stdout, "    " );
         fprintf( stdout, "%s (%s)\n", pProductInfo->GetBuffer(),
             pProductInfo->GetValue().GetBuffer());
         aPrintedList.PutString( new ByteString( *pProductInfo ));
 
-        for ( ULONG j = 0; j < pProductList->Count(); j++ ) {
+        for ( sal_uIntPtr j = 0; j < pProductList->Count(); j++ ) {
             GenericInformation *pCandidate = pProductList->GetObject( j );
             ByteString sKey( "DEPENDSON/" );
             sKey += rProduct;
-            GenericInformation *pDependsOn = pCandidate->GetSubInfo( sKey, TRUE );
+            GenericInformation *pDependsOn = pCandidate->GetSubInfo( sKey, sal_True );
             if ( pDependsOn )
                 PrintDependentTargets( *pCandidate, nLevel + 1 );
         }
@@ -197,7 +197,7 @@ USHORT ProductMapper::PrintDependentTargets(
             if ( pBasedOn ) {
                 GenericInformationList *pBases = pBasedOn->GetSubList();
                 if ( pBases ) {
-                    for ( ULONG k = 0; k < pBases->Count(); k++ ) {
+                    for ( sal_uIntPtr k = 0; k < pBases->Count(); k++ ) {
                         aBaseList.PutString( new ByteString( *pBases->GetObject( k )));
                     }
                 }
@@ -209,24 +209,24 @@ USHORT ProductMapper::PrintDependentTargets(
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::PrintAndDeleteBaseList()
+sal_uInt16 ProductMapper::PrintAndDeleteBaseList()
 /*****************************************************************************/
 {
     if ( aBaseList.Count()) {
         fprintf( stdout, "\nbased on\n" );
         while ( aBaseList.Count()) {
-            ByteString sProduct( *aBaseList.GetObject(( ULONG ) 0 ));
-            if ( aPrintedList.IsString( aBaseList.GetObject(( ULONG ) 0 )) == NOT_THERE ) {
-                aPrintedList.PutString( aBaseList.GetObject(( ULONG ) 0 ));
+            ByteString sProduct( *aBaseList.GetObject(( sal_uIntPtr ) 0 ));
+            if ( aPrintedList.IsString( aBaseList.GetObject(( sal_uIntPtr ) 0 )) == NOT_THERE ) {
+                aPrintedList.PutString( aBaseList.GetObject(( sal_uIntPtr ) 0 ));
                 PrintDependentTargets( sProduct );
             }
             else
-                delete aBaseList.GetObject(( ULONG ) 0 );
+                delete aBaseList.GetObject(( sal_uIntPtr ) 0 );
 
-            aBaseList.Remove(( ULONG ) 0 );
+            aBaseList.Remove(( sal_uIntPtr ) 0 );
         }
         while ( aPrintedList.Count())
-            delete aPrintedList.Remove(( ULONG ) 0 );
+            delete aPrintedList.Remove(( sal_uIntPtr ) 0 );
 
         fprintf( stdout, "\n" );
     }
@@ -234,16 +234,16 @@ USHORT ProductMapper::PrintAndDeleteBaseList()
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::PrintDependencies( const ByteString &rProduct )
+sal_uInt16 ProductMapper::PrintDependencies( const ByteString &rProduct )
 /*****************************************************************************/
 {
-    USHORT nResult = PrintDependentTargets( rProduct );
+    sal_uInt16 nResult = PrintDependentTargets( rProduct );
     PrintAndDeleteBaseList();
     return nResult;
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::PrintProductList()
+sal_uInt16 ProductMapper::PrintProductList()
 /*****************************************************************************/
 {
     if ( !pVersionList )
@@ -253,7 +253,7 @@ USHORT ProductMapper::PrintProductList()
         return PRODUCT_MAPPER_NO_PRODUCT;
 
     if ( pProductList->Count()) {
-        for ( ULONG i = 0; i < pProductList->Count(); i++ )
+        for ( sal_uIntPtr i = 0; i < pProductList->Count(); i++ )
             fprintf( stdout, "%s (%s)\n",
                 pProductList->GetObject( i )->GetBuffer(),
                 pProductList->GetObject( i )->GetValue().GetBuffer());
@@ -279,7 +279,7 @@ SByteStringList *ProductMapper::GetMinorList(
             aEntry += DirEntry( sWildcard );
 
             Dir aDir( aEntry, FSYS_KIND_DIR );
-            for ( USHORT i = 0; i < aDir.Count(); i++ ) {
+            for ( sal_uInt16 i = 0; i < aDir.Count(); i++ ) {
                 ByteString sInc( aDir[ i ].GetName(), RTL_TEXTENCODING_ASCII_US );
                 if ( sInc.GetTokenCount( '.' ) > 1 ) {
                     if ( !pList )
@@ -302,7 +302,7 @@ String ProductMapper::GetVersionRoot(
     if ( pVersion ) {
 #ifdef UNX
         sKey = "drives/o:/unixvolume";
-        GenericInformation *pUnixVolume = pVersion->GetSubInfo( sKey, TRUE );
+        GenericInformation *pUnixVolume = pVersion->GetSubInfo( sKey, sal_True );
         ByteString sPath;
         if ( pUnixVolume )
             sPath = pUnixVolume->GetValue();
@@ -311,7 +311,7 @@ String ProductMapper::GetVersionRoot(
         ByteString sPath( "o:\\" );
 #endif
         sKey = "settings/path";
-        GenericInformation *pPath = pVersion->GetSubInfo( sKey, TRUE );
+        GenericInformation *pPath = pVersion->GetSubInfo( sKey, sal_True );
         if ( pPath ) {
             sPath += pPath->GetValue().GetToken( 0, '\\' );
             sPath += "/";
@@ -331,7 +331,7 @@ String ProductMapper::GetVersionRoot(
 
 /*****************************************************************************/
 BaseProductList *ProductMapper::GetBases(
-    GenericInformation *pProductInfo, USHORT nLevel,
+    GenericInformation *pProductInfo, sal_uInt16 nLevel,
     BaseProductList *pBases )
 /*****************************************************************************/
 {
@@ -349,29 +349,29 @@ BaseProductList *ProductMapper::GetBases(
         if ( pBasedOn ) {
             GenericInformationList *pBasesInfo = pBasedOn->GetSubList();
             if ( pBasesInfo ) {
-                for ( ULONG k = 0; k < pBasesInfo->Count(); k++ ) {
+                for ( sal_uIntPtr k = 0; k < pBasesInfo->Count(); k++ ) {
                     GenericInformation *pBaseProduct;
                     if ( GetProductInformation( *pBasesInfo->GetObject( k ), pBaseProduct ) == PRODUCT_MAPPER_OK )
                         GetBases( pBaseProduct, ++ nLevel, pBases );
                 }
             }
         }
-        BOOL bFound = FALSE;
+        sal_Bool bFound = sal_False;
         ByteString sUpperCandidate( sCandidate );
         sUpperCandidate.ToUpperAscii();
-        for ( USHORT i = 0; i < pBases->Count() && !bFound; i++ ) {
+        for ( sal_uInt16 i = 0; i < pBases->Count() && !bFound; i++ ) {
             ByteString sTest( *pBases->GetObject( i ));
             if ( sTest.ToUpperAscii() == sUpperCandidate )
-                bFound = TRUE;
+                bFound = sal_True;
         }
         if ( !bFound )
-            pBases->Insert( new ByteString( sCandidate ), ( ULONG ) 0 );
+            pBases->Insert( new ByteString( sCandidate ), ( sal_uIntPtr ) 0 );
     }
     return pBases;
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::PrintMinorList(
+sal_uInt16 ProductMapper::PrintMinorList(
     const ByteString rProduct, const ByteString rEnvironment )
 /*****************************************************************************/
 {
@@ -389,18 +389,18 @@ USHORT ProductMapper::PrintMinorList(
     BaseProductList *pBases = GetBases( pProductInfo );
     if ( pBases->Count()) {
         if ( pBases->Count() > 1 )
-            fprintf( stdout, "Product \"%s\" based on ", pBases->GetObject(( ULONG ) 0 )->GetBuffer());
+            fprintf( stdout, "Product \"%s\" based on ", pBases->GetObject(( sal_uIntPtr ) 0 )->GetBuffer());
         else
-            fprintf( stdout, "Product \"%s\" based on no other products", pBases->GetObject(( ULONG ) 0 )->GetBuffer());
+            fprintf( stdout, "Product \"%s\" based on no other products", pBases->GetObject(( sal_uIntPtr ) 0 )->GetBuffer());
 
-        for ( ULONG i = 1; i < pBases->Count(); i++ ) {
+        for ( sal_uIntPtr i = 1; i < pBases->Count(); i++ ) {
             fprintf( stdout, "\"%s\"", pBases->GetObject( i )->GetBuffer());
             if ( i < pBases->Count() - 1 )
                 fprintf( stdout, ", " );
         }
         fprintf( stdout, "\n\n" );
     }
-    USHORT nResult = PRODUCT_MAPPER_OK;
+    sal_uInt16 nResult = PRODUCT_MAPPER_OK;
 
     if ( rEnvironment.Len())
         nResult = PrintSingleMinorList( pProductInfo, pBases, rEnvironment );
@@ -408,12 +408,12 @@ USHORT ProductMapper::PrintMinorList(
         ByteString sEnvKey( pProductInfo->GetValue());
         sEnvKey += "/Environments";
 
-        GenericInformation *pEnvironmentInfo = pVersionList->GetInfo( sEnvKey, TRUE );
+        GenericInformation *pEnvironmentInfo = pVersionList->GetInfo( sEnvKey, sal_True );
         if ( pEnvironmentInfo ) {
             GenericInformationList *pEnvironmentList = pEnvironmentInfo->GetSubList();
             if ( pEnvironmentList ) {
-                for ( ULONG i = 0; i < pEnvironmentList->Count(); i++ ) {
-                    USHORT nTmp = PrintSingleMinorList( pProductInfo, pBases, *pEnvironmentList->GetObject( i ));
+                for ( sal_uIntPtr i = 0; i < pEnvironmentList->Count(); i++ ) {
+                    sal_uInt16 nTmp = PrintSingleMinorList( pProductInfo, pBases, *pEnvironmentList->GetObject( i ));
                     if ( nTmp != PRODUCT_MAPPER_OK )
                         nResult = nTmp;
                 }
@@ -421,7 +421,7 @@ USHORT ProductMapper::PrintMinorList(
         }
     }
 
-    for ( ULONG m = 0; m < pBases->Count(); m++ )
+    for ( sal_uIntPtr m = 0; m < pBases->Count(); m++ )
         delete pBases->GetObject( m );
     delete pBases;
 
@@ -429,7 +429,7 @@ USHORT ProductMapper::PrintMinorList(
 }
 
 /*****************************************************************************/
-USHORT ProductMapper::PrintSingleMinorList(
+sal_uInt16 ProductMapper::PrintSingleMinorList(
     GenericInformation *pProductInfo, BaseProductList *pBases,
     const ByteString rEnvironment )
 /*****************************************************************************/
@@ -445,12 +445,12 @@ USHORT ProductMapper::PrintSingleMinorList(
     pMinors->Insert( new ByteString( "" ), LIST_APPEND );
 
     SByteStringList aOutputList;
-    BOOL bUnknownMinor = FALSE;
-    for ( ULONG i = 0; i < pMinors->Count(); i++ ) {
+    sal_Bool bUnknownMinor = sal_False;
+    for ( sal_uIntPtr i = 0; i < pMinors->Count(); i++ ) {
         ByteString sOutput;
         ByteString sProductVersion;
 
-        for ( ULONG j = 0; j < pBases->Count(); j++ ) {
+        for ( sal_uIntPtr j = 0; j < pBases->Count(); j++ ) {
             ByteString sCurProduct( *pBases->GetObject( j ));
             ByteString sVersion( sCurProduct.GetToken( sCurProduct.GetTokenCount( '(' ) - 1, '(' ).GetToken( 0, ')' ));
             if ( !j )
@@ -462,7 +462,7 @@ USHORT ProductMapper::PrintSingleMinorList(
             ByteString sMinor( pMinorMk->GetLastMinor().GetBuffer());
             if ( !sMinor.Len()) {
                 sMinor = "!";
-                bUnknownMinor = TRUE;
+                bUnknownMinor = sal_True;
             }
             if ( j == 0 ) {
                 sOutput += pMinorMk->GetBuildNr();
@@ -487,7 +487,7 @@ USHORT ProductMapper::PrintSingleMinorList(
     if ( aOutputList.Count())
         fprintf( stdout, "Available builds on %s:\n", rEnvironment.GetBuffer());
 
-    for ( ULONG o = 0; o < aOutputList.Count(); o++ ) {
+    for ( sal_uIntPtr o = 0; o < aOutputList.Count(); o++ ) {
         ByteString sOutput( *aOutputList.GetObject( o ));
         sOutput = sOutput.Copy( sOutput.GetToken( 0, ' ' ).Len() + 1 );
 
@@ -505,7 +505,7 @@ USHORT ProductMapper::PrintSingleMinorList(
     else if ( aOutputList.Count())
         fprintf( stdout, "\n" );
 
-    for ( ULONG l = 0; l < pMinors->Count(); l++ )
+    for ( sal_uIntPtr l = 0; l < pMinors->Count(); l++ )
         delete pMinors->GetObject( l );
     delete pMinors;
 
diff --git a/soldep/inc/dep.hxx b/soldep/inc/dep.hxx
index 4e7d4b80ec3e..74bf674203eb 100644
--- a/soldep/inc/dep.hxx
+++ b/soldep/inc/dep.hxx
@@ -33,9 +33,9 @@
 class SByteExtStringList : public SByteStringList
 {
     private:
-        BOOL        bDeleteStrings;
+        sal_Bool        bDeleteStrings;
     public:
-        SByteExtStringList(BOOL bDelete = TRUE) : bDeleteStrings (bDelete) {}
+        SByteExtStringList(sal_Bool bDelete = sal_True) : bDeleteStrings (bDelete) {}
         ~SByteExtStringList();
 };
 
diff --git a/soldep/inc/minormk.hxx b/soldep/inc/minormk.hxx
index 0f14497dbaa7..1f4205cd8981 100644
--- a/soldep/inc/minormk.hxx
+++ b/soldep/inc/minormk.hxx
@@ -41,7 +41,7 @@ private:
     ByteString sBUILD;
     ByteString sLAST_MINOR;
 
-    BOOL bExists;
+    sal_Bool bExists;
 
     void ReadMinorMk( const String &rFileName );
 
@@ -72,6 +72,6 @@ public:
     ByteString GetLastMinor()
         { return sLAST_MINOR; }
 
-    BOOL Exists()
+    sal_Bool Exists()
         { return bExists; }
 };
diff --git a/soldep/inc/prodmap.hxx b/soldep/inc/prodmap.hxx
index ac39b97b5bc3..c0f6ade654cd 100644
--- a/soldep/inc/prodmap.hxx
+++ b/soldep/inc/prodmap.hxx
@@ -52,13 +52,13 @@ private:
     SByteStringList aBaseList;
     SByteStringList aPrintedList;
 
-    USHORT PrintDependentTargets( const ByteString &rProduct, USHORT nLevel = 0 );
-    USHORT PrintAndDeleteBaseList();
+    sal_uInt16 PrintDependentTargets( const ByteString &rProduct, sal_uInt16 nLevel = 0 );
+    sal_uInt16 PrintAndDeleteBaseList();
 
     SByteStringList *GetMinorList( const ByteString &rVersion, const ByteString &rEnvironment );
-    BaseProductList *GetBases( GenericInformation *pProductInfo, USHORT nLevel = 0, BaseProductList *pBases = NULL );
+    BaseProductList *GetBases( GenericInformation *pProductInfo, sal_uInt16 nLevel = 0, BaseProductList *pBases = NULL );
 
-    USHORT PrintSingleMinorList( GenericInformation *pProductInfo, BaseProductList *pBases, const ByteString rEnvironment );
+    sal_uInt16 PrintSingleMinorList( GenericInformation *pProductInfo, BaseProductList *pBases, const ByteString rEnvironment );
 
 public:
     ProductMapper();
@@ -68,11 +68,11 @@ public:
 
     void CreateProductList( GenericInformationList *pVerList );
 
-    USHORT GetProductInformation( const ByteString &rProduct, GenericInformation *& pProductInfo );
-    USHORT PrintDependencies( const ByteString &rProduct );
-    USHORT PrintProductList();
+    sal_uInt16 GetProductInformation( const ByteString &rProduct, GenericInformation *& pProductInfo );
+    sal_uInt16 PrintDependencies( const ByteString &rProduct );
+    sal_uInt16 PrintProductList();
 
-    USHORT PrintMinorList( const ByteString rProduct, const ByteString rEnvironment );
+    sal_uInt16 PrintMinorList( const ByteString rProduct, const ByteString rEnvironment );
 
     static String GetVersionRoot( GenericInformationList *pList, const ByteString &rVersion );
 
diff --git a/soldep/inc/soldep/connctr.hxx b/soldep/inc/soldep/connctr.hxx
index 1982e252acf8..a7dd57d4a6e3 100644
--- a/soldep/inc/soldep/connctr.hxx
+++ b/soldep/inc/soldep/connctr.hxx
@@ -42,13 +42,13 @@ static Rectangle aEmptyRect( Point( 0, 0), Point( 0, 0));
 class Connector
 {
     ObjectWin *mpStartWin, *mpEndWin;
-    ULONG mnStartId, mnEndId;
+    sal_uIntPtr mnStartId, mnEndId;
     Point mStart, mEnd, mCenter;
     DepWin* mpParent;
 
-    BOOL bVisible;
-    BOOL mbHideIndependend;
-    static BOOL msbHideMode;
+    sal_Bool bVisible;
+    sal_Bool mbHideIndependend;
+    static sal_Bool msbHideMode;
 
 
 public:
@@ -56,26 +56,26 @@ public:
     Connector( DepWin* pParent, WinBits nWinStyle );
     ~Connector();
 
-    void    Initialize( ObjectWin* pStartWin, ObjectWin* pEndWin, BOOL bVis = FALSE );
+    void    Initialize( ObjectWin* pStartWin, ObjectWin* pEndWin, sal_Bool bVis = sal_False );
     Point   GetMiddle();
     void    Paint( const Rectangle& rRect );
-    void    UpdatePosition( ObjectWin* pWin, BOOL bPaint = TRUE );
-    USHORT  Save( SvFileStream& rOutFile );
-    USHORT  Load( SvFileStream& rInFile );
-    ULONG   GetStartId(){ return mnStartId; };
-    ULONG   GetEndId(){ return mnEndId; };
+    void    UpdatePosition( ObjectWin* pWin, sal_Bool bPaint = sal_True );
+    sal_uInt16  Save( SvFileStream& rOutFile );
+    sal_uInt16  Load( SvFileStream& rInFile );
+    sal_uIntPtr GetStartId(){ return mnStartId; };
+    sal_uIntPtr GetEndId(){ return mnEndId; };
     ObjectWin*  GetStartWin(){ return mpStartWin; };
     ObjectWin*  GetEndWin(){ return mpEndWin; };
     ObjectWin*  GetOtherWin( ObjectWin* pWin );
-    ULONG   GetOtherId( ULONG nId );
-    ULONG   GetLen();
-    BOOL    IsStart( ObjectWin* pWin );
-    void    SetHideIndependend( BOOL bHide) { mbHideIndependend = bHide; };
+    sal_uIntPtr GetOtherId( sal_uIntPtr nId );
+    sal_uIntPtr GetLen();
+    sal_Bool    IsStart( ObjectWin* pWin );
+    void    SetHideIndependend( sal_Bool bHide) { mbHideIndependend = bHide; };
 
-    BOOL    IsVisible() { return bVisible; }
-    void    SetVisibility( BOOL visible ) { bVisible = visible; }
+    sal_Bool    IsVisible() { return bVisible; }
+    void    SetVisibility( sal_Bool visible ) { bVisible = visible; }
     void    UpdateVisibility();
-    void    SetHideMode(BOOL bHide) { msbHideMode = bHide; };
+    void    SetHideMode(sal_Bool bHide) { msbHideMode = bHide; };
     void    DrawOutput( OutputDevice* pDevice, const Point& rOffset  );
 };
 
diff --git a/soldep/inc/soldep/depper.hxx b/soldep/inc/soldep/depper.hxx
index a9de33c57043..c160c68baffd 100644
--- a/soldep/inc/soldep/depper.hxx
+++ b/soldep/inc/soldep/depper.hxx
@@ -99,9 +99,9 @@ class FixedText;
 
 struct depper_head
 {
-    ULONG nID;
-    ULONG nObjectCount;
-    ULONG nCnctrCount;
+    sal_uIntPtr nID;
+    sal_uIntPtr nObjectCount;
+    sal_uIntPtr nCnctrCount;
 
 };
 
@@ -115,14 +115,14 @@ enum DistType
 
 class Depper : public SolDevDll, public Window
 {
-    BOOL    mbIsPrjView;
-    ULONG   mnMinDynXOffs;
+    sal_Bool    mbIsPrjView;
+    sal_uIntPtr mnMinDynXOffs;
     Point   maDefPos;
     Size    maDefSize;
 
     long    nZoomed;
 
-    ULONG   mnViewMask;
+    sal_uIntPtr mnViewMask;
 
     ProgressBar*    pSubBar;
     ProgressBar*    pMainBar;
@@ -137,10 +137,10 @@ protected:
     SolIdMapper*    mpPrjIdMapper;
     StarWriter*     mpStarWriter;
     StarWriter*     mpPrjStarWriter;        //for inside prj-view
-    ULONG           mnSolWinCount;
-    ULONG           mnSolLastId;
-    ULONG           mnPrjWinCount;
-    ULONG           mnPrjLastId;
+    sal_uIntPtr         mnSolWinCount;
+    sal_uIntPtr         mnSolLastId;
+    sal_uIntPtr         mnPrjWinCount;
+    sal_uIntPtr         mnPrjLastId;
     ObjectList*         mpObjectList;           //Extended ObjWinList class
     ObjectList*         mpObjectPrjList;        //for module internal dependencies
     DepWin*             mpBaseWin;
@@ -149,50 +149,50 @@ protected:
     GraphWin*           mpGraphPrjWin;          //for inside prj-view
     Window*             mpProcessWin;
     Window*             mpParentProcessWin;
-    ObjectWin*          ObjIdToPtr( ObjectList* pObjLst, ULONG nId );
+    ObjectWin*          ObjIdToPtr( ObjectList* pObjLst, sal_uIntPtr nId );
     SoldepToolBox       maToolBox;
     FloatingWindow      maTaskBarFrame; // For ToolBox
 
-    ULONG       AddObjectToList(DepWin* pParentWin, ObjectList* pObjLst, ULONG &LastID, ULONG &WinCount, ByteString& rBodyText, BOOL bInteract=TRUE );
-    ULONG       AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, ULONG &LastID, ULONG &WinCount, ByteString& rBodyText, Point& rPos, Size& rSize );
-    ObjectWin*  RemoveObjectFromList( ObjectList* pObjLst, ULONG &WinCount, USHORT nId, BOOL bDelete );
-    USHORT      AddConnectorToObjects( ObjectList* pObjLst, ULONG nStartId, ULONG nEndId );
-    USHORT      RemoveConnectorFromObjects( ObjectList* pObjLst, ULONG nStartId, ULONG nEndId );
-    USHORT      AddConnectorToObjects( ObjectWin* pStartWin, ObjectWin* pEndWin );
-    USHORT      RemoveConnectorFromObjects( ObjectWin* pStartWin, ObjectWin* pEndWin );
+    sal_uIntPtr       AddObjectToList(DepWin* pParentWin, ObjectList* pObjLst, sal_uIntPtr &LastID, sal_uIntPtr &WinCount, ByteString& rBodyText, sal_Bool bInteract=sal_True );
+    sal_uIntPtr       AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, sal_uIntPtr &LastID, sal_uIntPtr &WinCount, ByteString& rBodyText, Point& rPos, Size& rSize );
+    ObjectWin*  RemoveObjectFromList( ObjectList* pObjLst, sal_uIntPtr &WinCount, sal_uInt16 nId, sal_Bool bDelete );
+    sal_uInt16      AddConnectorToObjects( ObjectList* pObjLst, sal_uIntPtr nStartId, sal_uIntPtr nEndId );
+    sal_uInt16      RemoveConnectorFromObjects( ObjectList* pObjLst, sal_uIntPtr nStartId, sal_uIntPtr nEndId );
+    sal_uInt16      AddConnectorToObjects( ObjectWin* pStartWin, ObjectWin* pEndWin );
+    sal_uInt16      RemoveConnectorFromObjects( ObjectWin* pStartWin, ObjectWin* pEndWin );
 
 public:
     Depper( Window* pBaseWindow );
     ~Depper();
-    BOOL                TogglePrjViewStatus();
-    void                SetPrjViewStatus(BOOL state) { mbIsPrjView = state; }
-    BOOL                IsPrjView() { return mbIsPrjView; }
+    sal_Bool                TogglePrjViewStatus();
+    void                SetPrjViewStatus(sal_Bool state) { mbIsPrjView = state; }
+    sal_Bool                IsPrjView() { return mbIsPrjView; }
     GraphWin*           GetGraphWin() { return (!mbIsPrjView) ? mpGraphWin : mpGraphPrjWin; }   //scrollbar window
     DepWin*             GetDepWin() { return (!mbIsPrjView) ? mpBaseWin : mpBasePrjWin; }       //content of scrollbar window
     ProgressBar*        GetMainProgressBar() { return pMainBar; }
-    void                SetMainProgressBar( USHORT i);
-    void                UpdateMainProgressBar(USHORT i, USHORT nScaleVal, USHORT &nStep, BOOL bCountingDown = FALSE);
-    void                UpdateSubProgrssBar(ULONG i);
+    void                SetMainProgressBar( sal_uInt16 i);
+    void                UpdateMainProgressBar(sal_uInt16 i, sal_uInt16 nScaleVal, sal_uInt16 &nStep, sal_Bool bCountingDown = sal_False);
+    void                UpdateSubProgrssBar(sal_uIntPtr i);
     void                SetTitle( const String &rTitle ) { mpProcessWin->SetText( rTitle ); }
     virtual void        RemoveAllObjects( ObjectList* ObjLst );
-    USHORT              Save( const ByteString& rFileName );
-//  USHORT              Load( const ByteString& rFileName );
-    virtual USHORT      WriteSource();
-    virtual USHORT      ReadSource( BOOL bUpdater );
-    virtual USHORT      OpenSource();
+    sal_uInt16              Save( const ByteString& rFileName );
+//  sal_uInt16              Load( const ByteString& rFileName );
+    virtual sal_uInt16      WriteSource();
+    virtual sal_uInt16      ReadSource( sal_Bool bUpdater );
+    virtual sal_uInt16      OpenSource();
     void                SetDefPos( Point& rPos ) { maDefPos = rPos; };
     Point&              GetDefPos() { return maDefPos; };
     void                SetDefSize( Size& rSize ) { maDefSize = rSize; };
     Size&               GetDefSize() { return maDefSize; };
-    virtual USHORT      AutoArrangeDlgStart();
-    virtual USHORT      AutoArrangeDlgStop();
-    virtual USHORT      Zoom( MapMode& rMapMode );
-    virtual BOOL        ViewContent( ByteString& ) { return FALSE; };
-    virtual USHORT      CloseWindow() { return 0; };
+    virtual sal_uInt16      AutoArrangeDlgStart();
+    virtual sal_uInt16      AutoArrangeDlgStop();
+    virtual sal_uInt16      Zoom( MapMode& rMapMode );
+    virtual sal_Bool        ViewContent( ByteString& ) { return sal_False; };
+    virtual sal_uInt16      CloseWindow() { return 0; };
     virtual void        ShowHelp(){};
     ObjectList*         GetObjectList() { return (!mbIsPrjView) ? mpObjectList : mpObjectPrjList; }
-    ULONG               HandleNewPrjDialog( ByteString &rBodyText );
-    ULONG               HandleNewDirectoryDialog( ByteString &rBodyText );
+    sal_uIntPtr               HandleNewPrjDialog( ByteString &rBodyText );
+    sal_uIntPtr               HandleNewDirectoryDialog( ByteString &rBodyText );
     void                HideObjectsAndConnections( ObjectList* pObjLst );
     void                ShowObjectsAndConnections( ObjectList* pObjLst );
     //virtual void        MouseButtonDown( const MouseEvent& rMEvt );
@@ -201,8 +201,8 @@ public:
     DECL_LINK( PopupSelected, PopupMenu* );
 //#endif
 
-    //void SetViewMask( ULONG nMask );
-    ULONG GetViewMask() { return mnViewMask; }
+    //void SetViewMask( sal_uIntPtr nMask );
+    sal_uIntPtr GetViewMask() { return mnViewMask; }
 };
 
 #endif
diff --git a/soldep/inc/soldep/depwin.hxx b/soldep/inc/soldep/depwin.hxx
index 4464e91aa59a..8e8d123ff73b 100644
--- a/soldep/inc/soldep/depwin.hxx
+++ b/soldep/inc/soldep/depwin.hxx
@@ -43,7 +43,7 @@ private:
     ConnectorList   ConList;
 
     ObjectWin*      mpNewConWin;
-    BOOL            mbStartNewCon;
+    sal_Bool            mbStartNewCon;
     Point           maNewConStart;
     Point           maNewConEnd;
     ObjectWin*      mpSelectedProject;
@@ -64,7 +64,7 @@ public:
     virtual void    Command( const CommandEvent& rEvent);
 //  void            Resize();
     void            MouseMove( const MouseEvent& rMEvt );
-    BOOL            IsStartNewCon() { return mbStartNewCon; };
+    sal_Bool            IsStartNewCon() { return mbStartNewCon; };
     void            SetPopupHdl( void* pHdl );
     void            SetSelectedProject( ObjectWin* object ) { mpSelectedProject = object; };
     ObjectWin*      GetSelectedProject() { return mpSelectedProject; };
diff --git a/soldep/inc/soldep/hashobj.hxx b/soldep/inc/soldep/hashobj.hxx
index 73d4daf699e7..d92737f9ecda 100644
--- a/soldep/inc/soldep/hashobj.hxx
+++ b/soldep/inc/soldep/hashobj.hxx
@@ -35,10 +35,10 @@ class ObjectWin;
 class MyHashObject
 {
     ObjectWin* mpWin;
-    ULONG mnId;
+    sal_uIntPtr mnId;
 public:
-    MyHashObject( ULONG nId, ObjectWin* pWin );
-    ULONG GetId() { return mnId; };
+    MyHashObject( sal_uIntPtr nId, ObjectWin* pWin );
+    sal_uIntPtr GetId() { return mnId; };
 };
 
 #endif
diff --git a/soldep/inc/soldep/hashtbl.hxx b/soldep/inc/soldep/hashtbl.hxx
index 0308a6a33e0e..e955696588b9 100644
--- a/soldep/inc/soldep/hashtbl.hxx
+++ b/soldep/inc/soldep/hashtbl.hxx
@@ -41,16 +41,16 @@ class HashItem;
 
 class HashTable
 {
-    ULONG     m_lSize;
-    ULONG     m_lElem;
+    sal_uIntPtr     m_lSize;
+    sal_uIntPtr     m_lElem;
     HashItem *m_pData;
     double    m_dMaxLoadFactor;
     double    m_dGrowFactor;
-    BOOL      m_bOwner;
+    sal_Bool      m_bOwner;
 
-    ULONG Hash(ByteString const& Key) const;
-    ULONG DHash(ByteString const& Key, ULONG lHash) const;
-    ULONG Probe(ULONG lPos) const;
+    sal_uIntPtr Hash(ByteString const& Key) const;
+    sal_uIntPtr DHash(ByteString const& Key, sal_uIntPtr lHash) const;
+    sal_uIntPtr Probe(sal_uIntPtr lPos) const;
 
     HashItem* FindPos(ByteString const& Key) const;
     void      SmartGrow();
@@ -61,9 +61,9 @@ class HashTable
 private:
     struct
     {
-        ULONG m_lSingleHash;
-        ULONG m_lDoubleHash;
-        ULONG m_lProbe;
+        sal_uIntPtr m_lSingleHash;
+        sal_uIntPtr m_lDoubleHash;
+        sal_uIntPtr m_lProbe;
     }
         m_aStatistic;
 #endif
@@ -73,7 +73,7 @@ protected:
 
     virtual void OnDeleteObject(void* pObject);
 
-    void* GetObjectAt(ULONG lPos) const;
+    void* GetObjectAt(sal_uIntPtr lPos) const;
 
 // Default-Werte
 public:
@@ -83,19 +83,19 @@ public:
 public:
     HashTable
     (
-        ULONG   lSize,
-        BOOL    bOwner,
+        sal_uIntPtr lSize,
+        sal_Bool    bOwner,
         double  dMaxLoadFactor = HashTable::m_defMaxLoadFactor /* 0.8 */,
         double  dGrowFactor = HashTable::m_defDefGrowFactor /* 2.0 */
     );
 
     virtual ~HashTable();
 
-    BOOL  IsFull() const;
-    ULONG GetSize() const { return m_lSize; }
+    sal_Bool  IsFull() const;
+    sal_uIntPtr GetSize() const { return m_lSize; }
 
     void* Find   (ByteString const& Key) const;
-    BOOL  Insert (ByteString const& Key, void* pObject);
+    sal_Bool  Insert (ByteString const& Key, void* pObject);
     void* Delete (ByteString const& Key);
 };
 
@@ -105,10 +105,10 @@ public:
 //
 class HashTableIterator
 {
-    ULONG            m_lAt;
+    sal_uIntPtr          m_lAt;
     HashTable const& m_aTable;
 
-    void* FindValidObject(BOOL bForward);
+    void* FindValidObject(sal_Bool bForward);
 
 protected:
     void* GetFirst(); // Interation _ohne_ Sortierung
@@ -128,7 +128,7 @@ public:
     public:                                                             \
         ClassName                                                       \
         (                                                               \
-            ULONG   lSize,                                              \
+            sal_uIntPtr lSize,                                              \
             double  dMaxLoadFactor = HashTable::m_defMaxLoadFactor,     \
             double  dGrowFactor = HashTable::m_defDefGrowFactor         \
         )                                                               \
@@ -138,7 +138,7 @@ public:
         { return (ObjType) HashTable::Find(ByteString(Key)); }              \
                                                                         \
         using HashTable::Insert;                                        \
-        BOOL Insert (KeyType const& Key, ObjType Object)                \
+        sal_Bool Insert (KeyType const& Key, ObjType Object)                \
         { return HashTable::Insert(ByteString(Key), (void*) Object); }      \
                                                                         \
         ObjType  Delete (KeyType const&Key)                             \
@@ -147,11 +147,11 @@ public:
 
 // HashTable OHNE Owner-Verhalten
 #define DECLARE_HASHTABLE(ClassName,KeyType,ObjType)                 \
-    DECLARE_HASHTABLE_INTERN(ClassName,FALSE,KeyType,ObjType)
+    DECLARE_HASHTABLE_INTERN(ClassName,sal_False,KeyType,ObjType)
 
 // HashTable MIT Owner-Verhalten
 #define DECLARE_HASHTABLE_OWNER(ClassName,KeyType,ObjType)           \
-    DECLARE_HASHTABLE_INTERN(ClassName##2,TRUE,KeyType,ObjType)      \
+    DECLARE_HASHTABLE_INTERN(ClassName##2,sal_True,KeyType,ObjType)      \
     class ClassName : public ClassName##2                            \
     {                                                                \
     protected:                                                       \
@@ -159,7 +159,7 @@ public:
     public:                                                          \
         ClassName                                                    \
         (                                                            \
-            ULONG   lSize,                                           \
+            sal_uIntPtr lSize,                                           \
             double  dMaxLoadFactor = HashTable::m_defMaxLoadFactor,  \
             double  dGrowFactor = HashTable::m_defDefGrowFactor      \
         )                                                            \
@@ -173,7 +173,7 @@ public:
                                                                      \
     ClassName::~ClassName()                                          \
     {                                                                \
-        for (ULONG i=0; i<GetSize(); i++)                            \
+        for (sal_uIntPtr i=0; i<GetSize(); i++)                            \
         {                                                            \
             void *pObject = GetObjectAt(i);                          \
             if (pObject != NULL)                                     \
diff --git a/soldep/inc/soldep/objwin.hxx b/soldep/inc/soldep/objwin.hxx
index b3170a76ce11..20156cd74a3a 100644
--- a/soldep/inc/soldep/objwin.hxx
+++ b/soldep/inc/soldep/objwin.hxx
@@ -59,73 +59,73 @@ class ObjectWin : public Window
     Point       maCalcPos;
     ByteString      msBodyText;
     ByteString      msTipText;
-    ULONG       mnObjectId;
+    sal_uIntPtr     mnObjectId;
     PopupMenu*  mpPopup;
-    USHORT      mnPopupStaticItems;
+    sal_uInt16      mnPopupStaticItems;
     Wallpaper   maObjWallpaper;
     ConnectorList   mConnections;
-    ULONG       mnMarkMode;
-    ULONG       mnViewMask;
-    BOOL        mbVisible;
-    BOOL        mbMenuExecute;
-    static BOOL msbHideMode;
-    static ULONG msnGlobalViewMask;   //will be set by SolDep
+    sal_uIntPtr     mnMarkMode;
+    sal_uIntPtr         mnViewMask;
+    sal_Bool        mbVisible;
+    sal_Bool        mbMenuExecute;
+    static sal_Bool msbHideMode;
+    static sal_uIntPtr msnGlobalViewMask;   //will be set by SolDep
 
 public:
-    BOOL        mbVisited;
+    sal_Bool        mbVisited;
 //  double x, y;
 
-    USHORT mnRootDist;
-    USHORT mnHeadDist;
-    BOOL mbFixed;
+    sal_uInt16 mnRootDist;
+    sal_uInt16 mnHeadDist;
+    sal_Bool mbFixed;
     //Depper*       mpDepperDontuseme;
     Timer   aTipTimer;
 
                     ObjectWin( Window* pParent, WinBits nWinStyle );
                     ~ObjectWin();
-        void            SetHideMode(BOOL bHide);
-        BOOL            ToggleHideMode();
-        BOOL            IsHideMode() { return msbHideMode; };
-        BOOL            IsNullObject() { return (msBodyText == "null"); };
-        void            SetGlobalViewMask(ULONG gvm) { msnGlobalViewMask = gvm; };
+        void            SetHideMode(sal_Bool bHide);
+        sal_Bool            ToggleHideMode();
+        sal_Bool            IsHideMode() { return msbHideMode; };
+        sal_Bool            IsNullObject() { return (msBodyText == "null"); };
+        void            SetGlobalViewMask(sal_uIntPtr gvm) { msnGlobalViewMask = gvm; };
         void            SetBodyText( const ByteString& rNewText );
         ByteString&         GetBodyText();
-        ULONG           GetIdByName( const ByteString& rText );
+        sal_uIntPtr           GetIdByName( const ByteString& rText );
         void            SetTipText( const ByteString& rNewText );
         ByteString&         GetTipText();
-        Point           GetFixPoint( const Point& rRefPoint, BOOL bUseRealPos = TRUE );
+        Point           GetFixPoint( const Point& rRefPoint, sal_Bool bUseRealPos = sal_True );
 
         void            SetCalcPosPixel( const Point& rNewPos ){ maCalcPos = rNewPos; };
         Point           GetCalcPosPixel() const { return maCalcPos; }
 
         void            AddConnector( Connector* pNewCon );
         void            RemoveConnector( Connector* pOldCon );
-        Connector*      GetConnector( ULONG nIndex );
-        Connector*      GetConnector( ULONG nStartId, ULONG nEndId );
-        virtual void    SetMarkMode( ULONG nMarkMode = 0 );
-        virtual void    UnsetMarkMode( ULONG nMarkMode );
-        ULONG           GetMarkMode(){ return mnMarkMode; };
+        Connector*      GetConnector( sal_uIntPtr nIndex );
+        Connector*      GetConnector( sal_uIntPtr nStartId, sal_uIntPtr nEndId );
+        virtual void    SetMarkMode( sal_uIntPtr nMarkMode = 0 );
+        virtual void    UnsetMarkMode( sal_uIntPtr nMarkMode );
+        sal_uIntPtr         GetMarkMode(){ return mnMarkMode; };
         Wallpaper       GetActualWallpaper() { return maObjWallpaper;};
         void            SetActualWallpaper(const Wallpaper& aWp) { maObjWallpaper = aWp;};
-        void            MarkNeeded( BOOL bReset = FALSE );
-        void            MarkDepending( BOOL bReset = FALSE );
+        void            MarkNeeded( sal_Bool bReset = sal_False );
+        void            MarkDepending( sal_Bool bReset = sal_False );
         void            Paint( const Rectangle& rRecct );
         void            MouseButtonDown( const MouseEvent& rMEvt );
         void            MouseButtonUp( const MouseEvent& rMEvt );
         void            MouseMove( const MouseEvent& rMEvt );
 //      void            DoubleClick();
-        USHORT          Save( SvFileStream& rOutFile );
-        USHORT          Load( SvFileStream& rInFile );
-        void            SetId( ULONG nId );
-        ULONG           GetId();
+        sal_uInt16          Save( SvFileStream& rOutFile );
+        sal_uInt16          Load( SvFileStream& rInFile );
+        void            SetId( sal_uIntPtr nId );
+        sal_uIntPtr         GetId();
         void            UpdateConnectors();
         void            SetAllConnectorsUnvisible();
         virtual void    Command( const CommandEvent& rEvent);
 
-        void SetViewMask( ULONG nMask );
-        ULONG GetViewMask() { return mnViewMask; }
+        void SetViewMask( sal_uIntPtr nMask );
+        sal_uIntPtr GetViewMask() { return mnViewMask; }
         using Window::IsVisible;
-        BOOL IsVisible() { return mbVisible; }
+        sal_Bool IsVisible() { return mbVisible; }
 
         DECL_LINK( PopupSelected, PopupMenu * );
         DECL_LINK( PopupDeactivated, PopupMenu * );
@@ -134,9 +134,9 @@ public:
         //virtual void GetFocus();
         virtual void LoseFocus();
 
-        BOOL            ConnectionExistsInAnyDirection( ObjectWin *pWin );
+        sal_Bool            ConnectionExistsInAnyDirection( ObjectWin *pWin );
         void    DrawOutput( OutputDevice* pDevice, const Point& rOffset  );
-        BOOL    IsTop();
+        sal_Bool    IsTop();
 };
 
 DECL_DEST_LIST( TmpObjWinList, ObjWinList, ObjectWin* )
@@ -147,7 +147,7 @@ class ObjectList : public ObjWinList
 private:
     ObjectWin* pSelectedObjectWin;
 protected:
-    BOOL       mbHideMode;
+    sal_Bool       mbHideMode;
 public:
                ObjectList();
                ~ObjectList() {};
diff --git a/soldep/inc/soldep/prj.hxx b/soldep/inc/soldep/prj.hxx
index 7a75c5a1c310..766a89d72237 100644
--- a/soldep/inc/soldep/prj.hxx
+++ b/soldep/inc/soldep/prj.hxx
@@ -83,10 +83,10 @@ class CommandData
     ByteString      sClientRestriction;
     SByteStringList *pDepList;
     SByteStringList *pCommandList;
-    USHORT      nOSType;
-    USHORT      nCommand;
+    sal_uInt16      nOSType;
+    sal_uInt16      nCommand;
 
-    ULONG       nDepth;             // Tiefe der Abhaenigkeit
+    sal_uIntPtr     nDepth;             // Tiefe der Abhaenigkeit
 
 public:
                 CommandData();
@@ -113,19 +113,19 @@ public:
     void        SetPath( ByteString aName ){aPath = aName;}
     ByteString      GetPrePath(){return aPrePath;}
     void        SetPrePath( ByteString aName ){aPrePath = aName;}
-    USHORT      GetOSType(){return nOSType;}
+    sal_uInt16      GetOSType(){return nOSType;}
     ByteString      GetOSTypeString();
-    void        SetOSType( USHORT nType ){nOSType = nType;}
-    USHORT      GetCommandType(){return nCommand;}
+    void        SetOSType( sal_uInt16 nType ){nOSType = nType;}
+    sal_uInt16      GetCommandType(){return nCommand;}
     ByteString      GetCommandTypeString();
-    void        SetCommandType( USHORT nCommandType ){nCommand = nCommandType;}
+    void        SetCommandType( sal_uInt16 nCommandType ){nCommand = nCommandType;}
     SByteStringList* GetDependencies(){return pDepList;}
     void        SetDependencies( SByteStringList *pList ){pDepList = pList;}
     ByteString      GetClientRestriction() { return sClientRestriction; }
     void        SetClientRestriction( ByteString sRestriction ) { sClientRestriction = sRestriction; }
 
     void        AddDepth(){nDepth++;}
-    ULONG       GetDepth(){return nDepth;}
+    sal_uIntPtr     GetDepth(){return nDepth;}
 
     void AddCommand(ByteString* pCommand);
     SByteStringList* GetCommandList() {return pCommandList;}
@@ -155,7 +155,7 @@ public:
                     SimpleConfig(DirEntry& rDirEntry);
                     ~SimpleConfig();
     ByteString          GetNext();
-    ByteString          GetCleanedNextLine( BOOL bReadComments = FALSE );
+    ByteString          GetCleanedNextLine( sal_Bool bReadComments = sal_False );
 };
 
 #define ENV_GUI     0x00000000
@@ -197,14 +197,14 @@ class DepInfo
     private:
         ByteString*         pProject;
         SByteStringList*    pModeList;
-        BOOL                bAllModes;
+        sal_Bool                bAllModes;
 
         void                RemoveProject ();
         void                RemoveModeList ();
     public:
-                            DepInfo() : pProject(0), pModeList(0), bAllModes(FALSE) {}
-                            DepInfo(ByteString* pString) : pProject(0), pModeList(0), bAllModes(FALSE) {pProject = pString;}
-                            DepInfo(ByteString* pString, SByteStringList* pList) : pProject(0), pModeList(0), bAllModes(FALSE) {pProject = pString; pModeList = pList;}
+                            DepInfo() : pProject(0), pModeList(0), bAllModes(sal_False) {}
+                            DepInfo(ByteString* pString) : pProject(0), pModeList(0), bAllModes(sal_False) {pProject = pString;}
+                            DepInfo(ByteString* pString, SByteStringList* pList) : pProject(0), pModeList(0), bAllModes(sal_False) {pProject = pString; pModeList = pList;}
                             ~DepInfo();
 
         void                SetProject (ByteString* pStr);
@@ -212,8 +212,8 @@ class DepInfo
         void                PutModeString (ByteString* pStr);
         SByteStringList*    GetModeList() {return pModeList;}
         void                SetModeList (SByteStringList* pList) {pModeList = pList;}
-        BOOL                IsAllModes() {return bAllModes;}
-        void                SetAllModes(BOOL bModes=TRUE) {bAllModes = bModes;}
+        sal_Bool                IsAllModes() {return bAllModes;}
+        void                SetAllModes(sal_Bool bModes=sal_True) {bAllModes = bModes;}
 
         DepInfo&            operator<<  ( SvStream& rStream );
         DepInfo&            operator>>  ( SvStream& rStream );
@@ -237,19 +237,19 @@ class SDepInfoList : public DepInfoList
                 ~SDepInfoList();
 
                 // neuen ByteString in Liste einfuegen
-    ULONG       PutString( ByteString*, ByteString*);
-    ULONG       PutString( ByteString*);
+    sal_uIntPtr     PutString( ByteString*, ByteString*);
+    sal_uIntPtr     PutString( ByteString*);
     void        PutModeString( DepInfo* pInfoList, ByteString* pStr );
 
     ByteString*     RemoveString( const ByteString& rName );
 
                 // Position des ByteString in Liste, wenn nicht enthalten, dann
                 // return = NOT_THERE
-    ULONG       IsString( ByteString* );
+    sal_uIntPtr     IsString( ByteString* );
 
                 // Vorgaenger ermitteln ( auch wenn selbst noch nicht in
                 // Liste enthalten
-    ULONG       GetPrevString( ByteString* );
+    sal_uIntPtr     GetPrevString( ByteString* );
     SByteStringList*    GetAllDepModes();
 
     SDepInfoList& operator<< ( SvStream& rStream );
@@ -276,16 +276,16 @@ private:
     SByteStringList*    pPrjInitialDepList;
     SByteStringList*    pPrjDepList;
     SDepInfoList*       pPrjDepInfoList;
-    BOOL            bSorted;
-    BOOL            bHardDependencies;
-    BOOL            bFixedDependencies;
-    BOOL            bVisited;
-    BOOL            bIsAvailable;
+    sal_Bool            bSorted;
+    sal_Bool            bHardDependencies;
+    sal_Bool            bFixedDependencies;
+    sal_Bool            bVisited;
+    sal_Bool            bIsAvailable;
     SByteStringList* RemoveStringList(SByteStringList* pStringList );
     SDepInfoList*   RemoveDepInfoList(SDepInfoList* pInfoList );
     PrjList*        pTempCommandDataList;
-    BOOL            bTempCommandDataListPermanent;
-    BOOL            bError;
+    sal_Bool            bTempCommandDataListPermanent;
+    sal_Bool            bError;
 public:
                     Prj();
                     Prj( ByteString aName );
@@ -296,27 +296,27 @@ public:
                             {return aProjectName;}
     void            SetProjectName(ByteString aName)
                             {aProjectName = aName;}
-    BOOL            InsertDirectory( ByteString aDirName , USHORT aWhat,
-                                    USHORT aWhatOS, ByteString aLogFileName,
+    sal_Bool            InsertDirectory( ByteString aDirName , sal_uInt16 aWhat,
+                                    sal_uInt16 aWhatOS, ByteString aLogFileName,
                                     const ByteString &rClientRestriction );
     CommandData*    RemoveDirectory( ByteString aLogFileName );
-    CommandData*    GetDirectoryList ( USHORT nWhatOs, USHORT nCommand );
+    CommandData*    GetDirectoryList ( sal_uInt16 nWhatOs, sal_uInt16 nCommand );
     CommandData*    GetDirectoryData( ByteString aLogFileName );
     inline CommandData* GetData( ByteString aLogFileName )
                             { return GetDirectoryData( aLogFileName ); };
 
-    SByteStringList*    GetDependencies( BOOL bExpanded = TRUE );
+    SByteStringList*    GetDependencies( sal_Bool bExpanded = sal_True );
     SDepInfoList*   GetModeAndDependencies() {return pPrjDepInfoList;}
     void            AddDependencies( ByteString aStr );
     void            AddDependencies( ByteString aStr, ByteString aModeStr );
     void            SetMode(SByteStringList* pModeList);
-    void            HasHardDependencies( BOOL bHard ) { bHardDependencies = bHard; }
-    BOOL            HasHardDependencies() { return bHardDependencies; }
-    void            HasFixedDependencies( BOOL bFixed ) { bFixedDependencies = bFixed; }
-    BOOL            HasFixedDependencies() { return bFixedDependencies; }
+    void            HasHardDependencies( sal_Bool bHard ) { bHardDependencies = bHard; }
+    sal_Bool            HasHardDependencies() { return bHardDependencies; }
+    void            HasFixedDependencies( sal_Bool bFixed ) { bFixedDependencies = bFixed; }
+    sal_Bool            HasFixedDependencies() { return bFixedDependencies; }
 
-    BOOL            IsAvailable() { return bIsAvailable; }
-    void            IsAvailable( BOOL bAvailable ) { bIsAvailable=bAvailable; }
+    sal_Bool            IsAvailable() { return bIsAvailable; }
+    void            IsAvailable( sal_Bool bAvailable ) { bIsAvailable=bAvailable; }
 
     void            ExtractDependencies();
 
@@ -324,12 +324,12 @@ public:
     void            RemoveTempCommandDataList();
     void            GenerateTempCommandDataList();
     void            GenerateEmptyTempCommandDataList();
-    BOOL            HasTempCommandDataList() {return pTempCommandDataList != NULL;}
-    void            SetTempCommandDataListPermanent (BOOL bVar = TRUE) {bTempCommandDataListPermanent = bVar;}
-    BOOL            IsTempCommandDataListPermanent() {return bTempCommandDataListPermanent;}
+    sal_Bool            HasTempCommandDataList() {return pTempCommandDataList != NULL;}
+    void            SetTempCommandDataListPermanent (sal_Bool bVar = sal_True) {bTempCommandDataListPermanent = bVar;}
+    sal_Bool            IsTempCommandDataListPermanent() {return bTempCommandDataListPermanent;}
 
-    void            SetError (BOOL bVar = TRUE) {bError = bVar;}
-    BOOL            HasError () {return bError;}
+    void            SetError (sal_Bool bVar = sal_True) {bError = bVar;}
+    sal_Bool            HasError () {return bError;}
 
     Prj&            operator<<  ( SvStream& rStream );
     Prj&            operator>>  ( SvStream& rStream );
@@ -355,7 +355,7 @@ private:
     Date aDateCreated;
     Time aTimeCreated;
 
-    BOOL bExists;
+    sal_Bool bExists;
 
 public:
     StarFile( const String &rFile );
@@ -363,8 +363,8 @@ public:
     Date GetDate() { return aDate; }
     Time GetTime() { return aTime; }
 
-    BOOL NeedsUpdate();
-    BOOL Exists() { return bExists; }
+    sal_Bool NeedsUpdate();
+    sal_Bool Exists() { return bExists; }
 };
 
 DECLARE_LIST( StarFileList, StarFile * )
@@ -382,7 +382,7 @@ private:
 protected:
     vos:: OMutex  aMutex;
 
-    USHORT          nStarMode;
+    sal_uInt16          nStarMode;
     SolarFileList   aFileList;
     StarFileList    aLoadedFilesList;
     String          sSourceRoot;
@@ -397,12 +397,12 @@ protected:
 
     void            Expand_Impl();
     void            ExpandPrj_Impl( Prj *pPrj, Prj *pDepPrj );
-    ULONG           SearchFileEntry( StarFileList *pStarFiles, StarFile* pFile );
+    sal_uIntPtr         SearchFileEntry( StarFileList *pStarFiles, StarFile* pFile );
     void            InsertTokenLine (const ByteString& rToken, Prj** ppPrj, const ByteString& rProjectName, const sal_Bool bExtendAlias = sal_True);
 
 public:
                     Star();
-                    Star( String aFileName, USHORT nMode = STAR_MODE_SINGLE_PARSE );
+                    Star( String aFileName, sal_uInt16 nMode = STAR_MODE_SINGLE_PARSE );
                     Star( SolarFileList *pSolarFiles );
                     Star( GenericInformationList *pStandLst, ByteString &rVersion );
 
@@ -417,22 +417,22 @@ public:
 //  void            ReadXmlBuildList(const ByteString& sBuildLstPath);
 
 
-    BOOL            HasProject( ByteString aProjectName );
+    sal_Bool            HasProject( ByteString aProjectName );
     Prj*            GetPrj( ByteString aProjectName );
     ByteString          GetPrjName( DirEntry &rPath );
-    BOOL            RemovePrj ( Prj* pPrj );
+    sal_Bool            RemovePrj ( Prj* pPrj );
     void            RemoveAllPrj ();
 
-    StarFile*       ReadBuildlist (const String& rFilename, BOOL bReadComments = FALSE, BOOL bExtendAlias = TRUE);
-    BOOL            NeedsUpdate();
+    StarFile*       ReadBuildlist (const String& rFilename, sal_Bool bReadComments = sal_False, sal_Bool bExtendAlias = sal_True);
+    sal_Bool            NeedsUpdate();
     SolarFileList*  NeedsFilesForUpdate();
     void            ReplaceFileEntry( StarFileList *pStarFiles, StarFile* pFile );
-    void            UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bRead = FALSE );
-    void            FullReload( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bRead = FALSE );
+    void            UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion, sal_Bool bRead = sal_False );
+    void            FullReload( GenericInformationList *pStandLst, ByteString &rVersion, sal_Bool bRead = sal_False );
     void            GenerateFileLoadList( SolarFileList *pSolarFiles );
-    BOOL            CheckFileLoadList(SolarFileList *pSolarFiles);
+    sal_Bool            CheckFileLoadList(SolarFileList *pSolarFiles);
 
-    USHORT          GetMode() { return nStarMode; }
+    sal_uInt16          GetMode() { return nStarMode; }
     String          GetFileName(){ return sFileName; };
     String          GetSourceRoot(){ return sSourceRoot; };
     SByteStringList* GetAvailableDeps ();
@@ -454,23 +454,23 @@ public:
 class StarWriter : public Star
 {
 private:
-    USHORT          WritePrj( Prj *pPrj, SvFileStream& rStream );
+    sal_uInt16          WritePrj( Prj *pPrj, SvFileStream& rStream );
 
 public:
-                    StarWriter( String aFileName, BOOL bReadComments = FALSE, USHORT nMode = STAR_MODE_SINGLE_PARSE );
-                    StarWriter( SolarFileList *pSolarFiles, BOOL bReadComments = FALSE );
+                    StarWriter( String aFileName, sal_Bool bReadComments = sal_False, sal_uInt16 nMode = STAR_MODE_SINGLE_PARSE );
+                    StarWriter( SolarFileList *pSolarFiles, sal_Bool bReadComments = sal_False );
                     StarWriter( GenericInformationList *pStandLst, ByteString &rVersion, ByteString &rMinor,
-                        BOOL bReadComments = FALSE );
+                        sal_Bool bReadComments = sal_False );
 
     void            CleanUp();
 
-    BOOL            InsertProject ( Prj* pNewPrj );
+    sal_Bool            InsertProject ( Prj* pNewPrj );
     Prj*            RemoveProject ( ByteString aProjectName );
 
-    USHORT          Read( String aFileName, BOOL bReadComments = FALSE, USHORT nMode = STAR_MODE_SINGLE_PARSE  );
-       USHORT           Read( SolarFileList *pSolarFiles, BOOL bReadComments = FALSE );
-    USHORT          Write( String aFileName );
-    USHORT          WriteMultiple( String rSourceRoot );
+    sal_uInt16          Read( String aFileName, sal_Bool bReadComments = sal_False, sal_uInt16 nMode = STAR_MODE_SINGLE_PARSE  );
+       sal_uInt16           Read( SolarFileList *pSolarFiles, sal_Bool bReadComments = sal_False );
+    sal_uInt16          Write( String aFileName );
+    sal_uInt16          WriteMultiple( String rSourceRoot );
 
     void            InsertTokenLine ( const ByteString& rTokenLine );
 };
diff --git a/soldep/inc/soldep/sdtresid.hxx b/soldep/inc/soldep/sdtresid.hxx
index 02a3a57e37ea..2fcf49d70c5e 100644
--- a/soldep/inc/soldep/sdtresid.hxx
+++ b/soldep/inc/soldep/sdtresid.hxx
@@ -45,7 +45,7 @@ public:
 class DtSodResId : public ResId
 {
 public:
-    DtSodResId(USHORT nId);
+    DtSodResId(sal_uInt16 nId);
 };
 
 #endif
diff --git a/soldep/inc/soldep/soldep.hxx b/soldep/inc/soldep/soldep.hxx
index 55fb4fc0e11c..dccaa204e7de 100644
--- a/soldep/inc/soldep/soldep.hxx
+++ b/soldep/inc/soldep/soldep.hxx
@@ -40,10 +40,10 @@ class ObjectWin;
 
 class SolDep : public Depper
 {
-    BOOL            mbBServer;          //call from build server
-    ULONG           mnMinDynXOffs;
-    ULONG           mnLevelOffset;
-    ULONG           mnXOffset;
+    sal_Bool            mbBServer;          //call from build server
+    sal_uIntPtr         mnMinDynXOffs;
+    sal_uIntPtr         mnLevelOffset;
+    sal_uIntPtr         mnXOffset;
     ObjWinList*     mpTravellerList;
 
     String      msSourceName;
@@ -51,7 +51,7 @@ class SolDep : public Depper
     ByteString  msVersionMinor;
     ByteString  msProject;
     ObjectWin*  mpFocusWin;
-    BOOL        mbIsHide;
+    sal_Bool        mbIsHide;
 
     GenericInformationList *mpStandLst;
 
@@ -60,15 +60,15 @@ class SolDep : public Depper
 
     SolarFileList* GetPrjListFromDir();
 
-    Point       CalcPos( USHORT nSet, USHORT nIndex );
-    ULONG       CalcXOffset( ULONG nObjectsToFit );
+    Point       CalcPos( sal_uInt16 nSet, sal_uInt16 nIndex );
+    sal_uIntPtr       CalcXOffset( sal_uIntPtr nObjectsToFit );
     double      CalcDistSum( ObjWinList* pObjList, DistType eDistType = TOPDOWN );
-    USHORT      Impl_Traveller( ObjectWin* pWin, USHORT nDepth );
+    sal_uInt16      Impl_Traveller( ObjectWin* pWin, sal_uInt16 nDepth );
     double      Impl_PermuteMin( ObjWinList& rObjList, Point* pPosArray, ObjWinList& rResultList,
-                    double dMinDist, ULONG nStart, ULONG nSize, DistType eDisType = TOPDOWN );
-    USHORT      Load( const ByteString& rFileName );
+                    double dMinDist, sal_uIntPtr nStart, sal_uIntPtr nSize, DistType eDisType = TOPDOWN );
+    sal_uInt16      Load( const ByteString& rFileName );
     void        WriteToErrorFile();
-    BOOL        MarkObjects( ObjectWin* pObjectWin );
+    sal_Bool        MarkObjects( ObjectWin* pObjectWin );
     void        InitContextMenueMainWnd();
     void        InitContextMenuePrjViewWnd(DepWin* pWin);
 protected:
@@ -80,36 +80,36 @@ protected:
 public:
     SolDep( Window* pBaseWindow );
     ~SolDep();
-    BOOL                IsHideMode() { return mbIsHide;};
+    sal_Bool                IsHideMode() { return mbIsHide;};
     void                ToggleHideDependency();
 
-    virtual ULONG       GetStart(SolIdMapper* pIdMapper, ObjectList* pObjList);
-            ULONG       GetStartPrj(SolIdMapper* pIdMapper, ObjectList* pObjList);
-    virtual USHORT      ReadSource( BOOL bUpdater = FALSE );
-    virtual USHORT      WriteSource();
-    virtual USHORT      OpenSource();
-    BOOL                GetVersion();
+    virtual sal_uIntPtr     GetStart(SolIdMapper* pIdMapper, ObjectList* pObjList);
+            sal_uIntPtr       GetStartPrj(SolIdMapper* pIdMapper, ObjectList* pObjList);
+    virtual sal_uInt16      ReadSource( sal_Bool bUpdater = sal_False );
+    virtual sal_uInt16      WriteSource();
+    virtual sal_uInt16      OpenSource();
+    sal_Bool                GetVersion();
     void                Init();
     void                Init( ByteString &rVersion, GenericInformationList *pVersionList = NULL );
-    BOOL                InitPrj( ByteString& rListName );
+    sal_Bool                InitPrj( ByteString& rListName );
 //        using Depper::AddObject;
-    virtual ULONG       AddObject( ByteString& rBodyText, BOOL Interact=TRUE );
-            ULONG       AddPrjObject( ByteString& rBodyText, BOOL Interact=TRUE );
-    virtual ObjectWin*  RemoveObject( USHORT nId, BOOL bDelete = TRUE );
+    virtual sal_uIntPtr     AddObject( ByteString& rBodyText, sal_Bool Interact=sal_True );
+            sal_uIntPtr     AddPrjObject( ByteString& rBodyText, sal_Bool Interact=sal_True );
+    virtual ObjectWin*  RemoveObject( sal_uInt16 nId, sal_Bool bDelete = sal_True );
     virtual void        RemoveAllObjects( ObjectList* pObjLst );
-    virtual USHORT      AddConnector( ObjectWin* pStartWin, ObjectWin* pEndWin );
-            USHORT      AddConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin );
-    virtual USHORT      RemoveConnector( ObjectWin* pStartWin, ObjectWin* pEndWin );
-            USHORT      RemoveConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin );
-            USHORT      AutoArrange( SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nTopId, ULONG nBottmId, ULONG aObjID );
-            USHORT      OptimizePos( SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nTopId, ULONG nBottmId, ULONG aObjID );
-    virtual BOOL        ViewContent( ByteString& rObjectName );
-    virtual USHORT      CloseWindow();
+    virtual sal_uInt16      AddConnector( ObjectWin* pStartWin, ObjectWin* pEndWin );
+            sal_uInt16      AddConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin );
+    virtual sal_uInt16      RemoveConnector( ObjectWin* pStartWin, ObjectWin* pEndWin );
+            sal_uInt16      RemoveConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin );
+            sal_uInt16      AutoArrange( SolIdMapper* pIdMapper, ObjectList* pObjLst, sal_uIntPtr nTopId, sal_uIntPtr nBottmId, sal_uIntPtr aObjID );
+            sal_uInt16      OptimizePos( SolIdMapper* pIdMapper, ObjectList* pObjLst, sal_uIntPtr nTopId, sal_uIntPtr nBottmId, sal_uIntPtr aObjID );
+    virtual sal_Bool        ViewContent( ByteString& rObjectName );
+    virtual sal_uInt16      CloseWindow();
     virtual void        ShowHelp();
     FloatingWindow*     GetTaskBarFrame() { return &maTaskBarFrame; }
     SoldepToolBox*      GetSoldepToolBox() { return &maToolBox; }
 
-            BOOL        FindProject();
+            sal_Bool        FindProject();
             void        Resize();
 };
 
diff --git a/soldep/inc/soldep/tbox.hxx b/soldep/inc/soldep/tbox.hxx
index 69276895aad5..f8cb66b73fee 100644
--- a/soldep/inc/soldep/tbox.hxx
+++ b/soldep/inc/soldep/tbox.hxx
@@ -34,13 +34,13 @@
 class SoldepToolBox : public ToolBox
 {
 protected:
-//  USHORT          nBuildServerToolBoxId;
-    BOOL            bDockable;
-    BOOL            bCloseMode;
-    BOOL            bOldFloatMode;
-    BOOL            bBoxIsVisible;
-    BOOL            bPin;
-    BOOL            bPinable;
+//  sal_uInt16          nBuildServerToolBoxId;
+    sal_Bool            bDockable;
+    sal_Bool            bCloseMode;
+    sal_Bool            bOldFloatMode;
+    sal_Bool            bBoxIsVisible;
+    sal_Bool            bPin;
+    sal_Bool            bPinable;
 
     PopupMenu       aMenu;
 
@@ -56,7 +56,7 @@ protected:
     void            InitContextMenu();
 
 public:
-                    SoldepToolBox( Window* pParent, const ResId& aId, BOOL bDAble = TRUE );
+                    SoldepToolBox( Window* pParent, const ResId& aId, sal_Bool bDAble = sal_True );
                     ~SoldepToolBox();
 
     virtual void    Command( const CommandEvent& rCEvt);
@@ -69,8 +69,8 @@ public:
     virtual void    ToggleFloatingMode();
 //  void            SetFloatingWindow( FloatingWindow* pFW) { ToolBox::mpFloatWin = pFW; }
     virtual void    StartDocking();
-    virtual void    EndDocking( const Rectangle& rRect, BOOL bFloatMode );
-    virtual BOOL    Close();
+    virtual void    EndDocking( const Rectangle& rRect, sal_Bool bFloatMode );
+    virtual sal_Bool    Close();
     virtual void    CloseDockingMode();
 
                     //Called when toolbar droped
@@ -89,12 +89,12 @@ public:
     Link            GetMouseDownHdl() { return aMouseDownHdl; }
     void            SetResizeHdl(const Link& rLink) { aResizeHdl = rLink; }
 
-    BOOL            IsBoxVisible() { return bBoxIsVisible; }
+    sal_Bool            IsBoxVisible() { return bBoxIsVisible; }
 
-    void            EnablePin( BOOL bEnable = TRUE ) { bPinable = bEnable; Invalidate(); }
-    BOOL            GetPin();
+    void            EnablePin( sal_Bool bEnable = sal_True ) { bPinable = bEnable; Invalidate(); }
+    sal_Bool            GetPin();
     void            TogglePin();
-    void            SetPin(BOOL bP);
+    void            SetPin(sal_Bool bP);
     PopupMenu       *GetContextMenu();
     DECL_LINK( MenuSelectHdl, Menu * );
 };
diff --git a/soldep/source/connctr.cxx b/soldep/source/connctr.cxx
index 10650cb41fca..e8fba662cfb5 100644
--- a/soldep/source/connctr.cxx
+++ b/soldep/source/connctr.cxx
@@ -32,14 +32,14 @@
 #include <soldep/depwin.hxx>
 #include "math.h"
 
-BOOL Connector::msbHideMode = FALSE;
+sal_Bool Connector::msbHideMode = sal_False;
 
 Connector::Connector( DepWin* pParent, WinBits nWinStyle ) :
 mpStartWin( 0L ),
 mpEndWin( 0L ),
 mnStartId( 0 ),
 mnEndId( 0 ),
-bVisible( FALSE ),
+bVisible( sal_False ),
 len( 70 )
 {
     mpParent = pParent;
@@ -59,7 +59,7 @@ Connector::~Connector()
     mpParent->Invalidate( Rectangle( mEnd - Point( 3, 3), mEnd + Point( 3, 3)));
 }
 
-void Connector::Initialize( ObjectWin* pStartWin, ObjectWin* pEndWin, BOOL bVis )
+void Connector::Initialize( ObjectWin* pStartWin, ObjectWin* pEndWin, sal_Bool bVis )
 {
     mpStartWin = pStartWin;
     mpEndWin = pEndWin;
@@ -141,7 +141,7 @@ void Connector::Paint( const Rectangle& rRect )
     UpdateVisibility();
     } else //IsHideMode
     {
-        //bVisible = TRUE;
+        //bVisible = sal_True;
         if (!(mpStartWin->IsNullObject())) //null_project
         {
              mpStartWin->SetViewMask(1);
@@ -172,12 +172,12 @@ void Connector::DrawOutput( OutputDevice* pDevice, const Point& rOffset )
     }
 }
 
-void Connector::UpdatePosition( ObjectWin* pWin, BOOL bPaint )
+void Connector::UpdatePosition( ObjectWin* pWin, sal_Bool bPaint )
 {
 //  more than one call ?
 //
     Point OldStart, OldEnd;
-    static ULONG nCallCount = 0;
+    static sal_uIntPtr nCallCount = 0;
 
     //MyApp *pApp = (MyApp*)GetpApp();
     //SolDep *pSoldep = pApp->GetSolDep();
@@ -216,7 +216,7 @@ void Connector::UpdatePosition( ObjectWin* pWin, BOOL bPaint )
     }
 }
 
-USHORT Connector::Save( SvFileStream& rOutFile )
+sal_uInt16 Connector::Save( SvFileStream& rOutFile )
 {
     rOutFile << mpStartWin->GetId();
     rOutFile << mpEndWin->GetId();
@@ -224,7 +224,7 @@ USHORT Connector::Save( SvFileStream& rOutFile )
     return 0;
 }
 
-USHORT Connector::Load( SvFileStream& rInFile )
+sal_uInt16 Connector::Load( SvFileStream& rInFile )
 {
     rInFile >> mnStartId;
     rInFile >> mnEndId;
@@ -244,7 +244,7 @@ ObjectWin* Connector::GetOtherWin( ObjectWin* pWin )
     return NULL;
 }
 
-ULONG Connector::GetOtherId( ULONG nId )
+sal_uIntPtr Connector::GetOtherId( sal_uIntPtr nId )
 {
 // get correspondent object id
     if ( mnStartId == nId )
@@ -256,17 +256,17 @@ ULONG Connector::GetOtherId( ULONG nId )
     return NULL;
 }
 
-ULONG Connector::GetLen()
+sal_uIntPtr Connector::GetLen()
 {
     double dx, dy;
 
     dx = mStart.X() - mEnd.X();
     dy = mStart.Y() - mEnd.Y();
 
-    return (ULONG) sqrt( dx * dx + dy * dy );
+    return (sal_uIntPtr) sqrt( dx * dx + dy * dy );
 }
 
-BOOL Connector::IsStart( ObjectWin* pWin )
+sal_Bool Connector::IsStart( ObjectWin* pWin )
 {
     return pWin == mpStartWin;
 }
diff --git a/soldep/source/depper.cxx b/soldep/source/depper.cxx
index 11610ea1fcef..740558cde9a3 100644
--- a/soldep/source/depper.cxx
+++ b/soldep/source/depper.cxx
@@ -52,7 +52,7 @@ ByteString sDelimiterLine("#====================================================
 
 Depper::Depper( Window* pBaseWindow ):
     Window( pBaseWindow ),
-    mbIsPrjView(FALSE),
+    mbIsPrjView(sal_False),
     maDefPos( 50, 50 ),
     maDefSize( 60, 25 ),
     mnViewMask( 1 ),
@@ -105,7 +105,7 @@ Depper::~Depper()
     delete mpGraphWin;
 }
 
-BOOL Depper::TogglePrjViewStatus()
+sal_Bool Depper::TogglePrjViewStatus()
 {
     GetDepWin()->Hide();            //Hide old content window
     GetGraphWin()->Hide();
@@ -118,7 +118,7 @@ BOOL Depper::TogglePrjViewStatus()
 
 void Depper::HideObjectsAndConnections( ObjectList* pObjLst )
 {
-    for ( ULONG i = 0; i < pObjLst->Count(); i ++ ) {
+    for ( sal_uIntPtr i = 0; i < pObjLst->Count(); i ++ ) {
         ObjectWin *pWin = pObjLst->GetObject( i );
         pWin->Hide();
     }
@@ -130,7 +130,7 @@ void Depper::HideObjectsAndConnections( ObjectList* pObjLst )
 
 void Depper::ShowObjectsAndConnections( ObjectList* pObjLst )
 {
-    for ( ULONG i = 0; i < pObjLst->Count(); i ++ ) {
+    for ( sal_uIntPtr i = 0; i < pObjLst->Count(); i ++ ) {
         ObjectWin *pWin = pObjLst->GetObject( i );
         pWin->Show();
     }
@@ -143,23 +143,23 @@ void Depper::ShowObjectsAndConnections( ObjectList* pObjLst )
 
 void Depper::RemoveAllObjects( ObjectList* pObjLst )
 {
-    ULONG i;
+    sal_uIntPtr i;
 
     for ( i = pObjLst->Count(); i > 0; i-- )
         delete pObjLst->GetObject( i - 1 );
     pObjLst->Clear();
 }
 
-USHORT Depper::Save( const ByteString& rFileName )
+sal_uInt16 Depper::Save( const ByteString& rFileName )
 {
     DBG_ASSERT( FALSE , "you are dead!" );
     SvFileStream aOutFile( String( rFileName, RTL_TEXTENCODING_UTF8 ), STREAM_WRITE );
     depper_head dh;
-    USHORT i;
-    ULONG nObjCount = mpObjectList->Count();
+    sal_uInt16 i;
+    sal_uIntPtr nObjCount = mpObjectList->Count();
 
     ConnectorList* pConList = GetDepWin()->GetConnectorList();
-    ULONG nCnctrCount = pConList->Count();
+    sal_uIntPtr nCnctrCount = pConList->Count();
 
     dh.nID = DEPPER_ID;
     dh.nObjectCount = nObjCount;
@@ -181,30 +181,30 @@ USHORT Depper::Save( const ByteString& rFileName )
 }
 
 
-USHORT  Depper::WriteSource()
+sal_uInt16  Depper::WriteSource()
 {
     DBG_ASSERT( FALSE , "overload it!" );
     return 0;
 };
 
-USHORT  Depper::ReadSource( BOOL bUpdater )
+sal_uInt16  Depper::ReadSource( sal_Bool bUpdater )
 {
     DBG_ASSERT( FALSE , "overload it!" );
     return 0;
 };
 
-USHORT  Depper::OpenSource()
+sal_uInt16  Depper::OpenSource()
 {
     DBG_ASSERT( FALSE , "overload it!" );
     return 0;
 };
 
-ObjectWin* Depper::ObjIdToPtr( ObjectList* pObjLst, ULONG nId )
+ObjectWin* Depper::ObjIdToPtr( ObjectList* pObjLst, sal_uIntPtr nId )
 {
-    ULONG nObjCount = pObjLst->Count();
-    ULONG i = 0;
+    sal_uIntPtr nObjCount = pObjLst->Count();
+    sal_uIntPtr i = 0;
     ObjectWin* pWin;
-    ULONG nWinId = 0;
+    sal_uIntPtr nWinId = 0;
 
     do
     {
@@ -219,7 +219,7 @@ ObjectWin* Depper::ObjIdToPtr( ObjectList* pObjLst, ULONG nId )
         return NULL;
 }
 
-void Depper::SetMainProgressBar( USHORT i)
+void Depper::SetMainProgressBar( sal_uInt16 i)
 {
     if ( pMainBar ) {
         pMainBar->SetValue( 100 );
@@ -227,9 +227,9 @@ void Depper::SetMainProgressBar( USHORT i)
     }
 }
 
-void Depper::UpdateMainProgressBar(USHORT i, USHORT nScaleVal, USHORT &nStep, BOOL bCountingDown )
+void Depper::UpdateMainProgressBar(sal_uInt16 i, sal_uInt16 nScaleVal, sal_uInt16 &nStep, sal_Bool bCountingDown )
 {
-    ULONG val = 0;
+    sal_uIntPtr val = 0;
     if ( pMainBar ) {
  //       val = i * 50 / nScaleVal + 1;
         val = bCountingDown ? 50 + ( nScaleVal - i ) * 50 / nScaleVal : i * 50 / nScaleVal;
@@ -242,7 +242,7 @@ void Depper::UpdateMainProgressBar(USHORT i, USHORT nScaleVal, USHORT &nStep, BO
     }
 }
 
-void Depper::UpdateSubProgrssBar(ULONG i)
+void Depper::UpdateSubProgrssBar(sal_uIntPtr i)
 {
     if ( pSubBar )
     {
@@ -253,7 +253,7 @@ void Depper::UpdateSubProgrssBar(ULONG i)
 }
 
 
-USHORT Depper::AutoArrangeDlgStart()
+sal_uInt16 Depper::AutoArrangeDlgStart()
 {
     pSubBar = maArrangeDlg.GetSubBar();
     pMainBar = maArrangeDlg.GetMainBar();
@@ -261,15 +261,15 @@ USHORT Depper::AutoArrangeDlgStart()
     pMainText = maArrangeDlg.GetMainText();
     pMainText->SetText( String::CreateFromAscii( "Overall status" ));
     maArrangeDlg.Show();
-    GetDepWin()->Enable( FALSE );
+    GetDepWin()->Enable( sal_False );
     GetDepWin()->Hide();
     return 0;
 }
 
-USHORT Depper::AutoArrangeDlgStop()
+sal_uInt16 Depper::AutoArrangeDlgStop()
 {
     maArrangeDlg.Hide();
-    GetDepWin()->Enable( TRUE );
+    GetDepWin()->Enable( sal_True );
     GetDepWin()->Show();
     pSubBar = NULL;
     pMainBar = NULL;
@@ -280,9 +280,9 @@ USHORT Depper::AutoArrangeDlgStop()
 
 
 
-USHORT Depper::Zoom( MapMode& rMapMode )
+sal_uInt16 Depper::Zoom( MapMode& rMapMode )
 {
-    ULONG i;
+    sal_uIntPtr i;
     ObjectWin* pWin;
     Point aPos;
     Size aSize;
@@ -306,7 +306,7 @@ USHORT Depper::Zoom( MapMode& rMapMode )
     return 0;
 }
 
-ULONG Depper::AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, ULONG &LastID, ULONG &WinCount, ByteString& rBodyText, BOOL bInteract )
+sal_uIntPtr Depper::AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, sal_uIntPtr &LastID, sal_uIntPtr &WinCount, ByteString& rBodyText, sal_Bool bInteract )
 {
     Point aPos;
     Size aSize = GetDefSize();
@@ -316,7 +316,7 @@ ULONG Depper::AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, ULONG &L
     return AddObjectToList( pParentWin, pObjLst, LastID, WinCount, rBodyText, aPos, aSize );
 }
 
-ULONG Depper::AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, ULONG &LastID, ULONG &WinCount, ByteString& rBodyText, Point& rPos, Size& rSize )
+sal_uIntPtr Depper::AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, sal_uIntPtr &LastID, sal_uIntPtr &WinCount, ByteString& rBodyText, Point& rPos, Size& rSize )
 {
     ObjectWin* pWin = new ObjectWin( pParentWin, WB_BORDER );
     //pWin->mpDepperDontuseme = this;
@@ -350,14 +350,14 @@ ULONG Depper::AddObjectToList( DepWin* pParentWin, ObjectList* pObjLst, ULONG &L
 {
     GetDepWin()->DrawOutput( pDevice );
     ObjectList* pObjList = GetObjectList();
-    for ( USHORT i = pObjList->Count(); i > 0; i-- )
+    for ( sal_uInt16 i = pObjList->Count(); i > 0; i-- )
     {
         ObjectWin* pWin = pObjList->GetObject( i - 1 );
         pWin->DrawOutput( pDevice );
     }
 }*/
 
-ObjectWin* Depper::RemoveObjectFromList( ObjectList* pObjLst, ULONG &WinCount, USHORT nId, BOOL bDelete )
+ObjectWin* Depper::RemoveObjectFromList( ObjectList* pObjLst, sal_uIntPtr &WinCount, sal_uInt16 nId, sal_Bool bDelete )
 {
     ObjectWin* pWin = ObjIdToPtr( pObjLst, nId );
 
@@ -372,7 +372,7 @@ ObjectWin* Depper::RemoveObjectFromList( ObjectList* pObjLst, ULONG &WinCount, U
     else
         return NULL;
 }
-USHORT Depper::AddConnectorToObjects( ObjectList* pObjLst, ULONG nStartId, ULONG nEndId )
+sal_uInt16 Depper::AddConnectorToObjects( ObjectList* pObjLst, sal_uIntPtr nStartId, sal_uIntPtr nEndId )
 {
     ObjectWin* pStartWin = ObjIdToPtr( pObjLst, nStartId );
 
@@ -387,7 +387,7 @@ USHORT Depper::AddConnectorToObjects( ObjectList* pObjLst, ULONG nStartId, ULONG
     return AddConnectorToObjects( pStartWin, pEndWin );
 }
 
-USHORT Depper::RemoveConnectorFromObjects( ObjectList* pObjLst, ULONG nStartId, ULONG nEndId )
+sal_uInt16 Depper::RemoveConnectorFromObjects( ObjectList* pObjLst, sal_uIntPtr nStartId, sal_uIntPtr nEndId )
 {
 //  DBG_ASSERT( FALSE , "noch nicht" );
     ObjectWin* pStartWin = ObjIdToPtr( pObjLst, nStartId );
@@ -403,7 +403,7 @@ USHORT Depper::RemoveConnectorFromObjects( ObjectList* pObjLst, ULONG nStartId,
     return RemoveConnectorFromObjects( pStartWin, pEndWin );
 }
 
-USHORT Depper::AddConnectorToObjects( ObjectWin* pStartWin, ObjectWin* pEndWin )
+sal_uInt16 Depper::AddConnectorToObjects( ObjectWin* pStartWin, ObjectWin* pEndWin )
 {
     if ( pStartWin->ConnectionExistsInAnyDirection( pEndWin ))
         return 0;
@@ -411,13 +411,13 @@ USHORT Depper::AddConnectorToObjects( ObjectWin* pStartWin, ObjectWin* pEndWin )
     Connector* pCon = new Connector( GetDepWin(), WB_NOBORDER );
 //  pCon->Initialize( pStartWin, pEndWin );
     if (pStartWin->IsNullObject()) //null_project
-        pCon->Initialize( pStartWin, pEndWin, FALSE );
+        pCon->Initialize( pStartWin, pEndWin, sal_False );
     else
-        pCon->Initialize( pStartWin, pEndWin, TRUE );
+        pCon->Initialize( pStartWin, pEndWin, sal_True );
     return 0;
 }
 
-USHORT Depper::RemoveConnectorFromObjects( ObjectWin* pStartWin, ObjectWin* pEndWin )
+sal_uInt16 Depper::RemoveConnectorFromObjects( ObjectWin* pStartWin, ObjectWin* pEndWin )
 {
     Connector* pCon = pStartWin->GetConnector( pStartWin->GetId(), pEndWin->GetId() );
 
@@ -430,7 +430,7 @@ USHORT Depper::RemoveConnectorFromObjects( ObjectWin* pStartWin, ObjectWin* pEnd
     }
 }
 
-ULONG Depper::HandleNewPrjDialog( ByteString &rBodyText )
+sal_uIntPtr Depper::HandleNewPrjDialog( ByteString &rBodyText )
 {
         SolNewProjectDlg aNewProjectDlg( GetDepWin(), DtSodResId( RID_SD_DIALOG_NEWPROJECT ));
         if ( aNewProjectDlg.Execute() )
@@ -438,7 +438,7 @@ ULONG Depper::HandleNewPrjDialog( ByteString &rBodyText )
             rBodyText = ByteString( aNewProjectDlg.maEName.GetText(), RTL_TEXTENCODING_UTF8);
 //hashtable auf stand halten
             MyHashObject* pHObject;
-            ULONG nObjectId = AddObjectToList( mpBaseWin, mpObjectList, mnSolLastId, mnSolWinCount, rBodyText, FALSE );
+            sal_uIntPtr nObjectId = AddObjectToList( mpBaseWin, mpObjectList, mnSolLastId, mnSolWinCount, rBodyText, sal_False );
             pHObject = new MyHashObject( nObjectId, ObjIdToPtr( mpObjectList, nObjectId ));
             mpSolIdMapper->Insert( rBodyText, pHObject );
 
@@ -451,9 +451,9 @@ ULONG Depper::HandleNewPrjDialog( ByteString &rBodyText )
 
             if ( sDeps != "" )
             {
-                USHORT i;
+                sal_uInt16 i;
                 ByteString sDepName;
-                USHORT nToken = sDeps.GetTokenCount(' ');
+                sal_uInt16 nToken = sDeps.GetTokenCount(' ');
                 for ( i = 0 ; i < nToken ; i++)
                 {
                     sDepName =  sDeps.GetToken( i, ' ' );
@@ -468,11 +468,11 @@ ULONG Depper::HandleNewPrjDialog( ByteString &rBodyText )
 
             if ( sDeps != "" )
             {
-                USHORT i;
+                sal_uInt16 i;
                 ByteString sDepName;
-                ULONG nObjectId_l, nHashedId;
+                sal_uIntPtr nObjectId_l, nHashedId;
                 MyHashObject* pHObject_l;
-                USHORT nToken = sDeps.GetTokenCount(' ');
+                sal_uInt16 nToken = sDeps.GetTokenCount(' ');
                 for ( i = 0 ; i < nToken ; i++)
                 {
                     sDepName =  sDeps.GetToken( i, ' ' );
@@ -501,7 +501,7 @@ ULONG Depper::HandleNewPrjDialog( ByteString &rBodyText )
         return 0;
 }
 
-ULONG Depper::HandleNewDirectoryDialog(ByteString &rBodyText)
+sal_uIntPtr Depper::HandleNewDirectoryDialog(ByteString &rBodyText)
 {
         SolNewDirectoryDlg aNewDirectoryDlg( GetDepWin(), DtSodResId( RID_SD_DIALOG_NEWDIRECTORY ));
 //todo: set defaults
@@ -510,7 +510,7 @@ ULONG Depper::HandleNewDirectoryDialog(ByteString &rBodyText)
             rBodyText = ByteString( aNewDirectoryDlg.maEFlag.GetText(), RTL_TEXTENCODING_UTF8 );
 //hashtable auf stand halten
             MyHashObject* pHObject;
-            ULONG nObjectId = AddObjectToList( GetDepWin(), mpObjectPrjList, mnSolLastId, mnSolWinCount, rBodyText );
+            sal_uIntPtr nObjectId = AddObjectToList( GetDepWin(), mpObjectPrjList, mnSolLastId, mnSolWinCount, rBodyText );
             pHObject = new MyHashObject( nObjectId, ObjIdToPtr( mpObjectPrjList, nObjectId ));
             mpPrjIdMapper->Insert( rBodyText, pHObject ); // mpPrjIdMapper
 
@@ -542,12 +542,12 @@ ULONG Depper::HandleNewDirectoryDialog(ByteString &rBodyText)
 
             if ( aNewDirectoryDlg.maEDeps.GetText() != String( "", RTL_TEXTENCODING_UTF8 ))
             {
-                USHORT i;
+                sal_uInt16 i;
                 ByteString sDeps = ByteString( aNewDirectoryDlg.maEDeps.GetText(), RTL_TEXTENCODING_UTF8 );
                 ByteString sDepName;
-                ULONG nObjectId_l, nHashedId;
+                sal_uIntPtr nObjectId_l, nHashedId;
                 MyHashObject* pHObject_l;
-                USHORT nToken = sDeps.GetTokenCount(' ');
+                sal_uInt16 nToken = sDeps.GetTokenCount(' ');
                 for ( i = 0 ; i < nToken ; i++)
                 {
                     sDepName =  sDeps.GetToken( i, ' ' );
@@ -589,14 +589,14 @@ ULONG Depper::HandleNewDirectoryDialog(ByteString &rBodyText)
 // Context-Menue
 IMPL_LINK( Depper, PopupSelected, PopupMenu*, mpPopup )
 {
-    USHORT nItemId = mpPopup->GetCurItemId();
+    sal_uInt16 nItemId = mpPopup->GetCurItemId();
 
     switch( nItemId )
     {
         case DEPPOPUP_NEW :
                 {
                     ByteString sNewItem = ByteString("new");
-                     //AddObject( mpObjectList, sNewItem , TRUE );
+                     //AddObject( mpObjectList, sNewItem , sal_True );
                  }
                 break;
         case DEPPOPUP_AUTOARRANGE :
@@ -612,7 +612,7 @@ IMPL_LINK( Depper, PopupSelected, PopupMenu*, mpPopup )
                 WriteSource();
                 break;
         case DEPPOPUP_READ_SOURCE :
-                ReadSource(TRUE);
+                ReadSource(sal_True);
                 break;
         case DEPPOPUP_OPEN_SOURCE :
                 OpenSource();
@@ -684,4 +684,4 @@ IMPL_LINK( Depper, PopupSelected, PopupMenu*, mpPopup )
                 break;
     }
     return 0;
-}
\ No newline at end of file
+}
diff --git a/soldep/source/depwin.cxx b/soldep/source/depwin.cxx
index 5d7a1e36e4e7..f3bb1875724a 100644
--- a/soldep/source/depwin.cxx
+++ b/soldep/source/depwin.cxx
@@ -36,17 +36,17 @@ Bitmap* pWinCopy;
 
 DepWin::DepWin( Window* pParent, WinBits nWinStyle ) :
     Window( pParent, nWinStyle ),
-    mbStartNewCon( FALSE ),
+    mbStartNewCon( sal_False ),
     maNewConStart( 0, 0 ),
     maNewConEnd( 0, 0 )
 //    mpSelectedProject( NULL ) unbekannt
 //  mpCapturer( NULL )
 {
     if ( !pParent->IsChildNotify() )
-        pParent->EnableChildNotify( TRUE );
+        pParent->EnableChildNotify( sal_True );
 //  if ( !pParent->IsAllResizeEnabled())
-//      pParent->EnableAllResize( TRUE );
-    SetUpdateMode( TRUE );
+//      pParent->EnableAllResize( sal_True );
+    SetUpdateMode( sal_True );
     SetPosSizePixel( Point(0,0), Size( 2000, 2000 )); //Size of the scrollable Window
     mpPopup = new PopupMenu();
 }
@@ -77,7 +77,7 @@ void DepWin::NewConnector( ObjectWin* pWin )
     if ( !mbStartNewCon )
     {
         mpNewConWin = pWin;
-        mbStartNewCon = TRUE;
+        mbStartNewCon = sal_True;
         maNewConStart = pWin->GetFixPoint(Point(0,0));
     }
     else
@@ -93,15 +93,15 @@ void DepWin::NewConnector( ObjectWin* pWin )
 //          mpDepperDontuseme->AddConnector( mpNewConWin, pWin );
         }
         mpNewConWin = 0L;
-        mbStartNewCon = FALSE;
+        mbStartNewCon = sal_False;
     }
 
 }
 
 void DepWin::Paint( const Rectangle& rRect )
 {
-    ULONG i = 0;
-    ULONG nListCount = ConList.Count();
+    sal_uIntPtr i = 0;
+    sal_uIntPtr nListCount = ConList.Count();
 
     for ( i=0 ; i < nListCount ; i++ )
     {
@@ -115,8 +115,8 @@ void DepWin::Paint( const Rectangle& rRect )
 
 void DepWin::DrawOutput( OutputDevice* pDevice, const Point& rOffset  )
 {
-    ULONG i = 0;
-    ULONG nListCount = ConList.Count();
+    sal_uIntPtr i = 0;
+    sal_uIntPtr nListCount = ConList.Count();
 
     for ( i=0 ; i < nListCount ; i++ )
     {
diff --git a/soldep/source/hashobj.cxx b/soldep/source/hashobj.cxx
index 7f05dc33870a..944a3801fc59 100644
--- a/soldep/source/hashobj.cxx
+++ b/soldep/source/hashobj.cxx
@@ -30,7 +30,7 @@
 class ObjectWin;
 
 
-MyHashObject::MyHashObject( ULONG nId, ObjectWin* pWin )
+MyHashObject::MyHashObject( sal_uIntPtr nId, ObjectWin* pWin )
 {
     mnId = nId;
     mpWin = pWin;
diff --git a/soldep/source/objwin.cxx b/soldep/source/objwin.cxx
index 07eab4dd4cb7..4ba34956c59f 100644
--- a/soldep/source/objwin.cxx
+++ b/soldep/source/objwin.cxx
@@ -43,11 +43,11 @@ static Color aDefaultColor = 0L;
 static Wallpaper* pDefaultWallpaper = 0L;
 
 // Initialize static class member
-BOOL ObjectWin::msbHideMode = FALSE;
-ULONG ObjectWin::msnGlobalViewMask = 0;
+sal_Bool ObjectWin::msbHideMode = sal_False;
+sal_uIntPtr ObjectWin::msnGlobalViewMask = 0;
 
 
-UINT32 aColorMap[] = {
+sal_uInt32 aColorMap[] = {
     RGB_COLORDATA( 0xFF, 0xFF, 0x80 ),             //MARKMODE_DEFAULT    0
     COL_GREEN,              //MARKMODE_DEPENDING  1
     COL_RED,                //MARKMODE_NEEDED     2
@@ -80,12 +80,12 @@ ObjectWin::ObjectWin( Window* pParent, WinBits nWinStyle )
                 mnObjectId( 0 ),
                 mnMarkMode( 0 ),
                 mnViewMask( 0 ),
-                mbVisible( FALSE ),
-                mbMenuExecute( FALSE ),
-                mbVisited( FALSE ),
+                mbVisible( sal_False ),
+                mbMenuExecute( sal_False ),
+                mbVisited( sal_False ),
                 mnRootDist( 0 ),
                 mnHeadDist( 0 ),
-                mbFixed( FALSE )
+                mbFixed( sal_False )
 {
     SetBackground( Wallpaper( aColorMap[0] ));
 
@@ -129,13 +129,13 @@ ObjectWin::~ObjectWin()
     }
 }
 
-void ObjectWin::SetHideMode(BOOL bHide)
+void ObjectWin::SetHideMode(sal_Bool bHide)
 {
     msbHideMode = bHide;
     mConnections.GetObject(0)->SetHideMode(msbHideMode);
 }
 
-BOOL ObjectWin::ToggleHideMode()
+sal_Bool ObjectWin::ToggleHideMode()
 {
     msbHideMode = !msbHideMode;
     mConnections.GetObject(0)->SetHideMode(msbHideMode);
@@ -143,20 +143,20 @@ BOOL ObjectWin::ToggleHideMode()
 }
 
 /*****************************************************************************/
-void ObjectWin::SetViewMask( ULONG nMask )
+void ObjectWin::SetViewMask( sal_uIntPtr nMask )
 /*****************************************************************************/
 {
     mnViewMask = nMask;
     // Compares
     if ( mnViewMask & msnGlobalViewMask) {
-        mbVisible = TRUE;
+        mbVisible = sal_True;
         Show();
     }
     else {
         Hide();
-        mbVisible = FALSE;
+        mbVisible = sal_False;
     }
-    for ( ULONG i = 0; i < mConnections.Count(); i++ )
+    for ( sal_uIntPtr i = 0; i < mConnections.Count(); i++ )
         mConnections.GetObject( i )->UpdateVisibility();
 }
 
@@ -189,7 +189,7 @@ ByteString& ObjectWin::GetTipText()
 }
 
 /*****************************************************************************/
-Point ObjectWin::GetFixPoint( const Point& rRefPoint, BOOL bUseRealPos )
+Point ObjectWin::GetFixPoint( const Point& rRefPoint, sal_Bool bUseRealPos )
 /*****************************************************************************/
 {
     Point aLocalPoint;
@@ -201,8 +201,8 @@ Point ObjectWin::GetFixPoint( const Point& rRefPoint, BOOL bUseRealPos )
     Size aLocalSize = GetSizePixel();
     Point aRetPoint;
 
-    USHORT nRefX = aLocalPoint.X() + aLocalSize.Width() / 2 ;
-    USHORT nRefY = aLocalPoint.Y() + aLocalSize.Height() / 2 ;
+    sal_uInt16 nRefX = aLocalPoint.X() + aLocalSize.Width() / 2 ;
+    sal_uInt16 nRefY = aLocalPoint.Y() + aLocalSize.Height() / 2 ;
 
     // always false...
     //if ( nRefX < 0 ) nRefX = 0;
@@ -279,14 +279,14 @@ void ObjectWin::AddConnector( Connector* pNewCon )
 }
 
 /*****************************************************************************/
-BOOL ObjectWin::ConnectionExistsInAnyDirection( ObjectWin *pWin )
+sal_Bool ObjectWin::ConnectionExistsInAnyDirection( ObjectWin *pWin )
 /*****************************************************************************/
 {
-    for ( ULONG i = 0; i < mConnections.Count(); i++ )
+    for ( sal_uIntPtr i = 0; i < mConnections.Count(); i++ )
         if ( mConnections.GetObject( i )->GetOtherWin( this ) == pWin )
-            return TRUE;
+            return sal_True;
 
-    return FALSE;
+    return sal_False;
 }
 
 /*****************************************************************************/
@@ -297,10 +297,10 @@ void ObjectWin::RemoveConnector( Connector* pOldCon )
 }
 
 /*****************************************************************************/
-Connector* ObjectWin::GetConnector( ULONG nIndex )
+Connector* ObjectWin::GetConnector( sal_uIntPtr nIndex )
 /*****************************************************************************/
 {
-    ULONG nConCount = mConnections.Count();
+    sal_uIntPtr nConCount = mConnections.Count();
 
     if ( nIndex < nConCount )
         return mConnections.GetObject( nIndex );
@@ -308,15 +308,15 @@ Connector* ObjectWin::GetConnector( ULONG nIndex )
 }
 
 /*****************************************************************************/
-Connector* ObjectWin::GetConnector( ULONG nStartId, ULONG nEndId )
+Connector* ObjectWin::GetConnector( sal_uIntPtr nStartId, sal_uIntPtr nEndId )
 /*****************************************************************************/
 {
     if ( mnObjectId != nStartId )
         return NULL;
 
-    USHORT i;
+    sal_uInt16 i;
     Connector* pCon;
-    ULONG nConCount = mConnections.Count();
+    sal_uIntPtr nConCount = mConnections.Count();
 
     for ( i = 0; i < nConCount; i++ )
     {
@@ -330,16 +330,16 @@ Connector* ObjectWin::GetConnector( ULONG nStartId, ULONG nEndId )
 void ObjectWin::SetAllConnectorsUnvisible()
 {
     Connector* pCon;
-    ULONG nConCount = mConnections.Count();
-    for ( ULONG i = 0; i < nConCount; i++ )
+    sal_uIntPtr nConCount = mConnections.Count();
+    for ( sal_uIntPtr i = 0; i < nConCount; i++ )
     {
         pCon = mConnections.GetObject( i );
-        if (pCon) pCon->SetVisibility( FALSE );
+        if (pCon) pCon->SetVisibility( sal_False );
     }
 }
 
 /*****************************************************************************/
-void ObjectWin::SetMarkMode( ULONG nMarkMode )
+void ObjectWin::SetMarkMode( sal_uIntPtr nMarkMode )
 /*****************************************************************************/
 {
     //Wallpaper aWallpaper;
@@ -367,12 +367,12 @@ void ObjectWin::SetMarkMode( ULONG nMarkMode )
 }
 
 /*****************************************************************************/
-void ObjectWin::UnsetMarkMode( ULONG nMarkMode )
+void ObjectWin::UnsetMarkMode( sal_uIntPtr nMarkMode )
 /*****************************************************************************/
 {
     //Wallpaper aWallpaper;
 
-    ULONG nOldMode = mnMarkMode;
+    sal_uIntPtr nOldMode = mnMarkMode;
     mnMarkMode &= ( !nMarkMode );
 
     if ( nOldMode != mnMarkMode ) {
@@ -398,14 +398,14 @@ void ObjectWin::UnsetMarkMode( ULONG nMarkMode )
 }
 
 /*****************************************************************************/
-void ObjectWin::MarkNeeded( BOOL bReset )
+void ObjectWin::MarkNeeded( sal_Bool bReset )
 /*****************************************************************************/
 {
     Connector* pCon;
     ObjectWin* pWin;
 
-    ULONG nConCount = mConnections.Count();
-    ULONG i;
+    sal_uIntPtr nConCount = mConnections.Count();
+    sal_uIntPtr i;
 
     for ( i = 0; i < nConCount; i++ )
     {
@@ -426,7 +426,7 @@ void ObjectWin::MarkNeeded( BOOL bReset )
 }
 
 /*****************************************************************************/
-void ObjectWin::MarkDepending( BOOL bReset )
+void ObjectWin::MarkDepending( sal_Bool bReset )
 /*****************************************************************************/
 {
     //if ( !bReset )
@@ -435,8 +435,8 @@ void ObjectWin::MarkDepending( BOOL bReset )
     Connector* pCon;
     ObjectWin* pWin;
 
-    ULONG nConCount = mConnections.Count();
-    ULONG i;
+    sal_uIntPtr nConCount = mConnections.Count();
+    sal_uIntPtr i;
 
     for ( i = 0; i < nConCount; i++ )
     {
@@ -559,7 +559,7 @@ void ObjectWin::MouseButtonUp( const MouseEvent& rMEvt )
     }
     else if ( rMEvt.IsRight() )
     {
-        USHORT i;
+        sal_uInt16 i;
 
         while ( mnPopupStaticItems < mpPopup->GetItemCount() )
         {
@@ -574,7 +574,7 @@ void ObjectWin::MouseButtonUp( const MouseEvent& rMEvt )
                 mpPopup->InsertItem( mnPopupStaticItems + i + 1, String( ((mConnections.GetObject( i ))->GetOtherWin( this ))->GetBodyText(), RTL_TEXTENCODING_UTF8 ));
             }
         }
-        mbMenuExecute = TRUE;
+        mbMenuExecute = sal_True;
         mpPopup->Execute( GetParent(), rMEvt.GetPosPixel() + GetPosPixel());
     }
 }
@@ -585,7 +585,7 @@ void ObjectWin::MouseMove( const MouseEvent& rMEvt )
 {
     if ( IsMouseCaptured() )
     {
-        USHORT i;
+        sal_uInt16 i;
 
         Point aNewWinPos( GetPosPixel() + rMEvt.GetPosPixel() - maMouseOffset );
 
@@ -613,28 +613,28 @@ void ObjectWin::MouseMove( const MouseEvent& rMEvt )
 }
 
 /*****************************************************************************/
-USHORT ObjectWin::Save( SvFileStream& rOutFile )
+sal_uInt16 ObjectWin::Save( SvFileStream& rOutFile )
 /*****************************************************************************/
 {
     return 0;
 }
 
 /*****************************************************************************/
-USHORT ObjectWin::Load( SvFileStream& rInFile )
+sal_uInt16 ObjectWin::Load( SvFileStream& rInFile )
 /*****************************************************************************/
 {
     return 0;
 }
 
 /*****************************************************************************/
-void ObjectWin::SetId( ULONG nId )
+void ObjectWin::SetId( sal_uIntPtr nId )
 /*****************************************************************************/
 {
     mnObjectId = nId;
 }
 
 /*****************************************************************************/
-ULONG ObjectWin::GetId()
+sal_uIntPtr ObjectWin::GetId()
 /*****************************************************************************/
 {
     return mnObjectId;
@@ -644,7 +644,7 @@ ULONG ObjectWin::GetId()
 void ObjectWin::UpdateConnectors()
 /*****************************************************************************/
 {
-    USHORT i;
+    sal_uInt16 i;
 
     for ( i = 0; i < mConnections.Count(); i++ )
     {
@@ -654,7 +654,7 @@ void ObjectWin::UpdateConnectors()
 
 IMPL_LINK( ObjectWin, PopupSelected, PopupMenu*, mpPopup_l )
 {
-    USHORT nItemId = mpPopup_l->GetCurItemId();
+    sal_uInt16 nItemId = mpPopup_l->GetCurItemId();
 
     switch( nItemId )
     {
@@ -664,7 +664,7 @@ IMPL_LINK( ObjectWin, PopupSelected, PopupMenu*, mpPopup_l )
         case OBJWIN_REMOVE_WIN :
 //          DBG_ASSERT( FALSE,"remove");
 //          DBG_ASSERT( mpDepperDontuseme,"remove");
-            //mpDepperDontuseme->RemoveObject(mpDepperDontuseme->mpObjectList, ( USHORT ) GetId());
+            //mpDepperDontuseme->RemoveObject(mpDepperDontuseme->mpObjectList, ( sal_uInt16 ) GetId());
                 break;
         case OBJWIN_ADD_CONNECTOR :
 //          DBG_ASSERT( FALSE,"add con");
@@ -676,7 +676,7 @@ IMPL_LINK( ObjectWin, PopupSelected, PopupMenu*, mpPopup_l )
 //          TBD: CallEventListener
                 break;
         default :
-//          DBG_ASSERT( FALSE, String (nItemId) );
+//          DBG_ASSERT( sal_False, String (nItemId) );
             Connector* pCon = mConnections.GetObject( nItemId - mnPopupStaticItems - 1);
             pCon = 0;
 //          delete pCon;
@@ -717,24 +717,24 @@ void ObjectWin::LoseFocus()
     if ( !mbMenuExecute && !msbHideMode ) {
         UnsetMarkMode( MARKMODE_SELECTED );
         UnsetMarkMode( MARKMODE_ACTIVATED );
-        MarkNeeded( TRUE );
-        MarkDepending( TRUE );
+        MarkNeeded( sal_True );
+        MarkDepending( sal_True );
     }
     else
-        mbMenuExecute = FALSE;
+        mbMenuExecute = sal_False;
 }
 
 /*****************************************************************************/
 IMPL_LINK( ObjectWin, PopupDeactivated, PopupMenu*, mpPopup_l )
 /*****************************************************************************/
 {
-    mbMenuExecute = FALSE;
+    mbMenuExecute = sal_False;
 
     if ( !HasFocus()) {
         UnsetMarkMode( MARKMODE_SELECTED );
         UnsetMarkMode( MARKMODE_ACTIVATED );
-           MarkNeeded( TRUE );
-        MarkDepending( TRUE );
+           MarkNeeded( sal_True );
+        MarkDepending( sal_True );
     }
 
     return 0;
@@ -763,9 +763,9 @@ void ObjectList::ResetSelectedObject()
 {
 //    return;
 
-    ULONG nCount_l = Count();
+    sal_uIntPtr nCount_l = Count();
     ObjectWin* pObjectWin = NULL;
-    for (ULONG i=0; i < nCount_l; i++ )
+    for (sal_uIntPtr i=0; i < nCount_l; i++ )
     {
         pObjectWin = GetObject( i );
         pObjectWin->UnsetMarkMode( MARKMODE_SELECTED );
@@ -781,8 +781,8 @@ void ObjectList::ResetSelectedObject()
 ObjectWin* ObjectList::GetPtrByName( const ByteString& rText )
 /*****************************************************************************/
 {
-    ULONG i = 0;
-    ULONG nCount_l = Count();
+    sal_uIntPtr i = 0;
+    sal_uIntPtr nCount_l = Count();
     ObjectWin* pObjectWin = NULL;
     while ( i < nCount_l )
     {
@@ -797,7 +797,7 @@ ObjectWin* ObjectList::GetPtrByName( const ByteString& rText )
 ObjectList* ObjectList::FindTopLevelModules()
 {
     ObjectList* pList = new ObjectList;
-    for ( USHORT i=0; i<Count(); i++ )
+    for ( sal_uInt16 i=0; i<Count(); i++ )
     {
        ObjectWin* pObjectWin = GetObject( i );
        if ( pObjectWin->IsTop() )
@@ -807,15 +807,15 @@ ObjectList* ObjectList::FindTopLevelModules()
     return pList;
 }
 
-BOOL ObjectWin::IsTop()
+sal_Bool ObjectWin::IsTop()
 {
-    ULONG nConCount = mConnections.Count();
-    for ( ULONG i = 0; i < nConCount; i++ )
+    sal_uIntPtr nConCount = mConnections.Count();
+    for ( sal_uIntPtr i = 0; i < nConCount; i++ )
     {
         Connector* pCon = mConnections.GetObject( i );
         if ( pCon && pCon->IsStart( this) )
-            return FALSE;
+            return sal_False;
     }
 
-    return TRUE;
-}
\ No newline at end of file
+    return sal_True;
+}
diff --git a/soldep/source/sdtresid.cxx b/soldep/source/sdtresid.cxx
index 02977059f5c6..60d550982ba1 100644
--- a/soldep/source/sdtresid.cxx
+++ b/soldep/source/sdtresid.cxx
@@ -42,7 +42,7 @@ SolDevDll::~SolDevDll()
     delete pResMgr;
 }
 
-DtSodResId::DtSodResId( USHORT nId ) :
+DtSodResId::DtSodResId( sal_uInt16 nId ) :
 ResId(nId, *(*(SolDevDll**)GetAppData( SHL_SCH ))->GetResMgr())
 {
 }
diff --git a/soldep/source/soldep.cxx b/soldep/source/soldep.cxx
index 3f4a6df3e9b7..71edfb97370f 100644
--- a/soldep/source/soldep.cxx
+++ b/soldep/source/soldep.cxx
@@ -42,8 +42,8 @@
 #include <soldep/soldlg.hxx>
 #include "dtsodcmp.hrc"
 
-IMPLEMENT_HASHTABLE_OWNER( SolIdMapper, ByteString, ULONG* );
-//IMPLEMENT_HASHTABLE_OWNER( PrjIdMapper, ByteString, ULONG* );
+IMPLEMENT_HASHTABLE_OWNER( SolIdMapper, ByteString, sal_uIntPtr* );
+//IMPLEMENT_HASHTABLE_OWNER( PrjIdMapper, ByteString, sal_uIntPtr* );
 #define EVENT_RESIZE                0x00000001
 #define MIN(a,b) (a)<(b)?(a):(b)
 #define MAX(a,b) (a)>(b)?(a):(b)
@@ -60,9 +60,9 @@ IMPLEMENT_HASHTABLE_OWNER( SolIdMapper, ByteString, ULONG* );
 SolDep::SolDep( Window* pBaseWindow )
 /*****************************************************************************/
                 : Depper( pBaseWindow ),
-                mbBServer(FALSE),
+                mbBServer(sal_False),
                 mpTravellerList( NULL ),
-                mbIsHide( FALSE )
+                mbIsHide( sal_False )
 {
     mnSolWinCount = 0;
     mnSolLastId = 0;
@@ -100,7 +100,7 @@ void SolDep::Init()
     ByteString aUpdater( getenv("UPDATER") );
     if ( mpStandLst && (aUpdater == "YES") ) {
         if ( GetVersion() )
-            ReadSource( TRUE );
+            ReadSource( sal_True );
     } else
     {
         ReadSource();   // if stand.lst isn't available
@@ -112,7 +112,7 @@ void SolDep::Init( ByteString &rVersion, GenericInformationList *pVersionList )
 /*****************************************************************************/
 {
     // Interface for bs
-    mbBServer=TRUE;
+    mbBServer=sal_True;
     if ( pVersionList )
         mpStandLst = new GenericInformationList( *pVersionList );
     else {
@@ -122,7 +122,7 @@ void SolDep::Init( ByteString &rVersion, GenericInformationList *pVersionList )
     }
     if ( mpStandLst ) {
         msVersionMajor = ByteString( rVersion );
-        ReadSource(TRUE); //call from build server set UPDATER to TRUE
+        ReadSource(sal_True); //call from build server set UPDATER to TRUE
     }
 }
 
@@ -147,7 +147,7 @@ void SolDep::ProcessChildWindowEvent( const VclWindowEvent& _rVclWindowEvent )
 //Resize();
     if ( isAlive() )
         {
-            ULONG id = _rVclWindowEvent.GetId();
+            sal_uIntPtr id = _rVclWindowEvent.GetId();
             switch ( id )
             {
                 case VCLEVENT_USER_MOUSEBUTTON_DOWN:
@@ -170,8 +170,8 @@ void SolDep::ProcessChildWindowEvent( const VclWindowEvent& _rVclWindowEvent )
                                 pWin->LoseFocus();
                                 pWin->SetMarkMode( MARKMODE_SELECTED );
                                 pWin->UnsetMarkMode( MARKMODE_ACTIVATED );
-                                pWin->MarkNeeded( TRUE );
-                                pWin->MarkDepending( TRUE );
+                                pWin->MarkNeeded( sal_True );
+                                pWin->MarkDepending( sal_True );
                             }
 
                         }
@@ -229,7 +229,7 @@ void SolDep::ProcessChildWindowEvent( const VclWindowEvent& _rVclWindowEvent )
 IMPL_LINK( SolDep, ToolSelect, SoldepToolBox* , pBox)
 /*****************************************************************************/
 {
-    USHORT nItemId = pBox->GetCurItemId();
+    sal_uInt16 nItemId = pBox->GetCurItemId();
     switch ( nItemId )
     {
         case TID_SOLDEP_FIND:
@@ -240,7 +240,7 @@ IMPL_LINK( SolDep, ToolSelect, SoldepToolBox* , pBox)
             VirtualDevice   aVDev;
             aVDev.SetMapMode( MAP_100TH_MM );
             GDIMetaFile     aMtf;
-            aVDev.EnableOutput( FALSE );
+            aVDev.EnableOutput( sal_False );
             aMtf.Record( &aVDev );
 
             aVDev.SetLineColor( Color( COL_BLACK ) );
@@ -252,7 +252,7 @@ IMPL_LINK( SolDep, ToolSelect, SoldepToolBox* , pBox)
             long nYMax = 0;
             long nYMin = aSize.Height();
 
-            for ( USHORT i=0; i<mpObjectList->Count(); i++ )
+            for ( sal_uInt16 i=0; i<mpObjectList->Count(); i++ )
             {
                 Point aPoint = mpObjectList->GetObject(i)->GetPosPixel();
                 Size aSize = mpObjectList->GetObject(i)->GetSizePixel();
@@ -266,7 +266,7 @@ IMPL_LINK( SolDep, ToolSelect, SoldepToolBox* , pBox)
             aOffset = aVDev.PixelToLogic( aOffset );
 
             GetDepWin()->DrawOutput( &aVDev, aOffset );
-            for ( USHORT i=0; i<mpObjectList->Count(); i++ )
+            for ( sal_uInt16 i=0; i<mpObjectList->Count(); i++ )
                 if ( mpObjectList->GetObject(i)->IsVisible() )
                     mpObjectList->GetObject(i)->DrawOutput( &aVDev, aOffset );
 
@@ -283,7 +283,7 @@ IMPL_LINK( SolDep, ToolSelect, SoldepToolBox* , pBox)
         case TID_SOLDEP_HIDE_INDEPENDEND:
             {
                 ToggleHideDependency();
-                for ( USHORT i=0; i<mpObjectList->Count(); i++ )
+                for ( sal_uInt16 i=0; i<mpObjectList->Count(); i++ )
                     mpObjectList->GetObject(i)->SetViewMask(!mbIsHide);
 
                    maToolBox.CheckItem(TID_SOLDEP_HIDE_INDEPENDEND, IsHideMode());
@@ -298,7 +298,7 @@ IMPL_LINK( SolDep, ToolSelect, SoldepToolBox* , pBox)
                     delete mpSolIdMapper;
                     delete mpStarWriter;
                     mpObjectList->ClearAndDelete();
-                    ReadSource(TRUE);
+                    ReadSource(sal_True);
                 }
             }
             break;
@@ -325,16 +325,16 @@ void SolDep::ToggleHideDependency()
 };
 
 /*****************************************************************************/
-BOOL SolDep::GetVersion()
+sal_Bool SolDep::GetVersion()
 /*****************************************************************************/
 {
     SolSelectVersionDlg aVersionDlg( GetDepWin(), mpStandLst );
     if ( aVersionDlg.Execute() == RET_OK ) {
         msVersionMajor = aVersionDlg.GetVersionMajor();
         msVersionMinor = aVersionDlg.GetVersionMinor();
-        return TRUE;
+        return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
 void SolDep::InitContextMenueMainWnd()
@@ -361,13 +361,13 @@ void SolDep::InitContextMenuePrjViewWnd(DepWin* pBaseWin )
 }
 
 /*****************************************************************************/
-ObjectWin *SolDep::RemoveObject( USHORT nId, BOOL bDelete )
+ObjectWin *SolDep::RemoveObject( sal_uInt16 nId, sal_Bool bDelete )
 /*****************************************************************************/
 {
     Prj* pPrj;
 
 //hshtable auf stand halten
-    ObjectWin* pWin = RemoveObjectFromList( mpObjectList, mnSolWinCount, nId, FALSE );
+    ObjectWin* pWin = RemoveObjectFromList( mpObjectList, mnSolWinCount, nId, sal_False );
     if ( pWin )
     {
         ByteString aBodyText( pWin->GetBodyText() );
@@ -391,10 +391,10 @@ ObjectWin *SolDep::RemoveObject( USHORT nId, BOOL bDelete )
 }
 
 /*****************************************************************************/
-ULONG SolDep::AddObject( ByteString& rBodyText, BOOL bInteract )
+sal_uIntPtr SolDep::AddObject( ByteString& rBodyText, sal_Bool bInteract )
 /*****************************************************************************/
 {
-    ULONG nObjectId;
+    sal_uIntPtr nObjectId;
     if ( bInteract )
     {
         nObjectId = HandleNewPrjDialog( rBodyText );
@@ -403,7 +403,7 @@ ULONG SolDep::AddObject( ByteString& rBodyText, BOOL bInteract )
     {
 //hashtable auf stand halten
         MyHashObject* pHObject;
-        nObjectId = AddObjectToList( mpBaseWin, mpObjectList, mnSolLastId, mnSolWinCount, rBodyText, FALSE );
+        nObjectId = AddObjectToList( mpBaseWin, mpObjectList, mnSolLastId, mnSolWinCount, rBodyText, sal_False );
         pHObject = new MyHashObject( nObjectId, ObjIdToPtr(mpObjectList, nObjectId ));
         mpSolIdMapper->Insert( rBodyText, pHObject );
     }
@@ -411,10 +411,10 @@ ULONG SolDep::AddObject( ByteString& rBodyText, BOOL bInteract )
 }
 
 /*****************************************************************************/
-ULONG SolDep::AddPrjObject( ByteString& rBodyText, BOOL bInteract )
+sal_uIntPtr SolDep::AddPrjObject( ByteString& rBodyText, sal_Bool bInteract )
 /*****************************************************************************/
 {
-    ULONG nObjectId;
+    sal_uIntPtr nObjectId;
     if ( bInteract )
     {
         nObjectId = HandleNewDirectoryDialog( rBodyText );
@@ -431,7 +431,7 @@ ULONG SolDep::AddPrjObject( ByteString& rBodyText, BOOL bInteract )
 }
 
 /*****************************************************************************/
-USHORT SolDep::AddConnector( ObjectWin* pStartWin, ObjectWin* pEndWin )
+sal_uInt16 SolDep::AddConnector( ObjectWin* pStartWin, ObjectWin* pEndWin )
 /*****************************************************************************/
 {
 //  DBG_ASSERT( FALSE , "not yet" );
@@ -452,7 +452,7 @@ USHORT SolDep::AddConnector( ObjectWin* pStartWin, ObjectWin* pEndWin )
 }
 
 /*****************************************************************************/
-USHORT SolDep::RemoveConnector( ObjectWin* pStartWin, ObjectWin* pEndWin )
+sal_uInt16 SolDep::RemoveConnector( ObjectWin* pStartWin, ObjectWin* pEndWin )
 /*****************************************************************************/
 {
     SByteStringList* pPrjDeps = NULL;
@@ -460,12 +460,12 @@ USHORT SolDep::RemoveConnector( ObjectWin* pStartWin, ObjectWin* pEndWin )
     ByteString sStartName = pStartWin->GetBodyText();
 
     Prj* pPrj = mpStarWriter->GetPrj( sEndName );
-    pPrjDeps = pPrj->GetDependencies( FALSE );
+    pPrjDeps = pPrj->GetDependencies( sal_False );
     if ( pPrjDeps )
     {
         ByteString* pString;
-        ULONG nPrjDepsCount = pPrjDeps->Count();
-        for ( ULONG j = nPrjDepsCount; j > 0; j-- )
+        sal_uIntPtr nPrjDepsCount = pPrjDeps->Count();
+        for ( sal_uIntPtr j = nPrjDepsCount; j > 0; j-- )
         {
             pString = pPrjDeps->GetObject( j - 1 );
             if ( pString->GetToken( 0, '.') == sStartName )
@@ -496,7 +496,7 @@ void SolDep::RemoveAllObjects( ObjectList* pObjLst )
 }
 
 /*****************************************************************************/
-ULONG SolDep::GetStart(SolIdMapper* pIdMapper, ObjectList* pObjList)
+sal_uIntPtr SolDep::GetStart(SolIdMapper* pIdMapper, ObjectList* pObjList)
 /*****************************************************************************/
 {
 //  DBG_ASSERT( FALSE , "soldep" );
@@ -504,7 +504,7 @@ ULONG SolDep::GetStart(SolIdMapper* pIdMapper, ObjectList* pObjList)
 
     if ( !pHObject ) {
         ByteString sNullPrj = "null";//null_project
-        ULONG nObjectId = AddObject( sNullPrj, FALSE );
+        sal_uIntPtr nObjectId = AddObject( sNullPrj, sal_False );
         ObjIdToPtr( pObjList, nObjectId )->SetViewMask( 1 );
         return nObjectId;
     }
@@ -513,7 +513,7 @@ ULONG SolDep::GetStart(SolIdMapper* pIdMapper, ObjectList* pObjList)
 }
 
 /*****************************************************************************/
-ULONG SolDep::GetStartPrj(SolIdMapper* , ObjectList* )
+sal_uIntPtr SolDep::GetStartPrj(SolIdMapper* , ObjectList* )
 /*****************************************************************************/
 {
 //  DBG_ASSERT( FALSE , "prjdep" );
@@ -521,7 +521,7 @@ ULONG SolDep::GetStartPrj(SolIdMapper* , ObjectList* )
     if ( !pHObject )
     {
         ByteString bsNull("null");
-        ULONG nObjectId = AddPrjObject( bsNull, FALSE); //null_dir
+        sal_uIntPtr nObjectId = AddPrjObject( bsNull, sal_False); //null_dir
         return nObjectId;
     }
     else
@@ -529,7 +529,7 @@ ULONG SolDep::GetStartPrj(SolIdMapper* , ObjectList* )
 }
 
 /*****************************************************************************/
-USHORT SolDep::OpenSource()
+sal_uInt16 SolDep::OpenSource()
 /*****************************************************************************/
 {
     if ( mpStandLst ) {
@@ -540,13 +540,13 @@ USHORT SolDep::OpenSource()
 }
 
 /*****************************************************************************/
-USHORT SolDep::ReadSource(BOOL bUpdater)
+sal_uInt16 SolDep::ReadSource(sal_Bool bUpdater)
 /*****************************************************************************/
 {
-    mpBaseWin->EnablePaint( FALSE );
+    mpBaseWin->EnablePaint( sal_False );
     mpBaseWin->Hide();
-    ULONG nObjectId, nHashedId;
-    ULONG i;
+    sal_uIntPtr nObjectId, nHashedId;
+    sal_uIntPtr i;
     MyHashObject* pHObject;
     ByteString* pStr;
     ObjectWin *pStartWin, *pEndWin;
@@ -554,12 +554,12 @@ USHORT SolDep::ReadSource(BOOL bUpdater)
     mpSolIdMapper = new SolIdMapper( 63997 );
     if (mpStandLst && bUpdater)
     {
-        mpStarWriter = new StarWriter( mpStandLst, msVersionMajor, msVersionMinor, TRUE );
+        mpStarWriter = new StarWriter( mpStandLst, msVersionMajor, msVersionMinor, sal_True );
     } else
     {
         SolarFileList* pSolarFileList;
         pSolarFileList = GetPrjListFromDir();
-        mpStarWriter = new StarWriter( pSolarFileList, TRUE );
+        mpStarWriter = new StarWriter( pSolarFileList, sal_True );
     }
     ByteString sTitle( SOLDEPL_NAME );
     if ( mpStarWriter->GetMode() == STAR_MODE_SINGLE_PARSE ) {
@@ -573,22 +573,22 @@ USHORT SolDep::ReadSource(BOOL bUpdater)
     }
     SetTitle( String( sTitle, RTL_TEXTENCODING_UTF8) );
 
-    ULONG nCount = mpStarWriter->Count();
+    sal_uIntPtr nCount = mpStarWriter->Count();
     for ( i=0; i<nCount; i++ )
     {
         Prj *pPrj = mpStarWriter->GetObject(i);
         ByteString sPrjName = pPrj->GetProjectName();
-        nObjectId = AddObject( sPrjName, FALSE );
+        nObjectId = AddObject( sPrjName, sal_False );
         ObjIdToPtr( mpObjectList, nObjectId )->SetViewMask( 1 );
     }
     for ( i=0; i<nCount; i++ )
     {
         Prj *pPrj = mpStarWriter->GetObject(i);
-        SByteStringList *pLst = pPrj->GetDependencies( FALSE );
+        SByteStringList *pLst = pPrj->GetDependencies( sal_False );
         if ( pLst )
         {
-            ULONG nDepCount = pLst->Count();
-            for ( ULONG m=0; m<nDepCount; m++)
+            sal_uIntPtr nDepCount = pLst->Count();
+            for ( sal_uIntPtr m=0; m<nDepCount; m++)
             {
                 pStr = pLst->GetObject(m);
                 pHObject = mpSolIdMapper->Find( *pStr );
@@ -597,7 +597,7 @@ USHORT SolDep::ReadSource(BOOL bUpdater)
     // create new prj
                     Prj *pNewPrj = new Prj( *pStr );
                     ByteString sPrjName = pNewPrj->GetProjectName();
-                    nObjectId = AddObject( sPrjName, FALSE );
+                    nObjectId = AddObject( sPrjName, sal_False );
                     pHObject = mpSolIdMapper->Find( *pStr );
                     ObjIdToPtr( mpObjectList, nObjectId )->SetViewMask( 2 );
                 }*/
@@ -619,7 +619,7 @@ USHORT SolDep::ReadSource(BOOL bUpdater)
     if (!IsPrjView())
     {
         AutoArrange( mpSolIdMapper, mpObjectList, GetStart(mpSolIdMapper,mpObjectList), 0, GetStart(mpSolIdMapper,mpObjectList) );
-        GetDepWin()->EnablePaint( TRUE );
+        GetDepWin()->EnablePaint( sal_True );
     }
     return 0;
 }
@@ -634,11 +634,11 @@ SolarFileList* SolDep::GetPrjListFromDir()
     aCurrent.ToAbs();
     Dir aDir( aCurrent, FSYS_KIND_DIR );
 
-    USHORT nEntries = aDir.Count();
+    sal_uInt16 nEntries = aDir.Count();
     if( nEntries )
     {
         UniStringList aSortDirList;
-        for ( USHORT n = 0; n < nEntries; n++ )
+        for ( sal_uInt16 n = 0; n < nEntries; n++ )
         {
             DirEntry& rEntry = aDir[n];
             UniString aName( rEntry.GetName() );
@@ -665,11 +665,11 @@ SolarFileList* SolDep::GetPrjListFromDir()
 }
 
 /*****************************************************************************/
-USHORT SolDep::WriteSource()
+sal_uInt16 SolDep::WriteSource()
 /*****************************************************************************/
 {
 /* zur Sicherheit deaktiviert
-    USHORT nMode = mpStarWriter->GetMode();
+    sal_uInt16 nMode = mpStarWriter->GetMode();
     if ( nMode == STAR_MODE_SINGLE_PARSE ) {
         ByteString sFileName = mpStarWriter->GetName();
         if ( sFileName.Len()) {
@@ -696,32 +696,32 @@ USHORT SolDep::WriteSource()
     return 1;
 }
 
-USHORT SolDep::Load( const ByteString& rFileName )
+sal_uInt16 SolDep::Load( const ByteString& rFileName )
 {
 // moved from depper class
     DBG_ASSERT( FALSE , "you are dead!" );
     SvFileStream aInFile( String( rFileName, RTL_TEXTENCODING_UTF8 ), STREAM_READ );
     depper_head dh;
-    ULONG i;
-    ULONG nLoadOffs = mnSolLastId;     //or Prj??
+    sal_uIntPtr i;
+    sal_uIntPtr nLoadOffs = mnSolLastId;     //or Prj??
     ObjectWin* pNewWin;
     aInFile.Read( &dh, sizeof( dh ));
 
-    ULONG nObjCount = dh.nObjectCount;
-    ULONG nCnctrCount = dh.nCnctrCount;
+    sal_uIntPtr nObjCount = dh.nObjectCount;
+    sal_uIntPtr nCnctrCount = dh.nCnctrCount;
 
     for ( i=0; i < nObjCount ; i++ )
     {
         ObjectWin* pWin = new ObjectWin( mpBaseWin, WB_BORDER );
         pWin->Load( aInFile );
-        pNewWin = ObjIdToPtr( mpObjectList, AddObjectToList( mpBaseWin, mpObjectList, mnSolLastId, mnSolWinCount, pWin->GetBodyText(), FALSE ));
+        pNewWin = ObjIdToPtr( mpObjectList, AddObjectToList( mpBaseWin, mpObjectList, mnSolLastId, mnSolWinCount, pWin->GetBodyText(), sal_False ));
         pNewWin->SetId( nLoadOffs + pWin->GetId());
         pNewWin->SetPosPixel( pWin->GetPosPixel());
         pNewWin->SetSizePixel( pWin->GetSizePixel());
     }
 
-    ULONG nStartId;
-    ULONG nEndId;
+    sal_uIntPtr nStartId;
+    sal_uIntPtr nEndId;
 //  ueber addconnector fuehren!
     for ( i=0; i < nCnctrCount ; i++ )
     {
@@ -742,13 +742,13 @@ USHORT SolDep::Load( const ByteString& rFileName )
 }
 
 /*****************************************************************************/
-BOOL SolDep::ViewContent( ByteString& rObjectName )
+sal_Bool SolDep::ViewContent( ByteString& rObjectName )
 /*****************************************************************************/
 {
     mpFocusWin = NULL;
-    SetPrjViewStatus(TRUE);
+    SetPrjViewStatus(sal_True);
 
-    for ( ULONG i = 0; i < mpObjectList->Count() && !mpFocusWin; i++ )
+    for ( sal_uIntPtr i = 0; i < mpObjectList->Count() && !mpFocusWin; i++ )
         if ( mpObjectList->GetObject( i )->HasFocus())
             mpFocusWin = mpObjectList->GetObject( i );
     //HideObjectsAndConnections( mpObjectList );
@@ -758,11 +758,11 @@ BOOL SolDep::ViewContent( ByteString& rObjectName )
 }
 
 /*****************************************************************************/
-BOOL SolDep::InitPrj( ByteString& rListName )
+sal_Bool SolDep::InitPrj( ByteString& rListName )
 /*****************************************************************************/
 {
-    ULONG nObjectId, nHashedId;
-    ULONG i, j;
+    sal_uIntPtr nObjectId, nHashedId;
+    sal_uIntPtr i, j;
     MyHashObject* pHObject;
     ByteString *pDepName;
     ByteString *pFlagName;
@@ -782,14 +782,14 @@ BOOL SolDep::InitPrj( ByteString& rListName )
     mnPrjWinCount = 0;
     mnPrjLastId = 0;
 
-    ULONG nCount = mpStarWriter->Count();
-    GetDepWin()->EnablePaint( FALSE );
+    sal_uIntPtr nCount = mpStarWriter->Count();
+    GetDepWin()->EnablePaint( sal_False );
     Point aPnt = GetGraphWin()->GetPosPixel();
     Size aSize = GetGraphWin()->GetSizePixel();
 
     GetGraphWin()->SetPosSizePixel( aPnt, aSize );         // Hier wird das Window gesetzt
 
-    BOOL bReturn = FALSE;
+    sal_Bool bReturn = sal_False;
 
     for ( i=0; i<nCount; i++ )
     {
@@ -799,10 +799,10 @@ BOOL SolDep::InitPrj( ByteString& rListName )
         ByteString sPrjName = pPrj->GetProjectName();
         if ( sPrjName == rListName )
         {
-            bReturn = TRUE;
+            bReturn = sal_True;
 
             mpPrj = mpStarWriter->GetObject(i);
-            ULONG nDirCount = mpPrj->Count();
+            sal_uIntPtr nDirCount = mpPrj->Count();
             for ( j=0; j<nDirCount; j++ )
             {
                 CommandData *pData = mpPrj->GetObject(j);
@@ -813,7 +813,7 @@ BOOL SolDep::InitPrj( ByteString& rListName )
                 if ( pData->GetLogFile() != "" )
                 {
                     ByteString sItem = pData->GetLogFile();
-                    nObjectId = AddPrjObject( sItem, FALSE);
+                    nObjectId = AddPrjObject( sItem, sal_False);
 // there may be faster ways......
                     ObjectWin *pWin = ObjIdToPtr( mpObjectPrjList, nObjectId );
                     pWin->SetViewMask( 0x0001 );
@@ -840,8 +840,8 @@ BOOL SolDep::InitPrj( ByteString& rListName )
 
                         nObjectId = pHObject->GetId();
 
-                        ULONG nDepCount = pDeps->Count();
-                        for ( ULONG k=0; k<nDepCount; k++ )
+                        sal_uIntPtr nDepCount = pDeps->Count();
+                        for ( sal_uIntPtr k=0; k<nDepCount; k++ )
                         {
                             pDepName = pDeps->GetObject(k);
                             pHObject = mpPrjIdMapper->Find( (*pDepName).GetToken( 0, '.'));
@@ -872,10 +872,10 @@ BOOL SolDep::InitPrj( ByteString& rListName )
         }
     }
     ByteString sNullDir = "null";
-    nObjectId = AddPrjObject( sNullDir, FALSE);
+    nObjectId = AddPrjObject( sNullDir, sal_False);
     ObjectWin *pWin = ObjIdToPtr( mpObjectPrjList, nObjectId );
     pWin->SetViewMask( 0x0001 );
-    mpGraphPrjWin->EnablePaint( TRUE );
+    mpGraphPrjWin->EnablePaint( sal_True );
     //debug
 //    int test_l = GetStartPrj(mpPrjIdMapper, mpObjectPrjList);
 //    ObjectWin *pTestWin = ObjIdToPtr( mpObjectPrjList, test_l );
@@ -888,7 +888,7 @@ BOOL SolDep::InitPrj( ByteString& rListName )
 }
 
 /*****************************************************************************/
-USHORT SolDep::CloseWindow()
+sal_uInt16 SolDep::CloseWindow()
 /*****************************************************************************/
 {
 
@@ -918,12 +918,12 @@ void SolDep::ShowHelp()
     SolHelpDlg aHelpDlg( mpBaseWin, DtSodResId( RID_SD_DIALOG_HELP ));
     aHelpDlg.maMLEHelp.SetText( aHelpText );
     aHelpDlg.maMLEHelp.SetReadOnly();
-    aHelpDlg.maMLEHelp.EnableFocusSelectionHide( TRUE );
+    aHelpDlg.maMLEHelp.EnableFocusSelectionHide( sal_True );
     aHelpDlg.Execute();
 }
 
 /*****************************************************************************/
-BOOL SolDep::FindProject()
+sal_Bool SolDep::FindProject()
 /*****************************************************************************/
 {
     SolFindProjectDlg aFindProjectDlg( GetDepWin(), GetObjectList() );
@@ -949,18 +949,18 @@ BOOL SolDep::FindProject()
         else
         {
             mpObjectList->ResetSelectedObject();
-            for ( USHORT i=0; i<mpObjectList->Count(); i++ )
+            for ( sal_uInt16 i=0; i<mpObjectList->Count(); i++ )
             {
                ObjectWin* pObjectWin = mpObjectList->GetObject( i );
                if ( !pObjectWin->IsTop() )
-                    pObjectWin->SetViewMask(FALSE);
+                    pObjectWin->SetViewMask(sal_False);
             }
         }
     }
-    return FALSE;
+    return sal_False;
 }
 
-BOOL SolDep::MarkObjects( ObjectWin* pObjectWin )
+sal_Bool SolDep::MarkObjects( ObjectWin* pObjectWin )
 {
     if (pObjectWin)
     {
@@ -978,7 +978,7 @@ BOOL SolDep::MarkObjects( ObjectWin* pObjectWin )
             fprintf(stdout,"null\n");
         }
     }
-    return TRUE;
+    return sal_True;
 }
 
 void SolDep::Resize()
@@ -987,11 +987,11 @@ void SolDep::Resize()
     Point aOutPos = Point( 0, 0 );
     Size aOutSize = mpProcessWin->GetOutputSizePixel();
         // calculate output size
-    ULONG nTaskHeight = maToolBox.CalcWindowSizePixel().Height();
-    ULONG nTaskWidth  = maToolBox.CalcWindowSizePixel().Width();
+    sal_uIntPtr nTaskHeight = maToolBox.CalcWindowSizePixel().Height();
+    sal_uIntPtr nTaskWidth  = maToolBox.CalcWindowSizePixel().Width();
     Size aSize( aOutSize.Width(), nTaskHeight );
 
-//  ULONG nMenuHeight = 0;
+//  sal_uIntPtr nMenuHeight = 0;
     Point aGraphWinPos = Point(0,0);
     Size  aGraphWinSize = Size(0,0);
 
@@ -1076,7 +1076,7 @@ void SolDep::Resize()
 */
     maToolBox.SetDockingRects( rout, rin );
 
-    BOOL bFloating = maToolBox.IsFloatingMode();
+    sal_Bool bFloating = maToolBox.IsFloatingMode();
 
     if ( bFloating )
     {
@@ -1090,7 +1090,7 @@ void SolDep::Resize()
     if (maToolBox.IsVisible()) maToolBox.Show();
 }
 
-USHORT SolDep::AddConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin )
+sal_uInt16 SolDep::AddConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin )
 {
 //  DBG_ASSERT( FALSE , "not yet" );
     ByteString sEndName = pEndWin->GetBodyText();
@@ -1112,7 +1112,7 @@ USHORT SolDep::AddConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin )
     return AddConnectorToObjects( pStartWin, pEndWin );
 }
 
-USHORT SolDep::RemoveConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin )
+sal_uInt16 SolDep::RemoveConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin )
 {
     ByteString sEndName = pEndWin->GetBodyText();
     ByteString sStartName = pStartWin->GetBodyText();
@@ -1121,8 +1121,8 @@ USHORT SolDep::RemoveConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin
     if ( pDeps )
     {
         ByteString* pString;
-        ULONG nDepsCount = pDeps->Count();
-        for ( ULONG j = nDepsCount; j > 0; j-- )
+        sal_uIntPtr nDepsCount = pDeps->Count();
+        for ( sal_uIntPtr j = nDepsCount; j > 0; j-- )
         {
             pString = pDeps->GetObject( j - 1 );
             if ( pString->GetToken( 0, '.') == sStartName )
@@ -1132,7 +1132,7 @@ USHORT SolDep::RemoveConnectorPrjView( ObjectWin* pStartWin, ObjectWin* pEndWin
     return RemoveConnectorFromObjects( pStartWin, pEndWin );
 }
 
-USHORT SolDep::AutoArrange( SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nTopId, ULONG nBottmId, ULONG aObjID )
+sal_uInt16 SolDep::AutoArrange( SolIdMapper* pIdMapper, ObjectList* pObjLst, sal_uIntPtr nTopId, sal_uIntPtr nBottmId, sal_uIntPtr aObjID )
 {
     AutoArrangeDlgStart();
     OptimizePos(pIdMapper, pObjLst, nTopId, nBottmId, aObjID );
@@ -1140,30 +1140,30 @@ USHORT SolDep::AutoArrange( SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG n
     return 0;
 }
 
-Point SolDep::CalcPos( USHORT nSet, USHORT nIndex )
+Point SolDep::CalcPos( sal_uInt16 nSet, sal_uInt16 nIndex )
 {
     int nRowIndex = nIndex / DEPPER_MAX_WIDTH;
-    ULONG nPosX = mnXOffset + nRowIndex % 3 * GetDefSize().Width() / 3 + ( nIndex - ( DEPPER_MAX_WIDTH * nRowIndex )) * (GetDefSize().Width() + OBJWIN_X_SPACING );
+    sal_uIntPtr nPosX = mnXOffset + nRowIndex % 3 * GetDefSize().Width() / 3 + ( nIndex - ( DEPPER_MAX_WIDTH * nRowIndex )) * (GetDefSize().Width() + OBJWIN_X_SPACING );
 
-    ULONG nPosY = ( nSet + mnLevelOffset + nRowIndex ) * ( GetDefSize().Height() + OBJWIN_Y_SPACING ) + OBJWIN_Y_SPACING;
+    sal_uIntPtr nPosY = ( nSet + mnLevelOffset + nRowIndex ) * ( GetDefSize().Height() + OBJWIN_Y_SPACING ) + OBJWIN_Y_SPACING;
     Point aPos( nPosX, nPosY );
     return aPos;
 }
 
-ULONG SolDep::CalcXOffset( ULONG nObjectsToFit )
+sal_uIntPtr SolDep::CalcXOffset( sal_uIntPtr nObjectsToFit )
 {
     long nDynXOffs;
     long nXMiddle;
-    ULONG nTrigger;
+    sal_uIntPtr nTrigger;
 
     nXMiddle = GetDepWin()->PixelToLogic( GetDepWin()->GetSizePixel()).Width() / 2;
     if ( nObjectsToFit > DEPPER_MAX_WIDTH )
         nObjectsToFit = DEPPER_MAX_WIDTH - 1 + DEPPER_MAX_WIDTH % 2;
     nTrigger = ( nObjectsToFit - 1 ) / 2;
     nDynXOffs = ( GetDefSize().Width() + OBJWIN_X_SPACING ) * nTrigger;
-    ULONG nXOffs = nXMiddle - nDynXOffs;
+    sal_uIntPtr nXOffs = nXMiddle - nDynXOffs;
 
-    if ( ULONG(nXMiddle - nDynXOffs) < mnMinDynXOffs )
+    if ( sal_uIntPtr(nXMiddle - nDynXOffs) < mnMinDynXOffs )
         mnMinDynXOffs = nXMiddle - nDynXOffs;
 
     return nXOffs;
@@ -1174,11 +1174,11 @@ double SolDep::CalcDistSum( ObjWinList* pObjList, DistType eDistType )
 {
     ObjectWin* pWin;
     Connector* pCon;
-    ULONG nObjCount = pObjList->Count();
+    sal_uIntPtr nObjCount = pObjList->Count();
     double dRetVal = 0;
     double dWinVal;
-    USHORT i, j;
-    BOOL bIsStart;
+    sal_uInt16 i, j;
+    sal_Bool bIsStart;
 
     for ( i = 0; i < nObjCount; i++ )
     {
@@ -1197,7 +1197,7 @@ double SolDep::CalcDistSum( ObjWinList* pObjList, DistType eDistType )
                         {
                             if ( bIsStart )
                             {
-                                pCon->UpdatePosition( pWin, FALSE );
+                                pCon->UpdatePosition( pWin, sal_False );
                                 dWinVal += pCon->GetLen() * pWin->mnHeadDist;
                             }
                         }
@@ -1205,14 +1205,14 @@ double SolDep::CalcDistSum( ObjWinList* pObjList, DistType eDistType )
                         {
                             if ( !bIsStart )
                             {
-                                pCon->UpdatePosition( pWin, FALSE );
+                                pCon->UpdatePosition( pWin, sal_False );
                                 dWinVal += pCon->GetLen() * pWin->mnRootDist;
                             }
 
                         }
                     else
                     {
-                        pCon->UpdatePosition( pWin, FALSE );
+                        pCon->UpdatePosition( pWin, sal_False );
                         if ( !bIsStart )
                             dWinVal += pCon->GetLen() * ( pWin->mnHeadDist + 1 );
                         else
@@ -1230,17 +1230,17 @@ double SolDep::CalcDistSum( ObjWinList* pObjList, DistType eDistType )
     return dRetVal;
 }
 
-USHORT SolDep::Impl_Traveller( ObjectWin* pWin, USHORT nDepth )
+sal_uInt16 SolDep::Impl_Traveller( ObjectWin* pWin, sal_uInt16 nDepth )
 {
-    USHORT i = 0;
+    sal_uInt16 i = 0;
     ObjectWin* pNewWin;
     Connector* pCon;
 
     nDepth++;
 
-    USHORT nMaxDepth = nDepth;
+    sal_uInt16 nMaxDepth = nDepth;
 
-    pWin->mbVisited = TRUE;
+    pWin->mbVisited = sal_True;
     pWin->mnRootDist = Max ( nDepth, pWin-> mnRootDist );
     if ( nDepth > DEPPER_MAX_DEPTH )
     {
@@ -1268,31 +1268,31 @@ USHORT SolDep::Impl_Traveller( ObjectWin* pWin, USHORT nDepth )
 }
 
 
-double SolDep::Impl_PermuteMin( ObjWinList& rObjList, Point* pPosArray, ObjWinList& rResultList, double dMinDist, ULONG nStart, ULONG nSize, DistType eDistType )
+double SolDep::Impl_PermuteMin( ObjWinList& rObjList, Point* pPosArray, ObjWinList& rResultList, double dMinDist, sal_uIntPtr nStart, sal_uIntPtr nSize, DistType eDistType )
 {
 
-    ULONG i, j, l;
-    ULONG nEnd = nStart + nSize;
+    sal_uIntPtr i, j, l;
+    sal_uIntPtr nEnd = nStart + nSize;
     ObjectWin* pSwapWin;
-    ULONG nLevelObjCount = rObjList.Count();
+    sal_uIntPtr nLevelObjCount = rObjList.Count();
 
 //dont use full recusion for more than 6 objects
     if ( nLevelObjCount > 6 )
     {
         srand(( unsigned ) time( NULL ));
 
-        ULONG nIdx1, nIdx2;
+        sal_uIntPtr nIdx1, nIdx2;
         for ( i = 0; i < 101; i++ )
         {
             UpdateSubProgrssBar(i);
             for ( j = 0; j < 100; j++ )
             {
-                nIdx1 = (ULONG) ( double( rand() ) / RAND_MAX * nLevelObjCount );
+                nIdx1 = (sal_uIntPtr) ( double( rand() ) / RAND_MAX * nLevelObjCount );
                 while ( rObjList.GetObject( nIdx1 ) == NULL )
-                    nIdx1 = (ULONG) ( double( rand() ) / RAND_MAX * nLevelObjCount );
-                nIdx2 = (ULONG) ( double( rand() ) / RAND_MAX * nLevelObjCount );
+                    nIdx1 = (sal_uIntPtr) ( double( rand() ) / RAND_MAX * nLevelObjCount );
+                nIdx2 = (sal_uIntPtr) ( double( rand() ) / RAND_MAX * nLevelObjCount );
                 while ( nIdx1 == nIdx2 || nIdx2 == nLevelObjCount )
-                    nIdx2 = (ULONG) ( double( rand() ) / RAND_MAX * nLevelObjCount );
+                    nIdx2 = (sal_uIntPtr) ( double( rand() ) / RAND_MAX * nLevelObjCount );
 
                 pSwapWin = rObjList.GetObject( nIdx1 );
                 if ( pSwapWin )
@@ -1374,15 +1374,15 @@ double SolDep::Impl_PermuteMin( ObjWinList& rObjList, Point* pPosArray, ObjWinLi
 }
 
 
-USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nTopId, ULONG nBottmId, ULONG aObjID )
+sal_uInt16 SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, sal_uIntPtr nTopId, sal_uIntPtr nBottmId, sal_uIntPtr aObjID )
 {
     ObjWinList aWorkList;
     ObjectWin* pWin;
     Connector* pCon;
-    USHORT nRootDist = (USHORT) -1;
-    USHORT i, j, k, l, nRetVal;
-    USHORT LevelUse[ DEPPER_MAX_DEPTH ];
-    USHORT LevelSecUse[ DEPPER_MAX_DEPTH ];
+    sal_uInt16 nRootDist = (sal_uInt16) -1;
+    sal_uInt16 i, j, k, l, nRetVal;
+    sal_uInt16 LevelUse[ DEPPER_MAX_DEPTH ];
+    sal_uInt16 LevelSecUse[ DEPPER_MAX_DEPTH ];
     ObjWinList* LevelList[ DEPPER_MAX_DEPTH ];
     ObjWinList* LevelSecList[ DEPPER_MAX_DEPTH ];
     Point aPosArray[ DEPPER_MAX_LEVEL_WIDTH * DEPPER_MAX_WIDTH ];
@@ -1397,22 +1397,22 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
         LevelSecList[ i ] = NULL;
     }
 
-    GetDepWin()->EnablePaint( FALSE );
+    GetDepWin()->EnablePaint( sal_False );
 
-    ULONG nObjCount = pObjLst->Count();
+    sal_uIntPtr nObjCount = pObjLst->Count();
     for ( i = 0; i < nObjCount; i++ )
     {
         pWin = pObjLst->GetObject( i );
         if ( pWin->IsVisible()) {
-            pWin->mbVisited = FALSE;
+            pWin->mbVisited = sal_False;
             pWin->mnHeadDist = 0;
             pWin->mnRootDist = 0;
 
             // find initial objects which need to be connected with
             // root object
             j = 0;
-            USHORT nStartCount = 0;
-            USHORT nEndCount = 0;
+            sal_uInt16 nStartCount = 0;
+            sal_uInt16 nEndCount = 0;
             while ( (pCon = pWin->GetConnector( j )) )
             {
                 if ( pCon->IsVisible()) {                   //null_project
@@ -1452,8 +1452,8 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
         return nRetVal;
     }
 
-    ULONG nUnvisited = 0;
-    ULONG nUnvisYOffs = 0;
+    sal_uIntPtr nUnvisited = 0;
+    sal_uIntPtr nUnvisYOffs = 0;
 
     // seperate mainstream, secondary and unconnected
     for ( i = 0; i < nObjCount; i++ )
@@ -1492,7 +1492,7 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
 
     mnLevelOffset = 0;
 
-    USHORT nScaleVal;
+    sal_uInt16 nScaleVal;
 
     if ( nRetVal == 0 )
         nScaleVal = 1;
@@ -1501,14 +1501,14 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
 
     i = 0;
 
-    USHORT nStep = 0;
+    sal_uInt16 nStep = 0;
 
     while ( LevelList[ i ] )
     {
         UpdateMainProgressBar(i, nScaleVal, nStep);
         DBG_ASSERT( LevelUse[ i ] == LevelList[ i ]->Count() , "level index im a..." );
         ObjectWin* pSwapWin;
-        ULONG nLevelObjCount = LevelList[ i ]->Count();
+        sal_uIntPtr nLevelObjCount = LevelList[ i ]->Count();
 
         if ( nLevelObjCount % 2 == 0 )
         {
@@ -1555,7 +1555,7 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
 
         if ( LevelSecList[ i ] != NULL )
         {
-            ULONG nLevelSecObjCount = LevelSecList[ i ]->Count();
+            sal_uIntPtr nLevelSecObjCount = LevelSecList[ i ]->Count();
             // expand list for better positioning
             while ( nLevelSecObjCount + LevelUse[ i ] < DEPPER_MAX_WIDTH - 1 )
             {
@@ -1579,19 +1579,19 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
             aWorkList.Clear();
 
             l = 0;
-            BOOL bUsedPos;
+            sal_Bool bUsedPos;
 
             // find free positions for secondary objects
             for ( j = 0; j < ( LevelUse[ i ] + nLevelSecObjCount ) ; j++ )
             {
                 Point aPos = CalcPos( i, j );
-                bUsedPos = FALSE;
+                bUsedPos = sal_False;
                 // is already occupied?
                 for ( k = 0; k < nLevelObjCount; k++ )
                 {
                     if ( LevelList[ i ]->GetObject( k ) )
                         if ( aPos == LevelList[ i ]->GetObject( k )->GetCalcPosPixel() )
-                            bUsedPos = TRUE;
+                            bUsedPos = sal_True;
                 }
                 // if its free, add to pool
                 if ( !bUsedPos )
@@ -1636,11 +1636,11 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
     do
     {
         i--;
-        UpdateMainProgressBar(i, nScaleVal, nStep, TRUE); // TRUE ~ counting down
+        UpdateMainProgressBar(i, nScaleVal, nStep, sal_True); // sal_True ~ counting down
         if ( LevelUse[ i ] + LevelSecUse[ i ] > DEPPER_MAX_WIDTH )
             mnLevelOffset-= ( LevelUse[ i ] + LevelSecUse[ i ] ) / DEPPER_MAX_WIDTH ;
         ObjectWin* pSwapWin;
-        ULONG nLevelObjCount = LevelList[ i ]->Count();
+        sal_uIntPtr nLevelObjCount = LevelList[ i ]->Count();
         mnXOffset = CalcXOffset( nLevelObjCount );
         aWorkList.Clear();
 
@@ -1669,23 +1669,23 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
 
         if ( LevelSecList[ i ] != NULL )
         {
-            ULONG nLevelSecObjCount = LevelSecList[ i ]->Count();
+            sal_uIntPtr nLevelSecObjCount = LevelSecList[ i ]->Count();
             mnXOffset = CalcXOffset( LevelUse[ i ] + nLevelSecObjCount );
             aWorkList.Clear();
 
             l = 0;
-            BOOL bUsedPos;
+            sal_Bool bUsedPos;
 
             for ( j = 0; j < ( LevelUse[ i ] + nLevelSecObjCount ) ; j++ )
             {
                 Point aPos = CalcPos( i, j );
-                bUsedPos = FALSE;
+                bUsedPos = sal_False;
 // could be faster
                 for ( k = 0; k < nLevelObjCount; k++ )
                 {
                     if ( LevelList[ i ]->GetObject( k ) )
                         if ( aPos == LevelList[ i ]->GetObject( k )->GetCalcPosPixel() )
-                            bUsedPos = TRUE;
+                            bUsedPos = sal_True;
                 }
                 if ( !bUsedPos )
                 {
@@ -1716,18 +1716,18 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
     } while ( i != 0 );
     SetMainProgressBar( 100 );
 
-    ULONG nNewXSize = ( DEPPER_MAX_WIDTH + 1 )  * ( OBJWIN_X_SPACING + GetDefSize().Width() );
+    sal_uIntPtr nNewXSize = ( DEPPER_MAX_WIDTH + 1 )  * ( OBJWIN_X_SPACING + GetDefSize().Width() );
 
-    //    ULONG aObjID = GetStart(pIdMapper, pObjLst) //hier muß man switchen GetStart/GetPrjStart oder so
+    //    sal_uIntPtr aObjID = GetStart(pIdMapper, pObjLst) //hier muß man switchen GetStart/GetPrjStart oder so
 
     ObjectWin* pObjWin = ObjIdToPtr( pObjLst, aObjID);
 
-    ULONG nNewYSize = pObjWin->GetCalcPosPixel().Y() + GetDefSize().Height() + 2 * OBJWIN_Y_SPACING;
+    sal_uIntPtr nNewYSize = pObjWin->GetCalcPosPixel().Y() + GetDefSize().Height() + 2 * OBJWIN_Y_SPACING;
     if (( nUnvisYOffs + GetDefSize().Height()) > nNewYSize )
         nNewYSize = nUnvisYOffs + GetDefSize().Height();
 
     MapMode aMapMode = GetDepWin()->GetMapMode();
-    Size aTmpSize( (ULONG) (double(nNewXSize) * double( aMapMode.GetScaleX())), (ULONG) (double( nNewYSize) * double( aMapMode.GetScaleY())));
+    Size aTmpSize( (sal_uIntPtr) (double(nNewXSize) * double( aMapMode.GetScaleX())), (sal_uIntPtr) (double( nNewYSize) * double( aMapMode.GetScaleY())));
 
     Size aNowSize( GetGraphWin()->GetSizePixel());
 
@@ -1745,7 +1745,7 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
 //  }
 
 // now remap all objects
-    ULONG nAllObjCount = pObjLst->Count();
+    sal_uIntPtr nAllObjCount = pObjLst->Count();
     Point aTmpPos;
     for ( j = 0; j < nAllObjCount; j++ )
     {
@@ -1765,7 +1765,7 @@ USHORT SolDep::OptimizePos(SolIdMapper* pIdMapper, ObjectList* pObjLst, ULONG nT
         }
     }
     aWorkList.Clear();
-    GetDepWin()->EnablePaint( TRUE );
+    GetDepWin()->EnablePaint( sal_True );
     GetDepWin()->Invalidate();
 //LevelListen loeschen                  Hä? Welche Levellisten?
 
@@ -1797,7 +1797,7 @@ void SolDep::WriteToErrorFile()
     FILE* pErrFile = fopen( "depper.err", "w+" );
     if ( pErrFile )
     {
-        for ( USHORT i = 0; i < mpTravellerList->Count(); i++ )
+        for ( sal_uInt16 i = 0; i < mpTravellerList->Count(); i++ )
         {
             pWin = mpTravellerList->GetObject( i );
             fprintf( pErrFile, " %s -> \n", (pWin->GetBodyText()).GetBuffer());
diff --git a/soldep/source/soldlg.cxx b/soldep/source/soldlg.cxx
index 96ad469f8284..a561f5ae6f03 100644
--- a/soldep/source/soldlg.cxx
+++ b/soldep/source/soldlg.cxx
@@ -165,7 +165,7 @@ SolSelectVersionDlg::SolSelectVersionDlg(
 {
     FreeResource();
     //Fill the ListBox with MWS versions (e.g. SRC680) from "stand.lst"
-    for ( ULONG i = 0; i < pStandLst->Count(); i++ ) {
+    for ( sal_uIntPtr i = 0; i < pStandLst->Count(); i++ ) {
         String sVersion( *pStandLst->GetObject( i ), RTL_TEXTENCODING_ASCII_US );
         maVersionListBox.InsertEntry( sVersion );
     }
@@ -252,9 +252,9 @@ SolFindProjectDlg::SolFindProjectDlg( Window *pParent, ObjWinList* pObjList )
     maCombobox.SetDropDownLineCount(15);
 //    SolDep* pSolDep = ((MyApp*)GetpApp())->GetSolDep();
 //    ObjWinList* pObjList = pSolDep->GetObjectList();
-    ULONG n = pObjList->Count();
+    sal_uIntPtr n = pObjList->Count();
     //Fill combobox
-    for (ULONG i=0; i<n; i++) {
+    for (sal_uIntPtr i=0; i<n; i++) {
         ByteString prjname = pObjList->GetObject( i )->GetBodyText();
         if (prjname != ByteString("null"))                                 //null_project
             maCombobox.InsertEntry( String(prjname,RTL_TEXTENCODING_UTF8) );
@@ -264,4 +264,4 @@ SolFindProjectDlg::SolFindProjectDlg( Window *pParent, ObjWinList* pObjList )
 ByteString SolFindProjectDlg::GetProject()
 {
     return ByteString(maCombobox.GetText(),RTL_TEXTENCODING_UTF8);
-}
\ No newline at end of file
+}
diff --git a/soldep/source/tbox.cxx b/soldep/source/tbox.cxx
index 327941167808..4eec7dbb883c 100644
--- a/soldep/source/tbox.cxx
+++ b/soldep/source/tbox.cxx
@@ -34,16 +34,16 @@
 
 
 
-SoldepToolBox::SoldepToolBox( Window* pParent, const ResId& aId, BOOL bDAble ) :
+SoldepToolBox::SoldepToolBox( Window* pParent, const ResId& aId, sal_Bool bDAble ) :
                 ToolBox( pParent, aId ),
                 bDockable( bDAble ),
-                bCloseMode( FALSE ),
-                bBoxIsVisible( TRUE ),
-                bPinable( TRUE ),
+                bCloseMode( sal_False ),
+                bBoxIsVisible( sal_True ),
+                bPinable( sal_True ),
                 aPinedBitmap( DtSodResId( TID_SMALL_PIN_PINED )),     // BMP_SMALL_PIN_PINED
                 aUnpinedBitmap( DtSodResId( TID_SMALL_PIN_UNPINED ))   // BMP_SMALL_PIN_UNPINED
 {
-    bPinable = TRUE;
+    bPinable = sal_True;
 
     SetAlign( WINDOWALIGN_TOP );
     HideItem(TID_SOLDEP_BACK);    //Inital hide this item, activated in project view.
@@ -53,7 +53,7 @@ SoldepToolBox::SoldepToolBox( Window* pParent, const ResId& aId, BOOL bDAble ) :
     //SetMouseDownHdl(LINK(this,SoldepToolBox,MouseDownHdl));
     //SetFloatingLines( nFloatingLines );
     //SetFloatingMode( bFloatingMode );
-    BOOL bFloatingMode = FALSE;
+    sal_Bool bFloatingMode = sal_False;
     if ( bFloatingMode )
     {
         //Point aPos( sToolBoxInfo.GetToken( 4, ',' ).ToInt64(), sToolBoxInfo.GetToken( 5, ',' ).ToInt64());
@@ -64,11 +64,11 @@ SoldepToolBox::SoldepToolBox( Window* pParent, const ResId& aId, BOOL bDAble ) :
                                             // (ein Separator an 1er Pos wird
                                             // nicht gezeichnet,
                                             // schafft aber Platz.)
-    bBoxIsVisible = FALSE;
+    bBoxIsVisible = sal_False;
 //  if ( sToolBoxInfo.GetToken( 3, ',' ) == "Visible" ) {
-        for ( USHORT i = 0; i < GetItemCount() && !bBoxIsVisible; i++ )
+        for ( sal_uInt16 i = 0; i < GetItemCount() && !bBoxIsVisible; i++ )
         {
-//          USHORT nItemId = GetItemId( i );
+//          sal_uInt16 nItemId = GetItemId( i );
 
             switch ( GetItemType( i ))
             {
@@ -77,7 +77,7 @@ SoldepToolBox::SoldepToolBox( Window* pParent, const ResId& aId, BOOL bDAble ) :
                 case TOOLBOXITEM_SEPARATOR :
                     break;
                 default:
-                    bBoxIsVisible = TRUE;
+                    bBoxIsVisible = sal_True;
                     break;
             }
         }
@@ -115,12 +115,12 @@ void SoldepToolBox::Paint( const Rectangle& rRect )
 
     if ( bDockable )
     {
-        USHORT nItemId = GetItemId( 0 );
+        sal_uInt16 nItemId = GetItemId( 0 );
 
         // ... zeichnen wir den wunderbaren Abreiád”del �ber das erste Item (Seperator)
 
         if ( !IsFloatingMode() && ( mnCurLine == 1 )) {
-            BOOL bIsCloseable = (( mnWinStyle & WB_CLOSEABLE ) != 0 );
+            sal_Bool bIsCloseable = (( mnWinStyle & WB_CLOSEABLE ) != 0 );
 
             ShowItem( nItemId );
             Rectangle aRect = GetItemRect( nItemId );
@@ -236,7 +236,7 @@ void SoldepToolBox::MouseButtonDown(const MouseEvent& rEvent)
                 Invalidate();
             }
             else {
-                bCloseMode = TRUE;
+                bCloseMode = sal_True;
 
                 // ... und zeichnen ggf. den Button gedr�ckt.
 
@@ -274,7 +274,7 @@ void SoldepToolBox::MouseButtonUp(const MouseEvent& rEvent)
 
     if ( bCloseMode )
     {
-        bCloseMode = FALSE;
+        bCloseMode = sal_False;
 
         // ... so zeichen wir diesen wieder normal ...
 
@@ -338,7 +338,7 @@ void SoldepToolBox::MouseMove(const MouseEvent& rEvent)
                 DrawLine( Point( aRect.Left(), aRect.Bottom()), Point( aRect.Right(), aRect.Bottom()));
             DrawLine( Point( aRect.Right(), aRect.Bottom()), Point( aRect.Right(), aRect.Top()));
 
-            bCloseMode = FALSE;
+            bCloseMode = sal_False;
         }
         else
         {
@@ -360,7 +360,7 @@ void SoldepToolBox::ToggleFloatingMode()
 }
 
 /*****************************************************************************/
-void SoldepToolBox::EndDocking( const Rectangle& rRect, BOOL bFloatMode )
+void SoldepToolBox::EndDocking( const Rectangle& rRect, sal_Bool bFloatMode )
 /*****************************************************************************/
 {
     ToolBox::EndDocking( rRect, bFloatMode );
@@ -373,12 +373,12 @@ void SoldepToolBox::EndDocking( const Rectangle& rRect, BOOL bFloatMode )
 };
 
 /*****************************************************************************/
-BOOL SoldepToolBox::Close()
+sal_Bool SoldepToolBox::Close()
 /*****************************************************************************/
 {
-    if (!ToolBox::Close()) return FALSE;
+    if (!ToolBox::Close()) return sal_False;
 
-    return TRUE;
+    return sal_True;
 }
 
 /*****************************************************************************/
@@ -396,7 +396,7 @@ void SoldepToolBox::Move()
 void SoldepToolBox::CloseDockingMode()
 {
     Hide();
-    bBoxIsVisible = FALSE;
+    bBoxIsVisible = sal_False;
     CallEventListeners( VCLEVENT_USER_TBOX_RESIZE_APP, this);
 }
 
@@ -430,10 +430,10 @@ void SoldepToolBox::Command( const CommandEvent& rCEvt)
 
             switch( GetAlign())
             {
-                case WINDOWALIGN_TOP : aPopupMenu.EnableItem( 1, FALSE ); break;
-                case WINDOWALIGN_BOTTOM : aPopupMenu.EnableItem( 2, FALSE ); break;
-                case WINDOWALIGN_LEFT : aPopupMenu.EnableItem( 3, FALSE ); break;
-                case WINDOWALIGN_RIGHT : aPopupMenu.EnableItem( 4, FALSE ); break;
+                case WINDOWALIGN_TOP : aPopupMenu.EnableItem( 1, sal_False ); break;
+                case WINDOWALIGN_BOTTOM : aPopupMenu.EnableItem( 2, sal_False ); break;
+                case WINDOWALIGN_LEFT : aPopupMenu.EnableItem( 3, sal_False ); break;
+                case WINDOWALIGN_RIGHT : aPopupMenu.EnableItem( 4, sal_False ); break;
             }
 
             if (( mnWinStyle & WB_CLOSEABLE ) != 0 )
@@ -478,15 +478,15 @@ PopupMenu *SoldepToolBox::GetContextMenu()
 
 void SoldepToolBox::InitContextMenu()
 {
-    USHORT nStart = 0;
+    sal_uInt16 nStart = 0;
     if ( bDockable )
         nStart = 1;
 
     aMenu.Clear();
 
-    for ( USHORT i = nStart; i < GetItemCount(); i++ )
+    for ( sal_uInt16 i = nStart; i < GetItemCount(); i++ )
     {
-        USHORT nItemId = GetItemId( i );
+        sal_uInt16 nItemId = GetItemId( i );
 
         switch ( GetItemType( i ))
         {
@@ -498,8 +498,8 @@ void SoldepToolBox::InitContextMenu()
                 break;
             default:
                 aMenu.InsertItem( nItemId, GetItemText( nItemId ), GetItemImage( nItemId ));
-                if (IsItemChecked( nItemId )) aMenu.CheckItem( nItemId, TRUE );
-                if (!IsItemEnabled( nItemId )) aMenu.EnableItem( nItemId, FALSE );
+                if (IsItemChecked( nItemId )) aMenu.CheckItem( nItemId, sal_True );
+                if (!IsItemEnabled( nItemId )) aMenu.EnableItem( nItemId, sal_False );
                 if (!IsItemVisible( nItemId )) aMenu.HideItem(nItemId);
                 break;
         }
@@ -554,7 +554,7 @@ void SoldepToolBox::StartDocking()
     CallEventListeners( VCLEVENT_USER_TBOX_RESIZE_APP, this);
 };
 
-BOOL SoldepToolBox::GetPin()
+sal_Bool SoldepToolBox::GetPin()
 
 {
     return bPin;
@@ -565,7 +565,7 @@ void SoldepToolBox::TogglePin()
      bPin = !bPin;
 }
 
-void SoldepToolBox::SetPin( BOOL bP )
+void SoldepToolBox::SetPin( sal_Bool bP )
 {
     bPin = bP;
 }
@@ -579,13 +579,13 @@ void SoldepToolBox::SetPin( BOOL bP )
 IMPL_LINK ( SoldepToolBox, MenuSelectHdl, Menu*, pMenu )
 {
     // Wenn die CurItemId <= 6 ist, dann wurde das Abreiád”del-Context-Men� ausgef�hrt ...
-    ULONG itemid;
+    sal_uIntPtr itemid;
     itemid = pMenu->GetCurItemId();
 
     if ( pMenu == &aMenu )
     {
         // ... Andernfalls wurde das Default-Context-Men� ausgef�hrt ...
-        USHORT nTmpId = mnCurItemId;
+        sal_uInt16 nTmpId = mnCurItemId;
         mnCurItemId = pMenu->GetCurItemId();
 
         // ... und der gesetzte Handler (in soldep.cxx) wird gerufen.
@@ -593,4 +593,4 @@ IMPL_LINK ( SoldepToolBox, MenuSelectHdl, Menu*, pMenu )
         mnCurItemId = nTmpId;
     }
     return 0;
-}
\ No newline at end of file
+}