vcl: remove "Impl" prefix for method names in ImpGraphic

Change-Id: I86b63815d30100395181e5a6e9d343d2b7228c13
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/109460
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <quikee@gmail.com>

5 files changed, 123 insertions, 123 deletions

diff --git a/vcl/source/filter/graphicfilter.cxx b/vcl/source/filter/graphicfilter.cxx
index 51ba7859f7ac..36290a229f36 100644
--- a/vcl/source/filter/graphicfilter.cxx
+++ b/vcl/source/filter/graphicfilter.cxx
@@ -1419,7 +1419,7 @@ Graphic GraphicFilter::ImportUnloadedGraphic(SvStream& rIStream, sal_uInt64 size
                 }
             }
             aGraphic.SetGfxLink(std::make_shared<GfxLink>(std::move(pGraphicContent), nGraphicContentSize, eLinkType));
-            aGraphic.ImplGetImpGraphic()->ImplSetPrepared(bAnimated, pSizeHint);
+            aGraphic.ImplGetImpGraphic()->setPrepared(bAnimated, pSizeHint);
         }
     }
 
diff --git a/vcl/source/gdi/graph.cxx b/vcl/source/gdi/graph.cxx
index bd59be143d5a..033e5576ce20 100644
--- a/vcl/source/gdi/graph.cxx
+++ b/vcl/source/gdi/graph.cxx
@@ -277,69 +277,69 @@ bool Graphic::operator!=( const Graphic& rGraphic ) const
 
 bool Graphic::IsNone() const
 {
-    return GraphicType::NONE == mxImpGraphic->ImplGetType();
+    return GraphicType::NONE == mxImpGraphic->getType();
 }
 
 void Graphic::Clear()
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplClear();
+    mxImpGraphic->clear();
 }
 
 GraphicType Graphic::GetType() const
 {
-    return mxImpGraphic->ImplGetType();
+    return mxImpGraphic->getType();
 }
 
 void Graphic::SetDefaultType()
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplSetDefaultType();
+    mxImpGraphic->setDefaultType();
 }
 
 bool Graphic::IsSupportedGraphic() const
 {
-    return mxImpGraphic->ImplIsSupportedGraphic();
+    return mxImpGraphic->isSupportedGraphic();
 }
 
 bool Graphic::IsTransparent() const
 {
-    return mxImpGraphic->ImplIsTransparent();
+    return mxImpGraphic->isTransparent();
 }
 
 bool Graphic::IsAlpha() const
 {
-    return mxImpGraphic->ImplIsAlpha();
+    return mxImpGraphic->isAlpha();
 }
 
 bool Graphic::IsAnimated() const
 {
-    return mxImpGraphic->ImplIsAnimated();
+    return mxImpGraphic->isAnimated();
 }
 
 bool Graphic::IsEPS() const
 {
-    return mxImpGraphic->ImplIsEPS();
+    return mxImpGraphic->isEPS();
 }
 
 BitmapEx Graphic::GetBitmapEx(const GraphicConversionParameters& rParameters) const
 {
-    return mxImpGraphic->ImplGetBitmapEx(rParameters);
+    return mxImpGraphic->getBitmapEx(rParameters);
 }
 
 Animation Graphic::GetAnimation() const
 {
-    return mxImpGraphic->ImplGetAnimation();
+    return mxImpGraphic->getAnimation();
 }
 
 const GDIMetaFile& Graphic::GetGDIMetaFile() const
 {
-    return mxImpGraphic->ImplGetGDIMetaFile();
+    return mxImpGraphic->getGDIMetaFile();
 }
 
 const BitmapEx& Graphic::GetBitmapExRef() const
 {
-    return mxImpGraphic->ImplGetBitmapExRef();
+    return mxImpGraphic->getBitmapExRef();
 }
 
 uno::Reference<graphic::XGraphic> Graphic::GetXGraphic() const
@@ -358,24 +358,24 @@ uno::Reference<graphic::XGraphic> Graphic::GetXGraphic() const
 
 Size Graphic::GetPrefSize() const
 {
-    return mxImpGraphic->ImplGetPrefSize();
+    return mxImpGraphic->getPrefSize();
 }
 
 void Graphic::SetPrefSize( const Size& rPrefSize )
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplSetPrefSize( rPrefSize );
+    mxImpGraphic->setPrefSize( rPrefSize );
 }
 
 MapMode Graphic::GetPrefMapMode() const
 {
-    return mxImpGraphic->ImplGetPrefMapMode();
+    return mxImpGraphic->getPrefMapMode();
 }
 
 void Graphic::SetPrefMapMode( const MapMode& rPrefMapMode )
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplSetPrefMapMode( rPrefMapMode );
+    mxImpGraphic->setPrefMapMode( rPrefMapMode );
 }
 
 basegfx::B2DSize Graphic::GetPPI() const
