Merge branch 'master' of git://anongit.freedesktop.org/libreoffice/components

38 files changed, 414 insertions, 482 deletions

diff --git a/automation/inc/automation/commdefines.hxx b/automation/inc/automation/commdefines.hxx
index caf6da73d..3333a58a7 100644
--- a/automation/inc/automation/commdefines.hxx
+++ b/automation/inc/automation/commdefines.hxx
@@ -38,22 +38,22 @@
 #include <osl/endian.h>
 
 #ifndef MAKEDWORD
-#define MAKEDWORD(wl, wh)   ((comm_DWORD)((wl) & 0xFFFF) | (((comm_DWORD)(wh) & 0xFFFF) << 16))
+#define MAKEDWORD(wl, wh)   ((sal_uInt32)((wl) & 0xFFFF) | (((sal_uInt32)(wh) & 0xFFFF) << 16))
 #endif
 #ifndef LOWORD
-#define LOWORD(d)           ((comm_WORD)((comm_DWORD)(d) & 0xFFFF))
+#define LOWORD(d)           ((sal_uInt16)((sal_uInt32)(d) & 0xFFFF))
 #endif
 #ifndef HIWORD
-#define HIWORD(d)           ((comm_WORD)(((comm_DWORD)(d) >> 16) & 0xFFFF))
+#define HIWORD(d)           ((sal_uInt16)(((sal_uInt32)(d) >> 16) & 0xFFFF))
 #endif
 #ifndef MAKEWORD
-#define MAKEWORD(bl, bh)    ((comm_WORD)((bl) & 0xFF) | (((comm_WORD)(bh) & 0xFF) << 8))
+#define MAKEWORD(bl, bh)    ((sal_uInt16)((bl) & 0xFF) | (((sal_uInt16)(bh) & 0xFF) << 8))
 #endif
 #ifndef LOBYTE
-#define LOBYTE(w)           ((comm_BYTE)((comm_WORD)(w) & 0xFF))
+#define LOBYTE(w)           ((comm_BYTE)((sal_uInt16)(w) & 0xFF))
 #endif
 #ifndef HIBYTE
-#define HIBYTE(w)           ((comm_BYTE)(((comm_WORD)(w) >> 8) & 0xFF))
+#define HIBYTE(w)           ((comm_BYTE)(((sal_uInt16)(w) >> 8) & 0xFF))
 #endif
 #ifndef MAKEBYTE
 #define MAKEBYTE(nl, nh)    ((comm_BYTE)(((nl) & 0x0F) | (((nh) & 0x0F) << 4)))
@@ -74,10 +74,10 @@
 
 #ifdef OSL_BIGENDIAN
 #ifndef NETWORD
-#define NETWORD(w)          (comm_WORD)(w)
+#define NETWORD(w)          (sal_uInt16)(w)
 #endif
 #ifndef NETDWORD
-#define NETDWORD(d)         (comm_DWORD)(d)
+#define NETDWORD(d)         (sal_uInt32)(d)
 #endif
 #endif // OSL_BIGENDIAN
 
@@ -123,8 +123,8 @@ typedef comm_UINT16 CMProtocol;
 #define CM_PROTOCOL_BROADCASTER		(CMProtocol)0x0002
 #define CM_PROTOCOL_USER_START		(CMProtocol)0x0100
 
-typedef comm_USHORT HandshakeType;
-typedef comm_USHORT CommunicationOption;
+typedef comm_UINT16 HandshakeType;
+typedef comm_UINT16 CommunicationOption;
 
 #define CH_NoHeader					0x0000
 #define CH_SimpleMultiChannel		0x0001
diff --git a/automation/inc/automation/commtypes.hxx b/automation/inc/automation/commtypes.hxx
index 843172539..cb6bdfda2 100644
--- a/automation/inc/automation/commtypes.hxx
+++ b/automation/inc/automation/commtypes.hxx
@@ -36,13 +36,9 @@
  *
  ************************************************************************/
 
