loplugin: cstylecast

Change-Id: I58ec00d6f8a4cc6188877db1330c5e32c9db12e5

10 files changed, 382 insertions, 379 deletions

diff --git a/vcl/source/gdi/bitmapex.cxx b/vcl/source/gdi/bitmapex.cxx
index b2d0dde6820e..81fd6a399bdd 100644
--- a/vcl/source/gdi/bitmapex.cxx
+++ b/vcl/source/gdi/bitmapex.cxx
@@ -789,7 +789,7 @@ bool BitmapEx::Create( const ::com::sun::star::uno::Reference<
     {
         // 0 means get BitmapEx
         uno::Any aAny = xFastPropertySet->getFastPropertyValue( 0 );
-        boost::scoped_ptr<BitmapEx> pBitmapEx((BitmapEx*) *reinterpret_cast<const sal_Int64*>(aAny.getValue()));
+        boost::scoped_ptr<BitmapEx> pBitmapEx(reinterpret_cast<BitmapEx*>( *reinterpret_cast<const sal_Int64*>(aAny.getValue())));
         if( pBitmapEx )
         {
             *this = *pBitmapEx;
diff --git a/vcl/source/gdi/cvtsvm.cxx b/vcl/source/gdi/cvtsvm.cxx
index 24fed3716190..1da9c12da22e 100644
--- a/vcl/source/gdi/cvtsvm.cxx
+++ b/vcl/source/gdi/cvtsvm.cxx
@@ -1399,7 +1399,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
         {
             case( META_PIXEL_ACTION ):
             {
-                MetaPixelAction* pAct = (MetaPixelAction*) pAction;
+                const MetaPixelAction* pAct = static_cast<const MetaPixelAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_PIXEL_ACTION );
                 rOStm.WriteInt32( 18 );
@@ -1411,7 +1411,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_POINT_ACTION ):
             {
-                MetaPointAction* pAct = (MetaPointAction*) pAction;
+                const MetaPointAction* pAct = static_cast<const MetaPointAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_POINT_ACTION );
                 rOStm.WriteInt32( 12 );
@@ -1422,7 +1422,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_LINE_ACTION ):
             {
-                MetaLineAction* pAct = (MetaLineAction*) pAction;
+                const MetaLineAction* pAct = static_cast<const MetaLineAction*>(pAction);
                 const LineInfo& rInfo = pAct->GetLineInfo();
                 const bool bFatLine(!rInfo.IsDefault() && (LINE_NONE != rInfo.GetStyle()));
                 const bool bLineJoin(bFatLine && basegfx::B2DLINEJOIN_ROUND != rInfo.GetLineJoin());
@@ -1491,7 +1491,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_RECT_ACTION ):
             {
-                MetaRectAction* pAct = (MetaRectAction*) pAction;
+                const MetaRectAction* pAct = static_cast<const MetaRectAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_RECT_ACTION );
                 rOStm.WriteInt32( 28 );
@@ -1504,7 +1504,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_ROUNDRECT_ACTION ):
             {
-                MetaRoundRectAction* pAct = (MetaRoundRectAction*) pAction;
+                const MetaRoundRectAction* pAct = static_cast<const MetaRoundRectAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_RECT_ACTION );
                 rOStm.WriteInt32( 28 );
@@ -1517,7 +1517,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_ELLIPSE_ACTION ):
             {
-                MetaEllipseAction* pAct = (MetaEllipseAction*) pAction;
+                const MetaEllipseAction* pAct = static_cast<const MetaEllipseAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_ELLIPSE_ACTION );
                 rOStm.WriteInt32( 20 );
@@ -1528,7 +1528,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_ARC_ACTION ):
             {
-                MetaArcAction* pAct = (MetaArcAction*) pAction;
+                const MetaArcAction* pAct = static_cast<const MetaArcAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_ARC_ACTION );
                 rOStm.WriteInt32( 36 );
@@ -1541,7 +1541,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_PIE_ACTION ):
             {
-                MetaPieAction* pAct = (MetaPieAction*) pAction;
+                const MetaPieAction* pAct = static_cast<const MetaPieAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_PIE_ACTION );
                 rOStm.WriteInt32( 36 );
@@ -1554,10 +1554,10 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_CHORD_ACTION ):
             {
-                MetaChordAction*    pAct = (MetaChordAction*) pAction;
-                Polygon             aChordPoly( pAct->GetRect(), pAct->GetStartPoint(),
+                const MetaChordAction* pAct = static_cast<const MetaChordAction*>(pAction);
+                Polygon                aChordPoly( pAct->GetRect(), pAct->GetStartPoint(),
                                                 pAct->GetEndPoint(), POLY_CHORD );
-                const sal_uInt16        nPoints = aChordPoly.GetSize();
+                const sal_uInt16       nPoints = aChordPoly.GetSize();
 
                 rOStm.WriteInt16(  GDI_POLYGON_ACTION );
                 rOStm.WriteInt32( ( 8 + ( nPoints << 3 ) ) );
@@ -1572,14 +1572,14 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
             case( META_POLYLINE_ACTION ):
             {
                 // #i102224#
-                MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
+                const MetaPolyLineAction* pAct = static_cast<const MetaPolyLineAction*>(pAction);
                 // #i102224# Here the possible curved nature of Polygon was
                 // ignored (for all those years). Adapted to at least write
                 // a polygon representing the curve as good as possible
-                 Polygon aSimplePoly;
-                 pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
+                Polygon aSimplePoly;
+                pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
                 const LineInfo& rInfo = pAct->GetLineInfo();
-                 const sal_uInt16 nPoints(aSimplePoly.GetSize());
+                const sal_uInt16 nPoints(aSimplePoly.GetSize());
                 const bool bFatLine(!rInfo.IsDefault() && (LINE_NONE != rInfo.GetStyle()));
                 const bool bLineJoin(bFatLine && basegfx::B2DLINEJOIN_ROUND != rInfo.GetLineJoin());
                 const bool bLineCap(bFatLine && com::sun::star::drawing::LineCap_BUTT != rInfo.GetLineCap());
@@ -1658,12 +1658,12 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_POLYGON_ACTION ):
             {
-                MetaPolygonAction* pAct = (MetaPolygonAction*)pAction;
+                const MetaPolygonAction* pAct = static_cast<const MetaPolygonAction*>(pAction);
                 // #i102224# Here the possible curved nature of Polygon was
                 // ignored (for all those years). Adapted to at least write
                 // a polygon representing the curve as good as possible
-                 Polygon aSimplePoly;
-                 pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
+                Polygon aSimplePoly;
+                pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
                 const sal_uInt16 nPoints(aSimplePoly.GetSize());
 
                 rOStm.WriteInt16(  GDI_POLYGON_ACTION );
@@ -1685,7 +1685,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_POLYPOLYGON_ACTION ):
             {
-                MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
+                const MetaPolyPolygonAction* pAct = static_cast<const MetaPolyPolygonAction*>(pAction);
                 ImplWritePolyPolyAction( rOStm, pAct->GetPolyPolygon() );
                 nCount++;
 
@@ -1698,10 +1698,9 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_TEXT_ACTION ):
             {
-                MetaTextAction* pAct = (MetaTextAction*) pAction;
-                OUString        aUniText( pAct->GetText() );
-                OString aText(OUStringToOString(aUniText,
-                    rActualCharSet));
+                const MetaTextAction* pAct = static_cast<const MetaTextAction*>(pAction);
+                OUString aUniText( pAct->GetText() );
+                OString  aText(OUStringToOString(aUniText, rActualCharSet));
                 const sal_Int32 nStrLen = aText.getLength();
 
                 if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
@@ -1720,7 +1719,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_TEXTARRAY_ACTION ):
             {
-                MetaTextArrayAction* pAct = (MetaTextArrayAction*)pAction;
+                const MetaTextArrayAction* pAct = static_cast<const MetaTextArrayAction*>(pAction);
                 OString aText(OUStringToOString(pAct->GetText(), rActualCharSet));
                 OUString aUniText = pAct->GetText().copy(
                         pAct->GetIndex(),
@@ -1764,11 +1763,10 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_STRETCHTEXT_ACTION ):
             {
-                MetaStretchTextAction*  pAct = (MetaStretchTextAction*) pAction;
-                OUString                aUniText( pAct->GetText() );
-                OString aText(OUStringToOString(aUniText,
-                    rActualCharSet));
-                const sal_Int32         nStrLen = aText.getLength();
+                const MetaStretchTextAction* pAct = static_cast<const MetaStretchTextAction*>(pAction);
+                OUString aUniText( pAct->GetText() );
+                OString  aText(OUStringToOString(aUniText, rActualCharSet));
+                const sal_Int32 nStrLen = aText.getLength();
 
                 if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
                     nCount++;
@@ -1787,7 +1785,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_BMP_ACTION ):
             {
-                MetaBmpAction* pAct = (MetaBmpAction*) pAction;
+                const MetaBmpAction* pAct = static_cast<const MetaBmpAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_BITMAP_ACTION );
                 rOStm.WriteInt32( 12 );
@@ -1799,7 +1797,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_BMPSCALE_ACTION ):
             {
-                MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
+                const MetaBmpScaleAction* pAct = static_cast<const MetaBmpScaleAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_BITMAPSCALE_ACTION );
                 rOStm.WriteInt32( 20 );
@@ -1812,7 +1810,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_BMPSCALEPART_ACTION ):
             {
-                MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
+                const MetaBmpScalePartAction* pAct = static_cast<const MetaBmpScalePartAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_BITMAPSCALEPART_ACTION );
                 rOStm.WriteInt32( 36 );
@@ -1827,8 +1825,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_BMPEX_ACTION ):
             {
-                MetaBmpExAction*    pAct = (MetaBmpExAction*) pAction;
-                const Bitmap        aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
+                const MetaBmpExAction* pAct = static_cast<const MetaBmpExAction*>(pAction);
+                const Bitmap           aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
 
                 rOStm.WriteInt16(  GDI_BITMAP_ACTION );
                 rOStm.WriteInt32( 12 );
@@ -1840,8 +1838,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_BMPEXSCALE_ACTION ):
             {
-                MetaBmpExScaleAction*   pAct = (MetaBmpExScaleAction*) pAction;
-                const Bitmap            aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
+                const MetaBmpExScaleAction* pAct = static_cast<const MetaBmpExScaleAction*>(pAction);
+                const Bitmap                aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
 
                 rOStm.WriteInt16(  GDI_BITMAPSCALE_ACTION );
                 rOStm.WriteInt32( 20 );
@@ -1854,8 +1852,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_BMPEXSCALEPART_ACTION ):
             {
-                MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
-                const Bitmap            aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
+                const MetaBmpExScalePartAction* pAct = static_cast<const MetaBmpExScalePartAction*>(pAction);
+                const Bitmap                    aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
 
                 rOStm.WriteInt16(  GDI_BITMAPSCALEPART_ACTION );
                 rOStm.WriteInt32( 36 );
@@ -1870,8 +1868,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_GRADIENT_ACTION ):
             {
-                MetaGradientAction* pAct = (MetaGradientAction*) pAction;
-                const Gradient&     rGrad = pAct->GetGradient();
+                const MetaGradientAction* pAct = static_cast<const MetaGradientAction*>(pAction);
+                const Gradient&           rGrad = pAct->GetGradient();
 
                 rOStm.WriteInt16(  GDI_GRADIENT_ACTION );
                 rOStm.WriteInt32( 46 );
@@ -1891,8 +1889,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_GRADIENTEX_ACTION ):
             {
-                const MetaGradientExAction* pA = (MetaGradientExAction*) pAction;
-                sal_uLong                       nOldPos, nNewPos;
+                const MetaGradientExAction* pA = static_cast<const MetaGradientExAction*>(pAction);
+                sal_uLong                   nOldPos, nNewPos;
 
                 // write RefPoint comment
                 rOStm.WriteInt16(  GDI_GRADIENTEX_COMMENT );
@@ -1918,8 +1916,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_WALLPAPER_ACTION ):
             {
-                MetaWallpaperAction*    pAct = (MetaWallpaperAction*) pAction;
-                const Color&            rColor = pAct->GetWallpaper().GetColor();
+                const MetaWallpaperAction* pAct = static_cast<const MetaWallpaperAction*>(pAction);
+                const Color&               rColor = pAct->GetWallpaper().GetColor();
 
                 ImplWritePushAction( rOStm );
                 ImplWriteLineColor( rOStm, rColor, 1 );
@@ -1938,9 +1936,9 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_CLIPREGION_ACTION ):
             {
-                MetaClipRegionAction*   pAct = (MetaClipRegionAction*) pAction;
-                const Region&           rRegion = pAct->GetRegion();
-                Rectangle               aClipRect;
+                const MetaClipRegionAction* pAct = static_cast<const MetaClipRegionAction*>(pAction);
+                const Region&               rRegion = pAct->GetRegion();
+                Rectangle                   aClipRect;
 
                 rOStm.WriteInt16(  GDI_CLIPREGION_ACTION );
                 rOStm.WriteInt32( 24 );
@@ -1965,7 +1963,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_ISECTRECTCLIPREGION_ACTION ):
             {
-                MetaISectRectClipRegionAction* pAct = (MetaISectRectClipRegionAction*) pAction;
+                const MetaISectRectClipRegionAction* pAct = static_cast<const MetaISectRectClipRegionAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_ISECTCLIPREGION_ACTION );
                 rOStm.WriteInt32( 20 );
@@ -1976,7 +1974,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_MOVECLIPREGION_ACTION ):
             {
-                MetaMoveClipRegionAction* pAct = (MetaMoveClipRegionAction*) pAction;
+                const MetaMoveClipRegionAction* pAct = static_cast<const MetaMoveClipRegionAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_MOVECLIPREGION_ACTION );
                 rOStm.WriteInt32( 12 );
@@ -1988,7 +1986,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_LINECOLOR_ACTION ):
             {
-                MetaLineColorAction* pAct = (MetaLineColorAction*) pAction;
+                const MetaLineColorAction* pAct = static_cast<const MetaLineColorAction*>(pAction);
                 ImplWriteLineColor( rOStm, rLineCol = pAct->GetColor(), pAct->IsSetting() ? 1 : 0 );
                 nCount++;
             }
@@ -1996,7 +1994,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_FILLCOLOR_ACTION ):
             {
-                MetaFillColorAction* pAct = (MetaFillColorAction*) pAction;
+                const MetaFillColorAction* pAct = static_cast<const MetaFillColorAction*>(pAction);
                 ImplWriteFillColor( rOStm, pAct->GetColor(), pAct->IsSetting() ? 1 : 0 );
                 nCount++;
             }
@@ -2004,7 +2002,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_FONT_ACTION ):
             {
-                rSaveVDev.SetFont( ( (MetaFontAction*) pAction )->GetFont() );
+                rSaveVDev.SetFont( static_cast<const MetaFontAction*>(pAction)->GetFont() );
                 ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
                 nCount++;
             }