@@ -406,8 +406,8 @@ Size Graphic::GetSizePixel( const OutputDevice* pRefDevice ) const
 {
     Size aRet;
 
-    if( GraphicType::Bitmap == mxImpGraphic->ImplGetType() )
-        aRet = mxImpGraphic->ImplGetSizePixel();
+    if( GraphicType::Bitmap == mxImpGraphic->getType() )
+        aRet = mxImpGraphic->getSizePixel();
     else
         aRet = ( pRefDevice ? pRefDevice : Application::GetDefaultDevice() )->LogicToPixel( GetPrefSize(), GetPrefMapMode() );
 
@@ -416,21 +416,21 @@ Size Graphic::GetSizePixel( const OutputDevice* pRefDevice ) const
 
 sal_uLong Graphic::GetSizeBytes() const
 {
-    return mxImpGraphic->ImplGetSizeBytes();
+    return mxImpGraphic->getSizeBytes();
 }
 
 void Graphic::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
 {
-    mxImpGraphic->ImplDraw( pOutDev, rDestPt );
+    mxImpGraphic->draw( pOutDev, rDestPt );
 }
 
 void Graphic::Draw( OutputDevice* pOutDev,
                     const Point& rDestPt, const Size& rDestSz ) const
 {
-    if( GraphicType::Default == mxImpGraphic->ImplGetType() )
+    if( GraphicType::Default == mxImpGraphic->getType() )
         ImplDrawDefault( pOutDev, nullptr, nullptr, nullptr, rDestPt, rDestSz );
     else
-        mxImpGraphic->ImplDraw( pOutDev, rDestPt, rDestSz );
+        mxImpGraphic->draw( pOutDev, rDestPt, rDestSz );
 }
 
 void Graphic::DrawEx( OutputDevice* pOutDev, const OUString& rText,
@@ -445,74 +445,74 @@ void Graphic::StartAnimation( OutputDevice* pOutDev, const Point& rDestPt,
                               OutputDevice* pFirstFrameOutDev )
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplStartAnimation( pOutDev, rDestPt, rDestSz, nExtraData, pFirstFrameOutDev );
+    mxImpGraphic->startAnimation( pOutDev, rDestPt, rDestSz, nExtraData, pFirstFrameOutDev );
 }
 
 void Graphic::StopAnimation( const OutputDevice* pOutDev, tools::Long nExtraData )
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplStopAnimation( pOutDev, nExtraData );
+    mxImpGraphic->stopAnimation( pOutDev, nExtraData );
 }
 
 void Graphic::SetAnimationNotifyHdl( const Link<Animation*,void>& rLink )
 {
-    mxImpGraphic->ImplSetAnimationNotifyHdl( rLink );
+    mxImpGraphic->setAnimationNotifyHdl( rLink );
 }
 
 Link<Animation*,void> Graphic::GetAnimationNotifyHdl() const
 {
-    return mxImpGraphic->ImplGetAnimationNotifyHdl();
+    return mxImpGraphic->getAnimationNotifyHdl();
 }
 
 sal_uInt32 Graphic::GetAnimationLoopCount() const
 {
-    return mxImpGraphic->ImplGetAnimationLoopCount();
+    return mxImpGraphic->getAnimationLoopCount();
 }
 
 std::shared_ptr<GraphicReader>& Graphic::GetReaderContext()
 {
-    return mxImpGraphic->ImplGetContext();
+    return mxImpGraphic->getContext();
 }
 
 void Graphic::SetReaderContext( const std::shared_ptr<GraphicReader> &pReader )
 {
-    mxImpGraphic->ImplSetContext( pReader );
+    mxImpGraphic->setContext( pReader );
 }
 
 void Graphic::SetDummyContext( bool value )
 {
-    mxImpGraphic->ImplSetDummyContext( value );
+    mxImpGraphic->setDummyContext( value );
 }
 
 bool Graphic::IsDummyContext() const
 {
-    return mxImpGraphic->ImplIsDummyContext();
+    return mxImpGraphic->isDummyContext();
 }
 
 void Graphic::SetGfxLink( const std::shared_ptr<GfxLink>& rGfxLink )
 {
     ImplTestRefCount();
-    mxImpGraphic->ImplSetLink( rGfxLink );
+    mxImpGraphic->setGfxLink(rGfxLink);
 }
 
 std::shared_ptr<GfxLink> Graphic::GetSharedGfxLink() const
 {
-    return mxImpGraphic->ImplGetSharedGfxLink();
+    return mxImpGraphic->getSharedGfxLink();
 }
 
 GfxLink Graphic::GetGfxLink() const
 {
-    return mxImpGraphic->ImplGetLink();
+    return mxImpGraphic->getGfxLink();
 }
 
 bool Graphic::IsGfxLink() const
 {
-    return mxImpGraphic->ImplIsLink();
+    return mxImpGraphic->isGfxLink();
 }
 
 BitmapChecksum Graphic::GetChecksum() const
 {
-    return mxImpGraphic->ImplGetChecksum();
+    return mxImpGraphic->getChecksum();
 }
 
 const std::shared_ptr<VectorGraphicData>& Graphic::getVectorGraphicData() const