-/** defines al least types
+/** defines:
     comm_BYTE
-    comm_WORD;
-    comm_DWORD;
     comm_BOOL
-    comm_ULONG
-    comm_USHORT
     comm_UINT16
     comm_UINT32
     comm_UniChar
@@ -60,14 +56,9 @@ typedef sal_Unicode comm_UniChar;
 #include <tools/solar.h>
 typedef sal_uInt8 comm_BYTE;
 typedef sal_Bool comm_BOOL;
-typedef sal_uInt32 comm_ULONG;
-typedef sal_uInt16 comm_USHORT;
 typedef sal_uInt16 comm_UINT16;
 typedef sal_uInt32 comm_UINT32;
 
-typedef sal_uInt16      comm_WORD;
-typedef sal_uInt32      comm_DWORD;
-
 class String;
 #define comm_String String
 
diff --git a/automation/source/inc/cmdbasestream.hxx b/automation/source/inc/cmdbasestream.hxx
index a187a5bae..87803074d 100644
--- a/automation/source/inc/cmdbasestream.hxx
+++ b/automation/source/inc/cmdbasestream.hxx
@@ -51,33 +51,33 @@ public:
 
     void GenError( rtl::OString *pUId, comm_String *pString );
 
-    void GenReturn( comm_USHORT nRet, comm_ULONG nNr );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_ULONG nNr );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_String *pString );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_BOOL bBool );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_ULONG nNr, comm_String *pString, comm_BOOL bBool );
+    void GenReturn( comm_UINT16 nRet, comm_UINT32 nNr );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT32 nNr );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_String *pString );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_BOOL bBool );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT32 nNr, comm_String *pString, comm_BOOL bBool );
 
-    void GenReturn( comm_USHORT nRet, comm_USHORT nMethod, comm_ULONG nNr );
-    void GenReturn( comm_USHORT nRet, comm_USHORT nMethod, comm_String *pString );
-    void GenReturn( comm_USHORT nRet, comm_USHORT nMethod, comm_BOOL bBool );
-    void GenReturn( comm_USHORT nRet, comm_USHORT nMethod, comm_USHORT nNr );
+    void GenReturn( comm_UINT16 nRet, comm_UINT16 nMethod, comm_UINT32 nNr );
+    void GenReturn( comm_UINT16 nRet, comm_UINT16 nMethod, comm_String *pString );
+    void GenReturn( comm_UINT16 nRet, comm_UINT16 nMethod, comm_BOOL bBool );
+    void GenReturn( comm_UINT16 nRet, comm_UINT16 nMethod, comm_UINT16 nNr );
 
 // MacroRecorder
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod ); // also used outside MacroRecorder
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_String *pString );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_String *pString, comm_BOOL bBool );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_BOOL bBool );
-    void GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_ULONG nNr );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod ); // also used outside MacroRecorder
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_String *pString );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_String *pString, comm_BOOL bBool );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_BOOL bBool );
+    void GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_UINT32 nNr );
 
-    void Read ( comm_USHORT &nNr );
-    void Read ( comm_ULONG &nNr );
-    void Read (comm_UniChar* &aString, comm_USHORT &nLenInChars );
+    void Read ( comm_UINT16 &nNr );
+    void Read ( comm_UINT32 &nNr );
+    void Read (comm_UniChar* &aString, comm_UINT16 &nLenInChars );
     void Read ( comm_BOOL &bBool );
-    comm_USHORT GetNextType();
+    comm_UINT16 GetNextType();
 
-    void Write( comm_USHORT nNr );
-    void Write( comm_ULONG nNr );
-    void Write( const comm_UniChar* aString, comm_USHORT nLenInChars );
+    void Write( comm_UINT16 nNr );
+    void Write( comm_UINT32 nNr );
+    void Write( const comm_UniChar* aString, comm_UINT16 nLenInChars );
     void Write( comm_BOOL bBool );
 
 // Complex Datatypes to be handled system dependent
diff --git a/automation/source/inc/icommstream.hxx b/automation/source/inc/icommstream.hxx
index cb74977d6..147dfe56f 100644
--- a/automation/source/inc/icommstream.hxx
+++ b/automation/source/inc/icommstream.hxx
@@ -46,19 +46,19 @@ public:
     ICommStream(){}
     virtual ~ICommStream(){}
 
-    virtual ICommStream&	operator>>( comm_USHORT& rUShort )=0;
-    virtual ICommStream&	operator>>( comm_ULONG& rULong )=0;
+    virtual ICommStream&	operator>>( comm_UINT16& rUShort )=0;
+    virtual ICommStream&	operator>>( comm_UINT32& rULong )=0;
     virtual ICommStream&	operator>>( comm_BOOL& rChar )=0;
 
-    virtual ICommStream&	operator<<( comm_USHORT nUShort )=0;
-    virtual ICommStream&	operator<<( comm_ULONG nULong )=0;
+    virtual ICommStream&	operator<<( comm_UINT16 nUShort )=0;
+    virtual ICommStream&	operator<<( comm_UINT32 nULong )=0;
     virtual ICommStream&	operator<<( comm_BOOL nChar )=0;
 
-    virtual comm_ULONG			Read( void* pData, comm_ULONG nSize )=0;
-    virtual comm_ULONG			Write( const void* pData, comm_ULONG nSize )=0;
+    virtual comm_UINT32			Read( void* pData, comm_UINT32 nSize )=0;
+    virtual comm_UINT32			Write( const void* pData, comm_UINT32 nSize )=0;
 
     virtual comm_BOOL		IsEof() const=0;
-    virtual comm_ULONG		SeekRel( long nPos )=0;
+    virtual comm_UINT32		SeekRel( long nPos )=0;
 
 };
 
diff --git a/automation/source/inc/rcontrol.hxx b/automation/source/inc/rcontrol.hxx
index 67c8fa675..bc756ded1 100644
--- a/automation/source/inc/rcontrol.hxx
+++ b/automation/source/inc/rcontrol.hxx
@@ -54,8 +54,8 @@
 #define SIReturnError		13
 
 // Typisierung im Stream
-#define BinUSHORT			11
-#define BinULONG			14
+#define BinUINT16			11
+#define BinUINT32			14
 #define BinString			12
 #define BinBool				13
 #define BinSbxValue			15
@@ -443,12 +443,12 @@
 // Beschreibt die Parametertypen als Bitfeld  Reihenfolge immer!
 // wie hier Aufgelistet
 #define PARAM_NONE              0x0000
-#define PARAM_USHORT_1          0x0001
-#define PARAM_USHORT_2          0x0002
-#define PARAM_USHORT_3          0x0100		// Nicht in der Reihe!!
-#define PARAM_USHORT_4          0x0200		// Nicht in der Reihe!!
-#define PARAM_ULONG_1           0x0004
-#define PARAM_ULONG_2           0x0008
+#define PARAM_UINT16_1          0x0001
+#define PARAM_UINT16_2          0x0002
+#define PARAM_UINT16_3          0x0100		// Nicht in der Reihe!!
+#define PARAM_UINT16_4          0x0200		// Nicht in der Reihe!!
+#define PARAM_UINT32_1          0x0004
+#define PARAM_UINT32_2          0x0008
 #define PARAM_STR_1             0x0010
 #define PARAM_STR_2             0x0020
 #define PARAM_BOOL_1            0x0040
diff --git a/automation/source/inc/svcommstream.hxx b/automation/source/inc/svcommstream.hxx
index f3e8ee3d6..70c4a619e 100644
--- a/automation/source/inc/svcommstream.hxx
+++ b/automation/source/inc/svcommstream.hxx
@@ -41,19 +41,19 @@ public:
     SvCommStream( SvStream* pIO );
     ~SvCommStream();
 
-    ICommStream&		operator>>( comm_USHORT& rUShort );
-    ICommStream&		operator>>( comm_ULONG& rULong );
+    ICommStream&		operator>>( comm_UINT16& rUShort );
+    ICommStream&		operator>>( comm_UINT32& rULong );
     ICommStream&		operator>>( comm_BOOL& rChar );
 
-    ICommStream&		operator<<( comm_USHORT nUShort );
-    ICommStream&		operator<<( comm_ULONG nULong );
+    ICommStream&		operator<<( comm_UINT16 nUShort );
+    ICommStream&		operator<<( comm_UINT32 nULong );
     ICommStream&		operator<<( comm_BOOL nChar );
 
-    comm_ULONG		Read( void* pData, comm_ULONG nSize );
-    comm_ULONG		Write( const void* pData, comm_ULONG nSize );
+    comm_UINT32		Read( void* pData, comm_UINT32 nSize );
+    comm_UINT32		Write( const void* pData, comm_UINT32 nSize );
 
     comm_BOOL		IsEof() const;
-    comm_ULONG		SeekRel( long nPos );
+    comm_UINT32		SeekRel( long nPos );
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/automation/source/server/XMLParser.cxx b/automation/source/server/XMLParser.cxx
index dc9d11289..595eed464 100644
--- a/automation/source/server/XMLParser.cxx
+++ b/automation/source/server/XMLParser.cxx
@@ -496,7 +496,7 @@ void StatementCommand::HandleSAXParser()
             break;
         case RC_SAXGetNodeType:
             {
-                   pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)pSAXParser->GetCurrentNode()->GetNodeType() );
+                   pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)pSAXParser->GetCurrentNode()->GetNodeType() );
             }
             break;
         case RC_SAXGetAttributeCount:
@@ -514,17 +514,17 @@ void StatementCommand::HandleSAXParser()
                             pRet->GenReturn ( RET_Value, nMethodId, pElementNode->GetNodeName() );
                             break;
                         case RC_SAXGetChildCount:
-                            pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)pElementNode->GetChildCount() );
+                            pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)pElementNode->GetChildCount() );
                             break;
                         case RC_SAXGetAttributeCount:
                             if ( xAttributeList.is() )
-                                pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)xAttributeList->getLength() );
+                                pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)xAttributeList->getLength() );
                             else
-                                pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)0 );
+                                pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)0 );
                             break;
                         case RC_SAXGetAttributeName:
                             {
-                                if( (nParams & PARAM_USHORT_1) && ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, xAttributeList.is()?xAttributeList->getLength():0 ) )
+                                if( (nParams & PARAM_UINT16_1) && ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, xAttributeList.is()?xAttributeList->getLength():0 ) )
                                 {
                                     String aRet( xAttributeList->getNameByIndex( nNr1-1 ) );
                                     pRet->GenReturn ( RET_Value, nMethodId, aRet );
@@ -536,7 +536,7 @@ void StatementCommand::HandleSAXParser()
                         case RC_SAXGetAttributeValue:
                             // Number or String
                             {
-                                if( (nParams & PARAM_USHORT_1) && ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, xAttributeList.is()?xAttributeList->getLength():0 ) )
+                                if( (nParams & PARAM_UINT16_1) && ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, xAttributeList.is()?xAttributeList->getLength():0 ) )
                                 {
                                     String aRet( xAttributeList->getValueByIndex( nNr1-1 ) );
                                     pRet->GenReturn ( RET_Value, nMethodId, aRet );
@@ -578,7 +578,7 @@ void StatementCommand::HandleSAXParser()
             {
                 sal_Bool bCheckOnly = nMethodId == RC_SAXHasElement;
 
-                if( (nParams & PARAM_USHORT_1) && !(nParams & PARAM_STR_1) )
+                if( (nParams & PARAM_UINT16_1) && !(nParams & PARAM_STR_1) )
                 {
                     if ( nNr1 == 0 )
                     {
@@ -623,7 +623,7 @@ void StatementCommand::HandleSAXParser()
                     else if ( pElementNode )
                     {
                         sal_uInt16 nNthOccurrence;
-                        if( (nParams & PARAM_USHORT_1) )
+                        if( (nParams & PARAM_UINT16_1) )
                             nNthOccurrence = nNr1;
                         else
                             nNthOccurrence = 1;
diff --git a/automation/source/server/cmdbasestream.cxx b/automation/source/server/cmdbasestream.cxx
index d86e66245..b5a48e06a 100644
--- a/automation/source/server/cmdbasestream.cxx
+++ b/automation/source/server/cmdbasestream.cxx
@@ -53,184 +53,184 @@ CmdBaseStream::~CmdBaseStream()
 
 void CmdBaseStream::GenError (rtl::OString *pUId, comm_String *pString )
 {
-    Write(comm_USHORT(SIReturnError));
+    Write(comm_UINT16(SIReturnError));
     Write(pUId);
     Write(pString);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, comm_ULONG nUId )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, comm_UINT32 nUId )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     Write(nUId);
-    Write(comm_USHORT(PARAM_NONE));				// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_NONE));				// Typ der folgenden Parameter
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, rtl::OString *pUId, comm_ULONG nNr )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, rtl::OString *pUId, comm_UINT32 nNr )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     if ( pUId->equals( rtl::OString( "UID_ACTIVE" ) ) )
-        Write(comm_ULONG(0));
+        Write(comm_UINT32(0));
     else
         Write(pUId);
-    Write(comm_USHORT(PARAM_ULONG_1));			// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT32_1));			// Typ der folgenden Parameter
     Write(nNr);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, rtl::OString *pUId, comm_String *pString )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, rtl::OString *pUId, comm_String *pString )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     if ( pUId->equals( rtl::OString( "UID_ACTIVE" ) ) )
-        Write(comm_ULONG(0));
+        Write(comm_UINT32(0));
     else
         Write(pUId);
-    Write(comm_USHORT(PARAM_STR_1));				// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_STR_1));				// Typ der folgenden Parameter
     Write(pString);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, rtl::OString *pUId, comm_BOOL bBool )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, rtl::OString *pUId, comm_BOOL bBool )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     if ( pUId->equals( rtl::OString( "UID_ACTIVE" ) ) )
-        Write(comm_ULONG(0));
+        Write(comm_UINT32(0));
     else
         Write(pUId);
-    Write(comm_USHORT(PARAM_BOOL_1));			// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_BOOL_1));			// Typ der folgenden Parameter
     Write(bBool);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, rtl::OString *pUId, comm_ULONG nNr, comm_String *pString, comm_BOOL bBool )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, rtl::OString *pUId, comm_UINT32 nNr, comm_String *pString, comm_BOOL bBool )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     if ( pUId->equals( rtl::OString( "UID_ACTIVE" ) ) )
-        Write(comm_ULONG(0));
+        Write(comm_UINT32(0));
     else
         Write(pUId);
-    Write(comm_USHORT(PARAM_ULONG_1|PARAM_STR_1|PARAM_BOOL_1));		// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT32_1|PARAM_STR_1|PARAM_BOOL_1));		// Typ der folgenden Parameter
     Write(nNr);
     Write(pString);
     Write(bBool);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, comm_USHORT nMethod, comm_ULONG nNr )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, comm_UINT16 nMethod, comm_UINT32 nNr )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
-    Write((comm_ULONG)nMethod); //HELPID BACKWARD (no sal_uLong needed)
-    Write(comm_USHORT(PARAM_ULONG_1));			// Typ der folgenden Parameter
+    Write((comm_UINT32)nMethod); //HELPID BACKWARD (no sal_uLong needed)
+    Write(comm_UINT16(PARAM_UINT32_1));			// Typ der folgenden Parameter
     Write(nNr);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, comm_USHORT nMethod, comm_String *pString )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, comm_UINT16 nMethod, comm_String *pString )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
-    Write((comm_ULONG)nMethod); //HELPID BACKWARD (no sal_uLong needed)
-    Write(comm_USHORT(PARAM_STR_1));				// Typ der folgenden Parameter
+    Write((comm_UINT32)nMethod); //HELPID BACKWARD (no sal_uLong needed)
+    Write(comm_UINT16(PARAM_STR_1));				// Typ der folgenden Parameter
     Write(pString);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, comm_USHORT nMethod, comm_BOOL bBool )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, comm_UINT16 nMethod, comm_BOOL bBool )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
-    Write((comm_ULONG)nMethod); //HELPID BACKWARD (no sal_uLong needed)
-    Write(comm_USHORT(PARAM_BOOL_1));			// Typ der folgenden Parameter
+    Write((comm_UINT32)nMethod); //HELPID BACKWARD (no sal_uLong needed)
+    Write(comm_UINT16(PARAM_BOOL_1));			// Typ der folgenden Parameter
     Write(bBool);
 }
 
-void CmdBaseStream::GenReturn (comm_USHORT nRet, comm_USHORT nMethod, comm_USHORT nNr )
+void CmdBaseStream::GenReturn (comm_UINT16 nRet, comm_UINT16 nMethod, comm_UINT16 nNr )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
-    Write((comm_ULONG)nMethod); //HELPID BACKWARD (no sal_uLong needed)
-    Write(comm_USHORT(PARAM_USHORT_1));			// Typ der folgenden Parameter
+    Write((comm_UINT32)nMethod); //HELPID BACKWARD (no sal_uLong needed)
+    Write(comm_UINT16(PARAM_UINT16_1));			// Typ der folgenden Parameter
     Write(nNr);
 }
 
 
 // MacroRecorder
-void CmdBaseStream::GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod )
+void CmdBaseStream::GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     Write(pUId);
-    Write(comm_USHORT(PARAM_USHORT_1));		// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT16_1));		// Typ der folgenden Parameter
     Write(nMethod);
 }
 
-void CmdBaseStream::GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_String *pString )
+void CmdBaseStream::GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_String *pString )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     Write(pUId);
-    Write(comm_USHORT(PARAM_USHORT_1|PARAM_STR_1));		// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT16_1|PARAM_STR_1));		// Typ der folgenden Parameter
     Write(nMethod);
     Write(pString);
 }
 
-void CmdBaseStream::GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_String *pString, comm_BOOL bBool )
+void CmdBaseStream::GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_String *pString, comm_BOOL bBool )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     Write(pUId);
-    Write(comm_USHORT(PARAM_USHORT_1|PARAM_STR_1|PARAM_BOOL_1));		// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT16_1|PARAM_STR_1|PARAM_BOOL_1));		// Typ der folgenden Parameter
     Write(nMethod);
     Write(pString);
     Write(bBool);
 }
 
-void CmdBaseStream::GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_BOOL bBool )
+void CmdBaseStream::GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_BOOL bBool )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     Write(pUId);
-    Write(comm_USHORT(PARAM_USHORT_1|PARAM_BOOL_1));		// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT16_1|PARAM_BOOL_1));		// Typ der folgenden Parameter
     Write(nMethod);
     Write(bBool);
 }
 
-void CmdBaseStream::GenReturn( comm_USHORT nRet, rtl::OString *pUId, comm_USHORT nMethod, comm_ULONG nNr )
+void CmdBaseStream::GenReturn( comm_UINT16 nRet, rtl::OString *pUId, comm_UINT16 nMethod, comm_UINT32 nNr )
 {
-    Write(comm_USHORT(SIReturn));
+    Write(comm_UINT16(SIReturn));
     Write(nRet);
     Write(pUId);
-    Write(comm_USHORT(PARAM_USHORT_1|PARAM_ULONG_1));		// Typ der folgenden Parameter
+    Write(comm_UINT16(PARAM_UINT16_1|PARAM_UINT32_1));		// Typ der folgenden Parameter
     Write(nMethod);
     Write(nNr);
 }
 
 
 
-void CmdBaseStream::Read (comm_USHORT &nNr)
+void CmdBaseStream::Read (comm_UINT16 &nNr)
 {
-    comm_USHORT nId;
+    comm_UINT16 nId;
     *pCommStream >> nId;
     if (pCommStream->IsEof()) return;
 #if OSL_DEBUG_LEVEL > 1
-    if (nId != BinUSHORT) OSL_TRACE( "Falscher Typ im Stream: Erwartet USHORT, gefunden :%hu", nId );
+    if (nId != BinUINT16) OSL_TRACE( "Falscher Typ im Stream: Erwartet USHORT, gefunden :%hu", nId );
 #endif
     *pCommStream >> nNr;
 }
 
-void CmdBaseStream::Read (comm_ULONG &nNr)
+void CmdBaseStream::Read (comm_UINT32 &nNr)
 {
-    comm_USHORT nId;
+    comm_UINT16 nId;
     *pCommStream >> nId;
     if (pCommStream->IsEof()) return;
 #if OSL_DEBUG_LEVEL > 1
-    if (nId != BinULONG) OSL_TRACE( "Falscher Typ im Stream: Erwartet ULONG, gefunden :%hu", nId );
+    if (nId != BinUINT32) OSL_TRACE( "Falscher Typ im Stream: Erwartet ULONG, gefunden :%hu", nId );
 #endif
     *pCommStream >> nNr;
 }
 
-void CmdBaseStream::Read (comm_UniChar* &aString, comm_USHORT &nLenInChars )
+void CmdBaseStream::Read (comm_UniChar* &aString, comm_UINT16 &nLenInChars )
 {
-    comm_USHORT nId;
+    comm_UINT16 nId;
     *pCommStream >> nId;
 #if OSL_DEBUG_LEVEL > 1
     if (nId != BinString) OSL_TRACE( "Falscher Typ im Stream: Erwartet String, gefunden :%hu", nId );
@@ -239,10 +239,10 @@ void CmdBaseStream::Read (comm_UniChar* &aString, comm_USHORT &nLenInChars )
     *pCommStream >> nLenInChars;
 
     aString = new comm_UniChar [nLenInChars];
-    pCommStream->Read( aString, ((comm_ULONG)nLenInChars) * sizeof( comm_UniChar ) );
+    pCommStream->Read( aString, ((comm_UINT32)nLenInChars) * sizeof( comm_UniChar ) );
 #ifdef OSL_BIGENDIAN
     // we have to change the byteorder
-    comm_USHORT n;
+    comm_UINT16 n;
     for ( n = 0 ; n < nLenInChars ; n++ )
         aString[ n ] = aString[ n ] >> 8 | aString[ n ] << 8;
 #endif
@@ -250,7 +250,7 @@ void CmdBaseStream::Read (comm_UniChar* &aString, comm_USHORT &nLenInChars )
 
 void CmdBaseStream::Read (comm_BOOL &bBool)
 {
-    comm_USHORT nId;
+    comm_UINT16 nId;
     *pCommStream >> nId;
 #if OSL_DEBUG_LEVEL > 1
     if (nId != BinBool) OSL_TRACE( "Falscher Typ im Stream: Erwartet BOOL, gefunden :%hu", nId );
@@ -258,39 +258,39 @@ void CmdBaseStream::Read (comm_BOOL &bBool)
     *pCommStream >> bBool;
 }
 
-comm_USHORT CmdBaseStream::GetNextType()
+comm_UINT16 CmdBaseStream::GetNextType()
 {
-    comm_USHORT nId;
+    comm_UINT16 nId;
     *pCommStream >> nId;
     pCommStream->SeekRel(-2);
     return nId;
 }
 
 
-void CmdBaseStream::Write( comm_USHORT nNr )
+void CmdBaseStream::Write( comm_UINT16 nNr )
 {
-    *pCommStream << comm_USHORT( BinUSHORT );
+    *pCommStream << comm_UINT16( BinUINT16 );
     *pCommStream << nNr;
 }
 
-void CmdBaseStream::Write( comm_ULONG nNr )
+void CmdBaseStream::Write( comm_UINT32 nNr )
 {
-    *pCommStream << comm_USHORT( BinULONG );
+    *pCommStream << comm_UINT16( BinUINT32 );
     *pCommStream << nNr;
 }
 
-void CmdBaseStream::Write( const comm_UniChar* aString, comm_USHORT nLenInChars )
+void CmdBaseStream::Write( const comm_UniChar* aString, comm_UINT16 nLenInChars )
 {
-    *pCommStream << comm_USHORT(BinString);
+    *pCommStream << comm_UINT16(BinString);
 
-    comm_USHORT n;
+    comm_UINT16 n;
 
     // remove BiDi and zero-width-markers    0x200B - 0x200F 
     // remove BiDi and paragraph-markers     0x2028 - 0x202E
 
     comm_UniChar* aNoBiDiString;
     aNoBiDiString = new comm_UniChar [nLenInChars];
-    comm_USHORT nNewLenInChars = 0;
+    comm_UINT16 nNewLenInChars = 0;
     for ( n = 0 ; n < nLenInChars ; n++ )
     {
         comm_UniChar c = aString[ n ];
@@ -313,10 +313,10 @@ void CmdBaseStream::Write( const comm_UniChar* aString, comm_USHORT nLenInChars
     aNewString = new comm_UniChar [nNewLenInChars];
     for ( n = 0 ; n < nNewLenInChars ; n++ )
         aNewString[ n ] = aNoBiDiString[ n ] >> 8 | aNoBiDiString[ n ] << 8;
-    pCommStream->Write( aNewString, ((comm_ULONG)nNewLenInChars) * sizeof( comm_UniChar ) );
+    pCommStream->Write( aNewString, ((comm_UINT32)nNewLenInChars) * sizeof( comm_UniChar ) );
     delete [] aNewString;
 #else
-    pCommStream->Write( aNoBiDiString, ((comm_ULONG)nNewLenInChars) * sizeof( comm_UniChar ) );
+    pCommStream->Write( aNoBiDiString, ((comm_UINT32)nNewLenInChars) * sizeof( comm_UniChar ) );
 #endif
 
     delete [] aNoBiDiString;
@@ -324,7 +324,7 @@ void CmdBaseStream::Write( const comm_UniChar* aString, comm_USHORT nLenInChars
 
 void CmdBaseStream::Write( comm_BOOL bBool )
 {
-    *pCommStream << comm_USHORT( BinBool );
+    *pCommStream << comm_UINT16( BinBool );
     *pCommStream << bBool;
 }
 
diff --git a/automation/source/server/recorder.cxx b/automation/source/server/recorder.cxx
index c63e7c23e..a88efbebf 100644
--- a/automation/source/server/recorder.cxx
+++ b/automation/source/server/recorder.cxx
@@ -190,7 +190,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                     case VCLEVENT_WINDOW_ACTIVATE:
                         if ( m_bRecord )
                         {
-                            StatementList::pRet->GenReturn( RET_MacroRecorder, rtl::OString(), (comm_USHORT)(M_SetPage|M_RET_NUM_CONTROL), Id2Str( pWin->GetUniqueOrHelpId() ) );
+                            StatementList::pRet->GenReturn( RET_MacroRecorder, rtl::OString(), (comm_UINT16)(M_SetPage|M_RET_NUM_CONTROL), Id2Str( pWin->GetUniqueOrHelpId() ) );
                             bSendData = sal_True;
                         }
                         if ( m_bLog )
@@ -210,7 +210,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                             {
                                 if ( m_bRecord )
                                 {
-                                    StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_USHORT)M_Check );
+                                    StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_UINT16)M_Check );
                                     bSendData = sal_True;
                                 }
                                 if ( m_bLog )
@@ -228,7 +228,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                 {
                     case VCLEVENT_BUTTON_CLICK: //VCLEVENT_CHECKBOX_TOGGLE:
                         {
-                            comm_USHORT nMethod;
+                            comm_UINT16 nMethod;
                             String aMethod;
                             switch ( ((TriStateBox*)pWin)->GetState() )
                             {
@@ -273,7 +273,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                     case VCLEVENT_LISTBOX_SELECT:
                         if ( m_bRecord )
                         {
-                            StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_USHORT)M_Select, comm_ULONG( ((ListBox*)pWin)->GetSelectEntryPos() +1 ) );
+                            StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_UINT16)M_Select, comm_UINT32( ((ListBox*)pWin)->GetSelectEntryPos() +1 ) );
                             bSendData = sal_True;
                         }
                         if ( m_bLog )
@@ -308,7 +308,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                                     Sound::Beep();
                                 else
                                 {
-                                    StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_USHORT)M_Select, (comm_ULONG) nPos+1 );
+                                    StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_UINT16)M_Select, (comm_UINT32) nPos+1 );
                                     bSendData = sal_True;
                                 }
                             }
@@ -341,7 +341,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                                 case WINDOW_QUERYBOX:
                                 case WINDOW_BUTTONDIALOG:
                                     {
-                                        comm_USHORT nMethod;
+                                        comm_UINT16 nMethod;
                                         String aMethod;
                                         ButtonDialog* pBD = (ButtonDialog*)pParent;
 
@@ -372,7 +372,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                                             if ( nMethod != M_Click )
                                                 StatementList::pRet->GenReturn( RET_MacroRecorder, UID_ACTIVE, nMethod );
                                             else
-                                                StatementList::pRet->GenReturn( RET_MacroRecorder, UID_ACTIVE, nMethod, (comm_ULONG)nCurrentButtonId );
+                                                StatementList::pRet->GenReturn( RET_MacroRecorder, UID_ACTIVE, nMethod, (comm_UINT32)nCurrentButtonId );
                                             bSendData = sal_True;
                                         }
                                         if ( m_bLog )
@@ -387,7 +387,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                                     break;
                                 default:
                                     {
-                                        comm_USHORT nMethod;
+                                        comm_UINT16 nMethod;
                                         String aMethod;
                                         switch ( pWin->GetType() )
                                         {
@@ -415,7 +415,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                         {
                             if ( !bSendData && pWin->GetUniqueOrHelpId().getLength() )
                             {
-                                StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_USHORT)M_Click );
+                                StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_UINT16)M_Click );
                                 bSendData = sal_True;
                             }
                         }
@@ -443,7 +443,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                             pEditModify = NULL;
                             aEditModifyString.Erase();
 
-                            comm_USHORT nMethod;
+                            comm_UINT16 nMethod;
                             String aMethod;
                             switch ( nEventID )
                             {
@@ -478,7 +478,7 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                     case VCLEVENT_BUTTON_CLICK:
                         if ( m_bRecord )
                         {
-                            StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_USHORT)M_Click );
+                            StatementList::pRet->GenReturn( RET_MacroRecorder, pWin->GetUniqueOrHelpId(), (comm_UINT16)M_Click );
                             bSendData = sal_True;
                         }
                         if ( m_bLog )
@@ -502,10 +502,10 @@ IMPL_LINK( MacroRecorder, EventListener, VclSimpleEvent*, pEvent )
                                 {
                                     if ( !pWin->GetUniqueOrHelpId().getLength() /* || pWin->GetUniqueOrHelpId().Matches( 1 ) */ )
                                         // generate direct Button access
