replace sal_Size with std::size_t (or sal_uInt64 for SvStream pos)

... except in include/rtl, include/sal, include/uno, where sal_Size is
retained for compatibility, and where callers of rtl functions pass in
pointers that are incompatible on MSVC.

Change-Id: I8344453780689f5120ba0870e44965b6d292450c

2 files changed, 96 insertions, 96 deletions

diff --git a/canvas/source/cairo/cairo_canvashelper.cxx b/canvas/source/cairo/cairo_canvashelper.cxx
index c5e341951279..77a693d6be68 100644
--- a/canvas/source/cairo/cairo_canvashelper.cxx
+++ b/canvas/source/cairo/cairo_canvashelper.cxx
@@ -1629,14 +1629,14 @@ namespace cairocanvas
             virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const double*  pIn( deviceColor.getConstArray() );
-                const sal_Size nLen( deviceColor.getLength() );
+                const std::size_t nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                 rendering::RGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     const double fAlpha(pIn[3]);
                     if( fAlpha == 0.0 )
@@ -1650,14 +1650,14 @@ namespace cairocanvas
             virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const double*  pIn( deviceColor.getConstArray() );
-                const sal_Size nLen( deviceColor.getLength() );
+                const std::size_t nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                 rendering::ARGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     const double fAlpha(pIn[3]);
                     if( fAlpha == 0.0 )
@@ -1671,14 +1671,14 @@ namespace cairocanvas
             virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const double*  pIn( deviceColor.getConstArray() );
-                const sal_Size nLen( deviceColor.getLength() );
+                const std::size_t nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                 rendering::ARGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     *pOut++ = rendering::ARGBColor(pIn[3],pIn[2],pIn[1],pIn[1]);
                     pIn += 4;
@@ -1688,11 +1688,11 @@ namespace cairocanvas
             virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size             nLen( rgbColor.getLength() );
+                const std::size_t             nLen( rgbColor.getLength() );
 
                 uno::Sequence< double > aRes(nLen*4);
                 double* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = pIn->Blue;
                     *pColors++ = pIn->Green;
@@ -1705,11 +1705,11 @@ namespace cairocanvas
             virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size              nLen( rgbColor.getLength() );
+                const std::size_t              nLen( rgbColor.getLength() );
 
                 uno::Sequence< double > aRes(nLen*4);
                 double* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = pIn->Alpha*pIn->Blue;
                     *pColors++ = pIn->Alpha*pIn->Green;
@@ -1722,11 +1722,11 @@ namespace cairocanvas
             virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size              nLen( rgbColor.getLength() );
+                const std::size_t              nLen( rgbColor.getLength() );
 
                 uno::Sequence< double > aRes(nLen*4);
                 double* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = pIn->Blue;
                     *pColors++ = pIn->Green;
@@ -1757,14 +1757,14 @@ namespace cairocanvas
                 if( dynamic_cast<CairoColorSpace*>(targetColorSpace.get()) )
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence<double> aRes(nLen);
                     double* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
                         *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
@@ -1804,14 +1804,14 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const sal_Int8* pIn( deviceColor.getConstArray() );
-                const sal_Size  nLen( deviceColor.getLength() );
+                const std::size_t  nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                 rendering::RGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     const double fAlpha((sal_uInt8)pIn[3]);
                     if( fAlpha )
@@ -1830,14 +1830,14 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const sal_Int8* pIn( deviceColor.getConstArray() );
-                const sal_Size  nLen( deviceColor.getLength() );
+                const std::size_t  nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                 rendering::ARGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     const double fAlpha((sal_uInt8)pIn[3]);
                     if( fAlpha )