diff --git a/vcl/source/gdi/impgraph.cxx b/vcl/source/gdi/impgraph.cxx
index fe296fc510cf..1e56e57a8226 100644
--- a/vcl/source/gdi/impgraph.cxx
+++ b/vcl/source/gdi/impgraph.cxx
@@ -126,7 +126,7 @@ ImpGraphic::ImpGraphic(ImpGraphic&& rImpGraphic) noexcept
     , maLastUsed (std::chrono::high_resolution_clock::now())
     , mbPrepared (rImpGraphic.mbPrepared)
 {
-    rImpGraphic.ImplClear();
+    rImpGraphic.clear();
     rImpGraphic.mbDummyContext = false;
 }
 
@@ -252,7 +252,7 @@ ImpGraphic& ImpGraphic::operator=(ImpGraphic&& rImpGraphic)
     maGraphicExternalLink = rImpGraphic.maGraphicExternalLink;
     mbPrepared = rImpGraphic.mbPrepared;
 
-    rImpGraphic.ImplClear();
+    rImpGraphic.clear();
     rImpGraphic.mbDummyContext = false;
     maLastUsed = std::chrono::high_resolution_clock::now();
 
@@ -333,18 +333,18 @@ void ImpGraphic::createSwapInfo()
     if (isSwappedOut())
         return;
 
-    maSwapInfo.maSizePixel = ImplGetSizePixel();
-    maSwapInfo.maPrefMapMode = ImplGetPrefMapMode();
-    maSwapInfo.maPrefSize = ImplGetPrefSize();
-    maSwapInfo.mbIsAnimated = ImplIsAnimated();
-    maSwapInfo.mbIsEPS = ImplIsEPS();
-    maSwapInfo.mbIsTransparent = ImplIsTransparent();
-    maSwapInfo.mbIsAlpha = ImplIsAlpha();
-    maSwapInfo.mnAnimationLoopCount = ImplGetAnimationLoopCount();
+    maSwapInfo.maSizePixel = getSizePixel();
+    maSwapInfo.maPrefMapMode = getPrefMapMode();
+    maSwapInfo.maPrefSize = getPrefSize();
+    maSwapInfo.mbIsAnimated = isAnimated();
+    maSwapInfo.mbIsEPS = isEPS();
+    maSwapInfo.mbIsTransparent = isTransparent();
+    maSwapInfo.mbIsAlpha = isAlpha();
+    maSwapInfo.mnAnimationLoopCount = getAnimationLoopCount();
     maSwapInfo.mnPageIndex = getPageNumber();
 }
 
-void ImpGraphic::ImplClearGraphics()
+void ImpGraphic::clearGraphics()
 {
     maBitmapEx.Clear();
     maMetaFile.Clear();
@@ -352,7 +352,7 @@ void ImpGraphic::ImplClearGraphics()
     maVectorGraphicData.reset();
 }
 
-void ImpGraphic::ImplSetPrepared(bool bAnimated, const Size* pSizeHint)
+void ImpGraphic::setPrepared(bool bAnimated, const Size* pSizeHint)
 {
     mbPrepared = true;
     mbSwapOut = true;
@@ -403,14 +403,14 @@ void ImpGraphic::ImplSetPrepared(bool bAnimated, const Size* pSizeHint)
         maSwapInfo.mnPageIndex = maVectorGraphicData->getPageIndex();
 }
 