-                                        StatementList::pRet->GenReturn( RET_MacroRecorder, Str2Id( pTB->GetItemCommand( pTB->GetCurItemId() ) ), (comm_USHORT)(M_Click) );
+                                        StatementList::pRet->GenReturn( RET_MacroRecorder, Str2Id( pTB->GetItemCommand( pTB->GetCurItemId() ) ), (comm_UINT16)(M_Click) );
                                     else
                                         // access via Toolbox
-                                        StatementList::pRet->GenReturn( RET_MacroRecorder, pTB->GetUniqueOrHelpId(), (comm_USHORT)(M_Click|M_RET_NUM_CONTROL), Id2Str( pTB->GetHelpId( pTB->GetCurItemId() ) ) );
+                                        StatementList::pRet->GenReturn( RET_MacroRecorder, pTB->GetUniqueOrHelpId(), (comm_UINT16)(M_Click|M_RET_NUM_CONTROL), Id2Str( pTB->GetHelpId( pTB->GetCurItemId() ) ) );
                                     bSendData = sal_True;
                                 }
                             }
diff --git a/automation/source/server/retstrm.cxx b/automation/source/server/retstrm.cxx
index 99def011f..8cc639a43 100644
--- a/automation/source/server/retstrm.cxx
+++ b/automation/source/server/retstrm.cxx
@@ -58,18 +58,18 @@ void RetStream::GenReturn ( sal_uInt16 nRet, rtl::OString aUId, String aString )
     CmdBaseStream::GenReturn ( nRet, &aUId, &aString );
 }
 
-void RetStream::GenReturn ( sal_uInt16 nRet, rtl::OString aUId, comm_ULONG nNr, String aString, sal_Bool bBool )
+void RetStream::GenReturn ( sal_uInt16 nRet, rtl::OString aUId, comm_UINT32 nNr, String aString, sal_Bool bBool )
 {
     CmdBaseStream::GenReturn ( nRet, &aUId, nNr, &aString, bBool );
 }
 
 // MacroRecorder
-void RetStream::GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_USHORT nMethod, String aString )
+void RetStream::GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_UINT16 nMethod, String aString )
 {
     CmdBaseStream::GenReturn ( nRet, &aUId, nMethod, &aString );
 }
 
-void RetStream::GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_USHORT nMethod, String aString, sal_Bool bBool )
+void RetStream::GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_UINT16 nMethod, String aString, sal_Bool bBool )
 {
     CmdBaseStream::GenReturn ( nRet, &aUId, nMethod, &aString, bBool );
 }
@@ -79,7 +79,7 @@ void RetStream::GenReturn ( sal_uInt16 nRet, sal_uInt16 nMethod, SbxValue &aValu
 {
     Write(sal_uInt16(SIReturn));
     Write(nRet);
-    Write((comm_ULONG)nMethod); //HELPID BACKWARD (no sal_uLong needed)
+    Write((comm_UINT32)nMethod); //HELPID BACKWARD (no sal_uLong needed)
     Write(sal_uInt16(PARAM_SBXVALUE_1));		// Typ der folgenden Parameter
     Write(aValue);
 }
diff --git a/automation/source/server/retstrm.hxx b/automation/source/server/retstrm.hxx
index 2190d15f8..30e2625f5 100644
--- a/automation/source/server/retstrm.hxx
+++ b/automation/source/server/retstrm.hxx
@@ -44,25 +44,25 @@ public:
     void GenError( rtl::OString aUId, String aString );
 
     using CmdBaseStream::GenReturn;
-    void GenReturn( comm_USHORT nRet, comm_ULONG nNr ){CmdBaseStream::GenReturn( nRet, nNr );}
-    void GenReturn( comm_USHORT nRet, rtl::OString aUId, comm_ULONG nNr ){CmdBaseStream::GenReturn( nRet, &aUId, nNr );}
-    void GenReturn( comm_USHORT nRet, rtl::OString aUId, comm_BOOL bBool ){CmdBaseStream::GenReturn( nRet, &aUId, bBool );}
+    void GenReturn( comm_UINT16 nRet, comm_UINT32 nNr ){CmdBaseStream::GenReturn( nRet, nNr );}
+    void GenReturn( comm_UINT16 nRet, rtl::OString aUId, comm_UINT32 nNr ){CmdBaseStream::GenReturn( nRet, &aUId, nNr );}
+    void GenReturn( comm_UINT16 nRet, rtl::OString aUId, comm_BOOL bBool ){CmdBaseStream::GenReturn( nRet, &aUId, bBool );}
 
 // MacroRecorder
-    void GenReturn( comm_USHORT nRet, rtl::OString aUId, comm_USHORT nMethod ){CmdBaseStream::GenReturn( nRet, &aUId, nMethod );} // also used outside MacroRecorder
-    void GenReturn( comm_USHORT nRet, rtl::OString aUId, comm_USHORT nMethod, comm_BOOL bBool ){CmdBaseStream::GenReturn( nRet, &aUId, nMethod, bBool );}
-    void GenReturn( comm_USHORT nRet, rtl::OString aUId, comm_USHORT nMethod, comm_ULONG nNr ){CmdBaseStream::GenReturn( nRet, &aUId, nMethod, nNr );}
+    void GenReturn( comm_UINT16 nRet, rtl::OString aUId, comm_UINT16 nMethod ){CmdBaseStream::GenReturn( nRet, &aUId, nMethod );} // also used outside MacroRecorder
+    void GenReturn( comm_UINT16 nRet, rtl::OString aUId, comm_UINT16 nMethod, comm_BOOL bBool ){CmdBaseStream::GenReturn( nRet, &aUId, nMethod, bBool );}
+    void GenReturn( comm_UINT16 nRet, rtl::OString aUId, comm_UINT16 nMethod, comm_UINT32 nNr ){CmdBaseStream::GenReturn( nRet, &aUId, nMethod, nNr );}
 
     void GenReturn( sal_uInt16 nRet, rtl::OString aUId, String aString );
-    void GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_ULONG nNr, String aString, sal_Bool bBool );
+    void GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_UINT32 nNr, String aString, sal_Bool bBool );
 
 // needed for RemoteCommand and Profiling
     void GenReturn( sal_uInt16 nRet, sal_uInt16 nMethod, SbxValue &aValue );
     void GenReturn( sal_uInt16 nRet, sal_uInt16 nMethod, String aString );
 
 // MacroRecorder
-    void GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_USHORT nMethod, String aString );
-    void GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_USHORT nMethod, String aString, sal_Bool bBool );
+    void GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_UINT16 nMethod, String aString );
+    void GenReturn( sal_uInt16 nRet, rtl::OString aUId, comm_UINT16 nMethod, String aString, sal_Bool bBool );
 
     void Reset();
     SvStream* GetStream();
@@ -70,8 +70,8 @@ public:
 
 
     using CmdBaseStream::Write;
-    void Write( comm_USHORT nNr ){CmdBaseStream::Write( nNr );}
-    void Write( comm_ULONG nNr ){CmdBaseStream::Write( nNr );}
+    void Write( comm_UINT16 nNr ){CmdBaseStream::Write( nNr );}
+    void Write( comm_UINT32 nNr ){CmdBaseStream::Write( nNr );}
     void Write( comm_BOOL bBool ){CmdBaseStream::Write( bBool );}
     void Write( SbxValue &aValue );
 