@@ -2014,7 +2012,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
             {
                 vcl::Font aSaveFont( rSaveVDev.GetFont() );
 
-                aSaveFont.SetColor( ( (MetaTextColorAction*) pAction )->GetColor() );
+                aSaveFont.SetColor( static_cast<const MetaTextColorAction*>(pAction)->GetColor() );
                 rSaveVDev.SetFont( aSaveFont );
                 ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
                 nCount++;
@@ -2023,8 +2021,8 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_TEXTFILLCOLOR_ACTION ):
             {
-                MetaTextFillColorAction*    pAct = (MetaTextFillColorAction*) pAction;
-                vcl::Font                   aSaveFont( rSaveVDev.GetFont() );
+                const MetaTextFillColorAction* pAct = static_cast<const MetaTextFillColorAction*>(pAction);
+                vcl::Font                      aSaveFont( rSaveVDev.GetFont() );
 
                 if( pAct->IsSetting() )
                     aSaveFont.SetFillColor( pAct->GetColor() );
@@ -2041,7 +2039,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
             {
                 vcl::Font aSaveFont( rSaveVDev.GetFont() );
 
-                aSaveFont.SetAlign( ( (MetaTextAlignAction*) pAction )->GetTextAlign() );
+                aSaveFont.SetAlign( static_cast<const MetaTextAlignAction*>(pAction)->GetTextAlign() );
                 rSaveVDev.SetFont( aSaveFont );
                 ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
                 nCount++;
@@ -2050,7 +2048,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_MAPMODE_ACTION ):
             {
-                MetaMapModeAction* pAct = (MetaMapModeAction*) pAction;
+                const MetaMapModeAction* pAct = static_cast<const MetaMapModeAction*>(pAction);
 
                 rOStm.WriteInt16(  GDI_MAPMODE_ACTION );
                 rOStm.WriteInt32( 30 );
@@ -2093,7 +2091,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_RASTEROP_ACTION ):
             {
-                MetaRasterOpAction* pAct = (MetaRasterOpAction*) pAction;
+                const MetaRasterOpAction* pAct = static_cast<const MetaRasterOpAction*>(pAction);
 
                 if( ( pAct->GetRasterOp() != ROP_0 ) && ( pAct->GetRasterOp() != ROP_1 ) )
                 {
@@ -2145,10 +2143,10 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_TRANSPARENT_ACTION ):
             {
-                const PolyPolygon&  rPolyPoly = ( (MetaTransparentAction*) pAction )->GetPolyPolygon();
-                const sal_Int16         nTrans = ( (MetaTransparentAction*) pAction )->GetTransparence();
-                const sal_Int16         nBrushStyle = ( nTrans < 38 ) ? 8 : ( nTrans < 63 ) ? 9 : 10;
-                sal_uLong               nOldPos, nNewPos;
+                const PolyPolygon&  rPolyPoly = static_cast<const MetaTransparentAction*>(pAction)->GetPolyPolygon();
+                const sal_Int16     nTrans = static_cast<const MetaTransparentAction*>(pAction)->GetTransparence();
+                const sal_Int16     nBrushStyle = ( nTrans < 38 ) ? 8 : ( nTrans < 63 ) ? 9 : 10;
+                sal_uLong           nOldPos, nNewPos;
 
                 // write transparence comment
                 rOStm.WriteInt16(  GDI_TRANSPARENT_COMMENT );
@@ -2204,7 +2202,7 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_FLOATTRANSPARENT_ACTION ):
             {
-                const MetaFloatTransparentAction*   pA = (MetaFloatTransparentAction*) pAction;
+                const MetaFloatTransparentAction*   pA = static_cast<const MetaFloatTransparentAction*>(pAction);
                 const GDIMetaFile&                  rTransMtf = pA->GetGDIMetaFile();
                 const Point&                        rPos = pA->GetPoint();
                 const Size&                         rSize = pA->GetSize();
@@ -2266,10 +2264,10 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_HATCH_ACTION ):
             {
-                const MetaHatchAction*  pA = (MetaHatchAction*) pAction;
+                const MetaHatchAction*  pA = static_cast<const MetaHatchAction*>(pAction);
                 const PolyPolygon&      rPolyPoly = pA->GetPolyPolygon();
                 const Hatch&            rHatch = pA->GetHatch();
-                sal_uLong                   nOldPos, nNewPos, nAddCount;
+                sal_uLong               nOldPos, nNewPos, nAddCount;
 
                 // write hatch comment
                 rOStm.WriteInt16(  GDI_HATCH_COMMENT );
@@ -2309,10 +2307,10 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_REFPOINT_ACTION ):
             {
-                const MetaRefPointAction*   pA = (MetaRefPointAction*) pAction;
+                const MetaRefPointAction*   pA = static_cast<const MetaRefPointAction*>(pAction);
                 const Point&                rRefPoint = pA->GetRefPoint();
                 const bool                  bSet = pA->IsSetting();
-                sal_uLong                       nOldPos, nNewPos;
+                sal_uLong                   nOldPos, nNewPos;
 
                 // write RefPoint comment
                 rOStm.WriteInt16(  GDI_REFPOINT_COMMENT );
@@ -2338,9 +2336,9 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_TEXTLINECOLOR_ACTION ):
             {
-                const MetaTextLineColorAction*  pA = (MetaTextLineColorAction*) pAction;
+                const MetaTextLineColorAction*  pA = static_cast<const MetaTextLineColorAction*>(pAction);
                 const Color&                    rColor = pA->GetColor();
-                const bool                  bSet = pA->IsSetting();
+                const bool                      bSet = pA->IsSetting();
                 sal_uLong                       nOldPos, nNewPos;
 
                 // write RefPoint comment
@@ -2367,12 +2365,12 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_TEXTLINE_ACTION ):
             {
-                const MetaTextLineAction*   pA = (MetaTextLineAction*) pAction;
+                const MetaTextLineAction*   pA = static_cast<const MetaTextLineAction*>(pAction);
                 const Point&                rStartPt = pA->GetStartPoint();
                 const sal_Int32             nWidth = (sal_Int32) pA->GetWidth();
                 const FontStrikeout         eStrikeout = pA->GetStrikeout();
                 const FontUnderline         eUnderline = pA->GetUnderline();
-                sal_uLong                       nOldPos, nNewPos;
+                sal_uLong                   nOldPos, nNewPos;
 
                 // write RefPoint comment
                 rOStm.WriteInt16(  GDI_TEXTLINE_COMMENT );
@@ -2401,9 +2399,9 @@ sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
 
             case( META_COMMENT_ACTION ):
             {
-                const MetaCommentAction*    pA = (MetaCommentAction*) pAction;
+                const MetaCommentAction*    pA = static_cast<const MetaCommentAction*>(pAction);
                 const sal_uInt32            nDataSize = pA->GetDataSize();
-                sal_uLong                       nOldPos, nNewPos;
+                sal_uLong                   nOldPos, nNewPos;
 
                 // write RefPoint comment
                 rOStm.WriteInt16(  GDI_COMMENT_COMMENT );
diff --git a/vcl/source/gdi/gdimtf.cxx b/vcl/source/gdi/gdimtf.cxx
index 6d3d8a08a62c..ff71ff3212c9 100644
--- a/vcl/source/gdi/gdimtf.cxx
+++ b/vcl/source/gdi/gdimtf.cxx
@@ -374,7 +374,10 @@ void GDIMetaFile::Play( OutputDevice* pOut, size_t nPos )
 
                     // flush output from time to time
                     if( i++ > nSyncCount )
-                        ( (vcl::Window*) pOut )->Flush(), i = 0;
+                    {
+                        static_cast<vcl::Window*>( pOut )->Flush();
+                        i = 0;
+                    }
                 }
 
                 pAction = NextAction();
@@ -839,7 +842,7 @@ void GDIMetaFile::Clip( const Rectangle& i_rClipRect )
         }
         else if( nType == META_CLIPREGION_ACTION )
         {
-            MetaClipRegionAction* pOldAct = (MetaClipRegionAction*)pAct;
+            MetaClipRegionAction* pOldAct = static_cast<MetaClipRegionAction*>(pAct);
             Region aNewReg( aCurRect );
             if( pOldAct->IsClipping() )
                 aNewReg.Intersect( pOldAct->GetRegion() );
@@ -941,7 +944,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
             {
                 case( META_PIXEL_ACTION ):
                 {
-                    MetaPixelAction* pAct = (MetaPixelAction*) pAction;
+                    MetaPixelAction* pAct = static_cast<MetaPixelAction*>(pAction);
                     aMtf.AddAction( new MetaPixelAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                                               pAct->GetColor() ) );
                 }
@@ -949,14 +952,14 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_POINT_ACTION ):
                 {
-                    MetaPointAction* pAct = (MetaPointAction*) pAction;
+                    MetaPointAction* pAct = static_cast<MetaPointAction*>(pAction);
                     aMtf.AddAction( new MetaPointAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
                 }
                 break;
 
                 case( META_LINE_ACTION ):
                 {
-                    MetaLineAction* pAct = (MetaLineAction*) pAction;
+                    MetaLineAction* pAct = static_cast<MetaLineAction*>(pAction);
                     aMtf.AddAction( new MetaLineAction( ImplGetRotatedPoint( pAct->GetStartPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                         ImplGetRotatedPoint( pAct->GetEndPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                         pAct->GetLineInfo() ) );
@@ -965,14 +968,14 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_RECT_ACTION ):
                 {
-                    MetaRectAction* pAct = (MetaRectAction*) pAction;
+                    MetaRectAction* pAct = static_cast<MetaRectAction*>(pAction);
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( pAct->GetRect(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
                 }
                 break;
 
                 case( META_ROUNDRECT_ACTION ):
                 {
-                    MetaRoundRectAction*    pAct = (MetaRoundRectAction*) pAction;
+                    MetaRoundRectAction*    pAct = static_cast<MetaRoundRectAction*>(pAction);
                     const Polygon           aRoundRectPoly( pAct->GetRect(), pAct->GetHorzRound(), pAct->GetVertRound() );
 
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aRoundRectPoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
@@ -981,7 +984,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_ELLIPSE_ACTION ):
                 {
-                    MetaEllipseAction*      pAct = (MetaEllipseAction*) pAction;
+                    MetaEllipseAction*      pAct = static_cast<MetaEllipseAction*>(pAction);
                     const Polygon           aEllipsePoly( pAct->GetRect().Center(), pAct->GetRect().GetWidth() >> 1, pAct->GetRect().GetHeight() >> 1 );
 
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aEllipsePoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
@@ -990,7 +993,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_ARC_ACTION ):
                 {
-                    MetaArcAction*  pAct = (MetaArcAction*) pAction;
+                    MetaArcAction*  pAct = static_cast<MetaArcAction*>(pAction);
                     const Polygon   aArcPoly( pAct->GetRect(), pAct->GetStartPoint(), pAct->GetEndPoint(), POLY_ARC );
 
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aArcPoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
@@ -999,7 +1002,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_PIE_ACTION ):
                 {
-                    MetaPieAction*  pAct = (MetaPieAction*) pAction;
+                    MetaPieAction*  pAct = static_cast<MetaPieAction*>(pAction);
                     const Polygon   aPiePoly( pAct->GetRect(), pAct->GetStartPoint(), pAct->GetEndPoint(), POLY_PIE );
 
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aPiePoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
@@ -1008,7 +1011,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_CHORD_ACTION ):
                 {
-                    MetaChordAction*    pAct = (MetaChordAction*) pAction;
+                    MetaChordAction*    pAct = static_cast<MetaChordAction*>(pAction);
                     const Polygon       aChordPoly( pAct->GetRect(), pAct->GetStartPoint(), pAct->GetEndPoint(), POLY_CHORD );
 
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aChordPoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
@@ -1017,28 +1020,28 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_POLYLINE_ACTION ):
                 {
-                    MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
+                    MetaPolyLineAction* pAct = static_cast<MetaPolyLineAction*>(pAction);
                     aMtf.AddAction( new MetaPolyLineAction( ImplGetRotatedPolygon( pAct->GetPolygon(), aRotAnchor, aRotOffset, fSin, fCos ), pAct->GetLineInfo() ) );
                 }
                 break;
 
                 case( META_POLYGON_ACTION ):
                 {
-                    MetaPolygonAction* pAct = (MetaPolygonAction*) pAction;
+                    MetaPolygonAction* pAct = static_cast<MetaPolygonAction*>(pAction);
                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( pAct->GetPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
                 }
                 break;
 
                 case( META_POLYPOLYGON_ACTION ):
                 {
-                    MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
+                    MetaPolyPolygonAction* pAct = static_cast<MetaPolyPolygonAction*>(pAction);
                     aMtf.AddAction( new MetaPolyPolygonAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
                 }
                 break;
 
                 case( META_TEXT_ACTION ):
                 {
-                    MetaTextAction* pAct = (MetaTextAction*) pAction;
+                    MetaTextAction* pAct = static_cast<MetaTextAction*>(pAction);
                     aMtf.AddAction( new MetaTextAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                                              pAct->GetText(), pAct->GetIndex(), pAct->GetLen() ) );
                 }
@@ -1046,7 +1049,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_TEXTARRAY_ACTION ):
                 {
-                    MetaTextArrayAction* pAct = (MetaTextArrayAction*) pAction;
+                    MetaTextArrayAction* pAct = static_cast<MetaTextArrayAction*>(pAction);
                     aMtf.AddAction( new MetaTextArrayAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                                                   pAct->GetText(), pAct->GetDXArray(), pAct->GetIndex(), pAct->GetLen() ) );
                 }
@@ -1054,7 +1057,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_STRETCHTEXT_ACTION ):
                 {
-                    MetaStretchTextAction* pAct = (MetaStretchTextAction*) pAction;
+                    MetaStretchTextAction* pAct = static_cast<MetaStretchTextAction*>(pAction);
                     aMtf.AddAction( new MetaStretchTextAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                                                     pAct->GetWidth(), pAct->GetText(), pAct->GetIndex(), pAct->GetLen() ) );
                 }
@@ -1062,7 +1065,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_TEXTLINE_ACTION ):
                 {
-                    MetaTextLineAction* pAct = (MetaTextLineAction*) pAction;
+                    MetaTextLineAction* pAct = static_cast<MetaTextLineAction*>(pAction);
                     aMtf.AddAction( new MetaTextLineAction( ImplGetRotatedPoint( pAct->GetStartPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                                                  pAct->GetWidth(), pAct->GetStrikeout(), pAct->GetUnderline(), pAct->GetOverline() ) );
                 }
@@ -1070,7 +1073,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_BMPSCALE_ACTION ):
                 {
-                    MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
+                    MetaBmpScaleAction* pAct = static_cast<MetaBmpScaleAction*>(pAction);
                     Polygon             aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
                     Rectangle           aBmpRect( aBmpPoly.GetBoundRect() );
                     BitmapEx            aBmpEx( pAct->GetBitmap() );
@@ -1083,7 +1086,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_BMPSCALEPART_ACTION ):
                 {
-                    MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
+                    MetaBmpScalePartAction* pAct = static_cast<MetaBmpScalePartAction*>(pAction);
                     Polygon                 aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetDestPoint(), pAct->GetDestSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
                     Rectangle               aBmpRect( aBmpPoly.GetBoundRect() );
                     BitmapEx                aBmpEx( pAct->GetBitmap() );
@@ -1097,7 +1100,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_BMPEXSCALE_ACTION ):
                 {
-                    MetaBmpExScaleAction*   pAct = (MetaBmpExScaleAction*) pAction;
+                    MetaBmpExScaleAction*   pAct = static_cast<MetaBmpExScaleAction*>(pAction);
                     Polygon                 aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
                     Rectangle               aBmpRect( aBmpPoly.GetBoundRect() );
                     BitmapEx                aBmpEx( pAct->GetBitmapEx() );
@@ -1110,7 +1113,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_BMPEXSCALEPART_ACTION ):
                 {
-                    MetaBmpExScalePartAction*   pAct = (MetaBmpExScalePartAction*) pAction;
+                    MetaBmpExScalePartAction*   pAct = static_cast<MetaBmpExScalePartAction*>(pAction);
                     Polygon                     aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetDestPoint(), pAct->GetDestSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
                     Rectangle                   aBmpRect( aBmpPoly.GetBoundRect() );
                     BitmapEx                    aBmpEx( pAct->GetBitmapEx() );
@@ -1124,7 +1127,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_GRADIENT_ACTION ):
                 {
-                    MetaGradientAction* pAct = (MetaGradientAction*) pAction;
+                    MetaGradientAction* pAct = static_cast<MetaGradientAction*>(pAction);
 
                     ImplAddGradientEx( aMtf, aMapVDev,
                                        ImplGetRotatedPolygon( pAct->GetRect(), aRotAnchor, aRotOffset, fSin, fCos ),
@@ -1134,7 +1137,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_GRADIENTEX_ACTION ):
                 {
-                    MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
+                    MetaGradientExAction* pAct = static_cast<MetaGradientExAction*>(pAction);
                     aMtf.AddAction( new MetaGradientExAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                               pAct->GetGradient() ) );
                 }
@@ -1143,7 +1146,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
                 // Handle gradientex comment block correctly
                 case( META_COMMENT_ACTION ):
                 {
-                    MetaCommentAction* pCommentAct = (MetaCommentAction*) pAction;
+                    MetaCommentAction* pCommentAct = static_cast<MetaCommentAction*>(pAction);
                     if( pCommentAct->GetComment() == "XGRAD_SEQ_BEGIN" )
                     {
                         int nBeginComments( 1 );
@@ -1157,14 +1160,14 @@ void GDIMetaFile::Rotate( long nAngle10 )
                             if( META_GRADIENTEX_ACTION == nType )
                             {
                                 // Add rotated gradientex
-                                MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
+                                MetaGradientExAction* pAct = static_cast<MetaGradientExAction*>(pAction);
                                 ImplAddGradientEx( aMtf, aMapVDev,
                                                    ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                    pAct->GetGradient() );
                             }
                             else if( META_COMMENT_ACTION == nType)
                             {
-                                MetaCommentAction* pAct = (MetaCommentAction*) pAction;
+                                MetaCommentAction* pAct = static_cast<MetaCommentAction*>(pAction);
                                 if( pAct->GetComment() == "XGRAD_SEQ_END" )
                                 {
                                     // handle nested blocks
@@ -1231,7 +1234,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_HATCH_ACTION ):
                 {
-                    MetaHatchAction*    pAct = (MetaHatchAction*) pAction;
+                    MetaHatchAction*    pAct = static_cast<MetaHatchAction*>(pAction);
                     Hatch               aHatch( pAct->GetHatch() );
 
                     aHatch.SetAngle( aHatch.GetAngle() + (sal_uInt16) nAngle10 );
@@ -1242,7 +1245,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_TRANSPARENT_ACTION ):
                 {
-                    MetaTransparentAction* pAct = (MetaTransparentAction*) pAction;
+                    MetaTransparentAction* pAct = static_cast<MetaTransparentAction*>(pAction);
                     aMtf.AddAction( new MetaTransparentAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
                                                                                           pAct->GetTransparence() ) );
                 }
@@ -1250,7 +1253,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_FLOATTRANSPARENT_ACTION ):
                 {
-                    MetaFloatTransparentAction* pAct = (MetaFloatTransparentAction*) pAction;
+                    MetaFloatTransparentAction* pAct = static_cast<MetaFloatTransparentAction*>(pAction);
                     GDIMetaFile                 aTransMtf( pAct->GetGDIMetaFile() );
                     Polygon                     aMtfPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
                     Rectangle                   aMtfRect( aMtfPoly.GetBoundRect() );
@@ -1263,7 +1266,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_EPS_ACTION ):
                 {
-                    MetaEPSAction*  pAct = (MetaEPSAction*) pAction;
+                    MetaEPSAction*  pAct = static_cast<MetaEPSAction*>(pAction);
                     GDIMetaFile     aEPSMtf( pAct->GetSubstitute() );
                     Polygon         aEPSPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
                     Rectangle       aEPSRect( aEPSPoly.GetBoundRect() );
@@ -1276,7 +1279,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_CLIPREGION_ACTION ):
                 {
-                    MetaClipRegionAction* pAct = (MetaClipRegionAction*) pAction;
+                    MetaClipRegionAction* pAct = static_cast<MetaClipRegionAction*>(pAction);
 
                     if( pAct->IsClipping() && pAct->GetRegion().HasPolyPolygonOrB2DPolyPolygon() )
                         aMtf.AddAction( new MetaClipRegionAction( Region( ImplGetRotatedPolyPolygon( pAct->GetRegion().GetAsPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ), true ) );
@@ -1290,7 +1293,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_ISECTRECTCLIPREGION_ACTION ):
                 {
-                    MetaISectRectClipRegionAction*  pAct = (MetaISectRectClipRegionAction*) pAction;
+                    MetaISectRectClipRegionAction*  pAct = static_cast<MetaISectRectClipRegionAction*>(pAction);
                     aMtf.AddAction( new MetaISectRegionClipRegionAction(Region(
                         ImplGetRotatedPolygon( pAct->GetRect(), aRotAnchor,
                             aRotOffset, fSin, fCos )) ) );
@@ -1299,7 +1302,7 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_ISECTREGIONCLIPREGION_ACTION ):
                 {
-                    MetaISectRegionClipRegionAction*    pAct = (MetaISectRegionClipRegionAction*) pAction;
+                    MetaISectRegionClipRegionAction*    pAct = static_cast<MetaISectRegionClipRegionAction*>(pAction);
                     const Region&                       rRegion = pAct->GetRegion();
 
                     if( rRegion.HasPolyPolygonOrB2DPolyPolygon() )
@@ -1314,14 +1317,14 @@ void GDIMetaFile::Rotate( long nAngle10 )
 
                 case( META_REFPOINT_ACTION ):
                 {
-                    MetaRefPointAction* pAct = (MetaRefPointAction*) pAction;
+                    MetaRefPointAction* pAct = static_cast<MetaRefPointAction*>(pAction);
                     aMtf.AddAction( new MetaRefPointAction( ImplGetRotatedPoint( pAct->GetRefPoint(), aRotAnchor, aRotOffset, fSin, fCos ), pAct->IsSetting() ) );
                 }
                 break;
 
                 case( META_FONT_ACTION ):
                 {
-                    MetaFontAction* pAct = (MetaFontAction*) pAction;
+                    MetaFontAction* pAct = static_cast<MetaFontAction*>(pAction);
                     vcl::Font       aFont( pAct->GetFont() );
 
                     aFont.SetOrientation( aFont.GetOrientation() + (sal_uInt16) nAngle10 );
@@ -1421,7 +1424,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
         {
         case( META_PIXEL_ACTION ):
         {
-            MetaPixelAction* pAct = (MetaPixelAction*) pAction;
+            MetaPixelAction* pAct = static_cast<MetaPixelAction*>(pAction);
             ImplActionBounds( aBound,
                               Rectangle( OutputDevice::LogicToLogic( pAct->GetPoint(), aMapVDev.GetMapMode(), GetPrefMapMode() ),
                                        aMapVDev.PixelToLogic( Size( 1, 1 ), GetPrefMapMode() ) ),
@@ -1431,7 +1434,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_POINT_ACTION ):
         {
-            MetaPointAction* pAct = (MetaPointAction*) pAction;
+            MetaPointAction* pAct = static_cast<MetaPointAction*>(pAction);
             ImplActionBounds( aBound,
                               Rectangle( OutputDevice::LogicToLogic( pAct->GetPoint(), aMapVDev.GetMapMode(), GetPrefMapMode() ),
                                        aMapVDev.PixelToLogic( Size( 1, 1 ), GetPrefMapMode() ) ),
@@ -1441,7 +1444,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_LINE_ACTION ):
         {
-            MetaLineAction* pAct = (MetaLineAction*) pAction;
+            MetaLineAction* pAct = static_cast<MetaLineAction*>(pAction);
             Point aP1( pAct->GetStartPoint() ), aP2( pAct->GetEndPoint() );
             Rectangle aRect( aP1, aP2 );
             aRect.Justify();
@@ -1460,28 +1463,28 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_RECT_ACTION ):
         {
-            MetaRectAction* pAct = (MetaRectAction*) pAction;
+            MetaRectAction* pAct = static_cast<MetaRectAction*>(pAction);
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
         }
         break;
 
         case( META_ROUNDRECT_ACTION ):
         {
-            MetaRoundRectAction*    pAct = (MetaRoundRectAction*) pAction;
+            MetaRoundRectAction*    pAct = static_cast<MetaRoundRectAction*>(pAction);
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
         }
         break;
 
         case( META_ELLIPSE_ACTION ):
         {
-            MetaEllipseAction*      pAct = (MetaEllipseAction*) pAction;
+            MetaEllipseAction*      pAct = static_cast<MetaEllipseAction*>(pAction);
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
         }
         break;
 
         case( META_ARC_ACTION ):
         {
-            MetaArcAction*  pAct = (MetaArcAction*) pAction;
+            MetaArcAction*  pAct = static_cast<MetaArcAction*>(pAction);
             // FIXME: this is imprecise
             // e.g. for small arcs the whole rectangle is WAY too large
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
@@ -1490,7 +1493,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_PIE_ACTION ):
         {
-            MetaPieAction*  pAct = (MetaPieAction*) pAction;
+            MetaPieAction*  pAct = static_cast<MetaPieAction*>(pAction);
             // FIXME: this is imprecise
             // e.g. for small arcs the whole rectangle is WAY too large
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
@@ -1499,7 +1502,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_CHORD_ACTION ):
         {
-            MetaChordAction*    pAct = (MetaChordAction*) pAction;
+            MetaChordAction*    pAct = static_cast<MetaChordAction*>(pAction);
             // FIXME: this is imprecise
             // e.g. for small arcs the whole rectangle is WAY too large
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
@@ -1508,7 +1511,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_POLYLINE_ACTION ):
         {
-            MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
+            MetaPolyLineAction* pAct = static_cast<MetaPolyLineAction*>(pAction);
             Rectangle aRect( pAct->GetPolygon().GetBoundRect() );
 
             if(pUseHairline)
@@ -1525,7 +1528,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_POLYGON_ACTION ):
         {
-            MetaPolygonAction* pAct = (MetaPolygonAction*) pAction;
+            MetaPolygonAction* pAct = static_cast<MetaPolygonAction*>(pAction);
             Rectangle aRect( pAct->GetPolygon().GetBoundRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
         }
@@ -1533,7 +1536,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_POLYPOLYGON_ACTION ):
         {
-            MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
+            MetaPolyPolygonAction* pAct = static_cast<MetaPolyPolygonAction*>(pAction);
             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
         }
@@ -1541,7 +1544,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_TEXT_ACTION ):
         {
-            MetaTextAction* pAct = (MetaTextAction*) pAction;
+            MetaTextAction* pAct = static_cast<MetaTextAction*>(pAction);
             Rectangle aRect;
             // hdu said base = index
             aMapVDev.GetTextBoundRect( aRect, pAct->GetText(), pAct->GetIndex(), pAct->GetIndex(), pAct->GetLen() );
@@ -1553,7 +1556,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_TEXTARRAY_ACTION ):
         {
-            MetaTextArrayAction* pAct = (MetaTextArrayAction*) pAction;
+            MetaTextArrayAction* pAct = static_cast<MetaTextArrayAction*>(pAction);
             Rectangle aRect;
             // hdu said base = index
             aMapVDev.GetTextBoundRect( aRect, pAct->GetText(), pAct->GetIndex(), pAct->GetIndex(), pAct->GetLen(),
@@ -1566,7 +1569,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_STRETCHTEXT_ACTION ):
         {
-            MetaStretchTextAction* pAct = (MetaStretchTextAction*) pAction;
+            MetaStretchTextAction* pAct = static_cast<MetaStretchTextAction*>(pAction);
             Rectangle aRect;
             // hdu said base = index
             aMapVDev.GetTextBoundRect( aRect, pAct->GetText(), pAct->GetIndex(), pAct->GetIndex(), pAct->GetLen(),
@@ -1579,7 +1582,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_TEXTLINE_ACTION ):
         {
-            MetaTextLineAction* pAct = (MetaTextLineAction*) pAction;
+            MetaTextLineAction* pAct = static_cast<MetaTextLineAction*>(pAction);
             // measure a test string to get ascend and descent right
             static const sal_Unicode pStr[] = { 0xc4, 0x67, 0 };
             OUString aStr( pStr );
@@ -1595,7 +1598,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_BMPSCALE_ACTION ):
         {
-            MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
+            MetaBmpScaleAction* pAct = static_cast<MetaBmpScaleAction*>(pAction);
             Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1603,7 +1606,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_BMPSCALEPART_ACTION ):
         {
-            MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
+            MetaBmpScalePartAction* pAct = static_cast<MetaBmpScalePartAction*>(pAction);
             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1611,7 +1614,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_BMPEXSCALE_ACTION ):
         {
-            MetaBmpExScaleAction*   pAct = (MetaBmpExScaleAction*) pAction;
+            MetaBmpExScaleAction*   pAct = static_cast<MetaBmpExScaleAction*>(pAction);
             Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1619,7 +1622,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_BMPEXSCALEPART_ACTION ):
         {
-            MetaBmpExScalePartAction*   pAct = (MetaBmpExScalePartAction*) pAction;
+            MetaBmpExScalePartAction*   pAct = static_cast<MetaBmpExScalePartAction*>(pAction);
             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1627,7 +1630,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_GRADIENT_ACTION ):
         {
-            MetaGradientAction* pAct = (MetaGradientAction*) pAction;
+            MetaGradientAction* pAct = static_cast<MetaGradientAction*>(pAction);
             Rectangle aRect( pAct->GetRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1635,7 +1638,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_GRADIENTEX_ACTION ):
         {
-            MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
+            MetaGradientExAction* pAct = static_cast<MetaGradientExAction*>(pAction);
             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1649,7 +1652,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_HATCH_ACTION ):
         {
-            MetaHatchAction*    pAct = (MetaHatchAction*) pAction;
+            MetaHatchAction*    pAct = static_cast<MetaHatchAction*>(pAction);
             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1657,7 +1660,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_TRANSPARENT_ACTION ):
         {
-            MetaTransparentAction* pAct = (MetaTransparentAction*) pAction;
+            MetaTransparentAction* pAct = static_cast<MetaTransparentAction*>(pAction);
             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1665,7 +1668,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_FLOATTRANSPARENT_ACTION ):
         {
-            MetaFloatTransparentAction* pAct = (MetaFloatTransparentAction*) pAction;
+            MetaFloatTransparentAction* pAct = static_cast<MetaFloatTransparentAction*>(pAction);
             // MetaFloatTransparentAction is defined limiting it's content Metafile
             // to it's geometry definition(Point, Size), so use these directly
             const Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
@@ -1675,7 +1678,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_EPS_ACTION ):
         {
-            MetaEPSAction*  pAct = (MetaEPSAction*) pAction;
+            MetaEPSAction*  pAct = static_cast<MetaEPSAction*>(pAction);
             Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1683,7 +1686,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_CLIPREGION_ACTION ):
         {
-            MetaClipRegionAction* pAct = (MetaClipRegionAction*) pAction;
+            MetaClipRegionAction* pAct = static_cast<MetaClipRegionAction*>(pAction);
             if( pAct->IsClipping() )
                 aClipStack.back() = OutputDevice::LogicToLogic( pAct->GetRegion().GetBoundRect(), aMapVDev.GetMapMode(), GetPrefMapMode() );
             else
@@ -1693,7 +1696,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_ISECTRECTCLIPREGION_ACTION ):
         {
-            MetaISectRectClipRegionAction* pAct = (MetaISectRectClipRegionAction*) pAction;
+            MetaISectRectClipRegionAction* pAct = static_cast<MetaISectRectClipRegionAction*>(pAction);
             Rectangle aRect( OutputDevice::LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ) );
             if( aClipStack.back().IsEmpty() )
                 aClipStack.back() = aRect;
@@ -1704,7 +1707,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_ISECTREGIONCLIPREGION_ACTION ):
         {
-            MetaISectRegionClipRegionAction*    pAct = (MetaISectRegionClipRegionAction*) pAction;
+            MetaISectRegionClipRegionAction*    pAct = static_cast<MetaISectRegionClipRegionAction*>(pAction);
             Rectangle aRect( OutputDevice::LogicToLogic( pAct->GetRegion().GetBoundRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ) );
             if( aClipStack.back().IsEmpty() )
                 aClipStack.back() = aRect;
@@ -1715,7 +1718,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_BMP_ACTION ):
         {
-            MetaBmpAction* pAct = (MetaBmpAction*) pAction;
+            MetaBmpAction* pAct = static_cast<MetaBmpAction*>(pAction);
             Rectangle aRect( pAct->GetPoint(), aMapVDev.PixelToLogic( pAct->GetBitmap().GetSizePixel() ) );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1723,7 +1726,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_BMPEX_ACTION ):
         {
-            MetaBmpExAction* pAct = (MetaBmpExAction*) pAction;
+            MetaBmpExAction* pAct = static_cast<MetaBmpExAction*>(pAction);
             Rectangle aRect( pAct->GetPoint(), aMapVDev.PixelToLogic( pAct->GetBitmapEx().GetSizePixel() ) );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1731,7 +1734,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_MASK_ACTION ):
         {
-            MetaMaskAction* pAct = (MetaMaskAction*) pAction;
+            MetaMaskAction* pAct = static_cast<MetaMaskAction*>(pAction);
             Rectangle aRect( pAct->GetPoint(), aMapVDev.PixelToLogic( pAct->GetBitmap().GetSizePixel() ) );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1739,7 +1742,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_MASKSCALE_ACTION ):
         {
-            MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
+            MetaMaskScalePartAction* pAct = static_cast<MetaMaskScalePartAction*>(pAction);
             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1747,7 +1750,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_MASKSCALEPART_ACTION ):
         {
-            MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
+            MetaMaskScalePartAction* pAct = static_cast<MetaMaskScalePartAction*>(pAction);
             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1755,7 +1758,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_WALLPAPER_ACTION ):
         {
-            MetaWallpaperAction* pAct = (MetaWallpaperAction*) pAction;
+            MetaWallpaperAction* pAct = static_cast<MetaWallpaperAction*>(pAction);
             Rectangle aRect( pAct->GetRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1763,7 +1766,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_TEXTRECT_ACTION ):
         {
-            MetaTextRectAction* pAct = (MetaTextRectAction*) pAction;
+            MetaTextRectAction* pAct = static_cast<MetaTextRectAction*>(pAction);
             Rectangle aRect( pAct->GetRect() );
             ImplActionBounds( aBound, OutputDevice::LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
         }
@@ -1771,7 +1774,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
         case( META_MOVECLIPREGION_ACTION ):
         {
-            MetaMoveClipRegionAction* pAct = (MetaMoveClipRegionAction*) pAction;
+            MetaMoveClipRegionAction* pAct = static_cast<MetaMoveClipRegionAction*>(pAction);
             if( ! aClipStack.back().IsEmpty() )
             {
                 Size aDelta( pAct->GetHorzMove(), pAct->GetVertMove() );
@@ -1787,7 +1790,7 @@ Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHai
 
                 if( nActionType == META_PUSH_ACTION )
                 {
-                    MetaPushAction* pAct = (MetaPushAction*) pAction;
+                    MetaPushAction* pAct = static_cast<MetaPushAction*>(pAction);
                     aPushFlagStack.push_back( pAct->GetFlags() );
                     if( aPushFlagStack.back() & PUSH_CLIPREGION )
                     {
@@ -1926,14 +1929,14 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
         {
             case( META_PIXEL_ACTION ):
             {
-                MetaPixelAction* pAct = (MetaPixelAction*) pAction;
+                MetaPixelAction* pAct = static_cast<MetaPixelAction*>(pAction);
                 aMtf.push_back( new MetaPixelAction( pAct->GetPoint(), pFncCol( pAct->GetColor(), pColParam ) ) );
             }
             break;
 
             case( META_LINECOLOR_ACTION ):
             {
-                MetaLineColorAction* pAct = (MetaLineColorAction*) pAction;
+                MetaLineColorAction* pAct = static_cast<MetaLineColorAction*>(pAction);
 
                 if( !pAct->IsSetting() )
                     pAct->Duplicate();
@@ -1946,7 +1949,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_FILLCOLOR_ACTION ):
             {
-                MetaFillColorAction* pAct = (MetaFillColorAction*) pAction;
+                MetaFillColorAction* pAct = static_cast<MetaFillColorAction*>(pAction);
 
                 if( !pAct->IsSetting() )
                     pAct->Duplicate();
@@ -1959,14 +1962,14 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_TEXTCOLOR_ACTION ):
             {
-                MetaTextColorAction* pAct = (MetaTextColorAction*) pAction;
+                MetaTextColorAction* pAct = static_cast<MetaTextColorAction*>(pAction);
                 aMtf.push_back( new MetaTextColorAction( pFncCol( pAct->GetColor(), pColParam ) ) );
             }
             break;
 
             case( META_TEXTFILLCOLOR_ACTION ):
             {
-                MetaTextFillColorAction* pAct = (MetaTextFillColorAction*) pAction;
+                MetaTextFillColorAction* pAct = static_cast<MetaTextFillColorAction*>(pAction);
 
                 if( !pAct->IsSetting() )
                     pAct->Duplicate();
@@ -1979,7 +1982,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_TEXTLINECOLOR_ACTION ):
             {
-                MetaTextLineColorAction* pAct = (MetaTextLineColorAction*) pAction;
+                MetaTextLineColorAction* pAct = static_cast<MetaTextLineColorAction*>(pAction);
 
                 if( !pAct->IsSetting() )
                     pAct->Duplicate();
@@ -1992,7 +1995,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_OVERLINECOLOR_ACTION ):
             {
-                MetaOverlineColorAction* pAct = (MetaOverlineColorAction*) pAction;
+                MetaOverlineColorAction* pAct = static_cast<MetaOverlineColorAction*>(pAction);
 
                 if( !pAct->IsSetting() )
                     pAct->Duplicate();
@@ -2005,7 +2008,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_FONT_ACTION ):
             {
-                MetaFontAction* pAct = (MetaFontAction*) pAction;
+                MetaFontAction* pAct = static_cast<MetaFontAction*>(pAction);
                 vcl::Font       aFont( pAct->GetFont() );
 
                 aFont.SetColor( pFncCol( aFont.GetColor(), pColParam ) );
@@ -2016,7 +2019,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_WALLPAPER_ACTION ):
             {
-                MetaWallpaperAction*    pAct = (MetaWallpaperAction*) pAction;
+                MetaWallpaperAction*    pAct = static_cast<MetaWallpaperAction*>(pAction);
                 Wallpaper               aWall( pAct->GetWallpaper() );
                 const Rectangle&        rRect = pAct->GetRect();
 
@@ -2048,7 +2051,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_BMPSCALE_ACTION ):
             {
-                MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
+                MetaBmpScaleAction* pAct = static_cast<MetaBmpScaleAction*>(pAction);
                 aMtf.push_back( new MetaBmpScaleAction( pAct->GetPoint(), pAct->GetSize(),
                                     pFncBmp( pAct->GetBitmap(), pBmpParam ).GetBitmap() ) );
             }
@@ -2056,7 +2059,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_BMPSCALEPART_ACTION ):
             {
-                MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
+                MetaBmpScalePartAction* pAct = static_cast<MetaBmpScalePartAction*>(pAction);
                 aMtf.push_back( new MetaBmpScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(),
                                                     pAct->GetSrcPoint(), pAct->GetSrcSize(),
                                                     pFncBmp( pAct->GetBitmap(), pBmpParam ).GetBitmap() )
@@ -2066,7 +2069,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_BMPEXSCALE_ACTION ):
             {
-                MetaBmpExScaleAction* pAct = (MetaBmpExScaleAction*) pAction;
+                MetaBmpExScaleAction* pAct = static_cast<MetaBmpExScaleAction*>(pAction);
                 aMtf.push_back( new MetaBmpExScaleAction( pAct->GetPoint(), pAct->GetSize(),
                                                           pFncBmp( pAct->GetBitmapEx(), pBmpParam ) )
                                                         );
@@ -2075,7 +2078,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_BMPEXSCALEPART_ACTION ):
             {
-                MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
+                MetaBmpExScalePartAction* pAct = static_cast<MetaBmpExScalePartAction*>(pAction);
                 aMtf.push_back( new MetaBmpExScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(),
                                                               pAct->GetSrcPoint(), pAct->GetSrcSize(),
                                                               pFncBmp( pAct->GetBitmapEx(), pBmpParam ) )
@@ -2085,7 +2088,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_MASKSCALE_ACTION ):
             {
-                MetaMaskScaleAction* pAct = (MetaMaskScaleAction*) pAction;
+                MetaMaskScaleAction* pAct = static_cast<MetaMaskScaleAction*>(pAction);
                 aMtf.push_back( new MetaMaskScaleAction( pAct->GetPoint(), pAct->GetSize(),
                                                          pAct->GetBitmap(),
                                                          pFncCol( pAct->GetColor(), pColParam ) )
@@ -2095,7 +2098,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_MASKSCALEPART_ACTION ):
             {
-                MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
+                MetaMaskScalePartAction* pAct = static_cast<MetaMaskScalePartAction*>(pAction);
                 aMtf.push_back( new MetaMaskScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(),
                                                              pAct->GetSrcPoint(), pAct->GetSrcSize(),
                                                              pAct->GetBitmap(),
@@ -2106,7 +2109,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_GRADIENT_ACTION ):
             {
-                MetaGradientAction* pAct = (MetaGradientAction*) pAction;
+                MetaGradientAction* pAct = static_cast<MetaGradientAction*>(pAction);
                 Gradient            aGradient( pAct->GetGradient() );
 
                 aGradient.SetStartColor( pFncCol( aGradient.GetStartColor(), pColParam ) );
@@ -2117,7 +2120,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_GRADIENTEX_ACTION ):
             {
-                MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
+                MetaGradientExAction* pAct = static_cast<MetaGradientExAction*>(pAction);
                 Gradient              aGradient( pAct->GetGradient() );
 
                 aGradient.SetStartColor( pFncCol( aGradient.GetStartColor(), pColParam ) );
@@ -2128,7 +2131,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_HATCH_ACTION ):
             {
-                MetaHatchAction*    pAct = (MetaHatchAction*) pAction;
+                MetaHatchAction*    pAct = static_cast<MetaHatchAction*>(pAction);
                 Hatch               aHatch( pAct->GetHatch() );
 
                 aHatch.SetColor( pFncCol( aHatch.GetColor(), pColParam ) );
@@ -2138,7 +2141,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_FLOATTRANSPARENT_ACTION ):
             {
-                MetaFloatTransparentAction* pAct = (MetaFloatTransparentAction*) pAction;
+                MetaFloatTransparentAction* pAct = static_cast<MetaFloatTransparentAction*>(pAction);
                 GDIMetaFile                 aTransMtf( pAct->GetGDIMetaFile() );
 
                 aTransMtf.ImplExchangeColors( pFncCol, pColParam, pFncBmp, pBmpParam );
@@ -2151,7 +2154,7 @@ void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pCol
 
             case( META_EPS_ACTION ):
             {
-                MetaEPSAction*  pAct = (MetaEPSAction*) pAction;
+                MetaEPSAction*  pAct = static_cast<MetaEPSAction*>(pAction);
                 GDIMetaFile     aSubst( pAct->GetSubstitute() );
 
                 aSubst.ImplExchangeColors( pFncCol, pColParam, pFncBmp, pBmpParam );
@@ -2354,7 +2357,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
         {
             case( META_BMP_ACTION ):
             {
-                MetaBmpAction* pAct = (MetaBmpAction*) pAction;
+                MetaBmpAction* pAct = static_cast<MetaBmpAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2372,7 +2375,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_BMPSCALE_ACTION ):
             {
-                MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
+                MetaBmpScaleAction* pAct = static_cast<MetaBmpScaleAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2396,7 +2399,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_BMPSCALEPART_ACTION ):
             {
-                MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
+                MetaBmpScalePartAction* pAct = static_cast<MetaBmpScalePartAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2432,7 +2435,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_BMPEX_ACTION ):
             {
-                MetaBmpExAction* pAct = (MetaBmpExAction*) pAction;
+                MetaBmpExAction* pAct = static_cast<MetaBmpExAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2450,7 +2453,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_BMPEXSCALE_ACTION ):
             {
-                MetaBmpExScaleAction* pAct = (MetaBmpExScaleAction*) pAction;
+                MetaBmpExScaleAction* pAct = static_cast<MetaBmpExScaleAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2474,7 +2477,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_BMPEXSCALEPART_ACTION ):
             {
-                MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
+                MetaBmpExScalePartAction* pAct = static_cast<MetaBmpExScalePartAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2510,7 +2513,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_MASK_ACTION ):
             {
-                MetaMaskAction* pAct = (MetaMaskAction*) pAction;
+                MetaMaskAction* pAct = static_cast<MetaMaskAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2531,7 +2534,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_MASKSCALE_ACTION ):
             {
-                MetaMaskScaleAction* pAct = (MetaMaskScaleAction*) pAction;
+                MetaMaskScaleAction* pAct = static_cast<MetaMaskScaleAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2558,7 +2561,7 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case( META_MASKSCALEPART_ACTION ):
             {
-                MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
+                MetaMaskScalePartAction* pAct = static_cast<MetaMaskScalePartAction*>(pAction);
 
                 ShortToSVBT16( pAct->GetType(), aBT16 );
                 nCrc = rtl_crc32( nCrc, aBT16, 2 );
@@ -2597,14 +2600,14 @@ sal_uLong GDIMetaFile::GetChecksum() const
 
             case META_EPS_ACTION :
             {
-                MetaEPSAction* pAct = (MetaEPSAction*) pAction;
+                MetaEPSAction* pAct = static_cast<MetaEPSAction*>(pAction);
                 nCrc = rtl_crc32( nCrc, pAct->GetLink().GetData(), pAct->GetLink().GetDataSize() );
             }
             break;
 
             case META_CLIPREGION_ACTION :
             {
-                MetaClipRegionAction& rAct = dynamic_cast<MetaClipRegionAction&>(*pAction);
+                MetaClipRegionAction& rAct = static_cast<MetaClipRegionAction&>(*pAction);
                 const Region& rRegion = rAct.GetRegion();
 
                 if(rRegion.HasPolyPolygonOrB2DPolyPolygon())
@@ -2695,35 +2698,35 @@ sal_uLong GDIMetaFile::GetSizeBytes() const
         // add sizes for large action content
         switch( pAction->GetType() )
         {
-            case( META_BMP_ACTION ): nSizeBytes += ( (MetaBmpAction*) pAction )->GetBitmap().GetSizeBytes(); break;
-            case( META_BMPSCALE_ACTION ): nSizeBytes += ( (MetaBmpScaleAction*) pAction )->GetBitmap().GetSizeBytes(); break;
-            case( META_BMPSCALEPART_ACTION ): nSizeBytes += ( (MetaBmpScalePartAction*) pAction )->GetBitmap().GetSizeBytes(); break;
+            case( META_BMP_ACTION ): nSizeBytes += static_cast<MetaBmpAction*>( pAction )->GetBitmap().GetSizeBytes(); break;
+            case( META_BMPSCALE_ACTION ): nSizeBytes += static_cast<MetaBmpScaleAction*>( pAction )->GetBitmap().GetSizeBytes(); break;
+            case( META_BMPSCALEPART_ACTION ): nSizeBytes += static_cast<MetaBmpScalePartAction*>( pAction )->GetBitmap().GetSizeBytes(); break;
 
-            case( META_BMPEX_ACTION ): nSizeBytes += ( (MetaBmpExAction*) pAction )->GetBitmapEx().GetSizeBytes(); break;
-            case( META_BMPEXSCALE_ACTION ): nSizeBytes += ( (MetaBmpExScaleAction*) pAction )->GetBitmapEx().GetSizeBytes(); break;
-            case( META_BMPEXSCALEPART_ACTION ): nSizeBytes += ( (MetaBmpExScalePartAction*) pAction )->GetBitmapEx().GetSizeBytes(); break;
+            case( META_BMPEX_ACTION ): nSizeBytes += static_cast<MetaBmpExAction*>( pAction )->GetBitmapEx().GetSizeBytes(); break;
+            case( META_BMPEXSCALE_ACTION ): nSizeBytes += static_cast<MetaBmpExScaleAction*>( pAction )->GetBitmapEx().GetSizeBytes(); break;
+            case( META_BMPEXSCALEPART_ACTION ): nSizeBytes += static_cast<MetaBmpExScalePartAction*>( pAction )->GetBitmapEx().GetSizeBytes(); break;
 
-            case( META_MASK_ACTION ): nSizeBytes += ( (MetaMaskAction*) pAction )->GetBitmap().GetSizeBytes(); break;
-            case( META_MASKSCALE_ACTION ): nSizeBytes += ( (MetaMaskScaleAction*) pAction )->GetBitmap().GetSizeBytes(); break;
-            case( META_MASKSCALEPART_ACTION ): nSizeBytes += ( (MetaMaskScalePartAction*) pAction )->GetBitmap().GetSizeBytes(); break;
+            case( META_MASK_ACTION ): nSizeBytes += static_cast<MetaMaskAction*>( pAction )->GetBitmap().GetSizeBytes(); break;
+            case( META_MASKSCALE_ACTION ): nSizeBytes += static_cast<MetaMaskScaleAction*>( pAction )->GetBitmap().GetSizeBytes(); break;
+            case( META_MASKSCALEPART_ACTION ): nSizeBytes += static_cast<MetaMaskScalePartAction*>( pAction )->GetBitmap().GetSizeBytes(); break;
 
-            case( META_POLYLINE_ACTION ): nSizeBytes += ( ( (MetaPolyLineAction*) pAction )->GetPolygon().GetSize() * sizeof( Point ) ); break;
-            case( META_POLYGON_ACTION ): nSizeBytes += ( ( (MetaPolygonAction*) pAction )->GetPolygon().GetSize() * sizeof( Point ) ); break;
+            case( META_POLYLINE_ACTION ): nSizeBytes += static_cast<MetaPolyLineAction*>( pAction )->GetPolygon().GetSize() * sizeof( Point ); break;
+            case( META_POLYGON_ACTION ): nSizeBytes += static_cast<MetaPolygonAction*>( pAction )->GetPolygon().GetSize() * sizeof( Point ); break;
             case( META_POLYPOLYGON_ACTION ):
             {
-                const PolyPolygon& rPolyPoly = ( (MetaPolyPolygonAction*) pAction )->GetPolyPolygon();
+                const PolyPolygon& rPolyPoly = static_cast<MetaPolyPolygonAction*>( pAction )->GetPolyPolygon();
 
                 for( sal_uInt16 n = 0; n < rPolyPoly.Count(); ++n )
                     nSizeBytes += ( rPolyPoly[ n ].GetSize() * sizeof( Point ) );
             }
             break;
 
-            case( META_TEXT_ACTION ): nSizeBytes += ( ( (MetaTextAction*) pAction )->GetText().getLength() * sizeof( sal_Unicode ) ); break;
-            case( META_STRETCHTEXT_ACTION ): nSizeBytes += ( ( (MetaStretchTextAction*) pAction )->GetText().getLength() * sizeof( sal_Unicode ) ); break;
-            case( META_TEXTRECT_ACTION ): nSizeBytes += ( ( (MetaTextRectAction*) pAction )->GetText().getLength() * sizeof( sal_Unicode ) ); break;
+            case( META_TEXT_ACTION ): nSizeBytes += static_cast<MetaTextAction*>( pAction )->GetText().getLength() * sizeof( sal_Unicode ); break;
+            case( META_STRETCHTEXT_ACTION ): nSizeBytes += static_cast<MetaStretchTextAction*>( pAction )->GetText().getLength() * sizeof( sal_Unicode ); break;
+            case( META_TEXTRECT_ACTION ): nSizeBytes += static_cast<MetaTextRectAction*>( pAction )->GetText().getLength() * sizeof( sal_Unicode ); break;
             case( META_TEXTARRAY_ACTION ):
             {
-                MetaTextArrayAction* pTextArrayAction = (MetaTextArrayAction*) pAction;
+                MetaTextArrayAction* pTextArrayAction = static_cast<MetaTextArrayAction*>(pAction);
 
                 nSizeBytes += ( pTextArrayAction->GetText().getLength() * sizeof( sal_Unicode ) );
 
diff --git a/vcl/source/gdi/graph.cxx b/vcl/source/gdi/graph.cxx
index f628f5595943..4fe916ac5ade 100644
--- a/vcl/source/gdi/graph.cxx
+++ b/vcl/source/gdi/graph.cxx
@@ -316,7 +316,7 @@ void Graphic::Save( SvStream& rOStm )
 
 void Graphic::Assign( const SvDataCopyStream& rCopyStream )
 {
-    *this = (const Graphic& ) rCopyStream;
+    *this = static_cast<const Graphic&>( rCopyStream );
 }
 
 void Graphic::Clear()
diff --git a/vcl/source/gdi/impanmvw.cxx b/vcl/source/gdi/impanmvw.cxx
index 096e67fa48ae..bf36ae962c1a 100644
--- a/vcl/source/gdi/impanmvw.cxx
+++ b/vcl/source/gdi/impanmvw.cxx
@@ -78,7 +78,7 @@ ImplAnimView::ImplAnimView( Animation* pParent, OutputDevice* pOut,
         MapMode aTempMap( mpOut->GetMapMode() );
         aTempMap.SetOrigin( Point() );
         mpBackground->SetMapMode( aTempMap );
-        ( (vcl::Window*) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
+        static_cast<vcl::Window*>( mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
         mpBackground->SetMapMode( MapMode() );
     }
     else
@@ -282,7 +282,7 @@ void ImplAnimView::ImplDraw( sal_uLong nPos, VirtualDevice* pVDev )
             delete pDev;
 
             if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
-                ( (vcl::Window*) mpOut )->Sync();
+                static_cast<vcl::Window*>( mpOut )->Sync();
         }
     }
 }
@@ -296,7 +296,7 @@ void ImplAnimView::ImplRepaint()
         MapMode aTempMap( mpOut->GetMapMode() );
         aTempMap.SetOrigin( Point() );
         mpBackground->SetMapMode( aTempMap );
-        ( (vcl::Window*) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
+        static_cast<vcl::Window*>( mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
         mpBackground->SetMapMode( MapMode() );
     }
     else
diff --git a/vcl/source/gdi/impgraph.cxx b/vcl/source/gdi/impgraph.cxx
index 711229b92272..d48432941f0c 100644
--- a/vcl/source/gdi/impgraph.cxx
+++ b/vcl/source/gdi/impgraph.cxx
@@ -214,7 +214,7 @@ ImpGraphic::~ImpGraphic()
 {
     ImplClear();
 
-    if( (sal_uLong) mpContext > 1UL )
+    if( reinterpret_cast<sal_uLong>(mpContext) > 1UL )
         delete mpContext;
 }
 
diff --git a/vcl/source/gdi/impvect.cxx b/vcl/source/gdi/impvect.cxx
index 05a8bf51d615..e4ba7fcdb0d7 100644
--- a/vcl/source/gdi/impvect.cxx
+++ b/vcl/source/gdi/impvect.cxx
@@ -42,7 +42,9 @@
 
 #define VECT_MAP( _def_pIn, _def_pOut, _def_nVal )  _def_pOut[_def_nVal]=(_def_pIn[_def_nVal]=((_def_nVal)*4L)+1L)+5L;
 #define BACK_MAP( _def_nVal )                       ((((_def_nVal)+2)>>2)-1)
-#define VECT_PROGRESS( _def_pProgress, _def_nVal )  if(_def_pProgress&&_def_pProgress->IsSet())(_def_pProgress->Call((void*)(sal_IntPtr)_def_nVal));
+#define VECT_PROGRESS( _def_pProgress, _def_nVal ) \
+  if(_def_pProgress&&_def_pProgress->IsSet())      \
+      (_def_pProgress->Call(reinterpret_cast<void*>(_def_nVal)));
 
 struct ChainMove { long nDX; long nDY; };
 
diff --git a/vcl/source/gdi/metaact.cxx b/vcl/source/gdi/metaact.cxx
index faefe4b1e4ab..b1f2f5aac21d 100644
--- a/vcl/source/gdi/metaact.cxx
+++ b/vcl/source/gdi/metaact.cxx
@@ -316,8 +316,8 @@ void MetaPixelAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaPixelAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPt == ((MetaPixelAction&)rMetaAction).maPt ) &&
-           ( maColor == ((MetaPixelAction&)rMetaAction).maColor );
+    return ( maPt == static_cast<const MetaPixelAction&>(rMetaAction).maPt ) &&
+           ( maColor == static_cast<const MetaPixelAction&>(rMetaAction).maColor );
 }
 
 void MetaPixelAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -371,7 +371,7 @@ void MetaPointAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaPointAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maPt == ((MetaPointAction&)rMetaAction).maPt;
+    return maPt == static_cast<const MetaPointAction&>(rMetaAction).maPt;
 }
 
 void MetaPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -438,9 +438,9 @@ void MetaLineAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaLineAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maLineInfo == ((MetaLineAction&)rMetaAction).maLineInfo ) &&
-           ( maStartPt == ((MetaLineAction&)rMetaAction).maStartPt ) &&
-           ( maEndPt == ((MetaLineAction&)rMetaAction).maEndPt );
+    return ( maLineInfo == static_cast<const MetaLineAction&>(rMetaAction).maLineInfo ) &&
+           ( maStartPt == static_cast<const MetaLineAction&>(rMetaAction).maStartPt ) &&
+           ( maEndPt == static_cast<const MetaLineAction&>(rMetaAction).maEndPt );
 }
 
 void MetaLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -504,7 +504,7 @@ void MetaRectAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaRectAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maRect == ((MetaRectAction&)rMetaAction).maRect;
+    return maRect == static_cast<const MetaRectAction&>(rMetaAction).maRect;
 }
 
 void MetaRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -563,9 +563,9 @@ void MetaRoundRectAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaRoundRectAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaRoundRectAction&)rMetaAction).maRect ) &&
-           ( mnHorzRound == ((MetaRoundRectAction&)rMetaAction).mnHorzRound ) &&
-           ( mnVertRound == ((MetaRoundRectAction&)rMetaAction).mnVertRound );
+    return ( maRect == static_cast<const MetaRoundRectAction&>(rMetaAction).maRect ) &&
+           ( mnHorzRound == static_cast<const MetaRoundRectAction&>(rMetaAction).mnHorzRound ) &&
+           ( mnVertRound == static_cast<const MetaRoundRectAction&>(rMetaAction).mnVertRound );
 }
 
 void MetaRoundRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -618,7 +618,7 @@ void MetaEllipseAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaEllipseAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maRect == ((MetaEllipseAction&)rMetaAction).maRect;
+    return maRect == static_cast<const MetaEllipseAction&>(rMetaAction).maRect;
 }
 
 void MetaEllipseAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -677,9 +677,9 @@ void MetaArcAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaArcAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaArcAction&)rMetaAction).maRect ) &&
-           ( maStartPt == ((MetaArcAction&)rMetaAction).maStartPt ) &&
-           ( maEndPt == ((MetaArcAction&)rMetaAction).maEndPt );
+    return ( maRect == static_cast<const MetaArcAction&>(rMetaAction).maRect ) &&
+           ( maStartPt == static_cast<const MetaArcAction&>(rMetaAction).maStartPt ) &&
+           ( maEndPt == static_cast<const MetaArcAction&>(rMetaAction).maEndPt );
 }
 
 void MetaArcAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -742,9 +742,9 @@ void MetaPieAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaPieAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaPieAction&)rMetaAction).maRect ) &&
-           ( maStartPt == ((MetaPieAction&)rMetaAction).maStartPt ) &&
-           ( maEndPt == ((MetaPieAction&)rMetaAction).maEndPt );
+    return ( maRect == static_cast<const MetaPieAction&>(rMetaAction).maRect ) &&
+           ( maStartPt == static_cast<const MetaPieAction&>(rMetaAction).maStartPt ) &&
+           ( maEndPt == static_cast<const MetaPieAction&>(rMetaAction).maEndPt );
 }
 
 void MetaPieAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -807,9 +807,9 @@ void MetaChordAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaChordAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaChordAction&)rMetaAction).maRect ) &&
-           ( maStartPt == ((MetaChordAction&)rMetaAction).maStartPt ) &&
-           ( maEndPt == ((MetaChordAction&)rMetaAction).maEndPt );
+    return ( maRect == static_cast<const MetaChordAction&>(rMetaAction).maRect ) &&
+           ( maStartPt == static_cast<const MetaChordAction&>(rMetaAction).maStartPt ) &&
+           ( maEndPt == static_cast<const MetaChordAction&>(rMetaAction).maEndPt );
 }
 
 void MetaChordAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -876,10 +876,10 @@ void MetaPolyLineAction::Scale( double fScaleX, double fScaleY )
 bool MetaPolyLineAction::Compare( const MetaAction& rMetaAction ) const
 {
     bool bIsEqual = true;
-    if ( maLineInfo != ((MetaPolyLineAction&)rMetaAction).maLineInfo )
+    if ( maLineInfo != static_cast<const MetaPolyLineAction&>(rMetaAction).maLineInfo )
         bIsEqual = false;
     else
-        bIsEqual = maPoly.IsEqual(((MetaPolyLineAction&)rMetaAction).maPoly );
+        bIsEqual = maPoly.IsEqual(static_cast<const MetaPolyLineAction&>(rMetaAction).maPoly );
     return bIsEqual;
 
 }
@@ -956,7 +956,7 @@ void MetaPolygonAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaPolygonAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maPoly.IsEqual(((MetaPolygonAction&)rMetaAction).maPoly );
+    return maPoly.IsEqual(static_cast<const MetaPolygonAction&>(rMetaAction).maPoly );
 }
 
 void MetaPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1026,7 +1026,7 @@ void MetaPolyPolygonAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaPolyPolygonAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maPolyPoly.IsEqual(((MetaPolyPolygonAction&)rMetaAction).maPolyPoly );
+    return maPolyPoly.IsEqual(static_cast<const MetaPolyPolygonAction&>(rMetaAction).maPolyPoly );
 }
 
 void MetaPolyPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1130,10 +1130,10 @@ void MetaTextAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaTextAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPt == ((MetaTextAction&)rMetaAction).maPt ) &&
-           ( maStr == ((MetaTextAction&)rMetaAction).maStr ) &&
-           ( mnIndex == ((MetaTextAction&)rMetaAction).mnIndex ) &&
-           ( mnLen == ((MetaTextAction&)rMetaAction).mnLen );
+    return ( maPt == static_cast<const MetaTextAction&>(rMetaAction).maPt ) &&
+           ( maStr == static_cast<const MetaTextAction&>(rMetaAction).maStr ) &&
+           ( mnIndex == static_cast<const MetaTextAction&>(rMetaAction).mnIndex ) &&
+           ( mnLen == static_cast<const MetaTextAction&>(rMetaAction).mnLen );
 }
 
 void MetaTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1246,11 +1246,11 @@ void MetaTextArrayAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaTextArrayAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maStartPt == ((MetaTextArrayAction&)rMetaAction).maStartPt ) &&