-void ImpGraphic::ImplClear()
+void ImpGraphic::clear()
 {
     mpSwapFile.reset();
     mbSwapOut = false;
     mbPrepared = false;
 
     // cleanup
-    ImplClearGraphics();
+    clearGraphics();
     meType = GraphicType::NONE;
     sal_Int64 nOldSize = mnSizeBytes;
     mnSizeBytes = 0;
@@ -418,18 +418,18 @@ void ImpGraphic::ImplClear()
     maGraphicExternalLink.msURL.clear();
 }
 
-void ImpGraphic::ImplSetDefaultType()
+void ImpGraphic::setDefaultType()
 {
-    ImplClear();
+    clear();
     meType = GraphicType::Default;
 }
 
-bool ImpGraphic::ImplIsSupportedGraphic() const
+bool ImpGraphic::isSupportedGraphic() const
 {
     return( meType != GraphicType::NONE );
 }
 
-bool ImpGraphic::ImplIsTransparent() const
+bool ImpGraphic::isTransparent() const
 {
     bool bRet(true);
 
@@ -445,7 +445,7 @@ bool ImpGraphic::ImplIsTransparent() const
     return bRet;
 }
 
-bool ImpGraphic::ImplIsAlpha() const
+bool ImpGraphic::isAlpha() const
 {
     bool bRet(false);
 
@@ -465,12 +465,12 @@ bool ImpGraphic::ImplIsAlpha() const
     return bRet;
 }
 
-bool ImpGraphic::ImplIsAnimated() const
+bool ImpGraphic::isAnimated() const
 {
     return mbSwapOut ? maSwapInfo.mbIsAnimated : mpAnimation != nullptr;
 }
 
-bool ImpGraphic::ImplIsEPS() const
+bool ImpGraphic::isEPS() const
 {
     if (mbSwapOut)
         return maSwapInfo.mbIsEPS;
@@ -502,7 +502,7 @@ BitmapEx ImpGraphic::getVectorGraphicReplacement() const
     return aRet;
 }
 
-Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters) const
+Bitmap ImpGraphic::getBitmap(const GraphicConversionParameters& rParameters) const
 {
     Bitmap aRetBmp;
 
@@ -523,7 +523,7 @@ Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters)
         if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
             aRetBmp.Scale(rParameters.getSizePixel());
     }
-    else if( ( meType != GraphicType::Default ) && ImplIsSupportedGraphic() )
+    else if( ( meType != GraphicType::Default ) && isSupportedGraphic() )
     {
         if(maBitmapEx.IsEmpty())
         {
@@ -559,7 +559,7 @@ Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters)
             // need to be extended when hairlines are on the right or bottom edge
             Size aPixelSize(aDrawSize);
 
-            if(GraphicType::GdiMetafile == ImplGetType())
+            if(GraphicType::GdiMetafile == getType())
             {
                 // get hairline and full bound rect
                 tools::Rectangle aHairlineRect;
@@ -592,7 +592,7 @@ Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters)
                     aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::PixelSnapHairline);
                 }
 
-                ImplDraw( aVDev.get(), Point(), aDrawSize );
+                draw( aVDev.get(), Point(), aDrawSize );
 
                 // use maBitmapEx as local buffer for rendered metafile
                 const_cast< ImpGraphic* >(this)->maBitmapEx = aVDev->GetBitmapEx( Point(), aVDev->GetOutputSizePixel() );
@@ -604,14 +604,14 @@ Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters)
 
     if( !!aRetBmp )
     {
-        aRetBmp.SetPrefMapMode( ImplGetPrefMapMode() );
-        aRetBmp.SetPrefSize( ImplGetPrefSize() );
+        aRetBmp.SetPrefMapMode(getPrefMapMode());
+        aRetBmp.SetPrefSize(getPrefSize());
     }
 
     return aRetBmp;
 }
 
-BitmapEx ImpGraphic::ImplGetBitmapEx(const GraphicConversionParameters& rParameters) const
+BitmapEx ImpGraphic::getBitmapEx(const GraphicConversionParameters& rParameters) const
 {
     BitmapEx aRetBmpEx;
 
@@ -634,14 +634,14 @@ BitmapEx ImpGraphic::ImplGetBitmapEx(const GraphicConversionParameters& rParamet
                 BmpScaleFlag::Fast);
         }
     }