diff --git a/automation/source/server/scmdstrm.cxx b/automation/source/server/scmdstrm.cxx
index 186fff7f5..2ab459c7a 100644
--- a/automation/source/server/scmdstrm.cxx
+++ b/automation/source/server/scmdstrm.cxx
@@ -86,24 +86,24 @@ void SCmdStream::Read ( SfxPoolItem *&pItem )
     Read( nType );
     switch (nType)
     {
-        case BinUSHORT:
+        case BinUINT16:
             {
-                comm_USHORT nNr;
+                comm_UINT16 nNr;
                 Read (nNr );
                 pItem = new SfxUInt16Item(nId,nNr);
 #if OSL_DEBUG_LEVEL > 1
-                StatementList::m_pDbgWin->AddText( "USHORT:" );
+                StatementList::m_pDbgWin->AddText( "UINT16" );
                 StatementList::m_pDbgWin->AddText( String::CreateFromInt32( nNr ) );
 #endif
             }
             break;
-        case BinULONG:
+        case BinUINT32:
             {
-                comm_ULONG nNr;
+                comm_UINT32 nNr;
                 Read (nNr );
                 pItem = new SfxUInt32Item(nId,nNr);
 #if OSL_DEBUG_LEVEL > 1
-                StatementList::m_pDbgWin->AddText( "ULONG:" );
+                StatementList::m_pDbgWin->AddText( "UINT32" );
                 StatementList::m_pDbgWin->AddText( String::CreateFromInt64( nNr ) );
 #endif
             }
@@ -157,24 +157,24 @@ void SCmdStream::Read ( ::com::sun::star::beans::PropertyValue &rItem )
     nType = GetNextType();
     switch (nType)
     {
-        case BinUSHORT:
+        case BinUINT16:
             {
-                comm_USHORT nNr;
+                comm_UINT16 nNr;
                 Read (nNr );
                 rItem.Value <<= nNr;
 #if OSL_DEBUG_LEVEL > 1
-                StatementList::m_pDbgWin->AddText( "USHORT:" );
+                StatementList::m_pDbgWin->AddText( "UINT16" );
                 StatementList::m_pDbgWin->AddText( String::CreateFromInt32( nNr ) );
 #endif
             }
             break;
-        case BinULONG:
+        case BinUINT32:
             {
-                comm_ULONG nNr;
+                comm_UINT32 nNr;
                 Read (nNr );
                 rItem.Value <<= nNr;
 #if OSL_DEBUG_LEVEL > 1
-                StatementList::m_pDbgWin->AddText( "ULONG:" );
+                StatementList::m_pDbgWin->AddText( "UINT32" );
                 StatementList::m_pDbgWin->AddText( String::CreateFromInt64( nNr ) );
 #endif
             }
diff --git a/automation/source/server/scmdstrm.hxx b/automation/source/server/scmdstrm.hxx
index 54da7b418..5ef7a8c2b 100644
--- a/automation/source/server/scmdstrm.hxx
+++ b/automation/source/server/scmdstrm.hxx
@@ -47,8 +47,8 @@ public:
     ~SCmdStream();
 
     using CmdBaseStream::Read;
-    void Read ( comm_USHORT &nNr ){CmdBaseStream::Read ( nNr );}
-    void Read ( comm_ULONG &nNr ){CmdBaseStream::Read ( nNr );}
+    void Read ( comm_UINT16 &nNr ){CmdBaseStream::Read ( nNr );}
+    void Read ( comm_UINT32 &nNr ){CmdBaseStream::Read ( nNr );}
     void Read ( comm_BOOL &bBool ){CmdBaseStream::Read ( bBool );}
     void Read ( String &aString );
     void Read ( SfxPoolItem *&pItem );
diff --git a/automation/source/server/sta_list.cxx b/automation/source/server/sta_list.cxx
index 99906cd0b..69a021240 100644
--- a/automation/source/server/sta_list.cxx
+++ b/automation/source/server/sta_list.cxx
@@ -167,7 +167,7 @@ void StatementList::SendProfile( String aText )
 
             if ( pProfiler->IsPartitioning() )
                                 // FIXME: HELPID
-                pRet->GenReturn( RET_ProfileInfo, S_ProfileTime, static_cast<comm_ULONG>(pProfiler->GetPartitioningTime()) ); // GetPartitioningTime() sal_uLong != comm_ULONG on 64bit
+                pRet->GenReturn( RET_ProfileInfo, S_ProfileTime, static_cast<comm_UINT32>(pProfiler->GetPartitioningTime()) ); // GetPartitioningTime() sal_uLong != comm_UINT32 on 64bit
         }
 
         if ( pProfiler->IsAutoProfiling() )
diff --git a/automation/source/server/statemnt.cxx b/automation/source/server/statemnt.cxx
index e30c16773..2c99aaa6c 100644
--- a/automation/source/server/statemnt.cxx
+++ b/automation/source/server/statemnt.cxx
@@ -161,8 +161,8 @@ StatementFlow::StatementFlow( sal_uLong nServiceId, SCmdStream *pCmdIn, ImplRemo
     pCmdIn->Read( nArt );
     pCmdIn->Read( nParams );
 
-    if( nParams & PARAM_USHORT_1 ) pCmdIn->Read( nSNr1 );
-    if( nParams & PARAM_ULONG_1 )  pCmdIn->Read( nLNr1 );
+    if( nParams & PARAM_UINT16_1 ) pCmdIn->Read( nSNr1 );
+    if( nParams & PARAM_UINT32_1 )  pCmdIn->Read( nLNr1 );
     if( nParams & PARAM_STR_1 )    pCmdIn->Read( aString1 );
     if( nParams & PARAM_BOOL_1 )   pCmdIn->Read( bBool1 );// Should NEVER happen
 
@@ -170,8 +170,8 @@ StatementFlow::StatementFlow( sal_uLong nServiceId, SCmdStream *pCmdIn, ImplRemo
     m_pDbgWin->AddText( "Reading FlowControl: " );
     m_pDbgWin->AddText( String::CreateFromInt32( nArt ) );
     m_pDbgWin->AddText( " Params:" );
-    if( nParams & PARAM_USHORT_1 )  {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nSNr1 ) );}
-    if( nParams & PARAM_ULONG_1 )   {m_pDbgWin->AddText( " l1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
+    if( nParams & PARAM_UINT16_1 )  {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nSNr1 ) );}
+    if( nParams & PARAM_UINT32_1 )   {m_pDbgWin->AddText( " l1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
     if( nParams & PARAM_STR_1 )     {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
     if( nParams & PARAM_BOOL_1 )    {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
     m_pDbgWin->AddText( "\n" );
@@ -349,7 +349,7 @@ StatementSlot::StatementSlot( SCmdStream *pCmdIn )
     {
         switch ( pCmdIn->GetNextType() )
         {
-            case BinUSHORT: // use old calling method
+            case BinUINT16: // use old calling method
                 {
                     nAnzahl++;
                     pItemArr = new SfxPoolItem*[nAnzahl];
@@ -687,11 +687,11 @@ StatementCommand::StatementCommand( StatementList *pAfterThis, sal_uInt16 Method
     m_pDbgWin->AddText( " Methode: " );
     m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
     m_pDbgWin->AddText( " Params:" );
-    if( nParams & PARAM_USHORT_1 )	{m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
-    if( nParams & PARAM_USHORT_2 )	{m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
-    if( nParams & PARAM_USHORT_3 )	{m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
-    if( nParams & PARAM_USHORT_4 )	{m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
-    if( nParams & PARAM_ULONG_1 )	{m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
+    if( nParams & PARAM_UINT16_1 )	{m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
+    if( nParams & PARAM_UINT16_2 )	{m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
+    if( nParams & PARAM_UINT16_3 )	{m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
+    if( nParams & PARAM_UINT16_4 )	{m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
+    if( nParams & PARAM_UINT32_1 )	{m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
     if( nParams & PARAM_STR_1 )		{m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
     if( nParams & PARAM_STR_2 )		{m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
     if( nParams & PARAM_BOOL_1 )    {m_pDbgWin->AddText( " b1:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
@@ -718,11 +718,11 @@ StatementCommand::StatementCommand( SCmdStream *pCmdIn )
     pCmdIn->Read( nMethodId );
     pCmdIn->Read( nParams );
 
-    if( nParams & PARAM_USHORT_1 )	pCmdIn->Read( nNr1 );
-    if( nParams & PARAM_USHORT_2 )	pCmdIn->Read( nNr2 );
-    if( nParams & PARAM_USHORT_3 )	pCmdIn->Read( nNr3 );
-    if( nParams & PARAM_USHORT_4 )	pCmdIn->Read( nNr4 );
-    if( nParams & PARAM_ULONG_1 )	pCmdIn->Read( nLNr1 );
+    if( nParams & PARAM_UINT16_1 )	pCmdIn->Read( nNr1 );
+    if( nParams & PARAM_UINT16_2 )	pCmdIn->Read( nNr2 );
+    if( nParams & PARAM_UINT16_3 )	pCmdIn->Read( nNr3 );
+    if( nParams & PARAM_UINT16_4 )	pCmdIn->Read( nNr4 );
+    if( nParams & PARAM_UINT32_1 )	pCmdIn->Read( nLNr1 );
     if( nParams & PARAM_STR_1 )		pCmdIn->Read( aString1 );
     if( nParams & PARAM_STR_2 )		pCmdIn->Read( aString2 );
     if( nParams & PARAM_BOOL_1 )	pCmdIn->Read( bBool1 );
@@ -733,11 +733,11 @@ StatementCommand::StatementCommand( SCmdStream *pCmdIn )
     m_pDbgWin->AddText( " Methode: " );
     m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
     m_pDbgWin->AddText( " Params:" );
-    if( nParams & PARAM_USHORT_1 )	{m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
-    if( nParams & PARAM_USHORT_2 )	{m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
-    if( nParams & PARAM_USHORT_3 )	{m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
-    if( nParams & PARAM_USHORT_4 )	{m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
-    if( nParams & PARAM_ULONG_1 )	{m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
+    if( nParams & PARAM_UINT16_1 )	{m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
+    if( nParams & PARAM_UINT16_2 )	{m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
+    if( nParams & PARAM_UINT16_3 )	{m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
+    if( nParams & PARAM_UINT16_4 )	{m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
+    if( nParams & PARAM_UINT32_1 )	{m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
     if( nParams & PARAM_STR_1 )		{m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
     if( nParams & PARAM_STR_2 )		{m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
     if( nParams & PARAM_BOOL_1 )    {m_pDbgWin->AddText( " b1:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
@@ -772,7 +772,7 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
         return;
 
     if ( bFirst )
-        pRet->GenReturn ( RET_WinInfo, rtl::OString(), (comm_ULONG)nConf | DH_MODE_DATA_VALID, UniString(), sal_True );
+        pRet->GenReturn ( RET_WinInfo, rtl::OString(), (comm_UINT32)nConf | DH_MODE_DATA_VALID, UniString(), sal_True );
 
     if ( bFirst )
     {
@@ -882,7 +882,7 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
             }
 
             rtl::OString aId = pBase->GetUniqueOrHelpId();
-            pRet->GenReturn ( RET_WinInfo, aId, (comm_ULONG)pBase->GetType(),
+            pRet->GenReturn ( RET_WinInfo, aId, (comm_UINT32)pBase->GetType(),
                 TypeString(pBase->GetType()).Append(aTypeSuffix).AppendAscii(": ").Append(aName), sal_False );
 
 
@@ -903,10 +903,10 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
                     if ( pTB->GetItemType( i ) == TOOLBOXITEM_BUTTON && ( !pItemWin || !pItemWin->IsVisible() ) )
                     {
                         if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                            pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_ULONG)WINDOW_BUTTON,
+                            pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_UINT32)WINDOW_BUTTON,
                                 TypeString(WINDOW_BUTTON).AppendAscii(": ").Append(aName), sal_False );
                         if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                            pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)WINDOW_BUTTON,
+                            pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_UINT32)WINDOW_BUTTON,
                                 TypeString(WINDOW_BUTTON).AppendAscii(": ").Append(aName), sal_False );
                     }
                     else
@@ -914,10 +914,10 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
                         if ( pItemWin )
                         {
                             if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                                pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_ULONG)pItemWin->GetType(),
+                                pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_UINT32)pItemWin->GetType(),
                                     TypeString(pItemWin->GetType()).AppendAscii(": ").Append(aName), sal_False );
                             if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                                pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)pItemWin->GetType(),
+                                pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_UINT32)pItemWin->GetType(),
                                     TypeString(pItemWin->GetType()).AppendAscii(": ").Append(aName), sal_False );
                             sal_uInt16 ii;
                             for( ii = 0 ; ii < pItemWin->GetChildCount(); ii++ )
@@ -949,10 +949,10 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
                                     OSL_TRACE( "Unknown TOOLBOXITEM %i", pTB->GetItemType( i ) );
                                 }
                                 if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                                    pRet->GenReturn ( RET_WinInfo, Str2Id( pTB->GetItemCommand(pTB->GetItemId( i )) ), (comm_ULONG)WINDOW_BASE,
+                                    pRet->GenReturn ( RET_WinInfo, Str2Id( pTB->GetItemCommand(pTB->GetItemId( i )) ), (comm_UINT32)WINDOW_BASE,
                                         aToolBoxItemType.AppendAscii(": ").Append(aName), sal_False );
                                 if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                                    pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)WINDOW_BASE,
+                                    pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_UINT32)WINDOW_BASE,
                                         aToolBoxItemType.AppendAscii(": ").Append(aName), sal_False );
                             }
                         }
@@ -1003,7 +1003,7 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
                             break;
                     }
 
-                    pRet->GenReturn ( RET_WinInfo, aID, (comm_ULONG)pBD->GetPushButton( pBD->GetButtonId(i) )->GetType(),	// So da� der Text angezeigt wird!
+                    pRet->GenReturn ( RET_WinInfo, aID, (comm_UINT32)pBD->GetPushButton( pBD->GetButtonId(i) )->GetType(),	// So da� der Text angezeigt wird!
                         TypeString(pBD->GetPushButton( pBD->GetButtonId(i) )->GetType()).AppendAscii(": ").Append(aName)
                         .AppendAscii(" ButtonId = ").AppendAscii( aID.GetBuffer() ), sal_False );
                 }
@@ -1052,10 +1052,10 @@ void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Boo
                             OSL_TRACE( "Unknown MENUITEM %i", pMenu->GetItemType( i ) );
                         }
                         if ( pMenu->GetItemCommand(nID).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                            pRet->GenReturn ( RET_WinInfo, Str2Id( pMenu->GetItemCommand(nID) ), (comm_ULONG)0,
+                            pRet->GenReturn ( RET_WinInfo, Str2Id( pMenu->GetItemCommand(nID) ), (comm_UINT32)0,
                                 aMenuItemType.AppendAscii(": ").Append(aName), sal_False );
                         if ( !pMenu->GetItemCommand(nID).Len() || ( nConf & DH_MODE_ALLWIN ) )
-                            pRet->GenReturn ( RET_WinInfo, rtl::OString::valueOf( (sal_Int32)nID ), (comm_ULONG)0,
+                            pRet->GenReturn ( RET_WinInfo, rtl::OString::valueOf( (sal_Int32)nID ), (comm_UINT32)0,
                                 aMenuItemType.AppendAscii(": ").Append(aName), sal_False );
                     }
                 }
@@ -1365,7 +1365,7 @@ sal_Bool StatementCommand::DisplayHID()
         bBool2 = sal_True;				// Wir sind initialisiert.
         GetTTSettings()->pDisplayInstance = this;	// Und haben die Macht (Alle anderen beenden sich)
 
-        if ( !(nParams & PARAM_ULONG_1) )
+        if ( !(nParams & PARAM_UINT32_1) )
         {
             if( GetTTSettings()->pDisplayHidWin )	// Nichts ver�ndern
                 nLNr1 = GetTTSettings()->pDisplayHidWin->GetConfig();
@@ -2465,7 +2465,7 @@ sal_Bool StatementCommand::Execute()
             break;
         case RC_WaitSlot:
             {
-                if ( ! (nParams & PARAM_USHORT_1) )
+                if ( ! (nParams & PARAM_UINT16_1) )
                     nNr1 = 1000;    // defaults to 1000 = 1 Sec.
                 if ( !bBool1 )
                 {
@@ -2474,12 +2474,12 @@ sal_Bool StatementCommand::Execute()
                 }
 
                 if ( !bIsSlotInExecute )
-                    pRet->GenReturn ( RET_Value, nMethodId, comm_USHORT(CONST_WSFinished) );
+                    pRet->GenReturn ( RET_Value, nMethodId, comm_UINT16(CONST_WSFinished) );
                 else
                 {
                     if ( Time().GetTime() < long(nLNr1) )	// Aktuelle Zeit kleiner Endzeit
                         return sal_False;
-                    pRet->GenReturn ( RET_Value, nMethodId, comm_USHORT(CONST_WSTimeout) );
+                    pRet->GenReturn ( RET_Value, nMethodId, comm_UINT16(CONST_WSTimeout) );
                 }
             }
             break;
@@ -2593,7 +2593,7 @@ sal_Bool StatementCommand::Execute()
                     InitProfile();
                 }
 
-                if( !(nParams & PARAM_BOOL_1) && (nParams & PARAM_USHORT_1) )
+                if( !(nParams & PARAM_BOOL_1) && (nParams & PARAM_UINT16_1) )
                 {	// Autoprofiling: Profile nNr
                     if ( pProfiler->IsProfilingPerCommand() )
                     {
@@ -2604,13 +2604,13 @@ sal_Bool StatementCommand::Execute()
                     // Der Header ist abh�ngig vom Modus
                     pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetProfileHeader() );
                 }
-                else if ( nParams & PARAM_USHORT_1 )
+                else if ( nParams & PARAM_UINT16_1 )
                 {	// Partitioning initialisieren: Profile true [,nNr][,nNr][,nNr][,nNr]
-                    comm_ULONG nAnzahl=0;
-                    if ( nParams & PARAM_USHORT_1 ) { nAnzahl++; };
-                    if ( nParams & PARAM_USHORT_2 ) { nAnzahl++; };
-                    if ( nParams & PARAM_USHORT_3 ) { nAnzahl++; };
-                    if ( nParams & PARAM_USHORT_4 ) { nAnzahl++; };
+                    comm_UINT32 nAnzahl=0;
+                    if ( nParams & PARAM_UINT16_1 ) { nAnzahl++; };
+                    if ( nParams & PARAM_UINT16_2 ) { nAnzahl++; };
+                    if ( nParams & PARAM_UINT16_3 ) { nAnzahl++; };
+                    if ( nParams & PARAM_UINT16_4 ) { nAnzahl++; };
 
                     // Hier werden die Parameter ans Testtool zur�ck �bertragen.
                     // Das ist zwar etwas eigenartig, aber ansonsten m�sste man im Testtool
@@ -2618,10 +2618,10 @@ sal_Bool StatementCommand::Execute()
                     pRet->GenReturn( RET_ProfileInfo, S_ProfileReset, nAnzahl );
 
                     // Und die einzelnen Grenzen
-                    if ( nParams & PARAM_USHORT_1 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder1, (comm_ULONG)nNr1 ); };
-                    if ( nParams & PARAM_USHORT_2 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder2, (comm_ULONG)nNr2 ); };
-                    if ( nParams & PARAM_USHORT_3 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder3, (comm_ULONG)nNr3 ); };
-                    if ( nParams & PARAM_USHORT_4 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder4, (comm_ULONG)nNr4 ); };
+                    if ( nParams & PARAM_UINT16_1 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder1, (comm_UINT32)nNr1 ); };
+                    if ( nParams & PARAM_UINT16_2 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder2, (comm_UINT32)nNr2 ); };
+                    if ( nParams & PARAM_UINT16_3 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder3, (comm_UINT32)nNr3 ); };
+                    if ( nParams & PARAM_UINT16_4 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder4, (comm_UINT32)nNr4 ); };
 
                     pProfiler->StartPartitioning();
                 }
@@ -2657,7 +2657,7 @@ sal_Bool StatementCommand::Execute()
 
                     if ( pProfiler->IsPartitioning() )
                     {
-                        pRet->GenReturn( RET_ProfileInfo, S_ProfileDump, (comm_ULONG)0 );
+                        pRet->GenReturn( RET_ProfileInfo, S_ProfileDump, (comm_UINT32)0 );
                         pProfiler->StopPartitioning();
                     }
 
@@ -2755,13 +2755,13 @@ sal_Bool StatementCommand::Execute()
                 {
                     case RC_MenuGetItemCount:
                         {
-                            pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)nItemCount );
+                            pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)nItemCount );
                         }
                         break;
                     case RC_MenuGetItemId:
                         {
                             if ( ValueOK( rtl::OString(), RcString( nMethodId ),nNr1,nItemCount) )
-                                pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)pMenu->GetItemId(nPhysicalIndex-1) );
+                                pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)pMenu->GetItemId(nPhysicalIndex-1) );
                         }
                         break;
                     case RC_MenuGetItemPos:
@@ -2783,7 +2783,7 @@ sal_Bool StatementCommand::Execute()
                                     }
                                 }
                             }
-                            pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)(nLogicalPos+1) );
+                            pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)(nLogicalPos+1) );
                         }
                         break;
                     case RC_MenuIsSeperator:
@@ -2940,7 +2940,7 @@ sal_Bool StatementCommand::Execute()
                                 else
                                 {
                                     sal_uInt16 nFlags = 0;
-                                    if ( (nParams & PARAM_USHORT_1) )
+                                    if ( (nParams & PARAM_UINT16_1) )
                                         nDirFlags = nFlags = nNr1;
                                     else
                                         nDirFlags = nFlags = Sb_ATTR_HIDDEN | Sb_ATTR_SYSTEM | Sb_ATTR_DIRECTORY;
@@ -2994,7 +2994,7 @@ sal_Bool StatementCommand::Execute()
                             if ( FSYS_ERR_OK == nErrorcode )
                             {
                                 FileStat aFS( aFile );
-                                pRet->GenReturn ( RET_Value, nMethodId, static_cast<comm_ULONG>(aFS.GetSize()) ); //GetSize() sal_uLong != comm_ULONG on 64bit
+                                pRet->GenReturn ( RET_Value, nMethodId, static_cast<comm_UINT32>(aFS.GetSize()) ); //GetSize() sal_uLong != comm_UINT32 on 64bit
                                 nErrorcode = aFS.GetError();
                             }
                         }
@@ -3109,10 +3109,10 @@ sal_Bool StatementCommand::Execute()
                 {
                     bDoTypeKeysDelay = bBool1;
                 }
-                else if( nParams & PARAM_USHORT_1 )
+                else if( nParams & PARAM_UINT16_1 )
                 {
                     nMinTypeKeysDelay = nNr1;
-                    if( nParams & PARAM_USHORT_2 )
+                    if( nParams & PARAM_UINT16_2 )
                         nMaxTypeKeysDelay = nNr2;
                     else
                         nMaxTypeKeysDelay = nMinTypeKeysDelay;
@@ -3132,7 +3132,7 @@ sal_Bool StatementCommand::Execute()
                     ReportError( GEN_RES_STR1( S_POINTER_OUTSIDE_APPWIN, RcString( nMethodId ) ) );
                     aPointer = Pointer( POINTER_NULL );
                 }
-                pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)aPointer.GetStyle() );
+                pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT32)aPointer.GetStyle() );
             }
             break;
         case RC_UnpackStorage:
@@ -3171,7 +3171,7 @@ sal_Bool StatementCommand::Execute()
         case RC_CloseSysDialog:
         case RC_ExistsSysDialog:
             {
-                if( (nParams & PARAM_USHORT_1) )
+                if( (nParams & PARAM_UINT16_1) )
                 {
                     Reference < ::com::sun::star::util::XCancellable > xPicker;
                     switch( nNr1 )
@@ -3242,12 +3242,12 @@ sal_Bool StatementCommand::Execute()
             break;
         case RC_GetDocumentCount :
             {
-                pRet->GenReturn ( RET_Value, nMethodId, (comm_USHORT)GetDocWinCount() );
+                pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT16)GetDocWinCount() );
             }
             break;
         case RC_ActivateDocument :
             {
-                if( nParams & PARAM_USHORT_1 )
+                if( nParams & PARAM_UINT16_1 )
                 {
                     if ( ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, GetDocWinCount() ) )
                     {
@@ -3265,7 +3265,7 @@ sal_Bool StatementCommand::Execute()
             break;
         case RC_GetSystemLanguage :
             {
-                pRet->GenReturn ( RET_Value, nMethodId, (comm_USHORT)Application::GetSettings().GetLanguage() );
+                pRet->GenReturn ( RET_Value, nMethodId, (comm_UINT16)Application::GetSettings().GetLanguage() );
             }
             break;
         case RC_CatchGPF :
@@ -3364,7 +3364,7 @@ StatementControl::StatementControl( SCmdStream *pCmdIn, sal_uInt16 nControlIdTyp
     //HELPID BACKWARD (SIControl is no longer needed)
     if ( nControlIdType == SIControl )
     {
-        comm_ULONG nId;
+        comm_UINT32 nId;
         pCmdIn->Read( nId );
         aUId = rtl::OString( nId );
         if ( nId == 0 )
@@ -3386,11 +3386,11 @@ StatementControl::StatementControl( SCmdStream *pCmdIn, sal_uInt16 nControlIdTyp
     pCmdIn->Read( nMethodId );
     pCmdIn->Read( nParams );
 
-    if( nParams & PARAM_USHORT_1 )	pCmdIn->Read( nNr1 );
-    if( nParams & PARAM_USHORT_2 )	pCmdIn->Read( nNr2 );
-    if( nParams & PARAM_USHORT_3 )	pCmdIn->Read( nNr3 );
-    if( nParams & PARAM_USHORT_4 )	pCmdIn->Read( nNr4 );
-    if( nParams & PARAM_ULONG_1 )	pCmdIn->Read( nLNr1 );
+    if( nParams & PARAM_UINT16_1 )	pCmdIn->Read( nNr1 );
+    if( nParams & PARAM_UINT16_2 )	pCmdIn->Read( nNr2 );
+    if( nParams & PARAM_UINT16_3 )	pCmdIn->Read( nNr3 );
+    if( nParams & PARAM_UINT16_4 )	pCmdIn->Read( nNr4 );
+    if( nParams & PARAM_UINT32_1 )	pCmdIn->Read( nLNr1 );
     if( nParams & PARAM_STR_1 )		pCmdIn->Read( aString1 );
     if( nParams & PARAM_STR_2 )		pCmdIn->Read( aString2 );
     if( nParams & PARAM_BOOL_1 )	pCmdIn->Read( bBool1 );
@@ -3402,11 +3402,11 @@ StatementControl::StatementControl( SCmdStream *pCmdIn, sal_uInt16 nControlIdTyp
     m_pDbgWin->AddText( " Methode: " );
     m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
     m_pDbgWin->AddText( " Params:" );
-    if( nParams & PARAM_USHORT_1 )	{m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
-    if( nParams & PARAM_USHORT_2 )	{m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
-    if( nParams & PARAM_USHORT_3 )	{m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
-    if( nParams & PARAM_USHORT_4 )	{m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
-    if( nParams & PARAM_ULONG_1 )	{m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
+    if( nParams & PARAM_UINT16_1 )	{m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
+    if( nParams & PARAM_UINT16_2 )	{m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
+    if( nParams & PARAM_UINT16_3 )	{m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
+    if( nParams & PARAM_UINT16_4 )	{m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
+    if( nParams & PARAM_UINT32_1 )	{m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
     if( nParams & PARAM_STR_1 )		{m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
     if( nParams & PARAM_STR_2 )		{m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
     m_pDbgWin->AddText( "\n" );
@@ -3679,10 +3679,10 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
             {
                 Point aPos = pControl->GetPosPixel();
                 aPos = pControl->GET_REAL_PARENT()->OutputToScreenPixel( aPos );
-                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)aPos.X() );
+                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)aPos.X() );
             }
             else
-                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetPosPixel().X() );
+                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pControl->GetPosPixel().X() );
             break;
         case M_GetPosY:
             if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
@@ -3698,10 +3698,10 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
             {
                 Point aPos = pControl->GetPosPixel();
                 aPos = pControl->GET_REAL_PARENT()->OutputToScreenPixel( aPos );
-                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)aPos.Y() );
+                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)aPos.Y() );
             }
             else
-                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetPosPixel().Y() );
+                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pControl->GetPosPixel().Y() );
             break;
         case M_GetSizeX:
             if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
@@ -3713,7 +3713,7 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
             if ( (nParams & PARAM_BOOL_1) && bBool1 )
                 pControl = pControl->GetWindow( WINDOW_OVERLAP );
 
-            pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetSizePixel().Width() );
+            pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pControl->GetSizePixel().Width() );
             break;
         case M_GetSizeY:
             if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
@@ -3725,7 +3725,7 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
             if ( (nParams & PARAM_BOOL_1) && bBool1 )
                 pControl = pControl->GetWindow( WINDOW_OVERLAP );
 
-            pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetSizePixel().Height() );
+            pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pControl->GetSizePixel().Height() );
             break;
         case M_SnapShot:
             {
@@ -3742,12 +3742,12 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
                 if ( pControl->GetType() == WINDOW_WORKWINDOW )
                 {
                     Point aStart = pControl->GetPosPixel();
-                    if ( !(nParams & PARAM_USHORT_4) )
+                    if ( !(nParams & PARAM_UINT16_4) )
                     {
-                        nParams |= PARAM_USHORT_1;
-                        nParams |= PARAM_USHORT_2;
-                        nParams |= PARAM_USHORT_3;
-                        nParams |= PARAM_USHORT_4;
+                        nParams |= PARAM_UINT16_1;
+                        nParams |= PARAM_UINT16_2;
+                        nParams |= PARAM_UINT16_3;
+                        nParams |= PARAM_UINT16_4;
                         nNr1 = (sal_uInt16)-aStart.X();
                         nNr2 = (sal_uInt16)-aStart.Y();
                         nNr3 = (sal_uInt16)pControl->GetSizePixel().Width() + 2*(sal_uInt16)aStart.X();
@@ -3758,7 +3758,7 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
                     nNr3 = std::min((sal_uInt16)(pControl->GetSizePixel().Width() + 2*(sal_uInt16)aStart.X()),nNr3);
                     nNr4 = std::min((sal_uInt16)(pControl->GetSizePixel().Height() + 2*(sal_uInt16)aStart.Y()),nNr4);
                 }
-                if( nParams & PARAM_USHORT_4 )
+                if( nParams & PARAM_UINT16_4 )
                 {	// Zuschneiden
                     Point aPt(-nNr1,-nNr2);
                     Size aSz(nNr3,nNr4);
@@ -3784,7 +3784,7 @@ sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
             break;
         case M_GetFixedText:
             {
-                if( ( nParams & PARAM_USHORT_1 ) == 0 )
+                if( ( nParams & PARAM_UINT16_1 ) == 0 )
                     nNr1 = 1;
 
                 FixedText* pFixedText = (FixedText*)GetWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True, nNr1-1 );
@@ -3823,12 +3823,12 @@ sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
             break;
         case M_GetRT:
             {
-                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetType() );
+                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pControl->GetType() );
             }
             break;
         case M_TypeKeys:
             {
-                if( !(nParams & PARAM_USHORT_1) )	// Anzahl wiederholungen
+                if( !(nParams & PARAM_UINT16_1) )	// Anzahl wiederholungen
                     nNr1 = 1;
                 if( !(nParams & PARAM_BOOL_1) )		// Follow Focus
                     bBool1 = sal_False;		// so bleibt das bisherige Verhalten
@@ -3954,7 +3954,7 @@ sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
 
 #define CalcMouseButton\
     sal_uInt16 nButton = MOUSE_LEFT;\
-    if ( (nParams & PARAM_USHORT_3) )\
+    if ( (nParams & PARAM_UINT16_3) )\
     {\
         switch ( nNr3 )\
         {\
@@ -4127,7 +4127,7 @@ sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
         case M_IsPin:
             {
                 WindowAlign aWindowAlign = WINDOWALIGN_LEFT;
-                if ( (nParams & PARAM_USHORT_1) )
+                if ( (nParams & PARAM_UINT16_1) )
                 {
                     switch ( nNr1 )
                     {
@@ -4219,7 +4219,7 @@ sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
                 {
                     case M_StatusGetText:
                         {
-                            if ( (nParams & PARAM_USHORT_1) )
+                            if ( (nParams & PARAM_UINT16_1) )
                             {
                                 if ( pStatus->AreItemsVisible() )
                                     pRet->GenReturn ( RET_Value, aUId, String(pStatus->GetItemText(nNr1)));
@@ -4251,13 +4251,13 @@ sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
                         break;
                     case M_StatusGetItemCount:
                         if ( pStatus->AreItemsVisible() )
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pStatus->GetItemCount()));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(pStatus->GetItemCount()));
                         else
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(0));
                         break;
                     case M_StatusGetItemId:
                         if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pStatus->GetItemCount()) )
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pStatus->GetItemId(nNr1-1)));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(pStatus->GetItemId(nNr1-1)));
                         break;
                 }
             }
@@ -4265,13 +4265,13 @@ sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
         case M_HasScrollBar:
         case M_IsScrollBarEnabled:
             {
-                if ( (nParams | PARAM_USHORT_1) != PARAM_USHORT_1 )     // so there are other params
+                if ( (nParams | PARAM_UINT16_1) != PARAM_UINT16_1 )     // so there are other params
                 {
                     ReportError( aUId, GEN_RES_STR0( S_INVALID_PARAMETERS ) );
                     break;
                 }
 
-                if( !(nParams & PARAM_USHORT_1) )
+                if( !(nParams & PARAM_UINT16_1) )
                     nNr1 = CONST_ALIGN_RIGHT;		// default is right Scrollbar(vertical)
 
                 if ( (nNr1 != CONST_ALIGN_RIGHT) && (nNr1 != CONST_ALIGN_BOTTOM) )
@@ -4354,7 +4354,7 @@ sal_Bool StatementControl::Execute()
     else
     {
         sal_Bool bSearchButtonOnToolbox = (nParams == PARAM_NONE) && ((M_Click == nMethodId) || (M_TearOff == nMethodId) || (M_IsEnabled == nMethodId) || (M_OpenMenu == nMethodId));
-        bSearchButtonOnToolbox |= (nParams == PARAM_USHORT_1) && (M_GetState == nMethodId);
+        bSearchButtonOnToolbox |= (nParams == PARAM_UINT16_1) && (M_GetState == nMethodId);
         if ( nMethodId == M_TypeKeys || nMethodId == M_MouseDown
             || nMethodId == M_MouseUp || nMethodId ==  M_MouseMove
             || nMethodId == M_SnapShot )
@@ -4399,7 +4399,7 @@ sal_Bool StatementControl::Execute()
             {
                 bBool2 = sal_True;
                 nNr2 = aSeconds;
-                if( !(nParams & PARAM_USHORT_1) )
+                if( !(nParams & PARAM_UINT16_1) )
                     nNr1 = 0;		// defaultm��ig sofort zur�ck
             }
             if ( aSeconds < nNr2 )			// Falls die Stunde umgesprungen ist
@@ -4531,16 +4531,16 @@ sal_Bool StatementControl::Execute()
                     switch( nMethodId )
                     {
                         case M_GetPageId:
-                            if ( (nParams & PARAM_USHORT_1) )
+                            if ( (nParams & PARAM_UINT16_1) )
                             {
                                 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((TabControl*)pControl)->GetPageCount() ) )
-                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetPageId(nNr1-1));
+                                    pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)((TabControl*)pControl)->GetPageId(nNr1-1));
                             }
                             else
-                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetCurPageId());
+                                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)((TabControl*)pControl)->GetCurPageId());
                             break;
                         case M_GetPageCount:
-                            pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetPageCount());
+                            pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)((TabControl*)pControl)->GetPageCount());
                             break;
                         case M_SetPageId:
                             if (((TabControl*)pControl)->GetCurPageId())
@@ -4567,8 +4567,8 @@ sal_Bool StatementControl::Execute()
                                 sal_uInt16 i,anz;
                                 rtl::OString aID;
                                 rtl::OString aWantedID;
-                                //HELPID BACKWARD (No numbers please (remove PARAM_ULONG_1 part)
-                                if ( (nParams & PARAM_ULONG_1) )
+                                //HELPID BACKWARD (No numbers please (remove PARAM_UINT32_1 part)
+                                if ( (nParams & PARAM_UINT32_1) )
                                 {
                                     ReportError( aUId, GEN_RES_STR1c( S_INTERNAL_ERROR, "using numeric HelpID from old Testtool" ) );
                                 }
@@ -4635,7 +4635,7 @@ sal_Bool StatementControl::Execute()
                             pRet->GenReturn ( RET_Value, aUId, comm_BOOL( ((TriStateBox*)pControl)->GetState() == STATE_DONTKNOW) );
                             break;
                         case M_GetState :
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((TriStateBox*)pControl)->GetState()));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((TriStateBox*)pControl)->GetState()));
                             break;
                         case M_Check :
                             ((TriStateBox*)pControl)->SetState( STATE_CHECK );
@@ -4723,28 +4723,28 @@ sal_Bool StatementControl::Execute()
                             AnimateMouse( pControl, MitteOben);
                             break;
                         case M_GetSelCount :
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetSelectEntryCount()));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((ListBox*)pControl)->GetSelectEntryCount()));
                             break;
                         case M_GetSelIndex :
-                            if ( ! (nParams & PARAM_USHORT_1) )
+                            if ( ! (nParams & PARAM_UINT16_1) )
                             {
                                 if ( ((ListBox*)pControl)->GetSelectEntryCount() == 0 )
                                 {
-                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
+                                    pRet->GenReturn ( RET_Value, aUId, comm_UINT32(0));
                                     break;
                                 }
                                 nNr1 = 1;
                             }
                             ValueOK(aUId, MethodString( nMethodId ),nNr1,((ListBox*)pControl)->GetSelectEntryCount());
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetSelectEntryPos(nNr1-1)) +1);
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((ListBox*)pControl)->GetSelectEntryPos(nNr1-1)) +1);
                             break;
                         case M_GetSelText :
-                            if ( ! (nParams & PARAM_USHORT_1) )
+                            if ( ! (nParams & PARAM_UINT16_1) )
                                 nNr1 = 1;
                             pRet->GenReturn ( RET_Value, aUId, ((ListBox*)pControl)->GetSelectEntry(nNr1-1));
                             break;
                         case M_GetItemCount :
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetEntryCount()));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((ListBox*)pControl)->GetEntryCount()));
                             break;
                         case M_GetItemText :
                             pRet->GenReturn ( RET_Value, aUId, ((ListBox*)pControl)->GetEntry(nNr1-1));
@@ -4834,11 +4834,11 @@ sal_Bool StatementControl::Execute()
                                     nPos = 0;
                                 else
                                     nPos++;
-                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG) nPos);
+                                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32) nPos);
                             }
                             break;
                         case M_GetItemCount :
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ComboBox*)pControl)->GetEntryCount()));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((ComboBox*)pControl)->GetEntryCount()));
                             break;
                         case M_GetItemText :
                             pRet->GenReturn ( RET_Value, aUId, ((ComboBox*)pControl)->GetEntry(nNr1-1));
@@ -4847,7 +4847,7 @@ sal_Bool StatementControl::Execute()
                             pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((ComboBox*)pControl)->IsReadOnly() );
                             break;
                         case M_Select :
-                            if( nParams & PARAM_USHORT_1 )
+                            if( nParams & PARAM_UINT16_1 )
                             {
                                 if ( !ValueOK(aUId, MethodString( nMethodId ),nNr1,((ComboBox*)pControl)->GetEntryCount()) )
                                     break;
@@ -4954,7 +4954,7 @@ sal_Bool StatementControl::Execute()
                             break;
                         case M_More :
                             {
-                                if ( !(nParams & PARAM_USHORT_1) )
+                                if ( !(nParams & PARAM_UINT16_1) )
                                     nNr1 = 1;
                                 for (int i = 1; i<= nNr1; i++)
                                 {
@@ -4966,7 +4966,7 @@ sal_Bool StatementControl::Execute()
                             break;
                         case M_Less :
                             {
-                                if ( !(nParams & PARAM_USHORT_1) )
+                                if ( !(nParams & PARAM_UINT16_1) )
                                     nNr1 = 1;
                                 for (int i = 1; i<= nNr1; i++)
                                 {
@@ -5038,7 +5038,7 @@ sal_Bool StatementControl::Execute()
                         ToolBox *pTB = ((ToolBox*)pControl);
                         if ( !aUId.equals( pTB->GetUniqueOrHelpId() ) )	// So we found a Button on the ToolBox
                         {
-                            if ( (nParams == PARAM_NONE) || (nParams == PARAM_USHORT_1) )
+                            if ( (nParams == PARAM_NONE) || (nParams == PARAM_UINT16_1) )
                             {			// Wir f�lschen einen Parameter
                                 nParams |= PARAM_STR_1;
                                 aString1 = Id2Str( aUId );
@@ -5122,7 +5122,7 @@ sal_Bool StatementControl::Execute()
                                             aSubMenuId3 = 0;
                                             pMenuWindow = NULL;
 
-                                            new StatementCommand( this, RC_MenuSelect, PARAM_USHORT_1, pTB->GetItemId(nItemPos) + TOOLBOX_MENUITEM_START );
+                                            new StatementCommand( this, RC_MenuSelect, PARAM_UINT16_1, pTB->GetItemId(nItemPos) + TOOLBOX_MENUITEM_START );
                                         }
                                         else
                                         {
@@ -5210,17 +5210,17 @@ sal_Bool StatementControl::Execute()
                                                 pRet->GenReturn ( RET_Value, aUId, Id2Str( pTB->GetHelpId(pTB->GetItemId(nItemPos)) ) );
                                                 break;
                                             case 1:
-                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemType(nItemPos));
+                                                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pTB->GetItemType(nItemPos));
                                                 break;
                                             case 2:
-                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemState(pTB->GetItemId(nItemPos)));
+                                                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pTB->GetItemState(pTB->GetItemId(nItemPos)));
                                                 break;
                                             case 3:
-                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemId(nItemPos));
+                                                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pTB->GetItemId(nItemPos));
                                                 break;
                                             default:
                                                 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32(0));
                                                 break;
                                             }
                                     }
@@ -5233,7 +5233,7 @@ sal_Bool StatementControl::Execute()
                                 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetText());
                                 break;
                             case M_GetItemCount :
-                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemCount());
+                                pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pTB->GetItemCount());
                                 break;
                             case M_SetNextToolBox :
                                 if ( (nParams & PARAM_STR_1) )
@@ -5283,7 +5283,7 @@ sal_Bool StatementControl::Execute()
                             {                          // should get removed some time
                                 SvTreeListBox *pTree = (SvTreeListBox*)pControl;
                                 SvLBoxEntry *pThisEntry = pTree->GetCurEntry();
-                                if ( ! (nParams & PARAM_USHORT_1) )
+                                if ( ! (nParams & PARAM_UINT16_1) )
                                     nNr1 = 1;
                                 if ( pThisEntry )
                                 {
@@ -5311,19 +5311,19 @@ sal_Bool StatementControl::Execute()
                             }
                             break;
                         case M_GetSelCount :
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetSelectionCount()));
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((SvLBox*)pControl)->GetSelectionCount()));
                             break;
                         case M_GetItemCount :
-                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetVisibleCount()) );
+                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32(((SvLBox*)pControl)->GetVisibleCount()) );
                             break;
                         case M_GetSelIndex :