-           ( maStr == ((MetaTextArrayAction&)rMetaAction).maStr ) &&
-           ( mnIndex == ((MetaTextArrayAction&)rMetaAction).mnIndex ) &&
-           ( mnLen == ((MetaTextArrayAction&)rMetaAction).mnLen ) &&
-           ( memcmp( mpDXAry, ((MetaTextArrayAction&)rMetaAction).mpDXAry, mnLen ) == 0 );
+    return ( maStartPt == static_cast<const MetaTextArrayAction&>(rMetaAction).maStartPt ) &&
+           ( maStr == static_cast<const MetaTextArrayAction&>(rMetaAction).maStr ) &&
+           ( mnIndex == static_cast<const MetaTextArrayAction&>(rMetaAction).mnIndex ) &&
+           ( mnLen == static_cast<const MetaTextArrayAction&>(rMetaAction).mnLen ) &&
+           ( memcmp( mpDXAry, static_cast<const MetaTextArrayAction&>(rMetaAction).mpDXAry, mnLen ) == 0 );
 }
 
 void MetaTextArrayAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1381,11 +1381,11 @@ void MetaStretchTextAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaStretchTextAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPt == ((MetaStretchTextAction&)rMetaAction).maPt ) &&
-           ( maStr == ((MetaStretchTextAction&)rMetaAction).maStr ) &&
-           ( mnWidth == ((MetaStretchTextAction&)rMetaAction).mnWidth ) &&
-           ( mnIndex == ((MetaStretchTextAction&)rMetaAction).mnIndex ) &&
-           ( mnLen == ((MetaStretchTextAction&)rMetaAction).mnLen );
+    return ( maPt == static_cast<const MetaStretchTextAction&>(rMetaAction).maPt ) &&
+           ( maStr == static_cast<const MetaStretchTextAction&>(rMetaAction).maStr ) &&
+           ( mnWidth == static_cast<const MetaStretchTextAction&>(rMetaAction).mnWidth ) &&
+           ( mnIndex == static_cast<const MetaStretchTextAction&>(rMetaAction).mnIndex ) &&
+           ( mnLen == static_cast<const MetaStretchTextAction&>(rMetaAction).mnLen );
 }
 
 void MetaStretchTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1458,9 +1458,9 @@ void MetaTextRectAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaTextRectAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaTextRectAction&)rMetaAction).maRect ) &&
