loplugin: cstylecast

Change-Id: I06957bb1a736331995be810672e9d47b47cc6c0e

drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx

@@ -61,7 +61,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const BackgroundColorPrimitive2D& rCompare = (BackgroundColorPrimitive2D&)rPrimitive;
+                const BackgroundColorPrimitive2D& rCompare = static_cast<const BackgroundColorPrimitive2D&>(rPrimitive);
 
                 return (getBColor() == rCompare.getBColor());
             }

drawinglayer/source/primitive2d/bitmapprimitive2d.cxx

@@ -44,7 +44,7 @@ namespace drawinglayer
         {
             if(BasePrimitive2D::operator==(rPrimitive))
             {
-                const BitmapPrimitive2D& rCompare = (BitmapPrimitive2D&)rPrimitive;
+                const BitmapPrimitive2D& rCompare = static_cast<const BitmapPrimitive2D&>(rPrimitive);
 
                 return (getBitmapEx() == rCompare.getBitmapEx()
                     && getTransform() == rCompare.getTransform());

drawinglayer/source/primitive2d/borderlineprimitive2d.cxx

@@ -342,7 +342,7 @@ primitive2d::Primitive2DReference makeSolidLinePrimitive(
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const BorderLinePrimitive2D& rCompare = (BorderLinePrimitive2D&)rPrimitive;
+                const BorderLinePrimitive2D& rCompare = static_cast<const BorderLinePrimitive2D&>(rPrimitive);
 
                 return (getStart() == rCompare.getStart()
                     && getEnd() == rCompare.getEnd()

drawinglayer/source/primitive2d/clippedborderlineprimitive2d.cxx

@@ -46,7 +46,7 @@ namespace drawinglayer
         {
             if(BorderLinePrimitive2D::operator==(rPrimitive))
             {
-                const ClippedBorderLinePrimitive2D& rCompare = (ClippedBorderLinePrimitive2D&)rPrimitive;
+                const ClippedBorderLinePrimitive2D& rCompare = static_cast<const ClippedBorderLinePrimitive2D&>(rPrimitive);
 
                 return maIntersection == rCompare.maIntersection;
             }

drawinglayer/source/primitive2d/discretebitmapprimitive2d.cxx

@@ -86,7 +86,7 @@ namespace drawinglayer
         {
             if(ObjectAndViewTransformationDependentPrimitive2D::operator==(rPrimitive))
             {
-                const DiscreteBitmapPrimitive2D& rCompare = (DiscreteBitmapPrimitive2D&)rPrimitive;
+                const DiscreteBitmapPrimitive2D& rCompare = static_cast<const DiscreteBitmapPrimitive2D&>(rPrimitive);
 
                 return (getBitmapEx() == rCompare.getBitmapEx()
                     && getTopLeft() == rCompare.getTopLeft());

drawinglayer/source/primitive2d/discreteshadowprimitive2d.cxx

@@ -285,7 +285,7 @@ namespace drawinglayer
         {
             if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
             {
-                const DiscreteShadowPrimitive2D& rCompare = (DiscreteShadowPrimitive2D&)rPrimitive;
+                const DiscreteShadowPrimitive2D& rCompare = static_cast<const DiscreteShadowPrimitive2D&>(rPrimitive);
 
                 return (getTransform() == rCompare.getTransform()
                     && getDiscreteShadow() == rCompare.getDiscreteShadow());

drawinglayer/source/primitive2d/epsprimitive2d.cxx

@@ -61,7 +61,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const EpsPrimitive2D& rCompare = (EpsPrimitive2D&)rPrimitive;
+                const EpsPrimitive2D& rCompare = static_cast<const EpsPrimitive2D&>(rPrimitive);
 
                 return (getEpsTransform() == rCompare.getEpsTransform()
                     && getGfxLink().IsEqual(rCompare.getGfxLink())

drawinglayer/source/primitive2d/fillgradientprimitive2d.cxx

@@ -328,7 +328,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const FillGradientPrimitive2D& rCompare = (FillGradientPrimitive2D&)rPrimitive;
+                const FillGradientPrimitive2D& rCompare = static_cast<const FillGradientPrimitive2D&>(rPrimitive);
 
                 return (getOutputRange() == rCompare.getOutputRange()
                     && getDefinitionRange() == rCompare.getDefinitionRange()

drawinglayer/source/primitive2d/fillhatchprimitive2d.cxx

@@ -168,7 +168,7 @@ namespace drawinglayer
         {
             if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
             {
-                const FillHatchPrimitive2D& rCompare = (FillHatchPrimitive2D&)rPrimitive;
+                const FillHatchPrimitive2D& rCompare = static_cast<const FillHatchPrimitive2D&>(rPrimitive);
 
                 return (getOutputRange() == rCompare.getOutputRange()
                     && getDefinitionRange() == rCompare.getDefinitionRange()

drawinglayer/source/primitive2d/gridprimitive2d.cxx

@@ -291,7 +291,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const GridPrimitive2D& rCompare = (GridPrimitive2D&)rPrimitive;
+                const GridPrimitive2D& rCompare = static_cast<const GridPrimitive2D&>(rPrimitive);
 
                 return (getTransform() == rCompare.getTransform()
                     && getWidth() == rCompare.getWidth()

drawinglayer/source/primitive2d/helplineprimitive2d.cxx

@@ -164,7 +164,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const HelplinePrimitive2D& rCompare = (HelplinePrimitive2D&)rPrimitive;
+                const HelplinePrimitive2D& rCompare = static_cast<const HelplinePrimitive2D&>(rPrimitive);
 
                 return (getPosition() == rCompare.getPosition()
                     && getDirection() == rCompare.getDirection()

drawinglayer/source/primitive2d/markerarrayprimitive2d.cxx

@@ -91,7 +91,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const MarkerArrayPrimitive2D& rCompare = (MarkerArrayPrimitive2D&)rPrimitive;
+                const MarkerArrayPrimitive2D& rCompare = static_cast<const MarkerArrayPrimitive2D&>(rPrimitive);
 
                 return (getPositions() == rCompare.getPositions()
                     && getMarker() == rCompare.getMarker());

drawinglayer/source/primitive2d/modifiedcolorprimitive2d.cxx

@@ -42,7 +42,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive2D::operator==(rPrimitive))
             {
-                const ModifiedColorPrimitive2D& rCompare = (ModifiedColorPrimitive2D&)rPrimitive;
+                const ModifiedColorPrimitive2D& rCompare = static_cast<const ModifiedColorPrimitive2D&>(rPrimitive);
 
                 if(getColorModifier().get() == rCompare.getColorModifier().get())
                 {

drawinglayer/source/primitive2d/objectinfoprimitive2d.cxx

@@ -41,7 +41,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive2D::operator==(rPrimitive))
             {
-                const ObjectInfoPrimitive2D& rCompare = (ObjectInfoPrimitive2D&)rPrimitive;
+                const ObjectInfoPrimitive2D& rCompare = static_cast<const ObjectInfoPrimitive2D&>(rPrimitive);
 
                 return (getName() == rCompare.getName()
                     && getTitle() == rCompare.getTitle()

drawinglayer/source/primitive2d/pointarrayprimitive2d.cxx

@@ -44,7 +44,7 @@ namespace drawinglayer
         {
             if(BasePrimitive2D::operator==(rPrimitive))
             {
-                const PointArrayPrimitive2D& rCompare = (PointArrayPrimitive2D&)rPrimitive;
+                const PointArrayPrimitive2D& rCompare = static_cast<const PointArrayPrimitive2D&>(rPrimitive);
 
                 return (getPositions() == rCompare.getPositions()
                     && getRGBColor() == rCompare.getRGBColor());

drawinglayer/source/primitive2d/polygonprimitive2d.cxx

@@ -50,7 +50,7 @@ namespace drawinglayer
         {
             if(BasePrimitive2D::operator==(rPrimitive))
             {
-                const PolygonHairlinePrimitive2D& rCompare = (PolygonHairlinePrimitive2D&)rPrimitive;
+                const PolygonHairlinePrimitive2D& rCompare = static_cast<const PolygonHairlinePrimitive2D&>(rPrimitive);
 
                 return (getB2DPolygon() == rCompare.getB2DPolygon()
                     && getBColor() == rCompare.getBColor());
@@ -143,7 +143,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolygonMarkerPrimitive2D& rCompare = (PolygonMarkerPrimitive2D&)rPrimitive;
+                const PolygonMarkerPrimitive2D& rCompare = static_cast<const PolygonMarkerPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolygon() == rCompare.getB2DPolygon()
                     && getRGBColorA() == rCompare.getRGBColorA()
@@ -321,7 +321,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolygonStrokePrimitive2D& rCompare = (PolygonStrokePrimitive2D&)rPrimitive;
+                const PolygonStrokePrimitive2D& rCompare = static_cast<const PolygonStrokePrimitive2D&>(rPrimitive);
 
                 return (getB2DPolygon() == rCompare.getB2DPolygon()
                     && getLineAttribute() == rCompare.getLineAttribute()
@@ -475,7 +475,7 @@ namespace drawinglayer
         {
             if(PolygonStrokePrimitive2D::operator==(rPrimitive))
             {
-                const PolygonWavePrimitive2D& rCompare = (PolygonWavePrimitive2D&)rPrimitive;
+                const PolygonWavePrimitive2D& rCompare = static_cast<const PolygonWavePrimitive2D&>(rPrimitive);
 
                 return (getWaveWidth() == rCompare.getWaveWidth()
                     && getWaveHeight() == rCompare.getWaveHeight());
@@ -619,7 +619,7 @@ namespace drawinglayer
         {
             if(PolygonStrokePrimitive2D::operator==(rPrimitive))
             {
-                const PolygonStrokeArrowPrimitive2D& rCompare = (PolygonStrokeArrowPrimitive2D&)rPrimitive;
+                const PolygonStrokeArrowPrimitive2D& rCompare = static_cast<const PolygonStrokeArrowPrimitive2D&>(rPrimitive);
 
                 return (getStart() == rCompare.getStart()
                     && getEnd() == rCompare.getEnd());

drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx

@@ -75,7 +75,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonHairlinePrimitive2D& rCompare = (PolyPolygonHairlinePrimitive2D&)rPrimitive;
+                const PolyPolygonHairlinePrimitive2D& rCompare = static_cast<const PolyPolygonHairlinePrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getBColor() == rCompare.getBColor());
@@ -146,7 +146,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonMarkerPrimitive2D& rCompare = (PolyPolygonMarkerPrimitive2D&)rPrimitive;
+                const PolyPolygonMarkerPrimitive2D& rCompare = static_cast<const PolyPolygonMarkerPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getRGBColorA() == rCompare.getRGBColorA()
@@ -224,7 +224,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonStrokePrimitive2D& rCompare = (PolyPolygonStrokePrimitive2D&)rPrimitive;
+                const PolyPolygonStrokePrimitive2D& rCompare = static_cast<const PolyPolygonStrokePrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getLineAttribute() == rCompare.getLineAttribute()
@@ -273,7 +273,7 @@ namespace drawinglayer
         {
             if(BasePrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonColorPrimitive2D& rCompare = (PolyPolygonColorPrimitive2D&)rPrimitive;
+                const PolyPolygonColorPrimitive2D& rCompare = static_cast<const PolyPolygonColorPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getBColor() == rCompare.getBColor());
@@ -350,7 +350,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonGradientPrimitive2D& rCompare = (PolyPolygonGradientPrimitive2D&)rPrimitive;
+                const PolyPolygonGradientPrimitive2D& rCompare = static_cast<const PolyPolygonGradientPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getDefinitionRange() == rCompare.getDefinitionRange()
@@ -427,7 +427,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonHatchPrimitive2D& rCompare = (PolyPolygonHatchPrimitive2D&)rPrimitive;
+                const PolyPolygonHatchPrimitive2D& rCompare = static_cast<const PolyPolygonHatchPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getDefinitionRange() == rCompare.getDefinitionRange()
@@ -556,7 +556,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonGraphicPrimitive2D& rCompare = (PolyPolygonGraphicPrimitive2D&)rPrimitive;
+                const PolyPolygonGraphicPrimitive2D& rCompare = static_cast<const PolyPolygonGraphicPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getDefinitionRange() == rCompare.getDefinitionRange()
@@ -642,7 +642,7 @@ namespace drawinglayer
         {
             if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
             {
-                const PolyPolygonSelectionPrimitive2D& rCompare = (PolyPolygonSelectionPrimitive2D&)rPrimitive;
+                const PolyPolygonSelectionPrimitive2D& rCompare = static_cast<const PolyPolygonSelectionPrimitive2D&>(rPrimitive);
 
                 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
                     && getColor() == rCompare.getColor()

drawinglayer/source/primitive2d/sceneprimitive2d.cxx

@@ -418,7 +418,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const ScenePrimitive2D& rCompare = (ScenePrimitive2D&)rPrimitive;
+                const ScenePrimitive2D& rCompare = static_cast<const ScenePrimitive2D&>(rPrimitive);
 
                 return (primitive3d::arePrimitive3DSequencesEqual(getChildren3D(), rCompare.getChildren3D())
                     && getSdrSceneAttribute() == rCompare.getSdrSceneAttribute()

drawinglayer/source/primitive2d/textdecoratedprimitive2d.cxx

@@ -362,7 +362,7 @@ namespace drawinglayer
         {
             if(TextSimplePortionPrimitive2D::operator==(rPrimitive))
             {
-                const TextDecoratedPortionPrimitive2D& rCompare = (TextDecoratedPortionPrimitive2D&)rPrimitive;
+                const TextDecoratedPortionPrimitive2D& rCompare = static_cast<const TextDecoratedPortionPrimitive2D&>(rPrimitive);
 
                 return (getOverlineColor() == rCompare.getOverlineColor()
                     && getTextlineColor() == rCompare.getTextlineColor()

drawinglayer/source/primitive2d/texteffectprimitive2d.cxx

@@ -200,7 +200,7 @@ namespace drawinglayer
         {
             if(BasePrimitive2D::operator==(rPrimitive))
             {
-                const TextEffectPrimitive2D& rCompare = (TextEffectPrimitive2D&)rPrimitive;
+                const TextEffectPrimitive2D& rCompare = static_cast<const TextEffectPrimitive2D&>(rPrimitive);
 
                 return (getTextContent() == rCompare.getTextContent()
                     && getRotationCenter() == rCompare.getRotationCenter()

drawinglayer/source/primitive2d/texthierarchyprimitive2d.cxx

@@ -112,7 +112,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive2D::operator==(rPrimitive))
             {
-                const TextHierarchyFieldPrimitive2D& rCompare = (TextHierarchyFieldPrimitive2D&)rPrimitive;
+                const TextHierarchyFieldPrimitive2D& rCompare = static_cast<const TextHierarchyFieldPrimitive2D&>(rPrimitive);
 
                 return (getType() == rCompare.getType()
                     &&  getString() == rCompare.getString());

drawinglayer/source/primitive2d/textlineprimitive2d.cxx

@@ -275,7 +275,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const TextLinePrimitive2D& rCompare = (TextLinePrimitive2D&)rPrimitive;
+                const TextLinePrimitive2D& rCompare = static_cast<const TextLinePrimitive2D&>(rPrimitive);
 
                 return (getObjectTransformation() == rCompare.getObjectTransformation()
                     && getWidth() == rCompare.getWidth()

drawinglayer/source/primitive2d/textprimitive2d.cxx

@@ -262,7 +262,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const TextSimplePortionPrimitive2D& rCompare = (TextSimplePortionPrimitive2D&)rPrimitive;
+                const TextSimplePortionPrimitive2D& rCompare = static_cast<const TextSimplePortionPrimitive2D&>(rPrimitive);
 
                 return (getTextTransform() == rCompare.getTextTransform()
                     && getText() == rCompare.getText()

drawinglayer/source/primitive2d/textstrikeoutprimitive2d.cxx

@@ -48,7 +48,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const BaseTextStrikeoutPrimitive2D& rCompare = (BaseTextStrikeoutPrimitive2D&)rPrimitive;
+                const BaseTextStrikeoutPrimitive2D& rCompare = static_cast<const BaseTextStrikeoutPrimitive2D&>(rPrimitive);
 
                 return (getObjectTransformation() == rCompare.getObjectTransformation()
                     && getWidth() == rCompare.getWidth()
@@ -129,7 +129,7 @@ namespace drawinglayer
         {
             if(BaseTextStrikeoutPrimitive2D::operator==(rPrimitive))
             {
-                const TextCharacterStrikeoutPrimitive2D& rCompare = (TextCharacterStrikeoutPrimitive2D&)rPrimitive;
+                const TextCharacterStrikeoutPrimitive2D& rCompare = static_cast<const TextCharacterStrikeoutPrimitive2D&>(rPrimitive);
 
                 return (getStrikeoutChar() == rCompare.getStrikeoutChar()
                     && getFontAttribute() == rCompare.getFontAttribute()
@@ -255,7 +255,7 @@ namespace drawinglayer
         {
             if(BaseTextStrikeoutPrimitive2D::operator==(rPrimitive))
             {
-                const TextGeometryStrikeoutPrimitive2D& rCompare = (TextGeometryStrikeoutPrimitive2D&)rPrimitive;
+                const TextGeometryStrikeoutPrimitive2D& rCompare = static_cast<const TextGeometryStrikeoutPrimitive2D&>(rPrimitive);
 
                 return (getHeight() == rCompare.getHeight()
                     && getOffset() == rCompare.getOffset()

drawinglayer/source/primitive2d/transparenceprimitive2d.cxx

@@ -42,7 +42,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive2D::operator==(rPrimitive))
             {
-                const TransparencePrimitive2D& rCompare = (TransparencePrimitive2D&)rPrimitive;
+                const TransparencePrimitive2D& rCompare = static_cast<const TransparencePrimitive2D&>(rPrimitive);
 
                 return (getTransparence() == rCompare.getTransparence());
             }

drawinglayer/source/primitive2d/unifiedtransparenceprimitive2d.cxx

@@ -48,7 +48,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive2D::operator==(rPrimitive))
             {
-                const UnifiedTransparencePrimitive2D& rCompare = (UnifiedTransparencePrimitive2D&)rPrimitive;
+                const UnifiedTransparencePrimitive2D& rCompare = static_cast<const UnifiedTransparencePrimitive2D&>(rPrimitive);
 
                 return (getTransparence() == rCompare.getTransparence());
             }

drawinglayer/source/primitive2d/wallpaperprimitive2d.cxx

@@ -233,7 +233,7 @@ namespace drawinglayer
         {
             if(ViewTransformationDependentPrimitive2D::operator==(rPrimitive))
             {
-                const WallpaperBitmapPrimitive2D& rCompare = (WallpaperBitmapPrimitive2D&)rPrimitive;
+                const WallpaperBitmapPrimitive2D& rCompare = static_cast<const WallpaperBitmapPrimitive2D&>(rPrimitive);
 
                 return (getLocalObjectRange() == rCompare.getLocalObjectRange()
                     && getBitmapEx() == rCompare.getBitmapEx()

drawinglayer/source/primitive2d/wrongspellprimitive2d.cxx

@@ -90,7 +90,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
             {
-                const WrongSpellPrimitive2D& rCompare = (WrongSpellPrimitive2D&)rPrimitive;
+                const WrongSpellPrimitive2D& rCompare = static_cast<const WrongSpellPrimitive2D&>(rPrimitive);
 
                 return (getTransformation() == rCompare.getTransformation()
                     && getStart() == rCompare.getStart()

drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx

@@ -292,7 +292,7 @@ namespace drawinglayer
         {
             if(TexturePrimitive3D::operator==(rPrimitive))
             {
-                const HatchTexturePrimitive3D& rCompare = (HatchTexturePrimitive3D&)rPrimitive;
+                const HatchTexturePrimitive3D& rCompare = static_cast<const HatchTexturePrimitive3D&>(rPrimitive);
 
                 return (getHatch() == rCompare.getHatch());
             }

drawinglayer/source/primitive3d/modifiedcolorprimitive3d.cxx

@@ -42,7 +42,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive3D::operator==(rPrimitive))
             {
-                const ModifiedColorPrimitive3D& rCompare = (ModifiedColorPrimitive3D&)rPrimitive;
+                const ModifiedColorPrimitive3D& rCompare = static_cast<const ModifiedColorPrimitive3D&>(rPrimitive);
 
                 if(getColorModifier().get() == rCompare.getColorModifier().get())
                 {

drawinglayer/source/primitive3d/polygonprimitive3d.cxx

@@ -47,7 +47,7 @@ namespace drawinglayer
         {
             if(BasePrimitive3D::operator==(rPrimitive))
             {
-                const PolygonHairlinePrimitive3D& rCompare = (PolygonHairlinePrimitive3D&)rPrimitive;
+                const PolygonHairlinePrimitive3D& rCompare = static_cast<const PolygonHairlinePrimitive3D&>(rPrimitive);
 
                 return (getB3DPolygon() == rCompare.getB3DPolygon()
                     && getBColor() == rCompare.getBColor());
@@ -144,7 +144,7 @@ namespace drawinglayer
         {
             if(BufferedDecompositionPrimitive3D::operator==(rPrimitive))
             {
-                const PolygonStrokePrimitive3D& rCompare = (PolygonStrokePrimitive3D&)rPrimitive;
+                const PolygonStrokePrimitive3D& rCompare = static_cast<const PolygonStrokePrimitive3D&>(rPrimitive);
 
                 return (getB3DPolygon() == rCompare.getB3DPolygon()
                     && getLineAttribute() == rCompare.getLineAttribute()

drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx

@@ -761,7 +761,7 @@ namespace drawinglayer
         {
             if(PolygonHairlinePrimitive3D::operator==(rPrimitive))
             {
-                const PolygonTubePrimitive3D& rCompare = (PolygonTubePrimitive3D&)rPrimitive;
+                const PolygonTubePrimitive3D& rCompare = static_cast<const PolygonTubePrimitive3D&>(rPrimitive);
 
                 return (getRadius() == rCompare.getRadius()
                     && getDegreeStepWidth() == rCompare.getDegreeStepWidth()

drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx

@@ -47,7 +47,7 @@ namespace drawinglayer
         {
             if(BasePrimitive3D::operator==(rPrimitive))
             {
-                const PolyPolygonMaterialPrimitive3D& rCompare = (PolyPolygonMaterialPrimitive3D&)rPrimitive;
+                const PolyPolygonMaterialPrimitive3D& rCompare = static_cast<const PolyPolygonMaterialPrimitive3D&>(rPrimitive);
 
                 return (getB3DPolyPolygon() == rCompare.getB3DPolyPolygon()
                     && getMaterial() == rCompare.getMaterial()

drawinglayer/source/primitive3d/shadowprimitive3d.cxx

@@ -48,7 +48,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive3D::operator==(rPrimitive))
             {
-                const ShadowPrimitive3D& rCompare = (ShadowPrimitive3D&)rPrimitive;
+                const ShadowPrimitive3D& rCompare = static_cast<const ShadowPrimitive3D&>(rPrimitive);
 
                 return (getShadowTransform() == rCompare.getShadowTransform()
                     && getShadowColor() == rCompare.getShadowColor()

drawinglayer/source/primitive3d/textureprimitive3d.cxx

@@ -46,7 +46,7 @@ namespace drawinglayer
         {
             if(GroupPrimitive3D::operator==(rPrimitive))
             {
-                const TexturePrimitive3D& rCompare = (TexturePrimitive3D&)rPrimitive;
+                const TexturePrimitive3D& rCompare = static_cast<const TexturePrimitive3D&>(rPrimitive);
 
                 return (getModulate() == rCompare.getModulate()
                     && getFilter() == rCompare.getFilter());
@@ -75,7 +75,7 @@ namespace drawinglayer
         {
             if(TexturePrimitive3D::operator==(rPrimitive))
             {
-                const UnifiedTransparenceTexturePrimitive3D& rCompare = (UnifiedTransparenceTexturePrimitive3D&)rPrimitive;
+                const UnifiedTransparenceTexturePrimitive3D& rCompare = static_cast<const UnifiedTransparenceTexturePrimitive3D&>(rPrimitive);
 
                 return (getTransparence() == rCompare.getTransparence());
             }
@@ -139,7 +139,7 @@ namespace drawinglayer
         {
             if(TexturePrimitive3D::operator==(rPrimitive))
             {
-                const GradientTexturePrimitive3D& rCompare = (GradientTexturePrimitive3D&)rPrimitive;
+                const GradientTexturePrimitive3D& rCompare = static_cast<const GradientTexturePrimitive3D&>(rPrimitive);
 
                 return (getGradient() == rCompare.getGradient());
             }
@@ -173,7 +173,7 @@ namespace drawinglayer
         {
             if(TexturePrimitive3D::operator==(rPrimitive))
             {
-                const BitmapTexturePrimitive3D& rCompare = (BitmapTexturePrimitive3D&)rPrimitive;
+                const BitmapTexturePrimitive3D& rCompare = static_cast<const BitmapTexturePrimitive3D&>(rPrimitive);
 
                 return (getFillGraphicAttribute() == rCompare.getFillGraphicAttribute());
             }