-    else if( ( meType != GraphicType::Default ) && ImplIsSupportedGraphic() )
+    else if( ( meType != GraphicType::Default ) && isSupportedGraphic() )
     {
         if(maBitmapEx.IsEmpty())
         {
             const ImpGraphic aMonoMask( maMetaFile.GetMonochromeMtf( COL_BLACK ) );
 
             // use maBitmapEx as local buffer for rendered metafile
-            const_cast< ImpGraphic* >(this)->maBitmapEx = BitmapEx(ImplGetBitmap(rParameters), aMonoMask.ImplGetBitmap(rParameters));
+            const_cast< ImpGraphic* >(this)->maBitmapEx = BitmapEx(getBitmap(rParameters), aMonoMask.getBitmap(rParameters));
         }
 
         aRetBmpEx = maBitmapEx;
@@ -650,7 +650,7 @@ BitmapEx ImpGraphic::ImplGetBitmapEx(const GraphicConversionParameters& rParamet
     return aRetBmpEx;
 }
 
-Animation ImpGraphic::ImplGetAnimation() const
+Animation ImpGraphic::getAnimation() const
 {
     Animation aAnimation;
 
@@ -661,13 +661,13 @@ Animation ImpGraphic::ImplGetAnimation() const
     return aAnimation;
 }
 
-const BitmapEx& ImpGraphic::ImplGetBitmapExRef() const
+const BitmapEx& ImpGraphic::getBitmapExRef() const
 {
     ensureAvailable();
     return maBitmapEx;
 }
 
-const GDIMetaFile& ImpGraphic::ImplGetGDIMetaFile() const
+const GDIMetaFile& ImpGraphic::getGDIMetaFile() const
 {
     ensureAvailable();
     if (!maMetaFile.GetActionSize()
@@ -732,19 +732,19 @@ const GDIMetaFile& ImpGraphic::ImplGetGDIMetaFile() const
     return maMetaFile;
 }
 
-Size ImpGraphic::ImplGetSizePixel() const
+Size ImpGraphic::getSizePixel() const
 {
     Size aSize;
 
     if (isSwappedOut())
         aSize = maSwapInfo.maSizePixel;
     else
-        aSize = ImplGetBitmapEx(GraphicConversionParameters()).GetSizePixel();
+        aSize = getBitmapEx(GraphicConversionParameters()).GetSizePixel();
 
     return aSize;
 }
 
-Size ImpGraphic::ImplGetPrefSize() const
+Size ImpGraphic::getPrefSize() const
 {
     Size aSize;
 
@@ -814,7 +814,7 @@ void ImpGraphic::setValuesForPrefSize(const Size& rPrefSize)
 
             // #108077# Push through pref size to animation object,
             // will be lost on copy otherwise
-            if (ImplIsAnimated())
+            if (isAnimated())
             {
                 const_cast< BitmapEx& >(mpAnimation->GetBitmapEx()).SetPrefSize(rPrefSize);
             }
@@ -828,7 +828,7 @@ void ImpGraphic::setValuesForPrefSize(const Size& rPrefSize)
 
         case GraphicType::GdiMetafile:
         {
-            if (ImplIsSupportedGraphic())
+            if (isSupportedGraphic())
                 maMetaFile.SetPrefSize(rPrefSize);
         }
         break;
@@ -839,13 +839,13 @@ void ImpGraphic::setValuesForPrefSize(const Size& rPrefSize)
     }
 }
 
-void ImpGraphic::ImplSetPrefSize(const Size& rPrefSize)
+void ImpGraphic::setPrefSize(const Size& rPrefSize)
 {
     ensureAvailable();
     setValuesForPrefSize(rPrefSize);
 }
 
-MapMode ImpGraphic::ImplGetPrefMapMode() const
+MapMode ImpGraphic::getPrefMapMode() const
 {
     MapMode aMapMode;
 
@@ -904,7 +904,7 @@ void ImpGraphic::setValuesForPrefMapMod(const MapMode& rPrefMapMode)
             {
                 // #108077# Push through pref mapmode to animation object,
                 // will be lost on copy otherwise
-                if (ImplIsAnimated())
+                if (isAnimated())
                 {
                     const_cast<BitmapEx&>(mpAnimation->GetBitmapEx()).SetPrefMapMode(rPrefMapMode);
                 }
@@ -926,13 +926,13 @@ void ImpGraphic::setValuesForPrefMapMod(const MapMode& rPrefMapMode)
     }
 }
 
-void ImpGraphic::ImplSetPrefMapMode(const MapMode& rPrefMapMode)
+void ImpGraphic::setPrefMapMode(const MapMode& rPrefMapMode)
 {
     ensureAvailable();
     setValuesForPrefMapMod(rPrefMapMode);
 }
 
-sal_uLong ImpGraphic::ImplGetSizeBytes() const
+sal_uLong ImpGraphic::getSizeBytes() const
 {
     if (mnSizeBytes > 0)
         return mnSizeBytes;
@@ -974,7 +974,7 @@ sal_uLong ImpGraphic::ImplGetSizeBytes() const
     return mnSizeBytes;
 }
 
-void ImpGraphic::ImplDraw(OutputDevice* pOutDev, const Point& rDestPt) const
+void ImpGraphic::draw(OutputDevice* pOutDev, const Point& rDestPt) const
 {
     ensureAvailable();
 
@@ -1004,7 +1004,7 @@ void ImpGraphic::ImplDraw(OutputDevice* pOutDev, const Point& rDestPt) const
 
         case GraphicType::GdiMetafile:
         {
-            ImplDraw(pOutDev, rDestPt, maMetaFile.GetPrefSize());
+            draw(pOutDev, rDestPt, maMetaFile.GetPrefSize());
         }
         break;
 
@@ -1014,7 +1014,7 @@ void ImpGraphic::ImplDraw(OutputDevice* pOutDev, const Point& rDestPt) const
     }
 }
 