-           ( maStr == ((MetaTextRectAction&)rMetaAction).maStr ) &&
-           ( mnStyle == ((MetaTextRectAction&)rMetaAction).mnStyle );
+    return ( maRect == static_cast<const MetaTextRectAction&>(rMetaAction).maRect ) &&
+           ( maStr == static_cast<const MetaTextRectAction&>(rMetaAction).maStr ) &&
+           ( mnStyle == static_cast<const MetaTextRectAction&>(rMetaAction).mnStyle );
 }
 
 void MetaTextRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1533,11 +1533,11 @@ void MetaTextLineAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaTextLineAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPos == ((MetaTextLineAction&)rMetaAction).maPos ) &&
-           ( mnWidth == ((MetaTextLineAction&)rMetaAction).mnWidth ) &&
-           ( meStrikeout == ((MetaTextLineAction&)rMetaAction).meStrikeout ) &&
-           ( meUnderline == ((MetaTextLineAction&)rMetaAction).meUnderline ) &&
-           ( meOverline  == ((MetaTextLineAction&)rMetaAction).meOverline );
+    return ( maPos == static_cast<const MetaTextLineAction&>(rMetaAction).maPos ) &&
+           ( mnWidth == static_cast<const MetaTextLineAction&>(rMetaAction).mnWidth ) &&
+           ( meStrikeout == static_cast<const MetaTextLineAction&>(rMetaAction).meStrikeout ) &&
+           ( meUnderline == static_cast<const MetaTextLineAction&>(rMetaAction).meUnderline ) &&
+           ( meOverline  == static_cast<const MetaTextLineAction&>(rMetaAction).meOverline );
 }
 
 void MetaTextLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1611,8 +1611,8 @@ void MetaBmpAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaBmpAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maBmp.IsEqual(((MetaBmpAction&)rMetaAction).maBmp ) &&