-                            if ( ! (nParams & PARAM_USHORT_1) )
+                            if ( ! (nParams & PARAM_UINT16_1) )
                                 nNr1 = 1;
                             if ( ValueOK(aUId, CUniString("GetSelIndex"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                             {
                                 nNr1--;
                                 GET_NTH_ENTRY_LBOX( FirstSelected, NextSelected, nNr1);
-                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( ((SvTreeListBox*)pControl)->GetVisiblePos( pThisEntry )) +1 );
+                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32( ((SvTreeListBox*)pControl)->GetVisiblePos( pThisEntry )) +1 );
                             }
                             break;
                         case M_Select :
@@ -5343,9 +5343,9 @@ sal_Bool StatementControl::Execute()
                             }
                             break;
                         case M_GetSelText :
-                            if ( ! (nParams & PARAM_USHORT_1) )
+                            if ( ! (nParams & PARAM_UINT16_1) )
                                 nNr1 = 1;
-                            if ( ! (nParams & PARAM_USHORT_2) )
+                            if ( ! (nParams & PARAM_UINT16_2) )
                                 nNr2 = 1;
                             if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                             {
@@ -5354,7 +5354,7 @@ sal_Bool StatementControl::Execute()
                                 if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                 {
                                     SvLBoxString* pItem = NULL;
-                                    if ( ! (nParams & PARAM_USHORT_2) )
+                                    if ( ! (nParams & PARAM_UINT16_2) )
                                         pItem = (SvLBoxString*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
                                     else
                                     {
@@ -5374,12 +5374,12 @@ sal_Bool StatementControl::Execute()
                             if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                             {
                                 SvLBoxEntry *pThisEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
-                                if ( ! (nParams & PARAM_USHORT_2) )
+                                if ( ! (nParams & PARAM_UINT16_2) )
                                     nNr2 = 1;
                                 if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                 {
                                     SvLBoxString* pItem = NULL;
-                                    if ( ! (nParams & PARAM_USHORT_2) )
+                                    if ( ! (nParams & PARAM_UINT16_2) )
                                         pItem = (SvLBoxString*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
                                     else
                                     {
@@ -5405,7 +5405,7 @@ sal_Bool StatementControl::Execute()
                                 SvTreeListBox *pTree = (SvTreeListBox*)pControl;
                                 SvLBoxEntry *pThisEntry = NULL;
 
-                                if ( ! (nParams & PARAM_USHORT_1) )
+                                if ( ! (nParams & PARAM_UINT16_1) )
                                 {
                                     pThisEntry = pTree->GetCurEntry();
                                     if ( !pThisEntry )
@@ -5419,7 +5419,7 @@ sal_Bool StatementControl::Execute()
                                     }
                                 }
 
-                                if ( ! (nParams & PARAM_USHORT_2) )
+                                if ( ! (nParams & PARAM_UINT16_2) )
                                     nNr2 = 1;
 
                                 if ( pThisEntry )
@@ -5427,7 +5427,7 @@ sal_Bool StatementControl::Execute()
                                     if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                     {
                                         SvLBoxButton* pItem = NULL;
-                                        if ( ! (nParams & PARAM_USHORT_2) )
+                                        if ( ! (nParams & PARAM_UINT16_2) )
                                             pItem = (SvLBoxButton*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXBUTTON );
                                         else
                                         {
@@ -5447,7 +5447,7 @@ sal_Bool StatementControl::Execute()
                                                     pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pItem->IsStateTristate() ) );
                                                     break;
                                                 case M_GetState :
-                                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pItem->GetButtonFlags() & ~SV_STATE_MASK ));
+                                                    pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pItem->GetButtonFlags() & ~SV_STATE_MASK ));
                                                     break;
                                                 case M_Check :
                                                     if ( !pItem->IsStateChecked() )
@@ -5489,7 +5489,7 @@ sal_Bool StatementControl::Execute()
                                 SvTreeListBox *pTree = (SvTreeListBox*)pControl;
                                 SvLBoxEntry *pThisEntry = NULL;
 
-                                if ( ! (nParams & PARAM_USHORT_1) )
+                                if ( ! (nParams & PARAM_UINT16_1) )
                                 {
                                     pThisEntry = pTree->GetCurEntry();
                                     if ( !pThisEntry )
@@ -5505,12 +5505,12 @@ sal_Bool StatementControl::Execute()
 
                                 if ( pThisEntry )
                                 {
-                                    if ( ! (nParams & PARAM_USHORT_2) )
+                                    if ( ! (nParams & PARAM_UINT16_2) )
                                         nNr2 = 1;
                                     if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                     {
                                         SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
-                                        comm_USHORT nType;
+                                        comm_UINT16 nType;
                                         switch ( pMyItem->IsA() )
                                         {
                                             case SV_ITEM_ID_LBOXSTRING: nType = CONST_ItemTypeText ; break;
@@ -5566,7 +5566,7 @@ sal_Bool StatementControl::Execute()
                                             case M_GetColumnCount :
                                                 {
                                                     sal_uInt16 nColCount = pEBBox->GetColumnCount();
-                                                    comm_USHORT nUnfrozenColCount = 0;
+                                                    comm_UINT16 nUnfrozenColCount = 0;
                                                     sal_uInt16 i;
                                                     for ( i=0 ; i < nColCount ; i++ )
                                                     {
@@ -5578,7 +5578,7 @@ sal_Bool StatementControl::Execute()
                                                 break;
                                             case M_GetRowCount :
                                                 {
-                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pEBBox->GetRowCount() );
+                                                    pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pEBBox->GetRowCount() );
                                                 }
                                                 break;
                                             case M_IsEditing :
@@ -5593,7 +5593,7 @@ sal_Bool StatementControl::Execute()
                                                     if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pEBBox->GetRowCount() ) )
                                                     {
                                                         sal_uInt16 nColCount = pEBBox->GetColumnCount();
-                                                        comm_USHORT nUnfrozenColCount = 0;
+                                                        comm_UINT16 nUnfrozenColCount = 0;
                                                         sal_uInt16 i;
                                                         for ( i=0 ; i < nColCount ; i++ )
                                                         {
@@ -5618,7 +5618,7 @@ sal_Bool StatementControl::Execute()
                                         switch ( nMethodId )
                                         {
                                         case M_GetItemCount:
-                                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pVS->GetItemCount()));
+                                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pVS->GetItemCount()));
                                             break;
                                         case M_GetItemText:
                                             if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pVS->GetItemCount() ))
@@ -5630,9 +5630,9 @@ sal_Bool StatementControl::Execute()
                                             break;
                                         case M_GetSelIndex :
                                             if ( pVS->IsNoSelection() )
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32(0));
                                             else
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pVS->GetItemPos( pVS->GetSelectItemId() ) +1));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pVS->GetItemPos( pVS->GetSelectItemId() ) +1));
                                             break;
                                         case M_GetSelText :
                                             if ( pVS->IsNoSelection() )
@@ -5655,7 +5655,7 @@ sal_Bool StatementControl::Execute()
                                         switch ( nMethodId )
                                         {
                                         case M_GetItemCount:
-                                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pRM->GetItemCount()));
+                                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pRM->GetItemCount()));
                                             break;
                                         case M_GetItemText:
                                             if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
@@ -5671,7 +5671,7 @@ sal_Bool StatementControl::Execute()
                                             }
                                             break;
                                         case M_GetSelIndex :
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pRM->GetItemIndex( pRM->GetCurrentRoadmapItemID() ) +1));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pRM->GetItemIndex( pRM->GetCurrentRoadmapItemID() ) +1));
                                             break;
                                         case M_GetSelText :
                                                 pRet->GenReturn ( RET_Value, aUId, pRM->GetRoadmapItemLabel( pRM->GetCurrentRoadmapItemID() ) );
@@ -5692,7 +5692,7 @@ sal_Bool StatementControl::Execute()
                                         switch ( nMethodId )
                                         {
                                         case M_GetItemCount:
-                                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pELB->getItemCount()));
+                                            pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pELB->getItemCount()));
                                             break;
                                         case M_GetItemText:
                                             if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pELB->getItemCount() ))
@@ -5718,7 +5718,7 @@ sal_Bool StatementControl::Execute()
                                                 }
                                             break;
                                         case M_Select:
-                                            if ( (nParams & PARAM_USHORT_1) )
+                                            if ( (nParams & PARAM_UINT16_1) )
                                             {
                                                 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pELB->getItemCount() ))
                                                 {
@@ -5742,15 +5742,15 @@ sal_Bool StatementControl::Execute()
                                             break;
                                         case M_GetSelCount :
                                             if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 0 ));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32( 0 ));
                                             else
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 1 ));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32( 1 ));
                                             break;
                                         case M_GetSelIndex :
                                             if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
-                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 0 ));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32( 0 ));
                                             else
-                                                   pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pELB->getSelIndex() +1));
+                                                   pRet->GenReturn ( RET_Value, aUId, comm_UINT32( pELB->getSelIndex() +1));
                                             break;
                                         default:
                                             ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RoadMap" ) );
@@ -5812,20 +5812,20 @@ sal_Bool StatementControl::Execute()
                                                             case TypeClass_UNSIGNED_LONG:
                                                             case TypeClass_UNSIGNED_HYPER:
                                                                 {
-                                                                    comm_ULONG val = 0;
+                                                                    comm_UINT32 val = 0;
                                                                     aCell >>= val;
                                                                     pRet->GenReturn ( RET_Value, aUId, val );
                                                                 }
                                                                 break;
                                                             case TypeClass_UNSIGNED_SHORT:
                                                                 {
-                                                                    comm_USHORT val = 0;
+                                                                    comm_UINT16 val = 0;
                                                                     aCell >>= val;
                                                                     pRet->GenReturn ( RET_Value, aUId, val );
                                                                 }
                                                                 break;
                                                             default:
-                                                                pRet->GenReturn ( RET_Value, aUId, comm_USHORT(0) );
+                                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT16(0) );
                                                                 break;
                                                         }
                                                     }
@@ -5833,12 +5833,12 @@ sal_Bool StatementControl::Execute()
                                                 break;
                                             case M_GetColumnCount :
                                                 {
-                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTC->GetColumnCount() );
+                                                    pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pTC->GetColumnCount() );
                                                 }
                                                 break;
                                             case M_GetRowCount :
                                                 {
-                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTC->GetRowCount() );
+                                                    pRet->GenReturn ( RET_Value, aUId, (comm_UINT32)pTC->GetRowCount() );
                                                 }
                                                 break;
                                             case M_Select :
@@ -5876,13 +5876,13 @@ sal_Bool StatementControl::Execute()
                                                 }
                                                 break;
                                             case M_GetSelCount :
-                                                pRet->GenReturn ( RET_Value, aUId, comm_USHORT( pTC->GetSelectedRowCount() ));
+                                                pRet->GenReturn ( RET_Value, aUId, comm_UINT16( pTC->GetSelectedRowCount() ));
                                                 break;
                                             case M_GetSelIndex :
-                                                if ( ! (nParams & PARAM_USHORT_1) )
+                                                if ( ! (nParams & PARAM_UINT16_1) )
                                                     nNr1 = 1;
                                                 if ( ValueOK( aUId, CUniString("GetSelIndex"), nNr1, pTC->GetSelectedRowCount() ) )
-                                                    pRet->GenReturn ( RET_Value, aUId, comm_USHORT( pTC->GetSelectedRowIndex( nNr1-1 ) +1 ) );
+                                                    pRet->GenReturn ( RET_Value, aUId, comm_UINT16( pTC->GetSelectedRowIndex( nNr1-1 ) +1 ) );
                                                 break;
                                         default:
                                             ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TableControl" ) );
@@ -6267,7 +6267,7 @@ sal_Bool StatementControl::Execute()
                                 pRet->GenReturn ( RET_Value, aUId, pControl->GetText());
                                 break;
                             case M_Click:
-                                if ( nParams & PARAM_USHORT_1 )
+                                if ( nParams & PARAM_UINT16_1 )
                                 {
                                     if ( pBD->GetPushButton( nNr1 ) )
                                     {
@@ -6284,11 +6284,11 @@ sal_Bool StatementControl::Execute()
                                     ReportError( aUId, GEN_RES_STR1( S_BUTTONID_REQUIRED, MethodString( nMethodId ) ) );
                                 break;
                             case M_GetButtonCount :
-                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pBD->GetButtonCount()));
+                                pRet->GenReturn ( RET_Value, aUId, comm_UINT32(pBD->GetButtonCount()));
                                 break;
                             case M_GetButtonId :
                                 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pBD->GetButtonCount()) )
-                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pBD->GetButtonId(nNr1-1)));
+                                    pRet->GenReturn ( RET_Value, aUId, comm_UINT32(pBD->GetButtonId(nNr1-1)));
                                 break;
                             default:
                                 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MessageBox" ) );
diff --git a/automation/source/server/statemnt.hxx b/automation/source/server/statemnt.hxx
index 1d0af504b..9fcdd2a41 100644
--- a/automation/source/server/statemnt.hxx
+++ b/automation/source/server/statemnt.hxx
@@ -336,8 +336,8 @@ class StatementCommand : public StatementList	// Befehl ausf�hren (wintree, re
 protected:
     sal_uInt16 nMethodId;
     sal_uInt16 nParams;
-    comm_USHORT nNr1,nNr2,nNr3,nNr4;
-    comm_ULONG nLNr1;
+    comm_UINT16 nNr1,nNr2,nNr3,nNr4;
+    comm_UINT32 nLNr1;
     String aString1,aString2;
     sal_Bool bBool1,bBool2;
 
@@ -372,8 +372,8 @@ protected:
     rtl::OString aUId;
     sal_uInt16 nMethodId;
     sal_uInt16 nParams;
-    comm_USHORT nNr1,nNr2,nNr3,nNr4;
-    comm_ULONG nLNr1;
+    comm_UINT16 nNr1,nNr2,nNr3,nNr4;
+    comm_UINT32 nLNr1;
     String aString1,aString2;
     sal_Bool bBool1,bBool2;
     sal_Bool ControlOK( Window *pControl, const sal_Char* aBezeichnung );
@@ -396,8 +396,8 @@ class StatementFlow : public StatementList		// Kommunikation mit Sequence
     sal_uInt16 nArt;
 
     sal_uInt16 nParams;
-    comm_USHORT nSNr1;
-    comm_ULONG nLNr1;
+    comm_UINT16 nSNr1;
+    comm_UINT32 nLNr1;
     String aString1;
     sal_Bool bBool1;
 
diff --git a/automation/source/server/svcommstream.cxx b/automation/source/server/svcommstream.cxx
index 9258a6472..730cfabc6 100644
--- a/automation/source/server/svcommstream.cxx
+++ b/automation/source/server/svcommstream.cxx
@@ -34,18 +34,18 @@
 SvCommStream::SvCommStream( SvStream* pIO ) { pStream = pIO; }
 SvCommStream::~SvCommStream() {}
 
-ICommStream& SvCommStream::operator>>( comm_USHORT& rUShort ) { *pStream >> rUShort; return *this; }
-ICommStream& SvCommStream::operator>>( comm_ULONG& rULong ) { *pStream >> rULong; return *this; }
+ICommStream& SvCommStream::operator>>( comm_UINT16& rUShort ) { *pStream >> rUShort; return *this; }
+ICommStream& SvCommStream::operator>>( comm_UINT32& rULong ) { *pStream >> rULong; return *this; }
 ICommStream& SvCommStream::operator>>( comm_BOOL& rChar ) { *pStream >> rChar; return *this; }
 
-ICommStream& SvCommStream::operator<<( comm_USHORT nUShort ) { *pStream << nUShort; return *this; }
-ICommStream& SvCommStream::operator<<( comm_ULONG nULong ) { *pStream << nULong; return *this; }
+ICommStream& SvCommStream::operator<<( comm_UINT16 nUShort ) { *pStream << nUShort; return *this; }
+ICommStream& SvCommStream::operator<<( comm_UINT32 nULong ) { *pStream << nULong; return *this; }
 ICommStream& SvCommStream::operator<<( comm_BOOL nChar ) { *pStream << nChar; return *this; }
 
-comm_ULONG SvCommStream::Read( void* pData, comm_ULONG nSize ) { return pStream->Read( pData, nSize ); }
-comm_ULONG SvCommStream::Write( const void* pData, comm_ULONG nSize ) { return pStream->Write( pData, nSize ); }
+comm_UINT32 SvCommStream::Read( void* pData, comm_UINT32 nSize ) { return pStream->Read( pData, nSize ); }
+comm_UINT32 SvCommStream::Write( const void* pData, comm_UINT32 nSize ) { return pStream->Write( pData, nSize ); }
 
 comm_BOOL SvCommStream::IsEof() const { return pStream->IsEof(); }
