Replace "SAL_OVERRIDE" with "override" in LIBO_INTERNAL_ONLY code

Change-Id: I2ea407acd763ef2d7dae2d3b8f32525523ac8274

1 files changed, 45 insertions, 45 deletions

diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index b4540537f423..19e02009b567 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -102,134 +102,134 @@ public:
 
     explicit X11SalGraphicsImpl(X11SalGraphics& rParent);
 
-    virtual void freeResources() SAL_OVERRIDE;
+    virtual void freeResources() override;
 
     virtual ~X11SalGraphicsImpl();
 
-    virtual bool setClipRegion( const vcl::Region& ) SAL_OVERRIDE;
+    virtual bool setClipRegion( const vcl::Region& ) override;
     //
     // get the depth of the device
-    virtual sal_uInt16 GetBitCount() const SAL_OVERRIDE;
+    virtual sal_uInt16 GetBitCount() const override;
 
     // get the width of the device
-    virtual long GetGraphicsWidth() const SAL_OVERRIDE;
+    virtual long GetGraphicsWidth() const override;
 
     // set the clip region to empty
-    virtual void ResetClipRegion() SAL_OVERRIDE;
+    virtual void ResetClipRegion() override;
 
     // set the line color to transparent (= don't draw lines)
 
-    virtual void SetLineColor() SAL_OVERRIDE;
+    virtual void SetLineColor() override;
 
     // set the line color to a specific color
-    virtual void SetLineColor( SalColor nSalColor ) SAL_OVERRIDE;
+    virtual void SetLineColor( SalColor nSalColor ) override;
 
     // set the fill color to transparent (= don't fill)
-    virtual void SetFillColor() SAL_OVERRIDE;
+    virtual void SetFillColor() override;
 
     // set the fill color to a specific color, shapes will be
     // filled accordingly
-    virtual void SetFillColor( SalColor nSalColor ) SAL_OVERRIDE;
+    virtual void SetFillColor( SalColor nSalColor ) override;
 
     // enable/disable XOR drawing
-    virtual void SetXORMode( bool bSet, bool bInvertOnly ) SAL_OVERRIDE;
+    virtual void SetXORMode( bool bSet, bool bInvertOnly ) override;
 
     // set line color for raster operations
-    virtual void SetROPLineColor( SalROPColor nROPColor ) SAL_OVERRIDE;
+    virtual void SetROPLineColor( SalROPColor nROPColor ) override;
 
     // set fill color for raster operations
-    virtual void SetROPFillColor( SalROPColor nROPColor ) SAL_OVERRIDE;
+    virtual void SetROPFillColor( SalROPColor nROPColor ) override;
 
     // draw --> LineColor and FillColor and RasterOp and ClipRegion
-    virtual void drawPixel( long nX, long nY ) SAL_OVERRIDE;
-    virtual void drawPixel( long nX, long nY, SalColor nSalColor ) SAL_OVERRIDE;
+    virtual void drawPixel( long nX, long nY ) override;
+    virtual void drawPixel( long nX, long nY, SalColor nSalColor ) override;
 
-    virtual void drawLine( long nX1, long nY1, long nX2, long nY2 ) SAL_OVERRIDE;
+    virtual void drawLine( long nX1, long nY1, long nX2, long nY2 ) override;
 
-    virtual void drawRect( long nX, long nY, long nWidth, long nHeight ) SAL_OVERRIDE;
+    virtual void drawRect( long nX, long nY, long nWidth, long nHeight ) override;
 
-    virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) SAL_OVERRIDE;
+    virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 
-    virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) SAL_OVERRIDE;
+    virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 
-    virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) SAL_OVERRIDE;
-    virtual bool drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) SAL_OVERRIDE;
+    virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
+    virtual bool drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
 
     virtual bool drawPolyLine(
                 const ::basegfx::B2DPolygon&,
                 double fTransparency,
                 const ::basegfx::B2DVector& rLineWidths,
                 basegfx::B2DLineJoin,
-                com::sun::star::drawing::LineCap) SAL_OVERRIDE;
+                com::sun::star::drawing::LineCap) override;
 
     virtual bool drawPolyLineBezier(
                 sal_uInt32 nPoints,
                 const SalPoint* pPtAry,
-                const sal_uInt8* pFlgAry ) SAL_OVERRIDE;
+                const sal_uInt8* pFlgAry ) override;
 
     virtual bool drawPolygonBezier(
                 sal_uInt32 nPoints,
                 const SalPoint* pPtAry,
-                const sal_uInt8* pFlgAry ) SAL_OVERRIDE;
+                const sal_uInt8* pFlgAry ) override;
 
     virtual bool drawPolyPolygonBezier(
                 sal_uInt32 nPoly,
                 const sal_uInt32* pPoints,
                 const SalPoint* const* pPtAry,
-                const sal_uInt8* const* pFlgAry ) SAL_OVERRIDE;
+                const sal_uInt8* const* pFlgAry ) override;
 
     // CopyArea --> No RasterOp, but ClipRegion
     virtual void copyArea(
                 long nDestX, long nDestY,
                 long nSrcX, long nSrcY,
                 long nSrcWidth, long nSrcHeight,
-                sal_uInt16 nFlags ) SAL_OVERRIDE;
+                sal_uInt16 nFlags ) override;
 
     // CopyBits and DrawBitmap --> RasterOp and ClipRegion
     // CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics
-    virtual void copyBits( const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics ) SAL_OVERRIDE;
+    virtual void copyBits( const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics ) override;
 
-    virtual void drawBitmap( const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap ) SAL_OVERRIDE;
+    virtual void drawBitmap( const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap ) override;
 
     virtual void drawBitmap(
                 const SalTwoRect& rPosAry,
                 const SalBitmap& rSalBitmap,
-                const SalBitmap& rMaskBitmap ) SAL_OVERRIDE;
+                const SalBitmap& rMaskBitmap ) override;
 
     virtual void drawMask(
                 const SalTwoRect& rPosAry,
                 const SalBitmap& rSalBitmap,
-                SalColor nMaskColor ) SAL_OVERRIDE;
+                SalColor nMaskColor ) override;
 
-    virtual SalBitmap* getBitmap( long nX, long nY, long nWidth, long nHeight ) SAL_OVERRIDE;
+    virtual SalBitmap* getBitmap( long nX, long nY, long nWidth, long nHeight ) override;
 
-    virtual SalColor getPixel( long nX, long nY ) SAL_OVERRIDE;
+    virtual SalColor getPixel( long nX, long nY ) override;
 
     // invert --> ClipRegion (only Windows or VirDevs)
     virtual void invert(
                 long nX, long nY,
                 long nWidth, long nHeight,
-                SalInvert nFlags) SAL_OVERRIDE;
+                SalInvert nFlags) override;
 
-    virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert nFlags ) SAL_OVERRIDE;
+    virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert nFlags ) override;
 
     virtual bool drawEPS(
                 long nX, long nY,
                 long nWidth, long nHeight,
                 void* pPtr,
-                sal_uLong nSize ) SAL_OVERRIDE;
+                sal_uLong nSize ) override;
 
     /** Blend bitmap with color channels */
     virtual bool blendBitmap(
                 const SalTwoRect&,
-                const SalBitmap& rBitmap ) SAL_OVERRIDE;
+                const SalBitmap& rBitmap ) override;
 
     /** Render bitmap by blending using the mask and alpha channel */
     virtual bool blendAlphaBitmap(
                 const SalTwoRect&,
                 const SalBitmap& rSrcBitmap,
                 const SalBitmap& rMaskBitmap,
-                const SalBitmap& rAlphaBitmap ) SAL_OVERRIDE;
+                const SalBitmap& rAlphaBitmap ) override;
 
     /** Render bitmap with alpha channel
 
@@ -246,7 +246,7 @@ public:
     virtual bool drawAlphaBitmap(
                 const SalTwoRect&,
                 const SalBitmap& rSourceBitmap,
-                const SalBitmap& rAlphaBitmap ) SAL_OVERRIDE;
+                const SalBitmap& rAlphaBitmap ) override;
 
     /** draw transformed bitmap (maybe with alpha) where Null, X, Y define the coordinate system */
     virtual bool drawTransformedBitmap(
@@ -254,7 +254,7 @@ public:
                 const basegfx::B2DPoint& rX,
                 const basegfx::B2DPoint& rY,
                 const SalBitmap& rSourceBitmap,
-                const SalBitmap* pAlphaBitmap) SAL_OVERRIDE;
+                const SalBitmap* pAlphaBitmap) override;
 
     /** Render solid rectangle with given transparency
 
@@ -265,21 +265,21 @@ public:
     virtual bool drawAlphaRect(
                     long nX, long nY,
                     long nWidth, long nHeight,
-                    sal_uInt8 nTransparency ) SAL_OVERRIDE;
+                    sal_uInt8 nTransparency ) override;
 
-    virtual bool drawGradient(const tools::PolyPolygon& rPolygon, const Gradient& rGradient) SAL_OVERRIDE;
+    virtual bool drawGradient(const tools::PolyPolygon& rPolygon, const Gradient& rGradient) override;
 
 public:
     // implementation of X11GraphicsImpl
 
-    void Init() SAL_OVERRIDE;
-    bool FillPixmapFromScreen( X11Pixmap* pPixmap, int nX, int nY ) SAL_OVERRIDE;
-    bool RenderPixmapToScreen( X11Pixmap* pPixmap, X11Pixmap* pMask, int nX, int nY ) SAL_OVERRIDE;
+    void Init() override;
+    bool FillPixmapFromScreen( X11Pixmap* pPixmap, int nX, int nY ) override;
+    bool RenderPixmapToScreen( X11Pixmap* pPixmap, X11Pixmap* pMask, int nX, int nY ) override;
 
     virtual bool TryRenderCachedNativeControl(ControlCacheKey& rControlCacheKey,
-                                              int nX, int nY) SAL_OVERRIDE;
+                                              int nX, int nY) override;
     virtual bool RenderAndCacheNativeControl(X11Pixmap* pPixmap, X11Pixmap* pMask, int nX, int nY,
-                                             ControlCacheKey& aControlCacheKey) SAL_OVERRIDE;
+                                             ControlCacheKey& aControlCacheKey) override;
 };
 
 #endif