-           ( maPt == ((MetaBmpAction&)rMetaAction).maPt );
+    return maBmp.IsEqual(static_cast<const MetaBmpAction&>(rMetaAction).maBmp ) &&
+           ( maPt == static_cast<const MetaBmpAction&>(rMetaAction).maPt );
 }
 
 void MetaBmpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1675,9 +1675,9 @@ void MetaBmpScaleAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaBmpScaleAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmp.IsEqual(((MetaBmpScaleAction&)rMetaAction).maBmp )) &&
-           ( maPt == ((MetaBmpScaleAction&)rMetaAction).maPt ) &&
-           ( maSz == ((MetaBmpScaleAction&)rMetaAction).maSz );
+    return ( maBmp.IsEqual(static_cast<const MetaBmpScaleAction&>(rMetaAction).maBmp )) &&
+           ( maPt == static_cast<const MetaBmpScaleAction&>(rMetaAction).maPt ) &&
+           ( maSz == static_cast<const MetaBmpScaleAction&>(rMetaAction).maSz );
 }
 
 void MetaBmpScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1745,11 +1745,11 @@ void MetaBmpScalePartAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaBmpScalePartAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmp.IsEqual(((MetaBmpScalePartAction&)rMetaAction).maBmp )) &&
-           ( maDstPt == ((MetaBmpScalePartAction&)rMetaAction).maDstPt ) &&
-           ( maDstSz == ((MetaBmpScalePartAction&)rMetaAction).maDstSz ) &&
-           ( maSrcPt == ((MetaBmpScalePartAction&)rMetaAction).maSrcPt ) &&
-           ( maSrcSz == ((MetaBmpScalePartAction&)rMetaAction).maSrcSz );
+    return ( maBmp.IsEqual(static_cast<const MetaBmpScalePartAction&>(rMetaAction).maBmp )) &&
+           ( maDstPt == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maDstPt ) &&
+           ( maDstSz == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maDstSz ) &&
+           ( maSrcPt == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maSrcPt ) &&
+           ( maSrcSz == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maSrcSz );
 }
 
 void MetaBmpScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1813,8 +1813,8 @@ void MetaBmpExAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaBmpExAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmpEx.IsEqual(((MetaBmpExAction&)rMetaAction).maBmpEx )) &&