-void ImpGraphic::ImplDraw(OutputDevice* pOutDev,
+void ImpGraphic::draw(OutputDevice* pOutDev,
                           const Point& rDestPt, const Size& rDestSize) const
 {
     ensureAvailable();
@@ -1057,25 +1057,25 @@ void ImpGraphic::ImplDraw(OutputDevice* pOutDev,
     }
 }
 
-void ImpGraphic::ImplStartAnimation( OutputDevice* pOutDev, const Point& rDestPt,
+void ImpGraphic::startAnimation( OutputDevice* pOutDev, const Point& rDestPt,
                                      const Size& rDestSize, tools::Long nExtraData,
                                      OutputDevice* pFirstFrameOutDev )
 {
     ensureAvailable();
 
-    if( ImplIsSupportedGraphic() && !isSwappedOut() && mpAnimation )
+    if( isSupportedGraphic() && !isSwappedOut() && mpAnimation )
         mpAnimation->Start( pOutDev, rDestPt, rDestSize, nExtraData, pFirstFrameOutDev );
 }
 
-void ImpGraphic::ImplStopAnimation( const OutputDevice* pOutDev, tools::Long nExtraData )
+void ImpGraphic::stopAnimation( const OutputDevice* pOutDev, tools::Long nExtraData )
 {
     ensureAvailable();
 
-    if( ImplIsSupportedGraphic() && !isSwappedOut() && mpAnimation )
+    if( isSupportedGraphic() && !isSwappedOut() && mpAnimation )
         mpAnimation->Stop( pOutDev, nExtraData );
 }
 
-void ImpGraphic::ImplSetAnimationNotifyHdl( const Link<Animation*,void>& rLink )
+void ImpGraphic::setAnimationNotifyHdl( const Link<Animation*,void>& rLink )
 {
     ensureAvailable();
 
@@ -1083,7 +1083,7 @@ void ImpGraphic::ImplSetAnimationNotifyHdl( const Link<Animation*,void>& rLink )
         mpAnimation->SetNotifyHdl( rLink );
 }
 
-Link<Animation*,void> ImpGraphic::ImplGetAnimationNotifyHdl() const
+Link<Animation*,void> ImpGraphic::getAnimationNotifyHdl() const
 {
     Link<Animation*,void> aLink;
 
@@ -1095,7 +1095,7 @@ Link<Animation*,void> ImpGraphic::ImplGetAnimationNotifyHdl() const
     return aLink;
 }
 
-sal_uInt32 ImpGraphic::ImplGetAnimationLoopCount() const
+sal_uInt32 ImpGraphic::getAnimationLoopCount() const
 {
     if (mbSwapOut)
         return maSwapInfo.mnAnimationLoopCount;
@@ -1103,7 +1103,7 @@ sal_uInt32 ImpGraphic::ImplGetAnimationLoopCount() const
     return mpAnimation ? mpAnimation->GetLoopCount() : 0;
 }
 
-void ImpGraphic::ImplSetContext( const std::shared_ptr<GraphicReader>& pReader )
+void ImpGraphic::setContext( const std::shared_ptr<GraphicReader>& pReader )
 {
     mpContext = pReader;
     mbDummyContext = false;
@@ -1210,7 +1210,7 @@ bool ImpGraphic::swapOutGraphic(SvStream& rStream)
                     maVectorGraphicData->getBinaryDataContainer().getData(),
                     maVectorGraphicData->getBinaryDataContainer().getSize());
             }
-            else if (ImplIsAnimated())
+            else if (isAnimated())
             {
                 rStream.WriteInt32(sal_Int32(GraphicContentType::Animation));
                 WriteAnimation(rStream, *mpAnimation);
@@ -1281,7 +1281,7 @@ bool ImpGraphic::swapOut()
     {
         createSwapInfo();
 
-        ImplClearGraphics();
+        clearGraphics();
 
         // reset the swap file
         mpSwapFile.reset();
@@ -1327,7 +1327,7 @@ bool ImpGraphic::swapOut()
         {
             // We have swapped out, so can clean memory and prepare swap info
             createSwapInfo();
-            ImplClearGraphics();
+            clearGraphics();
 
             mpSwapFile = std::move(pSwapFile);
             mbSwapOut = true;
@@ -1353,19 +1353,19 @@ bool ImpGraphic::ensureAvailable() const
     return bResult;
 }
 
-void ImpGraphic::updateFromLoadedGraphic(ImpGraphic* graphic)
+void ImpGraphic::updateFromLoadedGraphic(ImpGraphic* pGraphic)
 {
-    if( mbPrepared )
+    if (mbPrepared)
     {
         GraphicExternalLink aLink = maGraphicExternalLink;
         Size aPrefSize = maSwapInfo.maPrefSize;
         MapMode aPrefMapMode = maSwapInfo.maPrefMapMode;
-        *this = *graphic;
-        if (aPrefSize.getWidth() && aPrefSize.getHeight() && aPrefMapMode == ImplGetPrefMapMode())
+        *this = *pGraphic;
+        if (aPrefSize.getWidth() && aPrefSize.getHeight() && aPrefMapMode == getPrefMapMode())
         {
             // Use custom preferred size if it was set when the graphic was still unloaded.
             // Only set the size in case the unloaded and loaded unit matches.
-            ImplSetPrefSize(aPrefSize);
+            setPrefSize(aPrefSize);
         }
         maGraphicExternalLink = aLink;
     }
@@ -1373,18 +1373,18 @@ void ImpGraphic::updateFromLoadedGraphic(ImpGraphic* graphic)
     {
         // Move over only graphic content
         mpAnimation.reset();
-        if (graphic->mpAnimation)
+        if (pGraphic->mpAnimation)
         {
-            mpAnimation = std::make_unique<Animation>(*graphic->mpAnimation);
+            mpAnimation = std::make_unique<Animation>(*pGraphic->mpAnimation);
             maBitmapEx = mpAnimation->GetBitmapEx();
         }
         else
         {
-            maBitmapEx = graphic->maBitmapEx;
+            maBitmapEx = pGraphic->maBitmapEx;
         }
 
-        maMetaFile = graphic->maMetaFile;
-        maVectorGraphicData = graphic->maVectorGraphicData;
+        maMetaFile = pGraphic->maMetaFile;
+        maVectorGraphicData = pGraphic->maVectorGraphicData;
 
         // Set to 0, to force recalculation
         mnSizeBytes = 0;
@@ -1492,7 +1492,7 @@ bool ImpGraphic::swapInFromStream(SvStream& rStream)
     if (rStream.GetError())
         return false;
 
-    ImplClearGraphics();
+    clearGraphics();
     mnSizeBytes = 0;
     mnChecksum = 0;
 
@@ -1501,7 +1501,7 @@ bool ImpGraphic::swapInFromStream(SvStream& rStream)
     if (!bRet)
     {
         //throw away swapfile, etc.
-        ImplClear();
+        clear();
     }
 
     mbSwapOut = false;
@@ -1619,31 +1619,31 @@ bool ImpGraphic::swapInGraphic(SvStream& rStream)
     return bReturn;
 }
 
-void ImpGraphic::ImplSetLink(const std::shared_ptr<GfxLink>& rGfxLink)
+void ImpGraphic::setGfxLink(const std::shared_ptr<GfxLink>& rGfxLink)
 {
     ensureAvailable();
 
     mpGfxLink = rGfxLink;
 }
 
-std::shared_ptr<GfxLink> ImpGraphic::ImplGetSharedGfxLink() const
+std::shared_ptr<GfxLink> ImpGraphic::getSharedGfxLink() const
 {
     return mpGfxLink;
 }
 
-GfxLink ImpGraphic::ImplGetLink()
+GfxLink ImpGraphic::getGfxLink()
 {
     ensureAvailable();
 
     return( mpGfxLink ? *mpGfxLink : GfxLink() );
 }
 
-bool ImpGraphic::ImplIsLink() const
+bool ImpGraphic::isGfxLink() const
 {
     return ( bool(mpGfxLink) );
 }
 
-BitmapChecksum ImpGraphic::ImplGetChecksum() const
+BitmapChecksum ImpGraphic::getChecksum() const
 {
     if (mnChecksum != 0)
         return mnChecksum;
diff --git a/vcl/source/graphic/GraphicID.cxx b/vcl/source/graphic/GraphicID.cxx
index f2a9afa60dbe..a27485da29aa 100644
--- a/vcl/source/graphic/GraphicID.cxx
+++ b/vcl/source/graphic/GraphicID.cxx
@@ -26,10 +26,10 @@ GraphicID::GraphicID(ImpGraphic const& rGraphic)
 {
     rGraphic.ensureAvailable();
 
-    mnID1 = static_cast<sal_uLong>(rGraphic.ImplGetType()) << 28;
+    mnID1 = static_cast<sal_uLong>(rGraphic.getType()) << 28;
     mnID2 = mnID3 = mnID4 = 0;
 
-    if (rGraphic.ImplGetType() == GraphicType::Bitmap)
+    if (rGraphic.getType() == GraphicType::Bitmap)
     {
         auto const& rVectorGraphicDataPtr = rGraphic.getVectorGraphicData();
         if (rVectorGraphicDataPtr)
@@ -42,35 +42,35 @@ GraphicID::GraphicID(ImpGraphic const& rGraphic)
             mnID4 = vcl_get_checksum(0, rVectorGraphicDataPtr->getBinaryDataContainer().getData(),
                                      rVectorGraphicDataPtr->getBinaryDataContainer().getSize());
         }
-        else if (rGraphic.ImplIsAnimated())
+        else if (rGraphic.isAnimated())
         {
-            const Animation aAnimation(rGraphic.ImplGetAnimation());
+            const Animation aAnimation(rGraphic.getAnimation());
 
             mnID1 |= (aAnimation.Count() & 0x0fffffff);
             mnID2 = aAnimation.GetDisplaySizePixel().Width();
             mnID3 = aAnimation.GetDisplaySizePixel().Height();
-            mnID4 = rGraphic.ImplGetChecksum();
+            mnID4 = rGraphic.getChecksum();
         }
         else
         {
-            const BitmapEx aBmpEx(rGraphic.ImplGetBitmapEx(GraphicConversionParameters()));
+            const BitmapEx aBmpEx(rGraphic.getBitmapEx(GraphicConversionParameters()));
 
             mnID1 |= (((static_cast<sal_uLong>(aBmpEx.GetTransparentType()) << 8)
                        | (aBmpEx.IsAlpha() ? 1 : 0))
                       & 0x0fffffff);
             mnID2 = aBmpEx.GetSizePixel().Width();
             mnID3 = aBmpEx.GetSizePixel().Height();
-            mnID4 = rGraphic.ImplGetChecksum();
+            mnID4 = rGraphic.getChecksum();
         }
     }
-    else if (rGraphic.ImplGetType() == GraphicType::GdiMetafile)
+    else if (rGraphic.getType() == GraphicType::GdiMetafile)
     {
-        const GDIMetaFile& rMtf = rGraphic.ImplGetGDIMetaFile();
+        const GDIMetaFile& rMtf = rGraphic.getGDIMetaFile();
 
         mnID1 |= (rMtf.GetActionSize() & 0x0fffffff);
         mnID2 = rMtf.GetPrefSize().Width();
         mnID3 = rMtf.GetPrefSize().Height();
-        mnID4 = rGraphic.ImplGetChecksum();
+        mnID4 = rGraphic.getChecksum();
     }
 }
 
diff --git a/vcl/source/graphic/Manager.cxx b/vcl/source/graphic/Manager.cxx
index 88e1f6e622df..5d535e446955 100644
--- a/vcl/source/graphic/Manager.cxx
+++ b/vcl/source/graphic/Manager.cxx
@@ -112,7 +112,7 @@ sal_Int64 Manager::getGraphicSizeBytes(const ImpGraphic* pImpGraphic)
 {
     if (!pImpGraphic->isAvailable())
         return 0;
-    return pImpGraphic->ImplGetSizeBytes();
+    return pImpGraphic->getSizeBytes();
 }
 
 IMPL_LINK(Manager, SwapOutTimerHandler, Timer*, pTimer, void)