prefix member variables of AnimationBitmap

Change-Id: Ic84773399c95d61f843e4388fe01d00cd4facc5a
Reviewed-on: https://gerrit.libreoffice.org/71425Reviewed-by: Tomaž Vajngerl <quikee@gmail.com>
Tested-by: Tomaž Vajngerl <quikee@gmail.com>

drawinglayer/source/primitive2d/graphicprimitivehelper2d.cxx

@@ -114,13 +114,13 @@ namespace drawinglayer
 
             sal_uInt32 generateStepTime(sal_uInt32 nIndex) const
             {
-                const AnimationBitmap& rAnimBitmap = maAnimation.Get(sal_uInt16(nIndex));
-                sal_uInt32 nWaitTime(rAnimBitmap.nWait * 10);
+                const AnimationBitmap& rAnimationBitmap = maAnimation.Get(sal_uInt16(nIndex));
+                sal_uInt32 nWaitTime(rAnimationBitmap.mnWait * 10);
 
                 // Take care of special value for MultiPage TIFFs. ATM these shall just
                 // show their first page. Later we will offer some switching when object
                 // is selected.
-                if (ANIMATION_TIMEOUT_ON_CLICK == rAnimBitmap.nWait)
+                if (ANIMATION_TIMEOUT_ON_CLICK == rAnimationBitmap.mnWait)
                 {
                     // ATM the huge value would block the timer, so
                     // use a long time to show first page (whole day)
@@ -233,14 +233,14 @@ namespace drawinglayer
                     while (mnNextFrameToPrepare <= nTarget)
                     {
                         // prepare step
-                        const AnimationBitmap& rAnimBitmap = maAnimation.Get(sal_uInt16(mnNextFrameToPrepare));
+                        const AnimationBitmap& rAnimationBitmap = maAnimation.Get(sal_uInt16(mnNextFrameToPrepare));
 
-                        switch (rAnimBitmap.eDisposal)
+                        switch (rAnimationBitmap.meDisposal)
                         {
                             case Disposal::Not:
                             {
-                                maVirtualDevice->DrawBitmapEx(rAnimBitmap.aPosPix, rAnimBitmap.aBmpEx);
-                                Bitmap aMask = rAnimBitmap.aBmpEx.GetMask();
+                                maVirtualDevice->DrawBitmapEx(rAnimationBitmap.maPositionPixel, rAnimationBitmap.maBitmapEx);
+                                Bitmap aMask = rAnimationBitmap.maBitmapEx.GetMask();
 
                                 if (aMask.IsEmpty())
                                 {
@@ -252,7 +252,7 @@ namespace drawinglayer
                                 else
                                 {
                                     BitmapEx aExpandVisibilityMask = BitmapEx(aMask, aMask);
-                                    maVirtualDeviceMask->DrawBitmapEx(rAnimBitmap.aPosPix, aExpandVisibilityMask);
+                                    maVirtualDeviceMask->DrawBitmapEx(rAnimationBitmap.maPositionPixel, aExpandVisibilityMask);
                                 }
 
                                 break;
@@ -260,15 +260,15 @@ namespace drawinglayer
                             case Disposal::Back:
                             {
                                 // #i70772# react on no mask, for primitives, too.
-                                const Bitmap aMask(rAnimBitmap.aBmpEx.GetMask());
-                                const Bitmap aContent(rAnimBitmap.aBmpEx.GetBitmap());
+                                const Bitmap aMask(rAnimationBitmap.maBitmapEx.GetMask());
+                                const Bitmap aContent(rAnimationBitmap.maBitmapEx.GetBitmap());
 
                                 maVirtualDeviceMask->Erase();
-                                maVirtualDevice->DrawBitmap(rAnimBitmap.aPosPix, aContent);
+                                maVirtualDevice->DrawBitmap(rAnimationBitmap.maPositionPixel, aContent);
 
                                 if (aMask.IsEmpty())
                                 {
-                                    const ::tools::Rectangle aRect(rAnimBitmap.aPosPix, aContent.GetSizePixel());
+                                    const ::tools::Rectangle aRect(rAnimationBitmap.maPositionPixel, aContent.GetSizePixel());
                                     maVirtualDeviceMask->SetFillColor(COL_BLACK);
                                     maVirtualDeviceMask->SetLineColor();
                                     maVirtualDeviceMask->DrawRect(aRect);
@@ -276,16 +276,16 @@ namespace drawinglayer
                                 else
                                 {
                                     BitmapEx aExpandVisibilityMask = BitmapEx(aMask, aMask);
-                                    maVirtualDeviceMask->DrawBitmapEx(rAnimBitmap.aPosPix, aExpandVisibilityMask);
+                                    maVirtualDeviceMask->DrawBitmapEx(rAnimationBitmap.maPositionPixel, aExpandVisibilityMask);
                                 }
 
                                 break;
                             }
                             case Disposal::Previous:
                             {
-                                maVirtualDevice->DrawBitmapEx(rAnimBitmap.aPosPix, rAnimBitmap.aBmpEx);
-                                BitmapEx aExpandVisibilityMask = BitmapEx(rAnimBitmap.aBmpEx.GetMask(), rAnimBitmap.aBmpEx.GetMask());
-                                maVirtualDeviceMask->DrawBitmapEx(rAnimBitmap.aPosPix, aExpandVisibilityMask);
+                                maVirtualDevice->DrawBitmapEx(rAnimationBitmap.maPositionPixel, rAnimationBitmap.maBitmapEx);
+                                BitmapEx aExpandVisibilityMask = BitmapEx(rAnimationBitmap.maBitmapEx.GetMask(), rAnimationBitmap.maBitmapEx.GetMask());
+                                maVirtualDeviceMask->DrawBitmapEx(rAnimationBitmap.maPositionPixel, aExpandVisibilityMask);
                                 break;
                             }
                         }

filter/source/graphicfilter/egif/egif.cxx

@@ -212,10 +212,10 @@ void GIFWriter::WriteAnimation( const Animation& rAnimation )
 
         for( sal_uInt16 i = 0; i < nCount; i++ )
         {
-            const AnimationBitmap& rAnimBmp = rAnimation.Get( i );
+            const AnimationBitmap& rAnimationBitmap = rAnimation.Get( i );
 
-            WriteBitmapEx( rAnimBmp.aBmpEx, rAnimBmp.aPosPix, true,
-                           rAnimBmp.nWait, rAnimBmp.eDisposal );
+            WriteBitmapEx(rAnimationBitmap.maBitmapEx, rAnimationBitmap.maPositionPixel, true,
+                           rAnimationBitmap.mnWait, rAnimationBitmap.meDisposal );
             nMinPercent = nMaxPercent;
             nMaxPercent = static_cast<sal_uInt32>(nMaxPercent + fStep);
         }

filter/source/graphicfilter/etiff/etiff.cxx

@@ -173,13 +173,13 @@ bool TIFFWriter::WriteTIFF( const Graphic& rGraphic, FilterConfigItem const * pF
             aAnimation.Insert(AnimationBitmap(rGraphic.GetBitmapEx(), Point(), Size()));
 
         for (size_t i = 0; i < aAnimation.Count(); ++i)
-            mnSumOfAllPictHeight += aAnimation.Get(i).aBmpEx.GetSizePixel().Height();
+            mnSumOfAllPictHeight += aAnimation.Get(i).maBitmapEx.GetSizePixel().Height();
 
         for (size_t i = 0; mbStatus && i < aAnimation.Count(); ++i)
         {
             mnPalPos = 0;
             const AnimationBitmap& rAnimationBitmap = aAnimation.Get( i );
-            Bitmap aBmp = rAnimationBitmap.aBmpEx.GetBitmap();
+            Bitmap aBmp = rAnimationBitmap.maBitmapEx.GetBitmap();
             mpAcc = aBmp.AcquireReadAccess();
             if ( mpAcc )
             {

include/vcl/animate/AnimationBitmap.hxx

@@ -33,39 +33,44 @@ enum class Disposal
 
 struct VCL_DLLPUBLIC AnimationBitmap
 {
-    BitmapEx aBmpEx;
-    Point aPosPix;
-    Size aSizePix;
-    long nWait;
-    Disposal eDisposal;
-    bool bUserInput;
+    BitmapEx maBitmapEx;
+    Point maPositionPixel;
+    Size maSizePixel;
+    long mnWait;
+    Disposal meDisposal;
+    bool mbUserInput;
 
     AnimationBitmap()
-        : nWait(0)
-        , eDisposal(Disposal::Not)
-        , bUserInput(false)
+        : mnWait(0)
+        , meDisposal(Disposal::Not)
+        , mbUserInput(false)
     {
     }
 
-    AnimationBitmap(const BitmapEx& rBmpEx, const Point& rPosPix, const Size& rSizePix,
-                    long _nWait = 0, Disposal _eDisposal = Disposal::Not)
-        : aBmpEx(rBmpEx)
-        , aPosPix(rPosPix)
-        , aSizePix(rSizePix)
-        , nWait(_nWait)
-        , eDisposal(_eDisposal)
-        , bUserInput(false)
+    AnimationBitmap(const BitmapEx& rBitmapEx, const Point& rPositionPixel, const Size& rSizePixel,
+                    long nWait = 0, Disposal eDisposal = Disposal::Not)
+        : maBitmapEx(rBitmapEx)
+        , maPositionPixel(rPositionPixel)
+        , maSizePixel(rSizePixel)
+        , mnWait(nWait)
+        , meDisposal(eDisposal)
+        , mbUserInput(false)
     {
     }
 
-    bool operator==(const AnimationBitmap& rAnimBmp) const
+    bool operator==(const AnimationBitmap& rAnimationBitmap) const
     {
-        return (rAnimBmp.aBmpEx == aBmpEx && rAnimBmp.aPosPix == aPosPix
-                && rAnimBmp.aSizePix == aSizePix && rAnimBmp.nWait == nWait
-                && rAnimBmp.eDisposal == eDisposal && rAnimBmp.bUserInput == bUserInput);
+        return (rAnimationBitmap.maBitmapEx == maBitmapEx
+                && rAnimationBitmap.maPositionPixel == maPositionPixel
+                && rAnimationBitmap.maSizePixel == maSizePixel && rAnimationBitmap.mnWait == mnWait
+                && rAnimationBitmap.meDisposal == meDisposal
+                && rAnimationBitmap.mbUserInput == mbUserInput);
     }
 
-    bool operator!=(const AnimationBitmap& rAnimBmp) const { return !(*this == rAnimBmp); }
+    bool operator!=(const AnimationBitmap& rAnimationBitmap) const
+    {
+        return !(*this == rAnimationBitmap);
+    }
 
     BitmapChecksum GetChecksum() const;
 };

sd/source/ui/dlg/animobjs.cxx

@@ -723,7 +723,7 @@ void AnimationWindow::AddObj (::sd::View& rView )
 
                 for( sal_uInt16 i = 0; i < nCount; i++ )
                 {
-                    const AnimationBitmap& rAnimBmp = aAnimation.Get( i );
+                    const AnimationBitmap& rAnimationBitmap = aAnimation.Get( i );
 
                     // LoopCount
                     if( i == 0 )
@@ -736,12 +736,12 @@ void AnimationWindow::AddObj (::sd::View& rView )
                             m_pLbLoopCount->SelectEntry(OUString::number( nLoopCount ) );
                     }
 
-                    long nTime = rAnimBmp.nWait;
+                    long nTime = rAnimationBitmap.mnWait;
                     ::tools::Time aTime( 0, 0, nTime / 100, nTime % 100 );
                     size_t nIndex = m_nCurrentFrame + 1;
                     m_FrameList.insert(
                             m_FrameList.begin() + nIndex,
-                            ::std::make_pair(rAnimBmp.aBmpEx, aTime));
+                            ::std::make_pair(rAnimationBitmap.maBitmapEx, aTime));
 
                     // increment => next one inserted after this one
                     ++m_nCurrentFrame;
@@ -958,21 +958,21 @@ void AnimationWindow::CreateAnimObj (::sd::View& rView )
             }
 
             // find LoopCount (number of passes)
-            AnimationBitmap aAnimBmp;
+            AnimationBitmap aAnimationBitmap;
             sal_uInt32 nLoopCount = 0;
             sal_Int32 nPos = m_pLbLoopCount->GetSelectedEntryPos();
 
             if( nPos != LISTBOX_ENTRY_NOTFOUND && nPos != m_pLbLoopCount->GetEntryCount() - 1 ) // endless
                 nLoopCount = m_pLbLoopCount->GetSelectedEntry().toUInt32();
 
-            aAnimBmp.aBmpEx = rBitmapEx;
-            aAnimBmp.aPosPix = aPt;
-            aAnimBmp.aSizePix = aBitmapSize;
-            aAnimBmp.nWait = nTime;
-            aAnimBmp.eDisposal = Disposal::Back;
-            aAnimBmp.bUserInput = false;
+            aAnimationBitmap.maBitmapEx = rBitmapEx;
+            aAnimationBitmap.maPositionPixel = aPt;
+            aAnimationBitmap.maSizePixel = aBitmapSize;
+            aAnimationBitmap.mnWait = nTime;
+            aAnimationBitmap.meDisposal = Disposal::Back;
+            aAnimationBitmap.mbUserInput = false;
 
-            aAnimation.Insert( aAnimBmp );
+            aAnimation.Insert( aAnimationBitmap );
             aAnimation.SetDisplaySizePixel( aMaxSizePix );
             aAnimation.SetLoopCount( nLoopCount );
         }

slideshow/source/engine/shapes/gdimtftools.cxx

@@ -293,14 +293,14 @@ bool getAnimationFromGraphic( VectorOfMtfAnimationFrames&   o_rFrames,
 
     for( sal_uInt16 i=0, nCount=aAnimation.Count(); i<nCount; ++i )
     {
-        const AnimationBitmap& rAnimBmp( aAnimation.Get(i) );
-        switch(rAnimBmp.eDisposal)
+        const AnimationBitmap& rAnimationBitmap( aAnimation.Get(i) );
+        switch(rAnimationBitmap.meDisposal)
         {
             case Disposal::Not:
             {
-                pVDev->DrawBitmapEx(rAnimBmp.aPosPix,
-                                   rAnimBmp.aBmpEx);
-                Bitmap aMask = rAnimBmp.aBmpEx.GetMask();
+                pVDev->DrawBitmapEx(rAnimationBitmap.maPositionPixel,
+                                    rAnimationBitmap.maBitmapEx);
+                Bitmap aMask = rAnimationBitmap.maBitmapEx.GetMask();
 
                 if( aMask.IsEmpty() )
                 {
@@ -314,8 +314,8 @@ bool getAnimationFromGraphic( VectorOfMtfAnimationFrames&   o_rFrames,
                 {
                     BitmapEx aTmpMask = BitmapEx(aMask,
                                                  aMask);
-                    pVDevMask->DrawBitmapEx(rAnimBmp.aPosPix,
-                                           aTmpMask );
+                    pVDevMask->DrawBitmapEx(rAnimationBitmap.maPositionPixel,
+                                            aTmpMask );
                 }
                 break;
             }
@@ -323,32 +323,32 @@ bool getAnimationFromGraphic( VectorOfMtfAnimationFrames&   o_rFrames,
             case Disposal::Back:
             {
                 // #i70772# react on no mask
-                const Bitmap aMask(rAnimBmp.aBmpEx.GetMask());
-                const Bitmap aContent(rAnimBmp.aBmpEx.GetBitmap());
+                const Bitmap aMask(rAnimationBitmap.maBitmapEx.GetMask());
+                const Bitmap aContent(rAnimationBitmap.maBitmapEx.GetBitmap());
 
                 pVDevMask->Erase();
-                pVDev->DrawBitmap(rAnimBmp.aPosPix, aContent);
+                pVDev->DrawBitmap(rAnimationBitmap.maPositionPixel, aContent);
 
                 if(aMask.IsEmpty())
                 {
-                    const tools::Rectangle aRect(rAnimBmp.aPosPix, aContent.GetSizePixel());
+                    const tools::Rectangle aRect(rAnimationBitmap.maPositionPixel, aContent.GetSizePixel());
                     pVDevMask->SetFillColor( COL_BLACK);
                     pVDevMask->SetLineColor();
                     pVDevMask->DrawRect(aRect);
                 }
                 else
                 {
-                    pVDevMask->DrawBitmap(rAnimBmp.aPosPix, aMask);
+                    pVDevMask->DrawBitmap(rAnimationBitmap.maPositionPixel, aMask);
                 }
                 break;
             }
 
             case Disposal::Previous :
             {
-                pVDev->DrawBitmapEx(rAnimBmp.aPosPix,
-                                   rAnimBmp.aBmpEx);
-                pVDevMask->DrawBitmap(rAnimBmp.aPosPix,
-                                     rAnimBmp.aBmpEx.GetMask());
+                pVDev->DrawBitmapEx(rAnimationBitmap.maPositionPixel,
+                                    rAnimationBitmap.maBitmapEx);
+                pVDevMask->DrawBitmap(rAnimationBitmap.maPositionPixel,
+                                      rAnimationBitmap.maBitmapEx.GetMask());
                 break;
             }
         }
@@ -374,7 +374,7 @@ bool getAnimationFromGraphic( VectorOfMtfAnimationFrames&   o_rFrames,
 
         // Take care of special value for MultiPage TIFFs. ATM these shall just
         // show their first page for _quite_ some time.
-        sal_Int32 nWaitTime100thSeconds( rAnimBmp.nWait );
+        sal_Int32 nWaitTime100thSeconds(rAnimationBitmap.mnWait);
         if( ANIMATION_TIMEOUT_ON_CLICK == nWaitTime100thSeconds )
         {
             // ATM the huge value would block the timer, so use a long

svx/source/dialog/_bmpmask.cxx

@@ -651,9 +651,9 @@ Animation SvxBmpMask::ImpMask( const Animation& rAnimation )
 
     for( sal_uInt16 i = 0; i < nAnimationCount; i++ )
     {
-        AnimationBitmap aAnimBmp( aAnimation.Get( i ) );
-        aAnimBmp.aBmpEx = Mask( aAnimBmp.aBmpEx ).GetBitmapEx();
-        aAnimation.Replace( aAnimBmp, i );
+        AnimationBitmap aAnimationBitmap( aAnimation.Get( i ) );
+        aAnimationBitmap.maBitmapEx = Mask(aAnimationBitmap.maBitmapEx).GetBitmapEx();
+        aAnimation.Replace(aAnimationBitmap, i);
     }
 
     return aAnimation;
@@ -921,9 +921,9 @@ Animation SvxBmpMask::ImpReplaceTransparency( const Animation& rAnim, const Colo
 
     for( sal_uInt16 i = 0; i < nAnimationCount; i++ )
     {
-        AnimationBitmap aAnimBmp( aAnimation.Get( i ) );
-        aAnimBmp.aBmpEx = ImpReplaceTransparency( aAnimBmp.aBmpEx, rColor );
-        aAnimation.Replace( aAnimBmp, i );
+        AnimationBitmap aAnimationBitmap(aAnimation.Get(i));
+        aAnimationBitmap.maBitmapEx = ImpReplaceTransparency(aAnimationBitmap.maBitmapEx, rColor);
+        aAnimation.Replace(aAnimationBitmap, i);
     }
 
     return aAnimation;

svx/source/dialog/_contdlg.cxx

@@ -126,9 +126,9 @@ tools::PolyPolygon SvxContourDlg::CreateAutoContour( const Graphic& rGraphic,
 
                     // Push Polygon output to the right place; this is the
                     // offset of the sub-image within the total animation
-                    aTransMap.SetOrigin( Point( rStepBmp.aPosPix.X(), rStepBmp.aPosPix.Y() ) );
+                    aTransMap.SetOrigin( Point( rStepBmp.maPositionPixel.X(), rStepBmp.maPositionPixel.Y() ) );
                     pVDev->SetMapMode( aTransMap );
-                    pVDev->DrawPolyPolygon( CreateAutoContour( rStepBmp.aBmpEx, pRect ) );
+                    pVDev->DrawPolyPolygon( CreateAutoContour( rStepBmp.maBitmapEx, pRect ) );
                 }
 
                 aTransMap.SetOrigin( Point() );

svx/source/xoutdev/_xoutbmp.cxx

@@ -64,21 +64,21 @@ Animation XOutBitmap::MirrorAnimation( const Animation& rAnimation, bool bHMirr,
 
         for( sal_uInt16 i = 0, nCount = aNewAnim.Count(); i < nCount; i++ )
         {
-            AnimationBitmap aAnimBmp( aNewAnim.Get( i ) );
+            AnimationBitmap aAnimationBitmap( aNewAnim.Get( i ) );
 
             // mirror the BitmapEx
-            aAnimBmp.aBmpEx.Mirror( nMirrorFlags );
+            aAnimationBitmap.maBitmapEx.Mirror( nMirrorFlags );
 
             // Adjust the positions inside the whole bitmap
             if( bHMirr )
-                aAnimBmp.aPosPix.setX( rGlobalSize.Width() - aAnimBmp.aPosPix.X() -
-                                       aAnimBmp.aSizePix.Width() );
+                aAnimationBitmap.maPositionPixel.setX(rGlobalSize.Width() - aAnimationBitmap.maPositionPixel.X() -
+                                       aAnimationBitmap.maSizePixel.Width());
 
             if( bVMirr )
-                aAnimBmp.aPosPix.setY( rGlobalSize.Height() - aAnimBmp.aPosPix.Y() -
-                                       aAnimBmp.aSizePix.Height() );
+                aAnimationBitmap.maPositionPixel.setY(rGlobalSize.Height() - aAnimationBitmap.maPositionPixel.Y() -
+                                       aAnimationBitmap.maSizePixel.Height());
 
-            aNewAnim.Replace( aAnimBmp, i );
+            aNewAnim.Replace(aAnimationBitmap, i);
         }
     }
 

vcl/source/animate/AnimationBitmap.cxx

@@ -24,28 +24,28 @@
 
 BitmapChecksum AnimationBitmap::GetChecksum() const
 {
-    BitmapChecksum nCrc = aBmpEx.GetChecksum();
+    BitmapChecksum nCrc = maBitmapEx.GetChecksum();
     SVBT32 aBT32;
 
-    Int32ToSVBT32(aPosPix.X(), aBT32);
+    Int32ToSVBT32(maPositionPixel.X(), aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
-    Int32ToSVBT32(aPosPix.Y(), aBT32);
+    Int32ToSVBT32(maPositionPixel.Y(), aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
-    Int32ToSVBT32(aSizePix.Width(), aBT32);
+    Int32ToSVBT32(maSizePixel.Width(), aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
-    Int32ToSVBT32(aSizePix.Height(), aBT32);
+    Int32ToSVBT32(maSizePixel.Height(), aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
-    Int32ToSVBT32(nWait, aBT32);
+    Int32ToSVBT32(mnWait, aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
-    UInt32ToSVBT32(o3tl::underlyingEnumValue(eDisposal), aBT32);
+    UInt32ToSVBT32(o3tl::underlyingEnumValue(meDisposal), aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
-    UInt32ToSVBT32(sal_uInt32(bUserInput), aBT32);
+    UInt32ToSVBT32(sal_uInt32(mbUserInput), aBT32);
     nCrc = vcl_get_checksum(nCrc, aBT32, 4);
 
     return nCrc;

vcl/source/bitmap/bitmapfilter.cxx

@@ -45,7 +45,7 @@ bool BitmapFilter::Filter(Animation& rAnimation, BitmapFilter const & rFilter)
         std::vector<std::unique_ptr<AnimationBitmap>>& aList = rAnimation.GetAnimationFrames();
         for (size_t i = 0, n = aList.size(); (i < n) && bRet; ++i)
         {
-            bRet = BitmapFilter::Filter(aList[i]->aBmpEx, rFilter);
+            bRet = BitmapFilter::Filter(aList[i]->maBitmapEx, rFilter);
         }
 
         BitmapEx aBmpEx(rAnimation.GetBitmapEx());

vcl/source/filter/igif/gifread.cxx

@@ -644,38 +644,38 @@ void GIFReader::FillImages( const sal_uInt8* pBytes, sal_uLong nCount )
 
 void GIFReader::CreateNewBitmaps()
 {
-    AnimationBitmap aAnimBmp;
+    AnimationBitmap aAnimationBitmap;
 
     pAcc8.reset();
 
     if( bGCTransparent )
     {
         pAcc1.reset();
-        aAnimBmp.aBmpEx = BitmapEx( aBmp8, aBmp1 );
+        aAnimationBitmap.maBitmapEx = BitmapEx( aBmp8, aBmp1 );
     }
     else
-        aAnimBmp.aBmpEx = BitmapEx( aBmp8 );
+        aAnimationBitmap.maBitmapEx = BitmapEx( aBmp8 );
 
-    aAnimBmp.aPosPix = Point( nImagePosX, nImagePosY );
-    aAnimBmp.aSizePix = Size( nImageWidth, nImageHeight );
-    aAnimBmp.nWait = ( nTimer != 65535 ) ? nTimer : ANIMATION_TIMEOUT_ON_CLICK;
-    aAnimBmp.bUserInput = false;
+    aAnimationBitmap.maPositionPixel = Point( nImagePosX, nImagePosY );
+    aAnimationBitmap.maSizePixel = Size( nImageWidth, nImageHeight );
+    aAnimationBitmap.mnWait = ( nTimer != 65535 ) ? nTimer : ANIMATION_TIMEOUT_ON_CLICK;
+    aAnimationBitmap.mbUserInput = false;
 
     // tdf#104121 . Internet Explorer, Firefox, Chrome and Safari all set a minimum default playback speed.
     // IE10 Consumer Preview sets default of 100ms for rates less that 20ms. We do the same
-    if (aAnimBmp.nWait < 2) // 20ms, specified in 100's of a second
-        aAnimBmp.nWait = 10;
+    if (aAnimationBitmap.mnWait < 2) // 20ms, specified in 100's of a second
+        aAnimationBitmap.mnWait = 10;
 
     if( nGCDisposalMethod == 2 )
-        aAnimBmp.eDisposal = Disposal::Back;
+        aAnimationBitmap.meDisposal = Disposal::Back;
     else if( nGCDisposalMethod == 3 )
-        aAnimBmp.eDisposal = Disposal::Previous;
+        aAnimationBitmap.meDisposal = Disposal::Previous;
     else
-        aAnimBmp.eDisposal = Disposal::Not;
+        aAnimationBitmap.meDisposal = Disposal::Not;
 
-    nAnimationByteSize += aAnimBmp.aBmpEx.GetSizeBytes();
+    nAnimationByteSize += aAnimationBitmap.maBitmapEx.GetSizeBytes();
     nAnimationMinFileData += static_cast<sal_uInt64>(nImageWidth) * nImageHeight / 2560;
-    aAnimation.Insert( aAnimBmp );
+    aAnimation.Insert(aAnimationBitmap);
 
     if( aAnimation.Count() == 1 )
     {
@@ -923,7 +923,7 @@ ReadState GIFReader::ReadGIF( Graphic& rGraphic )
 
     if( aAnimation.Count() == 1 )
     {
-        rGraphic = aAnimation.Get( 0 ).aBmpEx;
+        rGraphic = aAnimation.Get(0).maBitmapEx;
 
         if( nLogWidth100 && nLogHeight100 )
         {

vcl/source/gdi/impanmvw.cxx

@@ -121,11 +121,11 @@ bool ImplAnimView::matches( OutputDevice* pOut, long nExtraData ) const
     return bRet;
 }
 
-void ImplAnimView::getPosSize( const AnimationBitmap& rAnm, Point& rPosPix, Size& rSizePix )
+void ImplAnimView::getPosSize( const AnimationBitmap& rAnimationBitmap, Point& rPosPix, Size& rSizePix )
 {
     const Size& rAnmSize = mpParent->GetDisplaySizePixel();
-    Point       aPt2( rAnm.aPosPix.X() + rAnm.aSizePix.Width() - 1,
-                      rAnm.aPosPix.Y() + rAnm.aSizePix.Height() - 1 );
+    Point       aPt2( rAnimationBitmap.maPositionPixel.X() + rAnimationBitmap.maSizePixel.Width() - 1,
+                      rAnimationBitmap.maPositionPixel.Y() + rAnimationBitmap.maSizePixel.Height() - 1 );
     double      fFactX, fFactY;
 
     // calculate x scaling
@@ -140,8 +140,8 @@ void ImplAnimView::getPosSize( const AnimationBitmap& rAnm, Point& rPosPix, Size
     else
         fFactY = 1.0;
 
-    rPosPix.setX( FRound( rAnm.aPosPix.X() * fFactX ) );
-    rPosPix.setY( FRound( rAnm.aPosPix.Y() * fFactY ) );
+    rPosPix.setX( FRound( rAnimationBitmap.maPositionPixel.X() * fFactX ) );
+    rPosPix.setY( FRound( rAnimationBitmap.maPositionPixel.Y() * fFactY ) );
 
     aPt2.setX( FRound( aPt2.X() * fFactX ) );
     aPt2.setY( FRound( aPt2.Y() * fFactY ) );
@@ -216,9 +216,9 @@ void ImplAnimView::draw( sal_uLong nPos, VirtualDevice* pVDev )
         Size                    aBmpSizePix;
         const sal_uLong             nLastPos = mpParent->Count() - 1;
         mnActPos = std::min( nPos, nLastPos );
-        const AnimationBitmap&  rAnm = mpParent->Get( static_cast<sal_uInt16>( mnActPos ) );
+        const AnimationBitmap&  rAnimationBitmap = mpParent->Get( static_cast<sal_uInt16>( mnActPos ) );
 
-        getPosSize( rAnm, aPosPix, aSizePix );
+        getPosSize( rAnimationBitmap, aPosPix, aSizePix );
 
         // Mirrored horizontally?
         if( mbHMirr )
@@ -271,7 +271,7 @@ void ImplAnimView::draw( sal_uLong nPos, VirtualDevice* pVDev )
                 pDev->DrawOutDev( maRestPt, maRestSz, Point(), maRestSz, *mpRestore );
         }
 
-        meLastDisposal = rAnm.eDisposal;
+        meLastDisposal = rAnimationBitmap.meDisposal;
         maRestPt = aPosPix;
         maRestSz = aSizePix;
 
@@ -286,7 +286,7 @@ void ImplAnimView::draw( sal_uLong nPos, VirtualDevice* pVDev )
             mpRestore->DrawOutDev( Point(), maRestSz, aPosPix, aSizePix, *pDev );
         }
 
-        pDev->DrawBitmapEx( aBmpPosPix, aBmpSizePix, rAnm.aBmpEx );
+        pDev->DrawBitmapEx( aBmpPosPix, aBmpSizePix, rAnimationBitmap.maBitmapEx );
 
         if( !pVDev )
         {

vcl/source/graphic/GraphicObject.cxx

@@ -778,21 +778,21 @@ Graphic GraphicObject::GetTransformedGraphic( const Size& rDestSize, const MapMo
 
             for( size_t nFrame=0; nFrame<aAnim.Count(); ++nFrame )
             {
-                AnimationBitmap aAnimBmp( aAnim.Get( nFrame ) );
+                AnimationBitmap aAnimationBitmap( aAnim.Get( nFrame ) );
 
-                if( !aCropRect.IsInside( tools::Rectangle(aAnimBmp.aPosPix, aAnimBmp.aSizePix) ) )
+                if( !aCropRect.IsInside( tools::Rectangle(aAnimationBitmap.maPositionPixel, aAnimationBitmap.maSizePixel) ) )
                 {
                     // setup actual cropping (relative to frame position)
                     tools::Rectangle aCropRectRel( aCropRect );
-                    aCropRectRel.Move( -aAnimBmp.aPosPix.X(),
-                                       -aAnimBmp.aPosPix.Y() );
+                    aCropRectRel.Move( -aAnimationBitmap.maPositionPixel.X(),
+                                       -aAnimationBitmap.maPositionPixel.Y() );
 
                     // cropping affects this frame, apply it then
                     // do _not_ apply enlargement, this is done below
-                    ImplTransformBitmap( aAnimBmp.aBmpEx, rAttr, Size(), Size(),
+                    ImplTransformBitmap( aAnimationBitmap.maBitmapEx, rAttr, Size(), Size(),
                                          aCropRectRel, rDestSize, false );
 
-                    aAnim.Replace( aAnimBmp, nFrame );
+                    aAnim.Replace( aAnimationBitmap, nFrame );
                 }
                 // else: bitmap completely within crop area,
                 // i.e. nothing is cropped away
@@ -822,11 +822,11 @@ Graphic GraphicObject::GetTransformedGraphic( const Size& rDestSize, const MapMo
 
                 for( size_t nFrame=0; nFrame<aAnim.Count(); ++nFrame )
                 {
-                    AnimationBitmap aAnimBmp( aAnim.Get( nFrame ) );
+                    AnimationBitmap aAnimationBitmap( aAnim.Get( nFrame ) );
 
-                    aAnimBmp.aPosPix += aPosOffset;
+                    aAnimationBitmap.maPositionPixel += aPosOffset;
 
-                    aAnim.Replace( aAnimBmp, nFrame );
+                    aAnim.Replace( aAnimationBitmap, nFrame );
                 }
             }