-           ( maPt == ((MetaBmpExAction&)rMetaAction).maPt );
+    return ( maBmpEx.IsEqual(static_cast<const MetaBmpExAction&>(rMetaAction).maBmpEx )) &&
+           ( maPt == static_cast<const MetaBmpExAction&>(rMetaAction).maPt );
 }
 
 void MetaBmpExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1877,9 +1877,9 @@ void MetaBmpExScaleAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaBmpExScaleAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmpEx.IsEqual(((MetaBmpExScaleAction&)rMetaAction).maBmpEx )) &&
-           ( maPt == ((MetaBmpExScaleAction&)rMetaAction).maPt ) &&
-           ( maSz == ((MetaBmpExScaleAction&)rMetaAction).maSz );
+    return ( maBmpEx.IsEqual(static_cast<const MetaBmpExScaleAction&>(rMetaAction).maBmpEx )) &&
+           ( maPt == static_cast<const MetaBmpExScaleAction&>(rMetaAction).maPt ) &&
+           ( maSz == static_cast<const MetaBmpExScaleAction&>(rMetaAction).maSz );
 }
 
 void MetaBmpExScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -1947,11 +1947,11 @@ void MetaBmpExScalePartAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaBmpExScalePartAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmpEx.IsEqual(((MetaBmpExScalePartAction&)rMetaAction).maBmpEx )) &&
-           ( maDstPt == ((MetaBmpExScalePartAction&)rMetaAction).maDstPt ) &&
-           ( maDstSz == ((MetaBmpExScalePartAction&)rMetaAction).maDstSz ) &&
-           ( maSrcPt == ((MetaBmpExScalePartAction&)rMetaAction).maSrcPt ) &&
-           ( maSrcSz == ((MetaBmpExScalePartAction&)rMetaAction).maSrcSz );
+    return ( maBmpEx.IsEqual(static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maBmpEx )) &&
+           ( maDstPt == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maDstPt ) &&
+           ( maDstSz == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maDstSz ) &&
+           ( maSrcPt == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maSrcPt ) &&
+           ( maSrcSz == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maSrcSz );
 }
 
 void MetaBmpExScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2018,9 +2018,9 @@ void MetaMaskAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaMaskAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmp.IsEqual(((MetaMaskAction&)rMetaAction).maBmp )) &&
-           ( maColor == ((MetaMaskAction&)rMetaAction).maColor ) &&
-           ( maPt == ((MetaMaskAction&)rMetaAction).maPt );
+    return ( maBmp.IsEqual(static_cast<const MetaMaskAction&>(rMetaAction).maBmp )) &&
+           ( maColor == static_cast<const MetaMaskAction&>(rMetaAction).maColor ) &&
+           ( maPt == static_cast<const MetaMaskAction&>(rMetaAction).maPt );
 }
 
 void MetaMaskAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2085,10 +2085,10 @@ void MetaMaskScaleAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaMaskScaleAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmp.IsEqual(((MetaMaskScaleAction&)rMetaAction).maBmp )) &&
-           ( maColor == ((MetaMaskScaleAction&)rMetaAction).maColor ) &&
-           ( maPt == ((MetaMaskScaleAction&)rMetaAction).maPt ) &&
-           ( maSz == ((MetaMaskScaleAction&)rMetaAction).maSz );
+    return ( maBmp.IsEqual(static_cast<const MetaMaskScaleAction&>(rMetaAction).maBmp )) &&
+           ( maColor == static_cast<const MetaMaskScaleAction&>(rMetaAction).maColor ) &&
+           ( maPt == static_cast<const MetaMaskScaleAction&>(rMetaAction).maPt ) &&
+           ( maSz == static_cast<const MetaMaskScaleAction&>(rMetaAction).maSz );
 }
 
 void MetaMaskScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2158,12 +2158,12 @@ void MetaMaskScalePartAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaMaskScalePartAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maBmp.IsEqual(((MetaMaskScalePartAction&)rMetaAction).maBmp )) &&
-           ( maColor == ((MetaMaskScalePartAction&)rMetaAction).maColor ) &&
-           ( maDstPt == ((MetaMaskScalePartAction&)rMetaAction).maDstPt ) &&
-           ( maDstSz == ((MetaMaskScalePartAction&)rMetaAction).maDstSz ) &&
-           ( maSrcPt == ((MetaMaskScalePartAction&)rMetaAction).maSrcPt ) &&
-           ( maSrcSz == ((MetaMaskScalePartAction&)rMetaAction).maSrcSz );
+    return ( maBmp.IsEqual(static_cast<const MetaMaskScalePartAction&>(rMetaAction).maBmp )) &&
+           ( maColor == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maColor ) &&
+           ( maDstPt == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maDstPt ) &&
+           ( maDstSz == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maDstSz ) &&
+           ( maSrcPt == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maSrcPt ) &&
+           ( maSrcSz == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maSrcSz );
 }
 
 void MetaMaskScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2229,8 +2229,8 @@ void MetaGradientAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaGradientAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaGradientAction&)rMetaAction).maRect ) &&
-           ( maGradient == ((MetaGradientAction&)rMetaAction).maGradient );
+    return ( maRect == static_cast<const MetaGradientAction&>(rMetaAction).maRect ) &&
+           ( maGradient == static_cast<const MetaGradientAction&>(rMetaAction).maGradient );
 }
 
 void MetaGradientAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2290,8 +2290,8 @@ void MetaGradientExAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaGradientExAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPolyPoly == ((MetaGradientExAction&)rMetaAction).maPolyPoly ) &&
-           ( maGradient == ((MetaGradientExAction&)rMetaAction).maGradient );
+    return ( maPolyPoly == static_cast<const MetaGradientExAction&>(rMetaAction).maPolyPoly ) &&
+           ( maGradient == static_cast<const MetaGradientExAction&>(rMetaAction).maGradient );
 }
 
 void MetaGradientExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2352,8 +2352,8 @@ void MetaHatchAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaHatchAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPolyPoly == ((MetaHatchAction&)rMetaAction).maPolyPoly ) &&
-           ( maHatch == ((MetaHatchAction&)rMetaAction).maHatch );
+    return ( maPolyPoly == static_cast<const MetaHatchAction&>(rMetaAction).maPolyPoly ) &&
+           ( maHatch == static_cast<const MetaHatchAction&>(rMetaAction).maHatch );
 }
 
 void MetaHatchAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2414,8 +2414,8 @@ void MetaWallpaperAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaWallpaperAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRect == ((MetaWallpaperAction&)rMetaAction).maRect ) &&
-           ( maWallpaper == ((MetaWallpaperAction&)rMetaAction).maWallpaper );
+    return ( maRect == static_cast<const MetaWallpaperAction&>(rMetaAction).maRect ) &&
+           ( maWallpaper == static_cast<const MetaWallpaperAction&>(rMetaAction).maWallpaper );
 }
 
 void MetaWallpaperAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2473,8 +2473,8 @@ void MetaClipRegionAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaClipRegionAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRegion == ((MetaClipRegionAction&)rMetaAction).maRegion ) &&
-           ( mbClip == ((MetaClipRegionAction&)rMetaAction).mbClip );
+    return ( maRegion == static_cast<const MetaClipRegionAction&>(rMetaAction).maRegion ) &&
+           ( mbClip == static_cast<const MetaClipRegionAction&>(rMetaAction).mbClip );
 }
 
 void MetaClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2529,7 +2529,7 @@ void MetaISectRectClipRegionAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaISectRectClipRegionAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maRect == ((MetaISectRectClipRegionAction&)rMetaAction).maRect;
+    return maRect == static_cast<const MetaISectRectClipRegionAction&>(rMetaAction).maRect;
 }
 
 void MetaISectRectClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2582,7 +2582,7 @@ void MetaISectRegionClipRegionAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaISectRegionClipRegionAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maRegion == ((MetaISectRegionClipRegionAction&)rMetaAction).maRegion;
+    return maRegion == static_cast<const MetaISectRegionClipRegionAction&>(rMetaAction).maRegion;
 }
 
 void MetaISectRegionClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2633,8 +2633,8 @@ void MetaMoveClipRegionAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaMoveClipRegionAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( mnHorzMove == ((MetaMoveClipRegionAction&)rMetaAction).mnHorzMove ) &&