@@ -1856,14 +1856,14 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const sal_Int8* pIn( deviceColor.getConstArray() );
-                const sal_Size  nLen( deviceColor.getLength() );
+                const std::size_t  nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                 rendering::ARGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     *pOut++ = rendering::ARGBColor(
                         vcl::unotools::toDoubleColor(pIn[3]),
@@ -1879,11 +1879,11 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size             nLen( rgbColor.getLength() );
+                const std::size_t             nLen( rgbColor.getLength() );
 
                 uno::Sequence< sal_Int8 > aRes(nLen*4);
                 sal_Int8* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
                     *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -1898,11 +1898,11 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size              nLen( rgbColor.getLength() );
+                const std::size_t              nLen( rgbColor.getLength() );
 
                 uno::Sequence< sal_Int8 > aRes(nLen*4);
                 sal_Int8* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     const double fAlpha(pIn->Alpha);
                     *pColors++ = vcl::unotools::toByteColor(fAlpha*pIn->Blue);
@@ -1917,11 +1917,11 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size              nLen( rgbColor.getLength() );
+                const std::size_t              nLen( rgbColor.getLength() );
 
                 uno::Sequence< sal_Int8 > aRes(nLen*4);
                 sal_Int8* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
                     *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -1986,14 +1986,14 @@ namespace cairocanvas
             virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const double*  pIn( deviceColor.getConstArray() );
-                const sal_Size nLen( deviceColor.getLength() );
+                const std::size_t nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                 rendering::RGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     *pOut++ = rendering::RGBColor(pIn[2], pIn[1], pIn[0]);
                     pIn += 4;
@@ -2003,14 +2003,14 @@ namespace cairocanvas
             uno::Sequence< rendering::ARGBColor > impl_convertToARGB( const uno::Sequence< double >& deviceColor )
             {
                 const double*  pIn( deviceColor.getConstArray() );
-                const sal_Size nLen( deviceColor.getLength() );
+                const std::size_t nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                 rendering::ARGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     *pOut++ = rendering::ARGBColor(1.0, pIn[2], pIn[1], pIn[0]);
                     pIn += 4;
@@ -2028,11 +2028,11 @@ namespace cairocanvas
             virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size             nLen( rgbColor.getLength() );
+                const std::size_t             nLen( rgbColor.getLength() );
 
                 uno::Sequence< double > aRes(nLen*4);
                 double* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = pIn->Blue;
                     *pColors++ = pIn->Green;
@@ -2045,11 +2045,11 @@ namespace cairocanvas
             uno::Sequence< double > impl_convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor )
             {
                 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size              nLen( rgbColor.getLength() );
+                const std::size_t              nLen( rgbColor.getLength() );
 
                 uno::Sequence< double > aRes(nLen*4);
                 double* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = pIn->Blue;
                     *pColors++ = pIn->Green;
@@ -2088,14 +2088,14 @@ namespace cairocanvas
                 if( dynamic_cast<CairoColorSpace*>(targetColorSpace.get()) )
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence<double> aRes(nLen);
                     double* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
                         *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
@@ -2135,14 +2135,14 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const sal_Int8* pIn( deviceColor.getConstArray() );
-                const sal_Size  nLen( deviceColor.getLength() );
+                const std::size_t  nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                 rendering::RGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     *pOut++ = rendering::RGBColor( pIn[2], pIn[1], pIn[0] );
                     pIn += 4;
@@ -2163,14 +2163,14 @@ namespace cairocanvas
             uno::Sequence< rendering::ARGBColor > impl_convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor )
             {
                 const sal_Int8* pIn( deviceColor.getConstArray() );
-                const sal_Size  nLen( deviceColor.getLength() );
+                const std::size_t  nLen( deviceColor.getLength() );
                 ENSURE_ARG_OR_THROW2(nLen%4==0,
                                      "number of channels no multiple of 4",
                                      static_cast<rendering::XColorSpace*>(this), 0);
 
                 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                 rendering::ARGBColor* pOut( aRes.getArray() );
-                for( sal_Size i=0; i<nLen; i+=4 )
+                for( std::size_t i=0; i<nLen; i+=4 )
                 {
                     *pOut++ = rendering::ARGBColor(
                         1.0,
@@ -2186,11 +2186,11 @@ namespace cairocanvas
                 throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
             {
                 const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size             nLen( rgbColor.getLength() );
+                const std::size_t             nLen( rgbColor.getLength() );
 
                 uno::Sequence< sal_Int8 > aRes(nLen*4);
                 sal_Int8* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
                     *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -2214,11 +2214,11 @@ namespace cairocanvas
             uno::Sequence< ::sal_Int8 > impl_convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor )
             {
                 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                const sal_Size              nLen( rgbColor.getLength() );
+                const std::size_t              nLen( rgbColor.getLength() );
 
                 uno::Sequence< sal_Int8 > aRes(nLen*4);
                 sal_Int8* pColors=aRes.getArray();
-                for( sal_Size i=0; i<nLen; ++i )
+                for( std::size_t i=0; i<nLen; ++i )
                 {
                     *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
                     *pColors++ = vcl::unotools::toByteColor(pIn->Green);
diff --git a/canvas/source/tools/canvastools.cxx b/canvas/source/tools/canvastools.cxx
index 02b81a462ad7..0b874e518e2e 100644
--- a/canvas/source/tools/canvastools.cxx
+++ b/canvas/source/tools/canvastools.cxx
@@ -213,14 +213,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                     rendering::RGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -231,14 +231,14 @@ namespace canvas
                 {
                     SAL_WARN_IF(deviceColor.getLength() == 0, "canvas", "empty deviceColor argument");
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(pIn[3],pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -248,14 +248,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]);
                         pIn += 4;
@@ -265,11 +265,11 @@ namespace canvas
                 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size             nLen( rgbColor.getLength() );
+                    const std::size_t             nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red;
                         *pColors++ = pIn->Green;
@@ -282,11 +282,11 @@ namespace canvas
                 virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red;
                         *pColors++ = pIn->Green;
@@ -299,11 +299,11 @@ namespace canvas
                 virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red/pIn->Alpha;
                         *pColors++ = pIn->Green/pIn->Alpha;
@@ -334,14 +334,14 @@ namespace canvas
                     if( dynamic_cast<StandardColorSpace*>(targetColorSpace.get()) )
                     {
                         const sal_Int8* pIn( deviceColor.getConstArray() );
-                        const sal_Size  nLen( deviceColor.getLength() );
+                        const std::size_t  nLen( deviceColor.getLength() );
                         ENSURE_ARG_OR_THROW2(nLen%4==0,
                                              "number of channels no multiple of 4",
                                              static_cast<rendering::XColorSpace*>(this), 0);
 
                         uno::Sequence<double> aRes(nLen);
                         double* pOut( aRes.getArray() );
-                        for( sal_Size i=0; i<nLen; i+=4 )
+                        for( std::size_t i=0; i<nLen; i+=4 )
                         {
                             *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
                             *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
@@ -380,14 +380,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                     rendering::RGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::RGBColor(
                             vcl::unotools::toDoubleColor(pIn[0]),
@@ -401,14 +401,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(
                             vcl::unotools::toDoubleColor(pIn[3]),
@@ -423,14 +423,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         const sal_Int8 nAlpha( pIn[3] );
                         *pOut++ = rendering::ARGBColor(
@@ -446,11 +446,11 @@ namespace canvas
                 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size             nLen( rgbColor.getLength() );
+                    const std::size_t             nLen( rgbColor.getLength() );
 
                     uno::Sequence< sal_Int8 > aRes(nLen*4);
                     sal_Int8* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = vcl::unotools::toByteColor(pIn->Red);
                         *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -464,11 +464,11 @@ namespace canvas
                 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< sal_Int8 > aRes(nLen*4);
                     sal_Int8* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = vcl::unotools::toByteColor(pIn->Red);
                         *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -482,11 +482,11 @@ namespace canvas
                 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< sal_Int8 > aRes(nLen*4);
                     sal_Int8* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = vcl::unotools::toByteColor(pIn->Red/pIn->Alpha);
                         *pColors++ = vcl::unotools::toByteColor(pIn->Green/pIn->Alpha);
@@ -551,14 +551,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                     rendering::RGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -568,14 +568,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(1.0,pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -585,14 +585,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(1.0,pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -602,11 +602,11 @@ namespace canvas
                 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size             nLen( rgbColor.getLength() );
+                    const std::size_t             nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red;
                         *pColors++ = pIn->Green;
@@ -619,11 +619,11 @@ namespace canvas
                 virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red;
                         *pColors++ = pIn->Green;
@@ -636,11 +636,11 @@ namespace canvas
                 virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red/pIn->Alpha;
                         *pColors++ = pIn->Green/pIn->Alpha;
@@ -671,14 +671,14 @@ namespace canvas
                     if( dynamic_cast<StandardNoAlphaColorSpace*>(targetColorSpace.get()) )
                     {
                         const sal_Int8* pIn( deviceColor.getConstArray() );
-                        const sal_Size  nLen( deviceColor.getLength() );
+                        const std::size_t  nLen( deviceColor.getLength() );
                         ENSURE_ARG_OR_THROW2(nLen%4==0,
                                              "number of channels no multiple of 4",
                                              static_cast<rendering::XColorSpace*>(this), 0);
 
                         uno::Sequence<double> aRes(nLen);
                         double* pOut( aRes.getArray() );
-                        for( sal_Size i=0; i<nLen; i+=4 )
+                        for( std::size_t i=0; i<nLen; i+=4 )
                         {
                             *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
                             *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
@@ -717,14 +717,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                     rendering::RGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::RGBColor(
                             vcl::unotools::toDoubleColor(pIn[0]),
@@ -738,14 +738,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(
                             1.0,
@@ -760,14 +760,14 @@ namespace canvas
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const sal_Int8* pIn( deviceColor.getConstArray() );
-                    const sal_Size  nLen( deviceColor.getLength() );
+                    const std::size_t  nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(
                             1.0,
@@ -782,11 +782,11 @@ namespace canvas
                 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size             nLen( rgbColor.getLength() );
+                    const std::size_t             nLen( rgbColor.getLength() );
 
                     uno::Sequence< sal_Int8 > aRes(nLen*4);
                     sal_Int8* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = vcl::unotools::toByteColor(pIn->Red);
                         *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -800,11 +800,11 @@ namespace canvas
                 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< sal_Int8 > aRes(nLen*4);
                     sal_Int8* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = vcl::unotools::toByteColor(pIn->Red);
                         *pColors++ = vcl::unotools::toByteColor(pIn->Green);
@@ -818,11 +818,11 @@ namespace canvas
                 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< sal_Int8 > aRes(nLen*4);
                     sal_Int8* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = vcl::unotools::toByteColor(pIn->Red/pIn->Alpha);
                         *pColors++ = vcl::unotools::toByteColor(pIn->Green/pIn->Alpha);