-comm_ULONG SvCommStream::SeekRel( long nPos ) { return pStream->SeekRel( nPos ); }
+comm_UINT32 SvCommStream::SeekRel( long nPos ) { return pStream->SeekRel( nPos ); }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/automation/source/simplecm/communiio.hxx b/automation/source/simplecm/communiio.hxx
index bb104078d..c6a342d39 100644
--- a/automation/source/simplecm/communiio.hxx
+++ b/automation/source/simplecm/communiio.hxx
@@ -44,25 +44,25 @@
 class ITransmiter
 {
 protected:
-    comm_ULONG nLastSent;
+    comm_UINT32 nLastSent;
 public:
     ITransmiter() :nLastSent( 0 ){}
     virtual ~ITransmiter() {}
-    virtual comm_USHORT TransferBytes( const void* pBuffer, comm_UINT32 nLen ) = 0;
+    virtual comm_UINT16 TransferBytes( const void* pBuffer, comm_UINT32 nLen ) = 0;
 
-    comm_ULONG GetLastSent() const { return nLastSent; }
+    comm_UINT32 GetLastSent() const { return nLastSent; }
 };
 
 class IReceiver
 {
 protected:
-    comm_ULONG nLastReceived;
+    comm_UINT32 nLastReceived;
 public:
     IReceiver() :nLastReceived( 0 ){}
     virtual ~IReceiver() {;}
-    virtual comm_USHORT ReceiveBytes( void* pBuffer, comm_UINT32 nLen ) = 0;
+    virtual comm_UINT16 ReceiveBytes( void* pBuffer, comm_UINT32 nLen ) = 0;
 
-    comm_ULONG GetLastReceived() const { return nLastReceived; }
+    comm_UINT32 GetLastReceived() const { return nLastReceived; }
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/automation/source/simplecm/packethandler.cxx b/automation/source/simplecm/packethandler.cxx
index aea8a1a94..70feb9c04 100644
--- a/automation/source/simplecm/packethandler.cxx
+++ b/automation/source/simplecm/packethandler.cxx
@@ -111,8 +111,8 @@ comm_BOOL PacketHandler::ReceiveData( void* &pData, comm_UINT32 &nLen )
 
         if ( bMultiChannel || bForceMultiChannelThisPacket )
         {
-            comm_ULONG nReadSoFar = 0;
-            comm_ULONG nHeaderReadSoFar = 0;
+            comm_UINT32 nReadSoFar = 0;
+            comm_UINT32 nHeaderReadSoFar = 0;
 
             // Pr�fbyte f�r L�ngenangabe
             unsigned char nLenCheck = 0;
diff --git a/automation/source/simplecm/tcpio.cxx b/automation/source/simplecm/tcpio.cxx
index e71afb399..9c0bc2185 100644
--- a/automation/source/simplecm/tcpio.cxx
+++ b/automation/source/simplecm/tcpio.cxx
@@ -32,7 +32,7 @@
 #include "tcpio.hxx"
 
 /// implement ITransmiter
-comm_USHORT TCPIO::TransferBytes( const void* pBuffer, comm_UINT32 nLen )
+comm_UINT16 TCPIO::TransferBytes( const void* pBuffer, comm_UINT32 nLen )
 {
     osl::MutexGuard aGuard( aMSocketWriteAccess );
     if ( !pStreamSocket )
@@ -48,7 +48,7 @@ comm_USHORT TCPIO::TransferBytes( const void* pBuffer, comm_UINT32 nLen )
 
 
 /// implement IReceiver
-comm_USHORT TCPIO::ReceiveBytes( void* pBuffer, comm_UINT32 nLen )
+comm_UINT16 TCPIO::ReceiveBytes( void* pBuffer, comm_UINT32 nLen )
 {
     osl::MutexGuard aGuard( aMSocketReadAccess );
     if ( !pStreamSocket )
diff --git a/automation/source/simplecm/tcpio.hxx b/automation/source/simplecm/tcpio.hxx
index 07c3edba7..3240a8156 100644
--- a/automation/source/simplecm/tcpio.hxx
+++ b/automation/source/simplecm/tcpio.hxx
@@ -49,10 +49,10 @@ public:
 
 
     /// implement ITransmiter
-    virtual comm_USHORT TransferBytes( const void* pBuffer, comm_UINT32 nLen );
+    virtual comm_UINT16 TransferBytes( const void* pBuffer, comm_UINT32 nLen );
 
     /// implement IReceiver
-    virtual comm_USHORT ReceiveBytes( void* pBuffer, comm_UINT32 nLen );
+    virtual comm_UINT16 ReceiveBytes( void* pBuffer, comm_UINT32 nLen );
 
     // helper
     void SetStreamSocket( osl::StreamSocket* pSocket );
diff --git a/automation/source/testtool/cmdstrm.cxx b/automation/source/testtool/cmdstrm.cxx
index efb8c3e1c..00cb14b7b 100644
--- a/automation/source/testtool/cmdstrm.cxx
+++ b/automation/source/testtool/cmdstrm.cxx
@@ -172,7 +172,7 @@ void CmdStream::WriteSortedParams( SbxArray* rPar, sal_Bool IsKeyString )
 {
     sal_uInt16 nParams = PARAM_NONE;
     sal_uInt16 nNr1=0,nNr2=0,nNr3=0,nNr4=0;
-    comm_ULONG nLNr1=0;
+    comm_UINT32 nLNr1=0;
     String aString1,aString2;
     sal_Bool bBool1=sal_False,bBool2=sal_False;
 
@@ -193,24 +193,24 @@ void CmdStream::WriteSortedParams( SbxArray* rPar, sal_Bool IsKeyString )
                 case SbxINT:
                 case SbxUINT:
                 case SbxSINGLE:
-                    if ( (nParams & PARAM_USHORT_1) == 0 )
+                    if ( (nParams & PARAM_UINT16_1) == 0 )
                     {
-                        nParams |= PARAM_USHORT_1;
+                        nParams |= PARAM_UINT16_1;
                         nNr1 = rPar->Get( i )->GetUShort();
                     }
-                    else if ( (nParams & PARAM_USHORT_2) == 0 )
+                    else if ( (nParams & PARAM_UINT16_2) == 0 )
                     {
-                        nParams |= PARAM_USHORT_2;
+                        nParams |= PARAM_UINT16_2;
                         nNr2 = rPar->Get( i )->GetUShort();
                     }
-                    else if ( (nParams & PARAM_USHORT_3) == 0 )
+                    else if ( (nParams & PARAM_UINT16_3) == 0 )
                     {
-                        nParams |= PARAM_USHORT_3;
+                        nParams |= PARAM_UINT16_3;
                         nNr3 = rPar->Get( i )->GetUShort();
                     }
-                    else if ( (nParams & PARAM_USHORT_4) == 0 )
+                    else if ( (nParams & PARAM_UINT16_4) == 0 )
                     {
-                        nParams |= PARAM_USHORT_4;
+                        nParams |= PARAM_UINT16_4;
                         nNr4 = rPar->Get( i )->GetUShort();
                     }
                     else
@@ -242,11 +242,11 @@ void CmdStream::WriteSortedParams( SbxArray* rPar, sal_Bool IsKeyString )
                             }
                             else if ( pMember->GetType() == SbxULONG )
                             {
-                                if ( nParams & PARAM_ULONG_1 )
+                                if ( nParams & PARAM_UINT32_1 )
                                     SbxBase::SetError( SbxERR_WRONG_ARGS );
                                 else
                                 {
-                                    nParams |= PARAM_ULONG_1;
+                                    nParams |= PARAM_UINT32_1;
                                     nLNr1 = pMember->GetULong();
                                 }
                             }
@@ -297,11 +297,11 @@ void CmdStream::WriteSortedParams( SbxArray* rPar, sal_Bool IsKeyString )
         }
     }
     Write (nParams);
-    if( nParams & PARAM_USHORT_1 )	Write( nNr1 );
-    if( nParams & PARAM_USHORT_2 )	Write( nNr2 );
-    if( nParams & PARAM_USHORT_3 )	Write( nNr3 );
-    if( nParams & PARAM_USHORT_4 )	Write( nNr4 );
-    if( nParams & PARAM_ULONG_1 )	Write( nLNr1 );
+    if( nParams & PARAM_UINT16_1 )	Write( nNr1 );
+    if( nParams & PARAM_UINT16_2 )	Write( nNr2 );
+    if( nParams & PARAM_UINT16_3 )	Write( nNr3 );
+    if( nParams & PARAM_UINT16_4 )	Write( nNr4 );
+    if( nParams & PARAM_UINT32_1 )	Write( nLNr1 );
     if( nParams & PARAM_STR_1 )		Write( aString1, IsKeyString );
     if( nParams & PARAM_STR_2 )		Write( aString2, IsKeyString );
     if( nParams & PARAM_BOOL_1 )	Write( bBool1 );
@@ -344,7 +344,7 @@ void CmdStream::GenCmdSlot( sal_uInt16 nNr, SbxArray* rPar )
                 case SbxUINT:
                 case SbxSINGLE:
                     if ( !bWriteUnoSlot )
-                        Write( (sal_uInt16)BinUSHORT );
+                        Write( (sal_uInt16)BinUINT16 );
                     Write(rPar->Get( 2*n )->GetUShort());
                     break;
                 case SbxLONG:
@@ -353,7 +353,7 @@ void CmdStream::GenCmdSlot( sal_uInt16 nNr, SbxArray* rPar )
                 case SbxSALUINT64:
                 case SbxDOUBLE:
                     if ( !bWriteUnoSlot )
-                        Write( (sal_uInt16)BinULONG );
+                        Write( (sal_uInt16)BinUINT32 );
                     Write(rPar->Get( 2*n )->GetULong());
                     break;
                 case SbxSTRING:
@@ -399,7 +399,7 @@ void CmdStream::GenCmdUNOSlot( const String &aURL )
     Write( aURL );			// Die UNO URL eben
 }
 
-void CmdStream::GenCmdControl( comm_ULONG nUId, sal_uInt16 nMethodId, SbxArray* rPar )
+void CmdStream::GenCmdControl( comm_UINT32 nUId, sal_uInt16 nMethodId, SbxArray* rPar )
 {
     Write(sal_uInt16(SIControl));
     Write(nUId);
@@ -426,15 +426,15 @@ void CmdStream::GenCmdFlow( sal_uInt16 nArt, sal_uInt16 nNr1 )
 {
     Write(sal_uInt16(SIFlow));
     Write(nArt);
-    Write(sal_uInt16(PARAM_USHORT_1));			// Typ der folgenden Parameter
+    Write(sal_uInt16(PARAM_UINT16_1));			// Typ der folgenden Parameter
     Write(nNr1);
 }
 
-void CmdStream::GenCmdFlow( sal_uInt16 nArt, comm_ULONG nNr1 )
+void CmdStream::GenCmdFlow( sal_uInt16 nArt, comm_UINT32 nNr1 )
 {
     Write(sal_uInt16(SIFlow));
     Write(nArt);
-    Write(sal_uInt16(PARAM_ULONG_1));			// Typ der folgenden Parameter
+    Write(sal_uInt16(PARAM_UINT32_1));			// Typ der folgenden Parameter
     Write(nNr1);
 }
 
@@ -459,7 +459,7 @@ SvMemoryStream* CmdStream::GetStream()
     return pSammel;
 }
 
-void CmdStream::Reset( comm_ULONG nSequence )
+void CmdStream::Reset( comm_UINT32 nSequence )
 {
     delete pCommStream;
     delete pSammel;
diff --git a/automation/source/testtool/cmdstrm.hxx b/automation/source/testtool/cmdstrm.hxx
index 8cf8f0b71..9f104e2b4 100644
--- a/automation/source/testtool/cmdstrm.hxx
+++ b/automation/source/testtool/cmdstrm.hxx
@@ -46,16 +46,16 @@ public:
 
     void GenCmdUNOSlot( const String &aURL );
 
-    void GenCmdControl( comm_ULONG nUId, sal_uInt16 nMethodId, SbxArray* rPar );
+    void GenCmdControl( comm_UINT32 nUId, sal_uInt16 nMethodId, SbxArray* rPar );
     void GenCmdControl( String aUId, sal_uInt16 nMethodId, SbxArray* rPar );
 
 
     void GenCmdFlow( sal_uInt16 nArt );
     void GenCmdFlow( sal_uInt16 nArt, sal_uInt16 nNr1 );
-    void GenCmdFlow( sal_uInt16 nArt, comm_ULONG nNr1 );
+    void GenCmdFlow( sal_uInt16 nArt, comm_UINT32 nNr1 );
     void GenCmdFlow( sal_uInt16 nArt, String aString1 );
 
-    void Reset(comm_ULONG nSequence);
+    void Reset(comm_UINT32 nSequence);
 
     SvMemoryStream* GetStream();
 
@@ -66,9 +66,9 @@ private:
     String WandleKeyEventString( String aKeys );	// Nutzt pKeyCodes.  <RETURN> <SHIFT LEFT LEFT>
 
     using CmdBaseStream::Write;
-    void Write( comm_USHORT nNr ){CmdBaseStream::Write( nNr );}
-    void Write( comm_ULONG nNr ){CmdBaseStream::Write( nNr );}
-    void Write( const comm_UniChar* aString, comm_USHORT nLenInChars ){CmdBaseStream::Write( aString, nLenInChars );}
+    void Write( comm_UINT16 nNr ){CmdBaseStream::Write( nNr );}
+    void Write( comm_UINT32 nNr ){CmdBaseStream::Write( nNr );}
+    void Write( const comm_UniChar* aString, comm_UINT16 nLenInChars ){CmdBaseStream::Write( aString, nLenInChars );}
     void Write( comm_BOOL bBool ){CmdBaseStream::Write( bBool );}
 //  new
     void Write( String aString, sal_Bool IsKeyString = sal_False );
diff --git a/automation/source/testtool/cretstrm.hxx b/automation/source/testtool/cretstrm.hxx
index 34098ae0d..f33dc65a8 100644
--- a/automation/source/testtool/cretstrm.hxx
+++ b/automation/source/testtool/cretstrm.hxx
@@ -43,8 +43,8 @@ public:
     ~CRetStream();
 
     using CmdBaseStream::Read;
-    void Read ( comm_USHORT &nNr ){CmdBaseStream::Read ( nNr );}
-    void Read ( comm_ULONG &nNr ){CmdBaseStream::Read ( nNr );}
+    void Read ( comm_UINT16 &nNr ){CmdBaseStream::Read ( nNr );}
+    void Read ( comm_UINT32 &nNr ){CmdBaseStream::Read ( nNr );}
     virtual void Read ( rtl::OString* &pId ){CmdBaseStream::Read ( pId );}
     void Read ( comm_BOOL &bBool ){CmdBaseStream::Read ( bBool );}
     void Read( String &aString );
diff --git a/automation/source/testtool/objtest.cxx b/automation/source/testtool/objtest.cxx
index 5f7d3de9d..90a484d73 100644
--- a/automation/source/testtool/objtest.cxx
+++ b/automation/source/testtool/objtest.cxx
@@ -169,7 +169,7 @@ void ControlDef::Write( SvStream &aStream )
     if ( pData->aUId.HasString() )
         aStream.WriteByteString( pData->aUId.GetStr(), RTL_TEXTENCODING_UTF8 );
     else
-        aStream << static_cast<comm_ULONG>(pData->aUId.GetNum()); //GetNum() sal_uLong != comm_ULONG on 64bit
+        aStream << static_cast<comm_UINT32>(pData->aUId.GetNum()); //GetNum() sal_uLong != comm_UINT32 on 64bit
     if ( pSons )
         for ( sal_uInt16 i = 0 ; pSons->Count() > i ; i++ )
             ((ControlDef*)(*pSons)[i])->Write(aStream);
@@ -1401,7 +1401,7 @@ sal_Bool TestToolObj::ReadNamesBin( String Filename, CNames *&pSIds, CNames *&pC
         }
         else
         {
-            comm_ULONG nUId;
+            comm_UINT32 nUId;
             aStream >> nUId;
             aUId = rtl::OString();// nUId;
         }
@@ -3168,7 +3168,7 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
             }
             else
             {
-                comm_ULONG nUId;
+                comm_UINT32 nUId;
                 pRetStream->Read( nUId );         // bei Sequence einfach die Sequence
                 // FIXME: HELPID
                 #if 0
@@ -3178,14 +3178,14 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
             pRetStream->Read(nParams);
 
             sal_uInt16 nNr1 = 0;
-            comm_ULONG nLNr1 = 0;
+            comm_UINT32 nLNr1 = 0;
             String aString1;
             sal_Bool bBool1 = sal_False;
             SbxValueRef xValue1 = new SbxValue;
 
-            if( nParams & PARAM_USHORT_1 )
+            if( nParams & PARAM_UINT16_1 )
                 pRetStream->Read( nNr1 );
-            if( nParams & PARAM_ULONG_1 )
+            if( nParams & PARAM_UINT32_1 )
                 pRetStream->Read( nLNr1 );
             if( nParams & PARAM_STR_1 )
             {
@@ -3222,14 +3222,14 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
                     {
                         if ( aNextReturnId.equals( aUId ) )
                         {
-                            if( nParams & PARAM_ULONG_1 )   // FIXME this is to allow negative numbers, hoping that no large numbers are interpreted wrong. should have new PARAM_LONG_1 instead
+                            if( nParams & PARAM_UINT32_1 )   // FIXME this is to allow negative numbers, hoping that no large numbers are interpreted wrong. should have new PARAM_LONG_1 instead
                             {
                                 if ( nLNr1 > 0x7fffffff )
                                     pImpl->pNextReturn->PutLong( long(nLNr1 - 0xffffffff) -1 );
                                 else
                                     pImpl->pNextReturn->PutULong( nLNr1 );
                             }
-                            if( nParams & PARAM_USHORT_1 )		pImpl->pNextReturn->PutUShort( nNr1 );
+                            if( nParams & PARAM_UINT16_1 )		pImpl->pNextReturn->PutUShort( nNr1 );
                             if( nParams & PARAM_STR_1 )			pImpl->pNextReturn->PutString( aString1 );
                             if( nParams & PARAM_BOOL_1 )		pImpl->pNextReturn->PutBool( bBool1 );
                             if( nParams & PARAM_SBXVALUE_1 )    // FIXME: allow generic datatype
@@ -3368,7 +3368,7 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
                                 aStrm.Close();
                             }
                         }
-                        if ( nParams & PARAM_ULONG_1 )
+                        if ( nParams & PARAM_UINT32_1 )
                         {
                             switch ( nUId )
                             {
@@ -3532,7 +3532,7 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
                         }
 
                         aULongNames.Erase();
-                        if( (nParams & PARAM_ULONG_1) && (nNr1 & M_RET_NUM_CONTROL) )
+                        if( (nParams & PARAM_UINT32_1) && (nNr1 & M_RET_NUM_CONTROL) )
                         {
                             if ( m_pReverseControls )
                             {
@@ -3729,7 +3729,7 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
                             }
                             aCommand.AppendAscii( "\"" );
                         }
-                        if( nParams & PARAM_ULONG_1 )
+                        if( nParams & PARAM_UINT32_1 )
                         {
                             if ( bWasParam )
                                 aCommand.AppendAscii( ", " );
@@ -3785,7 +3785,7 @@ sal_Bool TestToolObj::ReturnResults( SvStream *pIn )
             }
             else
             {
-                comm_ULONG nUId;
+                comm_UINT32 nUId;
                 pRetStream->Read( nUId );         // bei Sequence einfach die Sequence
                 // FIXME: HELPID
                 #if 0
diff --git a/xmlsecurity/source/component/documentdigitalsignatures.cxx b/xmlsecurity/source/component/documentdigitalsignatures.cxx
index f53acb4f5..44c71ba98 100644
--- a/xmlsecurity/source/component/documentdigitalsignatures.cxx
+++ b/xmlsecurity/source/component/documentdigitalsignatures.cxx
@@ -440,8 +440,6 @@ void DocumentDigitalSignatures::showCertificate(
     ::ucbhelper::ContentBroker* pBroker = NULL;
 
     //warning free code
-    //if ( aLocObj.GetProtocol() == INET_PROT_FILE && ( pBroker = ::ucbhelper::ContentBroker::get() ) )
-    //	xContentProvider = pBroker->getContentProviderInterface();
     if ( aLocObj.GetProtocol() == INET_PROT_FILE)
     {
         pBroker = ::ucbhelper::ContentBroker::get();
diff --git a/xmlsecurity/source/dialogs/certificateviewer.cxx b/xmlsecurity/source/dialogs/certificateviewer.cxx
index 7f9d00a6f..e39540eae 100644
--- a/xmlsecurity/source/dialogs/certificateviewer.cxx
+++ b/xmlsecurity/source/dialogs/certificateviewer.cxx
@@ -299,12 +299,6 @@ CertificateViewerDetailsTP::CertificateViewerDetailsTP( Window* _pParent, Certif
     aLBEntry = pairIssuer.first;
     aDetails = pairIssuer.second; 
     InsertElement( String( XMLSEC_RES( STR_ISSUER ) ), aLBEntry, aDetails );
-    /*
-    aSeq = xCert->getIssuerUniqueID();
-    aLBEntry = XmlSec::GetHexString( aSeq, pHexSep );
-    aDetails = XmlSec::GetHexString( aSeq, pHexSep, nLineBreak );
-    InsertElement( String( XMLSEC_RES( STR_ISSUER_ID ) ), aLBEntry, aDetails, true );
-    */
 
     DateTime aDateTime;
     utl::typeConvert( xCert->getNotValidBefore(), aDateTime );
@@ -323,12 +317,7 @@ CertificateViewerDetailsTP::CertificateViewerDetailsTP( Window* _pParent, Certif
     aLBEntry = pairSubject.first;
     aDetails = pairSubject.second;
     InsertElement( String( XMLSEC_RES( STR_SUBJECT ) ), aLBEntry, aDetails );
-    /*
-    aSeq = xCert->getSubjectUniqueID();
-    aLBEntry = XmlSec::GetHexString( aSeq, pHexSep );
-    aDetails = XmlSec::GetHexString( aSeq, pHexSep, nLineBreak );
-    InsertElement( String( XMLSEC_RES( STR_SUBJECT_ID ) ), aLBEntry, aDetails, true );
-    */
+
     aLBEntry = aDetails = xCert->getSubjectPublicKeyAlgorithm();
     InsertElement( String( XMLSEC_RES( STR_SUBJECT_PUBKEY_ALGO ) ), aLBEntry, aDetails );
     aSeq = xCert->getSubjectPublicKeyValue();
diff --git a/xmlsecurity/source/dialogs/dialogs.hrc b/xmlsecurity/source/dialogs/dialogs.hrc
index 9ea22bf2f..a7c547d1e 100644
--- a/xmlsecurity/source/dialogs/dialogs.hrc
+++ b/xmlsecurity/source/dialogs/dialogs.hrc
@@ -84,25 +84,19 @@
 #define FI_STATE_NOTVALIDATED           12
 #define FI_STATE_OLDSIGNATURE           16
 
-//#define DS_WIDTH						DLGS_WIDTH
-//#define DS_HEIGHT						DLGS_HEIGHT
 #define DS_BTNWIDTH_1					70
 #define DS_BTNSPACE_X					RSC_SP_CTRL_X
 #define DS_WIDTH						(RSC_SP_DLG_INNERBORDER_LEFT+RSC_SP_DLG_INNERBORDER_RIGHT+2*DS_BTNSPACE_X+3*DS_BTNWIDTH_1)
 #define DS_HEIGHT						(DLGS_WIDTH*2/3)
 
 #define DS_COL_0						RSC_SP_DLG_INNERBORDER_LEFT
-//#define DS_COL_MID						(DS_WIDTH/2)
-//#define DS_COL_3						(DS_COL_MID-(DS_BTNWIDTH_1/2))
-//#define DS_COL_4						(DS_COL_2+DS_BTNWIDTH_1)
-//#define DS_COL_2						(DS_COL_3-DS_BTNSPACE_X)
-//#define DS_COL_1						(DS_COL_2-DS_BTNWIDTH_1)
+
 #define DS_COL_1						DS_COL_0
 #define DS_COL_2						(DS_COL_1+DS_BTNWIDTH_1)
 #define DS_COL_3						(DS_COL_2+DS_BTNSPACE_X)
 #define DS_COL_4						(DS_COL_3+DS_BTNWIDTH_1)
 #define DS_COL_5						(DS_COL_4+DS_BTNSPACE_X)
-//#define	DS_COL_6						(DS_COL_5+DS_BTNWIDTH_1)
+
 #define DS_COL_7						(DS_WIDTH-RSC_SP_DLG_INNERBORDER_RIGHT)
 #define	DS_COL_6						DS_COL_7
 
@@ -242,8 +236,6 @@
 #define CVP_ROW_3                       (CVP_ROW_2+RSC_CD_PUSHBUTTON_HEIGHT)
 #define CVP_ROW_4                       (CVP_ROW_3+RSC_CD_FIXEDTEXT_HEIGHT+RSC_SP_CTRL_DESC_Y)
 
-//#define CV_ROW_0A                      (CV_ROW_0+RSC_SP_CTRL_DESC_Y+RSC_CD_FIXEDTEXT_HEIGHT)
-//#define CV_ROW_2A                      (CV_ROW_2+RSC_SP_CTRL_DESC_Y+RSC_CD_FIXEDTEXT_HEIGHT)
 
 // --------- tab dialog macro security ---------
 
diff --git a/xmlsecurity/source/dialogs/macrosecurity.cxx b/xmlsecurity/source/dialogs/macrosecurity.cxx
index e65ff886f..a05b0a9c8 100644
--- a/xmlsecurity/source/dialogs/macrosecurity.cxx
+++ b/xmlsecurity/source/dialogs/macrosecurity.cxx
@@ -370,8 +370,6 @@ MacroSecurityTrustedSourcesTP::MacroSecurityTrustedSourcesTP( Window* _pParent,
     mbAuthorsReadonly = mpDlg->maSecOptions.IsReadOnly( SvtSecurityOptions::E_MACRO_TRUSTEDAUTHORS );
     maTrustCertROFI.Show( mbAuthorsReadonly );
     mbAuthorsReadonly ? maTrustCertLB.DisableTable() : maTrustCertLB.EnableTable();
-//  unused button 
-//    maAddCertPB.Enable( !mbAuthorsReadonly );
 
     FillCertLB();
 
diff --git a/xmlsecurity/source/dialogs/resourcemanager.cxx b/xmlsecurity/source/dialogs/resourcemanager.cxx
index cecc68e5e..8e631a410 100644
--- a/xmlsecurity/source/dialogs/resourcemanager.cxx
+++ b/xmlsecurity/source/dialogs/resourcemanager.cxx
@@ -53,9 +53,6 @@ namespace XmlSec
         if( !pResMgr )
         {
             ByteString	aName( "xmlsec" );
-//    		pResMgr = ResMgr::CreateResMgr( aName.GetBuffer(), Application::GetSettings().GetUILanguage() );
-//			LanguageType	aLang( LANGUAGE_ENGLISH_US );
-//			pResMgr = ResMgr::CreateResMgr( aName.GetBuffer(), aLang );
 // MT: Change to Locale
             pResMgr = ResMgr::CreateResMgr( aName.GetBuffer() );
         }
diff --git a/xmlsecurity/source/dialogs/stbcontrl.cxx b/xmlsecurity/source/dialogs/stbcontrl.cxx
index 68729ad0a..f5064399e 100644
--- a/xmlsecurity/source/dialogs/stbcontrl.cxx
+++ b/xmlsecurity/source/dialogs/stbcontrl.cxx
@@ -95,13 +95,7 @@ void XmlSecStatusBarControl::StateChanged( sal_uInt16 nSID, SfxItemState eState,
 void XmlSecStatusBarControl::Command( const CommandEvent& rCEvt )
 {
     // can / has to be done when integrated in Office!
-//	if( rCEvt.GetCommand() == .... )
-    if( false )
-    {
-//		GetBindings().GetDispatcher()->Execute( SID_PSZ_FUNCTION, SFX_CALLMODE_RECORD, &aItem, 0L );
-    }
-    else
-        SfxStatusBarControl::Command( rCEvt );
+    SfxStatusBarControl::Command( rCEvt );
 }
 
 void XmlSecStatusBarControl::Paint( const UserDrawEvent& rUsrEvt )
diff --git a/xmlsecurity/source/dialogs/warnings.cxx b/xmlsecurity/source/dialogs/warnings.cxx
index 436eebbf7..a5cb29550 100644
--- a/xmlsecurity/source/dialogs/warnings.cxx
+++ b/xmlsecurity/source/dialogs/warnings.cxx
@@ -77,7 +77,6 @@ MacroWarning::MacroWarning( Window* _pParent, uno::Reference< dcss::xml::crypto:
 
     maViewSignsBtn.SetClickHdl( LINK( this, MacroWarning, ViewSignsBtnHdl ) );
     maEnableBtn.SetClickHdl( LINK( this, MacroWarning, EnableBtnHdl ) );
-//	maDisableBtn.SetClickHdl( LINK( this, MacroWarning, DisableBtnHdl ) );
 
     if( mxCert.is() )
         maSignsFI.SetText( XmlSec::GetContentPart( mxCert->getSubjectName() ) );
@@ -139,9 +138,4 @@ IMPL_LINK( MacroWarning, EnableBtnHdl, void*, EMPTYARG )
     return 0;
 }
 
-/*IMPL_LINK( MacroWarning, DisableBtnHdl, void*, EMPTYARG )
-{
-    return 0;
-}*/
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmlsecurity/source/framework/buffernode.cxx b/xmlsecurity/source/framework/buffernode.cxx
index e6f1c6334..2ba40f25c 100644
--- a/xmlsecurity/source/framework/buffernode.cxx
+++ b/xmlsecurity/source/framework/buffernode.cxx
@@ -286,12 +286,6 @@ rtl::OUString BufferNode::printChildren() const
         }
         
         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "(" ));
-        /*
-        if (((ElementCollector*)(*ii))->isInternalNotificationSuppressed())
-        {
-            rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "*IN-Suppressed* " ));
-        }
-        */
         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SecID=" ));
         rc += rtl::OUString::valueOf(((ElementCollector*)(*ii))->getSecurityId());
         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ")" ));
diff --git a/xmlsecurity/source/framework/elementcollector.cxx b/xmlsecurity/source/framework/elementcollector.cxx
index bff96c6f7..841900ae9 100644
--- a/xmlsecurity/source/framework/elementcollector.cxx
+++ b/xmlsecurity/source/framework/elementcollector.cxx
@@ -91,13 +91,6 @@ ElementCollector::ElementCollector(
     m_type = cssxc::sax::ElementMarkType_ELEMENTCOLLECTOR;
 }
 
-/*
-bool ElementCollector::isInternalNotificationSuppressed() const
-{
-    return m_bInternalNotificationSuppressed;
-}
-*/
-
 cssxc::sax::ElementMarkPriority ElementCollector::getPriority() const
 {
     return m_nPriority;
diff --git a/xmlsecurity/source/framework/elementcollector.hxx b/xmlsecurity/source/framework/elementcollector.hxx
index 6a6ae55b2..41bb0549d 100644
--- a/xmlsecurity/source/framework/elementcollector.hxx
+++ b/xmlsecurity/source/framework/elementcollector.hxx
@@ -86,7 +86,6 @@ public:
             xReferenceResolvedListener);
     virtual ~ElementCollector() {};
     
-    //bool isInternalNotificationSuppressed() const;
     com::sun::star::xml::crypto::sax::ElementMarkPriority getPriority() const;
     bool getModify() const;
     void notifyListener();
diff --git a/xmlsecurity/source/framework/securityengine.hxx b/xmlsecurity/source/framework/securityengine.hxx
index 71cc2ebf0..fb4c3cd44 100644
--- a/xmlsecurity/source/framework/securityengine.hxx
+++ b/xmlsecurity/source/framework/securityengine.hxx
@@ -105,7 +105,6 @@ protected:
     /*
      * the status of the operation
      */
-    //bool      m_bOperationSucceed;
     com::sun::star::xml::crypto::SecurityOperationStatus m_nStatus;
     
     /*
diff --git a/xmlsecurity/source/framework/xmlencryptiontemplateimpl.cxx b/xmlsecurity/source/framework/xmlencryptiontemplateimpl.cxx
index 73404b271..243d4dc7c 100644
--- a/xmlsecurity/source/framework/xmlencryptiontemplateimpl.cxx
+++ b/xmlsecurity/source/framework/xmlencryptiontemplateimpl.cxx
@@ -135,9 +135,6 @@ Reference< XInterface > SAL_CALL XMLEncryptionTemplateImpl :: impl_createInstanc
 }
 
 Reference< XSingleServiceFactory > XMLEncryptionTemplateImpl :: impl_createFactory( const Reference< XMultiServiceFactory >& aServiceManager ) {
-    //Reference< XSingleServiceFactory > xFactory ;
-    //xFactory = ::cppu::createSingleFactory( aServiceManager , impl_getImplementationName , impl_createInstance , impl_getSupportedServiceNames ) ;
-    //return xFactory ;
     return ::cppu::createSingleFactory( aServiceManager , impl_getImplementationName() , impl_createInstance , impl_getSupportedServiceNames() ) ;
 }
 
diff --git a/xmlsecurity/source/framework/xmlsignaturetemplateimpl.cxx b/xmlsecurity/source/framework/xmlsignaturetemplateimpl.cxx
index 30fcd040a..c4358d645 100644
--- a/xmlsecurity/source/framework/xmlsignaturetemplateimpl.cxx
+++ b/xmlsecurity/source/framework/xmlsignaturetemplateimpl.cxx
@@ -160,9 +160,6 @@ Reference< XInterface > SAL_CALL XMLSignatureTemplateImpl :: impl_createInstance
 }
 
 Reference< XSingleServiceFactory > XMLSignatureTemplateImpl :: impl_createFactory( const Reference< XMultiServiceFactory >& aServiceManager ) {
-    //Reference< XSingleServiceFactory > xFactory ;
-    //xFactory = ::cppu::createSingleFactory( aServiceManager , impl_getImplementationName , impl_createInstance , impl_getSupportedServiceNames ) ;
-    //return xFactory ;
     return ::cppu::createSingleFactory( aServiceManager , impl_getImplementationName() , impl_createInstance , impl_getSupportedServiceNames() ) ;
 }