-           ( mnVertMove == ((MetaMoveClipRegionAction&)rMetaAction).mnVertMove );
+    return ( mnHorzMove == static_cast<const MetaMoveClipRegionAction&>(rMetaAction).mnHorzMove ) &&
+           ( mnVertMove == static_cast<const MetaMoveClipRegionAction&>(rMetaAction).mnVertMove );
 }
 
 void MetaMoveClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2684,8 +2684,8 @@ MetaAction* MetaLineColorAction::Clone()
 
 bool MetaLineColorAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maColor == ((MetaLineColorAction&)rMetaAction).maColor ) &&
-           ( mbSet == ((MetaLineColorAction&)rMetaAction).mbSet );
+    return ( maColor == static_cast<const MetaLineColorAction&>(rMetaAction).maColor ) &&
+           ( mbSet == static_cast<const MetaLineColorAction&>(rMetaAction).mbSet );
 }
 
 void MetaLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2734,8 +2734,8 @@ MetaAction* MetaFillColorAction::Clone()
 
 bool MetaFillColorAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maColor == ((MetaFillColorAction&)rMetaAction).maColor ) &&
-           ( mbSet == ((MetaFillColorAction&)rMetaAction).mbSet );
+    return ( maColor == static_cast<const MetaFillColorAction&>(rMetaAction).maColor ) &&
+           ( mbSet == static_cast<const MetaFillColorAction&>(rMetaAction).mbSet );
 }
 
 void MetaFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2779,7 +2779,7 @@ MetaAction* MetaTextColorAction::Clone()
 
 bool MetaTextColorAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maColor == ((MetaTextColorAction&)rMetaAction).maColor;
+    return maColor == static_cast<const MetaTextColorAction&>(rMetaAction).maColor;
 }
 
 void MetaTextColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2826,8 +2826,8 @@ MetaAction* MetaTextFillColorAction::Clone()
 
 bool MetaTextFillColorAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maColor == ((MetaTextFillColorAction&)rMetaAction).maColor ) &&
-           ( mbSet == ((MetaTextFillColorAction&)rMetaAction).mbSet );
+    return ( maColor == static_cast<const MetaTextFillColorAction&>(rMetaAction).maColor ) &&
+           ( mbSet == static_cast<const MetaTextFillColorAction&>(rMetaAction).mbSet );
 }
 
 void MetaTextFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2876,8 +2876,8 @@ MetaAction* MetaTextLineColorAction::Clone()
 
 bool MetaTextLineColorAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maColor == ((MetaTextLineColorAction&)rMetaAction).maColor ) &&
-           ( mbSet == ((MetaTextLineColorAction&)rMetaAction).mbSet );
+    return ( maColor == static_cast<const MetaTextLineColorAction&>(rMetaAction).maColor ) &&
+           ( mbSet == static_cast<const MetaTextLineColorAction&>(rMetaAction).mbSet );
 }
 
 void MetaTextLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2926,8 +2926,8 @@ MetaAction* MetaOverlineColorAction::Clone()
 
 bool MetaOverlineColorAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maColor == ((MetaOverlineColorAction&)rMetaAction).maColor ) &&
-           ( mbSet == ((MetaOverlineColorAction&)rMetaAction).mbSet );
+    return ( maColor == static_cast<const MetaOverlineColorAction&>(rMetaAction).maColor ) &&
+           ( mbSet == static_cast<const MetaOverlineColorAction&>(rMetaAction).mbSet );
 }
 
 void MetaOverlineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -2972,7 +2972,7 @@ MetaAction* MetaTextAlignAction::Clone()
 
 bool MetaTextAlignAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maAlign == ((MetaTextAlignAction&)rMetaAction).maAlign;
+    return maAlign == static_cast<const MetaTextAlignAction&>(rMetaAction).maAlign;
 }
 
 void MetaTextAlignAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3024,7 +3024,7 @@ void MetaMapModeAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaMapModeAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maMapMode == ((MetaMapModeAction&)rMetaAction).maMapMode;
+    return maMapMode == static_cast<const MetaMapModeAction&>(rMetaAction).maMapMode;
 }
 
 void MetaMapModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3084,7 +3084,7 @@ void MetaFontAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaFontAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return maFont == ((MetaFontAction&)rMetaAction).maFont;
+    return maFont == static_cast<const MetaFontAction&>(rMetaAction).maFont;
 }
 
 void MetaFontAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3133,7 +3133,7 @@ MetaAction* MetaPushAction::Clone()
 
 bool MetaPushAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return mnFlags == ((MetaPushAction&)rMetaAction).mnFlags;
+    return mnFlags == static_cast<const MetaPushAction&>(rMetaAction).mnFlags;
 }
 
 void MetaPushAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3209,7 +3209,7 @@ MetaAction* MetaRasterOpAction::Clone()
 
 bool MetaRasterOpAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return meRasterOp == ((MetaRasterOpAction&)rMetaAction).meRasterOp;
+    return meRasterOp == static_cast<const MetaRasterOpAction&>(rMetaAction).meRasterOp;
 }
 
 void MetaRasterOpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3266,8 +3266,8 @@ void MetaTransparentAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaTransparentAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maPolyPoly == ((MetaTransparentAction&)rMetaAction).maPolyPoly ) &&
-           ( mnTransPercent == ((MetaTransparentAction&)rMetaAction).mnTransPercent );
+    return ( maPolyPoly == static_cast<const MetaTransparentAction&>(rMetaAction).maPolyPoly ) &&
+           ( mnTransPercent == static_cast<const MetaTransparentAction&>(rMetaAction).mnTransPercent );
 }
 
 void MetaTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3341,10 +3341,10 @@ void MetaFloatTransparentAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaFloatTransparentAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maMtf == ((MetaFloatTransparentAction&)rMetaAction).maMtf ) &&
-           ( maPoint == ((MetaFloatTransparentAction&)rMetaAction).maPoint ) &&
-           ( maSize == ((MetaFloatTransparentAction&)rMetaAction).maSize ) &&
-           ( maGradient == ((MetaFloatTransparentAction&)rMetaAction).maGradient );
+    return ( maMtf == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maMtf ) &&
+           ( maPoint == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maPoint ) &&
+           ( maSize == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maSize ) &&
+           ( maGradient == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maGradient );
 }
 
 void MetaFloatTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3410,10 +3410,10 @@ void MetaEPSAction::Scale( double fScaleX, double fScaleY )
 
 bool MetaEPSAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maGfxLink.IsEqual(((MetaEPSAction&)rMetaAction).maGfxLink )) &&
-           ( maSubst == ((MetaEPSAction&)rMetaAction).maSubst ) &&
-           ( maPoint == ((MetaEPSAction&)rMetaAction).maPoint ) &&
-           ( maSize == ((MetaEPSAction&)rMetaAction).maSize );
+    return ( maGfxLink.IsEqual(static_cast<const MetaEPSAction&>(rMetaAction).maGfxLink )) &&
+           ( maSubst == static_cast<const MetaEPSAction&>(rMetaAction).maSubst ) &&
+           ( maPoint == static_cast<const MetaEPSAction&>(rMetaAction).maPoint ) &&
+           ( maSize == static_cast<const MetaEPSAction&>(rMetaAction).maSize );
 }
 
 void MetaEPSAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3467,8 +3467,8 @@ MetaAction* MetaRefPointAction::Clone()
 
 bool MetaRefPointAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maRefPoint == ((MetaRefPointAction&)rMetaAction).maRefPoint ) &&
-           ( mbSet == ((MetaRefPointAction&)rMetaAction).mbSet );
+    return ( maRefPoint == static_cast<const MetaRefPointAction&>(rMetaAction).maRefPoint ) &&
+           ( mbSet == static_cast<const MetaRefPointAction&>(rMetaAction).mbSet );
 }
 
 void MetaRefPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3664,10 +3664,10 @@ void MetaCommentAction::Scale( double fXScale, double fYScale )
 
 bool MetaCommentAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return ( maComment == ((MetaCommentAction&)rMetaAction).maComment ) &&
-           ( mnValue == ((MetaCommentAction&)rMetaAction).mnValue ) &&
-           ( mnDataSize == ((MetaCommentAction&)rMetaAction).mnDataSize ) &&
-           ( memcmp( mpData, ((MetaCommentAction&)rMetaAction).mpData, mnDataSize ) == 0 );
+    return ( maComment == static_cast<const MetaCommentAction&>(rMetaAction).maComment ) &&
+           ( mnValue == static_cast<const MetaCommentAction&>(rMetaAction).mnValue ) &&
+           ( mnDataSize == static_cast<const MetaCommentAction&>(rMetaAction).mnDataSize ) &&
+           ( memcmp( mpData, static_cast<const MetaCommentAction&>(rMetaAction).mpData, mnDataSize ) == 0 );
 }
 
 void MetaCommentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3727,7 +3727,7 @@ MetaAction* MetaLayoutModeAction::Clone()
 
 bool MetaLayoutModeAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return mnLayoutMode == ((MetaLayoutModeAction&)rMetaAction).mnLayoutMode;
+    return mnLayoutMode == static_cast<const MetaLayoutModeAction&>(rMetaAction).mnLayoutMode;
 }
 
 void MetaLayoutModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
@@ -3772,7 +3772,7 @@ MetaAction* MetaTextLanguageAction::Clone()
 
 bool MetaTextLanguageAction::Compare( const MetaAction& rMetaAction ) const
 {
-    return meTextLanguage == ((MetaTextLanguageAction&)rMetaAction).meTextLanguage;
+    return meTextLanguage == static_cast<const MetaTextLanguageAction&>(rMetaAction).meTextLanguage;
 }
 
 void MetaTextLanguageAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
diff --git a/vcl/source/gdi/pdfwriter_impl2.cxx b/vcl/source/gdi/pdfwriter_impl2.cxx
index a107eeb83c0f..2d0a4d0cf551 100644
--- a/vcl/source/gdi/pdfwriter_impl2.cxx
+++ b/vcl/source/gdi/pdfwriter_impl2.cxx
@@ -264,21 +264,21 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
             {
                 case( META_PIXEL_ACTION ):
                 {
-                    const MetaPixelAction* pA = (const MetaPixelAction*) pAction;
+                    const MetaPixelAction* pA = static_cast<const MetaPixelAction*>(pAction);
                     m_rOuterFace.DrawPixel( pA->GetPoint(), pA->GetColor() );
                 }
                 break;
 
                 case( META_POINT_ACTION ):
                 {
-                    const MetaPointAction* pA = (const MetaPointAction*) pAction;
+                    const MetaPointAction* pA = static_cast<const MetaPointAction*>(pAction);
                     m_rOuterFace.DrawPixel( pA->GetPoint() );
                 }
                 break;
 
                 case( META_LINE_ACTION ):
                 {
-                    const MetaLineAction* pA = (const MetaLineAction*) pAction;
+                    const MetaLineAction* pA = static_cast<const MetaLineAction*>(pAction);
                     if ( pA->GetLineInfo().IsDefault() )
                         m_rOuterFace.DrawLine( pA->GetStartPoint(), pA->GetEndPoint() );
                     else
@@ -288,56 +288,56 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_RECT_ACTION ):
                 {
-                    const MetaRectAction* pA = (const MetaRectAction*) pAction;
+                    const MetaRectAction* pA = static_cast<const MetaRectAction*>(pAction);
                     m_rOuterFace.DrawRect( pA->GetRect() );
                 }
                 break;
 
                 case( META_ROUNDRECT_ACTION ):
                 {
-                    const MetaRoundRectAction* pA = (const MetaRoundRectAction*) pAction;
+                    const MetaRoundRectAction* pA = static_cast<const MetaRoundRectAction*>(pAction);
                     m_rOuterFace.DrawRect( pA->GetRect(), pA->GetHorzRound(), pA->GetVertRound() );
                 }
                 break;
 
                 case( META_ELLIPSE_ACTION ):
                 {
-                    const MetaEllipseAction* pA = (const MetaEllipseAction*) pAction;
+                    const MetaEllipseAction* pA = static_cast<const MetaEllipseAction*>(pAction);
                     m_rOuterFace.DrawEllipse( pA->GetRect() );
                 }
                 break;
 
                 case( META_ARC_ACTION ):
                 {
-                    const MetaArcAction* pA = (const MetaArcAction*) pAction;
+                    const MetaArcAction* pA = static_cast<const MetaArcAction*>(pAction);
                     m_rOuterFace.DrawArc( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint() );
                 }
                 break;
 
                 case( META_PIE_ACTION ):
                 {
-                    const MetaArcAction* pA = (const MetaArcAction*) pAction;
+                    const MetaArcAction* pA = static_cast<const MetaArcAction*>(pAction);
                     m_rOuterFace.DrawPie( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint() );
                 }
                 break;
 
                 case( META_CHORD_ACTION ):
                 {
-                    const MetaChordAction* pA = (const MetaChordAction*) pAction;
+                    const MetaChordAction* pA = static_cast<const MetaChordAction*>(pAction);
                     m_rOuterFace.DrawChord( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint() );
                 }
                 break;
 
                 case( META_POLYGON_ACTION ):
                 {
-                    const MetaPolygonAction* pA = (const MetaPolygonAction*) pAction;
+                    const MetaPolygonAction* pA = static_cast<const MetaPolygonAction*>(pAction);
                     m_rOuterFace.DrawPolygon( pA->GetPolygon() );
                 }
                 break;
 
                 case( META_POLYLINE_ACTION ):
                 {
-                    const MetaPolyLineAction* pA = (const MetaPolyLineAction*) pAction;
+                    const MetaPolyLineAction* pA = static_cast<const MetaPolyLineAction*>(pAction);
                     if ( pA->GetLineInfo().IsDefault() )
                         m_rOuterFace.DrawPolyLine( pA->GetPolygon() );
                     else
@@ -347,14 +347,14 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_POLYPOLYGON_ACTION ):
                 {
-                    const MetaPolyPolygonAction* pA = (const MetaPolyPolygonAction*) pAction;
+                    const MetaPolyPolygonAction* pA = static_cast<const MetaPolyPolygonAction*>(pAction);
                     m_rOuterFace.DrawPolyPolygon( pA->GetPolyPolygon() );
                 }
                 break;
 
                 case( META_GRADIENT_ACTION ):
                 {
-                    const MetaGradientAction* pA = (const MetaGradientAction*) pAction;
+                    const MetaGradientAction* pA = static_cast<const MetaGradientAction*>(pAction);
                     const Gradient& rGradient = pA->GetGradient();
                     if (lcl_canUsePDFAxialShading(rGradient))
                     {
@@ -370,7 +370,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_GRADIENTEX_ACTION ):
                 {
-                    const MetaGradientExAction* pA = (const MetaGradientExAction*) pAction;
+                    const MetaGradientExAction* pA = static_cast<const MetaGradientExAction*>(pAction);
                     const Gradient& rGradient = pA->GetGradient();
 
                     if (lcl_canUsePDFAxialShading(rGradient))
@@ -382,21 +382,21 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case META_HATCH_ACTION:
                 {
-                    const MetaHatchAction*  pA = (const MetaHatchAction*) pAction;
+                    const MetaHatchAction*  pA = static_cast<const MetaHatchAction*>(pAction);
                     m_rOuterFace.DrawHatch( pA->GetPolyPolygon(), pA->GetHatch() );
                 }
                 break;
 
                 case( META_TRANSPARENT_ACTION ):
                 {
-                    const MetaTransparentAction* pA = (const MetaTransparentAction*) pAction;
+                    const MetaTransparentAction* pA = static_cast<const MetaTransparentAction*>(pAction);
                     m_rOuterFace.DrawTransparent( pA->GetPolyPolygon(), pA->GetTransparence() );
                 }
                 break;
 
                 case( META_FLOATTRANSPARENT_ACTION ):
                 {
-                    const MetaFloatTransparentAction* pA = (const MetaFloatTransparentAction*) pAction;
+                    const MetaFloatTransparentAction* pA = static_cast<const MetaFloatTransparentAction*>(pAction);
 
                     GDIMetaFile     aTmpMtf( pA->GetGDIMetaFile() );
                     const Point&    rPos = pA->GetPoint();
@@ -489,7 +489,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_EPS_ACTION ):
                 {
-                    const MetaEPSAction*    pA = (const MetaEPSAction*) pAction;
+                    const MetaEPSAction*    pA = static_cast<const MetaEPSAction*>(pAction);
                     const GDIMetaFile       aSubstitute( pA->GetSubstitute() );
 
                     m_rOuterFace.Push();
@@ -512,7 +512,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
                 case( META_COMMENT_ACTION ):
                 if( ! i_rContext.m_bTransparenciesWereRemoved )
                 {
-                    const MetaCommentAction*    pA = (const MetaCommentAction*) pAction;
+                    const MetaCommentAction*    pA = static_cast<const MetaCommentAction*>(pAction);
 
                     if( pA->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN"))
                     {
@@ -524,9 +524,9 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
                             pAction = aMtf.GetAction( i );
 
                             if( pAction->GetType() == META_GRADIENTEX_ACTION )
-                                pGradAction = (const MetaGradientExAction*) pAction;
+                                pGradAction = static_cast<const MetaGradientExAction*>(pAction);
                             else if( ( pAction->GetType() == META_COMMENT_ACTION ) &&
-                                     ( ( (const MetaCommentAction*) pAction )->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END")) )
+                                     ( static_cast<const MetaCommentAction*>(pAction)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END")) )
                             {
                                 bDone = true;
                             }
@@ -748,7 +748,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
                                     pAction = aMtf.GetAction( i );
                                     if ( pAction->GetType() == META_COMMENT_ACTION )
                                     {
-                                        OString sComment( ((MetaCommentAction*)pAction)->GetComment() );
+                                        OString sComment( static_cast<const MetaCommentAction*>(pAction)->GetComment() );
                                         if (sComment == sSeqEnd)
                                             break;
                                     }
@@ -758,7 +758,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
                                     // state and must not be skipped
                                     else if( pAction->GetType() == META_FILLCOLOR_ACTION )
                                     {
-                                        const MetaFillColorAction* pMA = (const MetaFillColorAction*) pAction;
+                                        const MetaFillColorAction* pMA = static_cast<const MetaFillColorAction*>(pAction);
                                         if( pMA->IsSetting() )
                                             m_rOuterFace.SetFillColor( pMA->GetColor() );
                                         else
@@ -773,7 +773,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_BMP_ACTION ):
                 {
-                    const MetaBmpAction* pA = (const MetaBmpAction*) pAction;
+                    const MetaBmpAction* pA = static_cast<const MetaBmpAction*>(pAction);
                     BitmapEx aBitmapEx( pA->GetBitmap() );
                     Size aSize( OutputDevice::LogicToLogic( aBitmapEx.GetPrefSize(),
                                                             aBitmapEx.GetPrefMapMode(), pDummyVDev->GetMapMode() ) );
@@ -785,14 +785,14 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_BMPSCALE_ACTION ):
                 {
-                    const MetaBmpScaleAction* pA = (const MetaBmpScaleAction*) pAction;
+                    const MetaBmpScaleAction* pA = static_cast<const MetaBmpScaleAction*>(pAction);
                     implWriteBitmapEx( pA->GetPoint(), pA->GetSize(), BitmapEx( pA->GetBitmap() ), pDummyVDev, i_rContext );
                 }
                 break;
 
                 case( META_BMPSCALEPART_ACTION ):
                 {
-                    const MetaBmpScalePartAction* pA = (const MetaBmpScalePartAction*) pAction;
+                    const MetaBmpScalePartAction* pA = static_cast<const MetaBmpScalePartAction*>(pAction);
                     BitmapEx aBitmapEx( pA->GetBitmap() );
                     aBitmapEx.Crop( Rectangle( pA->GetSrcPoint(), pA->GetSrcSize() ) );
                     implWriteBitmapEx( pA->GetDestPoint(), pA->GetDestSize(), aBitmapEx, pDummyVDev, i_rContext );
@@ -801,7 +801,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_BMPEX_ACTION ):
                 {
-                    const MetaBmpExAction*  pA = (const MetaBmpExAction*) pAction;
+                    const MetaBmpExAction*  pA = static_cast<const MetaBmpExAction*>(pAction);
                     BitmapEx aBitmapEx( pA->GetBitmapEx() );
                     Size aSize( OutputDevice::LogicToLogic( aBitmapEx.GetPrefSize(),
                             aBitmapEx.GetPrefMapMode(), pDummyVDev->GetMapMode() ) );
@@ -811,14 +811,14 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_BMPEXSCALE_ACTION ):
                 {
-                    const MetaBmpExScaleAction* pA = (const MetaBmpExScaleAction*) pAction;
+                    const MetaBmpExScaleAction* pA = static_cast<const MetaBmpExScaleAction*>(pAction);
                     implWriteBitmapEx( pA->GetPoint(), pA->GetSize(), pA->GetBitmapEx(), pDummyVDev, i_rContext );
                 }
                 break;
 
                 case( META_BMPEXSCALEPART_ACTION ):
                 {
-                    const MetaBmpExScalePartAction* pA = (const MetaBmpExScalePartAction*) pAction;
+                    const MetaBmpExScalePartAction* pA = static_cast<const MetaBmpExScalePartAction*>(pAction);
                     BitmapEx aBitmapEx( pA->GetBitmapEx() );
                     aBitmapEx.Crop( Rectangle( pA->GetSrcPoint(), pA->GetSrcSize() ) );
                     implWriteBitmapEx( pA->GetDestPoint(), pA->GetDestSize(), aBitmapEx, pDummyVDev, i_rContext );
@@ -835,35 +835,35 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_TEXT_ACTION ):
                 {
-                    const MetaTextAction* pA = (const MetaTextAction*) pAction;
+                    const MetaTextAction* pA = static_cast<const MetaTextAction*>(pAction);
                     m_rOuterFace.DrawText( pA->GetPoint(), pA->GetText().copy( pA->GetIndex(), std::min<sal_Int32>(pA->GetText().getLength() - pA->GetIndex(), pA->GetLen()) ) );
                 }
                 break;
 
                 case( META_TEXTRECT_ACTION ):
                 {
-                    const MetaTextRectAction* pA = (const MetaTextRectAction*) pAction;
+                    const MetaTextRectAction* pA = static_cast<const MetaTextRectAction*>(pAction);
                     m_rOuterFace.DrawText( pA->GetRect(), pA->GetText(), pA->GetStyle() );
                 }
                 break;
 
                 case( META_TEXTARRAY_ACTION ):
                 {
-                    const MetaTextArrayAction* pA = (const MetaTextArrayAction*) pAction;
+                    const MetaTextArrayAction* pA = static_cast<const MetaTextArrayAction*>(pAction);
                     m_rOuterFace.DrawTextArray( pA->GetPoint(), pA->GetText(), pA->GetDXArray(), pA->GetIndex(), pA->GetLen() );
                 }
                 break;
 
                 case( META_STRETCHTEXT_ACTION ):
                 {
-                    const MetaStretchTextAction* pA = (const MetaStretchTextAction*) pAction;
+                    const MetaStretchTextAction* pA = static_cast<const MetaStretchTextAction*>(pAction);
                     m_rOuterFace.DrawStretchText( pA->GetPoint(), pA->GetWidth(), pA->GetText(), pA->GetIndex(), pA->GetLen() );
                 }
                 break;
 
                 case( META_TEXTLINE_ACTION ):
                 {
-                    const MetaTextLineAction* pA = (const MetaTextLineAction*) pAction;
+                    const MetaTextLineAction* pA = static_cast<const MetaTextLineAction*>(pAction);
                     m_rOuterFace.DrawTextLine( pA->GetStartPoint(), pA->GetWidth(), pA->GetStrikeout(), pA->GetUnderline(), pA->GetOverline() );
 
                 }
@@ -871,7 +871,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_CLIPREGION_ACTION ):
                 {
-                    const MetaClipRegionAction* pA = (const MetaClipRegionAction*) pAction;
+                    const MetaClipRegionAction* pA = static_cast<const MetaClipRegionAction*>(pAction);
 
                     if( pA->IsClipping() )
                     {
@@ -890,14 +890,14 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_ISECTRECTCLIPREGION_ACTION ):
                 {
-                    const MetaISectRectClipRegionAction* pA = (const MetaISectRectClipRegionAction*) pAction;
+                    const MetaISectRectClipRegionAction* pA = static_cast<const MetaISectRectClipRegionAction*>(pAction);
                     m_rOuterFace.IntersectClipRegion( pA->GetRect() );
                 }
                 break;
 
                 case( META_ISECTREGIONCLIPREGION_ACTION ):
                 {
-                    const MetaISectRegionClipRegionAction* pA = (const MetaISectRegionClipRegionAction*) pAction;
+                    const MetaISectRegionClipRegionAction* pA = static_cast<const MetaISectRegionClipRegionAction*>(pAction);
                     Region aReg( pA->GetRegion() );
                     m_rOuterFace.IntersectClipRegion( aReg.GetAsB2DPolyPolygon() );
                 }
@@ -905,7 +905,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_MOVECLIPREGION_ACTION ):
                 {
-                    const MetaMoveClipRegionAction* pA = (const MetaMoveClipRegionAction*) pAction;
+                    const MetaMoveClipRegionAction* pA = static_cast<const MetaMoveClipRegionAction*>(pAction);
                     m_rOuterFace.MoveClipRegion( pA->GetHorzMove(), pA->GetVertMove() );
                 }
                 break;
@@ -919,7 +919,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_LINECOLOR_ACTION ):
                 {
-                    const MetaLineColorAction* pA = (const MetaLineColorAction*) pAction;
+                    const MetaLineColorAction* pA = static_cast<const MetaLineColorAction*>(pAction);
 
                     if( pA->IsSetting() )
                         m_rOuterFace.SetLineColor( pA->GetColor() );
@@ -930,7 +930,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_FILLCOLOR_ACTION ):
                 {
-                    const MetaFillColorAction* pA = (const MetaFillColorAction*) pAction;
+                    const MetaFillColorAction* pA = static_cast<const MetaFillColorAction*>(pAction);
 
                     if( pA->IsSetting() )
                         m_rOuterFace.SetFillColor( pA->GetColor() );
@@ -941,7 +941,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_TEXTLINECOLOR_ACTION ):
                 {
-                    const MetaTextLineColorAction* pA = (const MetaTextLineColorAction*) pAction;
+                    const MetaTextLineColorAction* pA = static_cast<const MetaTextLineColorAction*>(pAction);
 
                     if( pA->IsSetting() )
                         m_rOuterFace.SetTextLineColor( pA->GetColor() );
@@ -952,7 +952,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_OVERLINECOLOR_ACTION ):
                 {
-                    const MetaOverlineColorAction* pA = (const MetaOverlineColorAction*) pAction;
+                    const MetaOverlineColorAction* pA = static_cast<const MetaOverlineColorAction*>(pAction);
 
                     if( pA->IsSetting() )
                         m_rOuterFace.SetOverlineColor( pA->GetColor() );
@@ -963,7 +963,7 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_TEXTFILLCOLOR_ACTION ):
                 {
-                    const MetaTextFillColorAction* pA = (const MetaTextFillColorAction*) pAction;
+                    const MetaTextFillColorAction* pA = static_cast<const MetaTextFillColorAction*>(pAction);
 
                     if( pA->IsSetting() )
                         m_rOuterFace.SetTextFillColor( pA->GetColor() );
@@ -974,28 +974,28 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_TEXTCOLOR_ACTION ):
                 {
-                    const MetaTextColorAction* pA = (const MetaTextColorAction*) pAction;
+                    const MetaTextColorAction* pA = static_cast<const MetaTextColorAction*>(pAction);
                     m_rOuterFace.SetTextColor( pA->GetColor() );
                 }
                 break;
 
                 case( META_TEXTALIGN_ACTION ):
                 {
-                    const MetaTextAlignAction* pA = (const MetaTextAlignAction*) pAction;
+                    const MetaTextAlignAction* pA = static_cast<const MetaTextAlignAction*>(pAction);
                     m_rOuterFace.SetTextAlign( pA->GetTextAlign() );
                 }
                 break;
 
                 case( META_FONT_ACTION ):
                 {
-                    const MetaFontAction* pA = (const MetaFontAction*) pAction;
+                    const MetaFontAction* pA = static_cast<const MetaFontAction*>(pAction);
                     m_rOuterFace.SetFont( pA->GetFont() );
                 }
                 break;
 
                 case( META_PUSH_ACTION ):
                 {
-                    const MetaPushAction* pA = (const MetaPushAction*) pAction;
+                    const MetaPushAction* pA = static_cast<const MetaPushAction*>(pAction);
 
                     pDummyVDev->Push( pA->GetFlags() );
                     m_rOuterFace.Push( pA->GetFlags() );
@@ -1011,21 +1011,21 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
 
                 case( META_LAYOUTMODE_ACTION ):
                 {
-                    const MetaLayoutModeAction* pA = (const MetaLayoutModeAction*) pAction;
+                    const MetaLayoutModeAction* pA = static_cast<const MetaLayoutModeAction*>(pAction);
                     m_rOuterFace.SetLayoutMode( pA->GetLayoutMode() );
                 }
                 break;
 
                 case META_TEXTLANGUAGE_ACTION:
                 {
-                    const  MetaTextLanguageAction* pA = (const MetaTextLanguageAction*) pAction;
+                    const  MetaTextLanguageAction* pA = static_cast<const MetaTextLanguageAction*>(pAction);
                     m_rOuterFace.SetDigitLanguage( pA->GetTextLanguage() );
                 }
                 break;
 
                 case( META_WALLPAPER_ACTION ):
                 {
-                    const MetaWallpaperAction* pA = (const MetaWallpaperAction*) pAction;
+                    const MetaWallpaperAction* pA = static_cast<const MetaWallpaperAction*>(pAction);
                     m_rOuterFace.DrawWallpaper( pA->GetRect(), pA->GetWallpaper() );
                 }
                 break;
diff --git a/vcl/source/gdi/virdev.cxx b/vcl/source/gdi/virdev.cxx
index 67a931236e18..5e218c93aedd 100644
--- a/vcl/source/gdi/virdev.cxx
+++ b/vcl/source/gdi/virdev.cxx
@@ -176,7 +176,7 @@ void VirtualDevice::ImplInitVirDev( const OutputDevice* pOutDev,
     if ( pOutDev->GetOutDevType() == OUTDEV_PRINTER )
         mbScreenComp = false;
     else if ( pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
-        mbScreenComp = ((VirtualDevice*)pOutDev)->mbScreenComp;
+        mbScreenComp = static_cast<const VirtualDevice*>(pOutDev)->mbScreenComp;
 
     meOutDevType    = OUTDEV_VIRDEV;
     mbDevOutput     = true;