Constify GlyphItem

This hides all the data, which shouldn't change after init. Real
const makes a lot of problems for copying, so this is the 2nd
option to just add getters for private data. While at it use
typed_flags for the GlyphItemFlags.

Change-Id: Ic1eeabe2398f6c30080fdd516285b72c620b11be
Reviewed-on: https://gerrit.libreoffice.org/75147
Tested-by: Jenkins
Reviewed-by: Jan-Marek Glogowski <glogow@fbihome.de>

12 files changed, 127 insertions, 103 deletions

diff --git a/include/vcl/vcllayout.hxx b/include/vcl/vcllayout.hxx
index c1d2db0bf152..99884011e928 100644
--- a/include/vcl/vcllayout.hxx
+++ b/include/vcl/vcllayout.hxx
@@ -28,7 +28,7 @@
 class ImplLayoutArgs;
 class PhysicalFontFace;
 class SalGraphics;
-struct GlyphItem;
+class GlyphItem;
 class SalLayoutGlyphs;
 
 // all positions/widths are in font units
diff --git a/vcl/inc/impglyphitem.hxx b/vcl/inc/impglyphitem.hxx
index 987df438894c..a04113a1fbae 100644
--- a/vcl/inc/impglyphitem.hxx
+++ b/vcl/inc/impglyphitem.hxx
@@ -20,6 +20,7 @@
 #ifndef INCLUDED_VCL_IMPGLYPHITEM_HXX
 #define INCLUDED_VCL_IMPGLYPHITEM_HXX
 
+#include <o3tl/typed_flags_set.hxx>
 #include <tools/gen.hxx>
 #include <vcl/dllapi.h>
 #include <vcl/glyphitem.hxx>
@@ -28,57 +29,75 @@
 
 #include "fontinstance.hxx"
 
-struct VCL_DLLPUBLIC GlyphItem
+enum class GlyphItemFlags
+{
+    NONE = 0,
+    IS_IN_CLUSTER = 0x001,
+    IS_RTL_GLYPH = 0x002,
+    IS_DIACRITIC = 0x004,
+    IS_VERTICAL = 0x008,
+    IS_SPACING = 0x010,
+    ALLOW_KASHIDA = 0x020,
+    IS_DROPPED = 0x040,
+    IS_CLUSTER_START = 0x080
+};
+namespace o3tl
+{
+template <> struct typed_flags<GlyphItemFlags> : is_typed_flags<GlyphItemFlags, 0xff>
+{
+};
+};
+
+class VCL_DLLPUBLIC GlyphItem
 {
     sal_GlyphId m_aGlyphId;
     int m_nCharCount; // number of characters making up this glyph
     int m_nOrigWidth; // original glyph width
     LogicalFontInstance* m_pFontInstance;
-
     int m_nCharPos; // index in string
-    int m_nFlags;
-    int m_nNewWidth; // width after adjustments
+    GlyphItemFlags m_nFlags;
     int m_nXOffset;
+
+public:
+    int m_nNewWidth; // width after adjustments
     Point m_aLinearPos; // absolute position of non rotated string
 
     GlyphItem(int nCharPos, int nCharCount, sal_GlyphId aGlyphId, const Point& rLinearPos,
-              long nFlags, int nOrigWidth, int nXOffset, LogicalFontInstance* pFontInstance)
+              GlyphItemFlags nFlags, int nOrigWidth, int nXOffset,
+              LogicalFontInstance* pFontInstance)
         : m_aGlyphId(aGlyphId)
         , m_nCharCount(nCharCount)
         , m_nOrigWidth(nOrigWidth)
         , m_pFontInstance(pFontInstance)
         , m_nCharPos(nCharPos)
         , m_nFlags(nFlags)
-        , m_nNewWidth(nOrigWidth)
         , m_nXOffset(nXOffset)
+        , m_nNewWidth(nOrigWidth)
         , m_aLinearPos(rLinearPos)
     {
         assert(m_pFontInstance);
     }
 
-    enum
-    {
-        IS_IN_CLUSTER = 0x001,
-        IS_RTL_GLYPH = 0x002,
-        IS_DIACRITIC = 0x004,
-        IS_VERTICAL = 0x008,
-        IS_SPACING = 0x010,
-        ALLOW_KASHIDA = 0x020,
-        IS_DROPPED = 0x040,
-        IS_CLUSTER_START = 0x080
-    };
-
-    bool IsInCluster() const { return ((m_nFlags & IS_IN_CLUSTER) != 0); }
-    bool IsRTLGlyph() const { return ((m_nFlags & IS_RTL_GLYPH) != 0); }
-    bool IsDiacritic() const { return ((m_nFlags & IS_DIACRITIC) != 0); }
-    bool IsVertical() const { return ((m_nFlags & IS_VERTICAL) != 0); }
-    bool IsSpacing() const { return ((m_nFlags & IS_SPACING) != 0); }
-    bool AllowKashida() const { return ((m_nFlags & ALLOW_KASHIDA) != 0); }
-    bool IsDropped() const { return ((m_nFlags & IS_DROPPED) != 0); }
-    bool IsClusterStart() const { return ((m_nFlags & IS_CLUSTER_START) != 0); }
+    bool IsInCluster() const { return bool(m_nFlags & GlyphItemFlags::IS_IN_CLUSTER); }
+    bool IsRTLGlyph() const { return bool(m_nFlags & GlyphItemFlags::IS_RTL_GLYPH); }
+    bool IsDiacritic() const { return bool(m_nFlags & GlyphItemFlags::IS_DIACRITIC); }
+    bool IsVertical() const { return bool(m_nFlags & GlyphItemFlags::IS_VERTICAL); }
+    bool IsSpacing() const { return bool(m_nFlags & GlyphItemFlags::IS_SPACING); }
+    bool AllowKashida() const { return bool(m_nFlags & GlyphItemFlags::ALLOW_KASHIDA); }
+    bool IsDropped() const { return bool(m_nFlags & GlyphItemFlags::IS_DROPPED); }
+    bool IsClusterStart() const { return bool(m_nFlags & GlyphItemFlags::IS_CLUSTER_START); }
 
     inline bool GetGlyphBoundRect(tools::Rectangle&) const;
     inline bool GetGlyphOutline(basegfx::B2DPolyPolygon&) const;
+    inline void dropGlyph();
+
+    sal_GlyphId glyphId() const { return m_aGlyphId; }
+    int charCount() const { return m_nCharCount; }
+    int origWidth() const { return m_nOrigWidth; }
+    LogicalFontInstance* fontInstance() const { return m_pFontInstance; }
+    GlyphItemFlags flags() const { return m_nFlags; }
+    int charPos() const { return m_nCharPos; }
+    int xOffset() const { return m_nXOffset; }
 };
 
 VCL_DLLPUBLIC bool GlyphItem::GetGlyphBoundRect(tools::Rectangle& rRect) const
@@ -91,6 +110,12 @@ VCL_DLLPUBLIC bool GlyphItem::GetGlyphOutline(basegfx::B2DPolyPolygon& rPoly) co
     return m_pFontInstance->GetGlyphOutline(m_aGlyphId, rPoly, IsVertical());
 }
 
+void GlyphItem::dropGlyph()
+{
+    m_nCharPos = -1;
+    m_nFlags |= GlyphItemFlags::IS_DROPPED;
+}
+
 class SalLayoutGlyphsImpl : public std::vector<GlyphItem>
 {
     friend class GenericSalLayout;
diff --git a/vcl/qt5/Qt5Graphics_Text.cxx b/vcl/qt5/Qt5Graphics_Text.cxx
index 510aa5053237..04107c2841af 100644
--- a/vcl/qt5/Qt5Graphics_Text.cxx
+++ b/vcl/qt5/Qt5Graphics_Text.cxx
@@ -196,7 +196,7 @@ void Qt5Graphics::DrawTextLayout(const GenericSalLayout& rLayout)
     int nStart = 0;
     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
     {
-        glyphIndexes.push_back(pGlyph->m_aGlyphId);
+        glyphIndexes.push_back(pGlyph->glyphId());
         positions.push_back(QPointF(aPos.X(), aPos.Y()));
     }
 
diff --git a/vcl/quartz/salgdi.cxx b/vcl/quartz/salgdi.cxx
index f27047a116f4..080cb1adaa11 100644
--- a/vcl/quartz/salgdi.cxx
+++ b/vcl/quartz/salgdi.cxx
@@ -414,7 +414,7 @@ void AquaSalGraphics::DrawTextLayout(const GenericSalLayout& rLayout)
             }
         }
 
-        aGlyphIds.push_back(pGlyph->m_aGlyphId);
+        aGlyphIds.push_back(pGlyph->glyphId());
         aGlyphPos.push_back(aGCPos);
         aGlyphOrientation.push_back(bUprightGlyph);
     }
diff --git a/vcl/source/gdi/CommonSalLayout.cxx b/vcl/source/gdi/CommonSalLayout.cxx
index 0ecf733a328d..eec3079074e0 100644
--- a/vcl/source/gdi/CommonSalLayout.cxx
+++ b/vcl/source/gdi/CommonSalLayout.cxx
@@ -530,37 +530,37 @@ bool GenericSalLayout::LayoutText(ImplLayoutArgs& rArgs, const SalLayoutGlyphs*
                         continue;
                 }
 
-                int nGlyphFlags = 0;
+                GlyphItemFlags nGlyphFlags = GlyphItemFlags::NONE;
                 if (bRightToLeft)
-                    nGlyphFlags |= GlyphItem::IS_RTL_GLYPH;
+                    nGlyphFlags |= GlyphItemFlags::IS_RTL_GLYPH;
 
                 if (bClusterStart)
-                    nGlyphFlags |= GlyphItem::IS_CLUSTER_START;
+                    nGlyphFlags |= GlyphItemFlags::IS_CLUSTER_START;
 
                 if (bInCluster)
-                    nGlyphFlags |= GlyphItem::IS_IN_CLUSTER;
+                    nGlyphFlags |= GlyphItemFlags::IS_IN_CLUSTER;
 
                 sal_Int32 indexUtf16 = nCharPos;
                 sal_UCS4 aChar = rArgs.mrStr.iterateCodePoints(&indexUtf16, 0);
 
                 if (u_getIntPropertyValue(aChar, UCHAR_GENERAL_CATEGORY) == U_NON_SPACING_MARK)
-                    nGlyphFlags |= GlyphItem::IS_DIACRITIC;
+                    nGlyphFlags |= GlyphItemFlags::IS_DIACRITIC;
 
                 if (u_isUWhiteSpace(aChar))
-                    nGlyphFlags |= GlyphItem::IS_SPACING;
+                    nGlyphFlags |= GlyphItemFlags::IS_SPACING;
 
                 if (aSubRun.maScript == HB_SCRIPT_ARABIC &&
                     HB_DIRECTION_IS_BACKWARD(aSubRun.maDirection) &&
-                    (nGlyphFlags & GlyphItem::IS_SPACING) == 0)
+                    !(nGlyphFlags & GlyphItemFlags::IS_SPACING))
                 {
-                    nGlyphFlags |= GlyphItem::ALLOW_KASHIDA;
+                    nGlyphFlags |= GlyphItemFlags::ALLOW_KASHIDA;
                     rArgs.mnFlags |= SalLayoutFlags::KashidaJustification;
                 }
 
                 DeviceCoordinate nAdvance, nXOffset, nYOffset;
                 if (aSubRun.maDirection == HB_DIRECTION_TTB)
                 {
-                    nGlyphFlags |= GlyphItem::IS_VERTICAL;
+                    nGlyphFlags |= GlyphItemFlags::IS_VERTICAL;
 
                     // We have glyph offsets that is relative to h origin now,
                     // add the origin back so it is relative to v origin.
@@ -612,7 +612,7 @@ void GenericSalLayout::GetCharWidths(DeviceCoordinate* pCharWidths) const
 
     for (auto const& aGlyphItem : *m_GlyphItems.Impl())
     {
-        const int nIndex = aGlyphItem.m_nCharPos - mnMinCharPos;
+        const int nIndex = aGlyphItem.charPos() - mnMinCharPos;
         if (nIndex >= nCharCount)
             continue;
         pCharWidths[nIndex] += aGlyphItem.m_nNewWidth;
@@ -682,9 +682,9 @@ void GenericSalLayout::ApplyDXArray(const ImplLayoutArgs& rArgs)
     {
         // Accumulate the width difference for all characters corresponding to
         // this glyph.
-        int nCharPos = (*m_GlyphItems.Impl())[i].m_nCharPos - mnMinCharPos;
+        int nCharPos = (*m_GlyphItems.Impl())[i].charPos() - mnMinCharPos;
         DeviceCoordinate nDiff = 0;
-        for (int j = 0; j < (*m_GlyphItems.Impl())[i].m_nCharCount; j++)
+        for (int j = 0; j < (*m_GlyphItems.Impl())[i].charCount(); j++)
             nDiff += pNewCharWidths[nCharPos + j] - pOldCharWidths[nCharPos + j];
 
         if (!(*m_GlyphItems.Impl())[i].IsRTLGlyph())
@@ -731,7 +731,7 @@ void GenericSalLayout::ApplyDXArray(const ImplLayoutArgs& rArgs)
             // last glyph in the cluster not the first as this would be the
             // base glyph.
             if (bKashidaJustify && (*m_GlyphItems.Impl())[i].AllowKashida() &&
-                nDiff > (*m_GlyphItems.Impl())[i].m_nCharCount) // Rounding errors, 1 pixel per character!
+                nDiff > (*m_GlyphItems.Impl())[i].charCount()) // Rounding errors, 1 pixel per character!
             {
                 pKashidas[i] = nDiff;
                 // Move any non-spacing marks attached to this cluster as well.
@@ -782,8 +782,8 @@ void GenericSalLayout::ApplyDXArray(const ImplLayoutArgs& rArgs)
             }
 
             Point aPos(pGlyphIter->m_aLinearPos.getX() - nTotalWidth, 0);
-            int nCharPos = pGlyphIter->m_nCharPos;
-            int const nFlags = GlyphItem::IS_IN_CLUSTER | GlyphItem::IS_RTL_GLYPH;
+            int nCharPos = pGlyphIter->charPos();
+            GlyphItemFlags const nFlags = GlyphItemFlags::IS_IN_CLUSTER | GlyphItemFlags::IS_RTL_GLYPH;
             while (nCopies--)
             {
                 GlyphItem aKashida(nCharPos, 0, nKashidaIndex, aPos, nFlags, nKashidaWidth, 0, &GetFont());
@@ -801,7 +801,7 @@ bool GenericSalLayout::IsKashidaPosValid(int nCharPos) const
 {
     for (auto pIter = m_GlyphItems.Impl()->begin(); pIter != m_GlyphItems.Impl()->end(); ++pIter)
     {
-        if (pIter->m_nCharPos == nCharPos)
+        if (pIter->charPos() == nCharPos)
         {
             // The position is the first glyph, this would happen if we
             // changed the text styling in the middle of a word. Since we don’t
@@ -812,7 +812,7 @@ bool GenericSalLayout::IsKashidaPosValid(int nCharPos) const
 
             // If the character is not supported by this layout, return false
             // so that fallback layouts would be checked for it.
-            if (pIter->m_aGlyphId == 0)
+            if (pIter->glyphId() == 0)
                 break;
 
             // Search backwards for previous glyph belonging to a different
@@ -820,12 +820,12 @@ bool GenericSalLayout::IsKashidaPosValid(int nCharPos) const
             // RTL glyphs, which will be in visual order.
             for (auto pPrev = pIter - 1; pPrev != m_GlyphItems.Impl()->begin(); --pPrev)
             {
-                if (pPrev->m_nCharPos != nCharPos)
+                if (pPrev->charPos() != nCharPos)
                 {
                     // Check if the found glyph belongs to the next character,
                     // otherwise the current glyph will be a ligature which is
                     // invalid kashida position.
-                    if (pPrev->m_nCharPos == (nCharPos + 1))
+                    if (pPrev->charPos() == (nCharPos + 1))
                         return true;
                     break;
                 }
diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx
index 19773af668b9..f7a619b6f3be 100644
--- a/vcl/source/gdi/pdfwriter_impl.cxx
+++ b/vcl/source/gdi/pdfwriter_impl.cxx
@@ -3943,7 +3943,7 @@ void PDFWriterImpl::createDefaultCheckBoxAppearance( PDFWidget& rBox, const PDFW
     // make sure OpenSymbol is embedded, and includes our checkmark
     const sal_Unicode cMark=0x2713;
     const GlyphItem aItem(0, 0, pMap->GetGlyphIndex(cMark),
-                          Point(), 0, 0, 0,
+                          Point(), GlyphItemFlags::NONE, 0, 0,
                           const_cast<LogicalFontInstance*>(pFontInstance));
     const std::vector<sal_Ucs> aCodeUnits={ cMark };
     sal_uInt8 nMappedGlyph;
@@ -5829,7 +5829,7 @@ void PDFWriterImpl::registerGlyph(const GlyphItem* pGlyph,
                                   sal_uInt8& nMappedGlyph,
                                   sal_Int32& nMappedFontObject)
 {
-    const int nFontGlyphId = pGlyph->m_aGlyphId;
+    const int nFontGlyphId = pGlyph->glyphId();
     FontSubset& rSubset = m_aSubsets[ pFont ];
     // search for font specific glyphID
     FontMapping::iterator it = rSubset.m_aMapping.find( nFontGlyphId );
@@ -5987,7 +5987,7 @@ void PDFWriterImpl::drawVerticalGlyphs(
             long nOffsetY = rGlyphs[i+1].m_aPos.Y() - rGlyphs[i].m_aPos.Y();
             nXOffset += static_cast<int>(sqrt(double(nOffsetX*nOffsetX + nOffsetY*nOffsetY)));
         }
-        if( ! rGlyphs[i].m_pGlyph->m_aGlyphId )
+        if (!rGlyphs[i].m_pGlyph->glyphId())
             continue;
 
         aDeltaPos = rRotScale.transform( aDeltaPos );
@@ -6282,9 +6282,9 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool
         // * Keep generating (now) redundant ToUnicode entries for
         //   compatibility with old tools not supporting ActualText.
 
-        assert(pGlyph->m_nCharCount >= 0);
-        for (int n = 0; n < pGlyph->m_nCharCount; n++)
-            aCodeUnits.push_back(rText[pGlyph->m_nCharPos + n]);
+        assert(pGlyph->charCount() >= 0);
+        for (int n = 0; n < pGlyph->charCount(); n++)
+            aCodeUnits.push_back(rText[pGlyph->charPos() + n]);
 
         bool bUseActualText = false;
 
@@ -6303,7 +6303,7 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool
         {
             for (const auto& rSubset : m_aSubsets[pFont].m_aSubsets)
             {
-                const auto& it = rSubset.m_aMapping.find(pGlyph->m_aGlyphId);
+                const auto& it = rSubset.m_aMapping.find(pGlyph->glyphId());
                 if (it != rSubset.m_aMapping.cend() && it->second.codes() != aCodeUnits)
                 {
                     bUseActualText = true;
@@ -6322,13 +6322,13 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool
         SalGraphics *pGraphics = GetGraphics();
         if (pGraphics)
             nGlyphWidth = m_aFontCache.getGlyphWidth(pFont,
-                                                     pGlyph->m_aGlyphId,
+                                                     pGlyph->glyphId(),
                                                      pGlyph->IsVertical(),
                                                      pGraphics);
 
         int nCharPos = -1;
         if (bUseActualText || pGlyph->IsInCluster())
-            nCharPos = pGlyph->m_nCharPos;
+            nCharPos = pGlyph->charPos();
 
         aGlyphs.emplace_back(aPos,
                              pGlyph,
@@ -6400,12 +6400,12 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool
             if (!aRun.front().m_pGlyph->IsRTLGlyph())
             {
                 nCharPos = aRun.front().m_nCharPos;
-                nCharCount = aRun.front().m_pGlyph->m_nCharCount;
+                nCharCount = aRun.front().m_pGlyph->charCount();
             }
             else
             {
                 nCharPos = aRun.back().m_nCharPos;
-                nCharCount = aRun.back().m_pGlyph->m_nCharCount;
+                nCharCount = aRun.back().m_pGlyph->charCount();
             }
 
             if (nCharPos >= 0 && nCharCount)
diff --git a/vcl/source/gdi/sallayout.cxx b/vcl/source/gdi/sallayout.cxx
index 3c197c016b1a..bcd8eaa74a77 100644
--- a/vcl/source/gdi/sallayout.cxx
+++ b/vcl/source/gdi/sallayout.cxx
@@ -674,7 +674,7 @@ DeviceCoordinate GenericSalLayout::GetTextWidth() const
         DeviceCoordinate nXPos = aGlyphItem.m_aLinearPos.getX();
         if( nMinPos > nXPos )
             nMinPos = nXPos;
-        nXPos += aGlyphItem.m_nNewWidth - aGlyphItem.m_nXOffset;
+        nXPos += aGlyphItem.m_nNewWidth - aGlyphItem.xOffset();
         if( nMaxPos < nXPos )
             nMaxPos = nXPos;
     }
@@ -705,17 +705,17 @@ void GenericSalLayout::Justify( DeviceCoordinate nNewWidth )
     {
         if( !pGlyphIter->IsDiacritic() )
             ++nStretchable;
-        if( nMaxGlyphWidth < pGlyphIter->m_nOrigWidth )
-            nMaxGlyphWidth = pGlyphIter->m_nOrigWidth;
+        if (nMaxGlyphWidth < pGlyphIter->origWidth())
+            nMaxGlyphWidth = pGlyphIter->origWidth();
     }
 
     // move rightmost glyph to requested position
-    nOldWidth -= pGlyphIterRight->m_nOrigWidth;
+    nOldWidth -= pGlyphIterRight->origWidth();
     if( nOldWidth <= 0 )
         return;
     if( nNewWidth < nMaxGlyphWidth)
         nNewWidth = nMaxGlyphWidth;
-    nNewWidth -= pGlyphIterRight->m_nOrigWidth;
+    nNewWidth -= pGlyphIterRight->origWidth();
     pGlyphIterRight->m_aLinearPos.setX( nNewWidth );
 
     // justify glyph widths and positions
@@ -811,7 +811,7 @@ void GenericSalLayout::ApplyAsianKerning(const OUString& rStr)
                                           pGlyphIterEnd = m_GlyphItems.Impl()->end();
          pGlyphIter != pGlyphIterEnd; ++pGlyphIter)
     {
-        const int n = pGlyphIter->m_nCharPos;
+        const int n = pGlyphIter->charPos();
         if (n < nLength - 1)
         {
             // ignore code ranges that are not affected by asian punctuation compression
@@ -834,7 +834,7 @@ void GenericSalLayout::ApplyAsianKerning(const OUString& rStr)
             int nDelta = (nKernCurrent < nKernNext) ? nKernCurrent : nKernNext;
             if (nDelta < 0)
             {
-                nDelta = (nDelta * pGlyphIter->m_nOrigWidth + 2) / 4;
+                nDelta = (nDelta * pGlyphIter->origWidth() + 2) / 4;
                 if( pGlyphIter+1 == pGlyphIterEnd )
                     pGlyphIter->m_nNewWidth += nDelta;
                 nOffset += nDelta;
@@ -857,8 +857,8 @@ void GenericSalLayout::GetCaretPositions( int nMaxIndex, long* pCaretXArray ) co
     for (auto const& aGlyphItem : *m_GlyphItems.Impl())
     {
         long nXPos = aGlyphItem.m_aLinearPos.getX();
-        long nXRight = nXPos + aGlyphItem.m_nOrigWidth;
-        int n = aGlyphItem.m_nCharPos;
+        long nXRight = nXPos + aGlyphItem.origWidth();
+        int n = aGlyphItem.charPos();
         int nCurrIdx = 2 * (n - mnMinCharPos);
         // tdf#86399 if this is not the start of a cluster, don't overwrite the caret bounds of the cluster start
         if (aGlyphItem.IsInCluster() && pCaretXArray[nCurrIdx] != -1)
@@ -907,7 +907,7 @@ bool GenericSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
     // find next glyph in substring
     for(; pGlyphIter != pGlyphIterEnd; ++nStart, ++pGlyphIter )
     {
-        int n = pGlyphIter->m_nCharPos;
+        int n = pGlyphIter->charPos();
         if( (mnMinCharPos <= n) && (n < mnEndCharPos) )
             break;
     }
@@ -947,7 +947,7 @@ void GenericSalLayout::MoveGlyph( int nStart, long nNewXPos )
     // as RTL-glyphs are right justified in their cell
     // the cell position needs to be adjusted to the glyph position
     if( pGlyphIter->IsRTLGlyph() )
-        nNewXPos += pGlyphIter->m_nNewWidth - pGlyphIter->m_nOrigWidth;
+        nNewXPos += pGlyphIter->m_nNewWidth - pGlyphIter->origWidth();
     // calculate the x-offset to the old position
     long nXDelta = nNewXPos - pGlyphIter->m_aLinearPos.getX();
     // adjust all following glyph positions if needed
@@ -967,8 +967,7 @@ void GenericSalLayout::DropGlyph( int nStart )
 
     std::vector<GlyphItem>::iterator pGlyphIter = m_GlyphItems.Impl()->begin();
     pGlyphIter += nStart;
-    pGlyphIter->m_nCharPos = -1;
-    pGlyphIter->m_nFlags |= GlyphItem::IS_DROPPED;
+    pGlyphIter->dropGlyph();
 }
 
 void GenericSalLayout::Simplify( bool bIsBase )
@@ -979,7 +978,7 @@ void GenericSalLayout::Simplify( bool bIsBase )
     {
         if (bIsBase && (*m_GlyphItems.Impl())[i].IsDropped())
             continue;
-        if (!bIsBase && (*m_GlyphItems.Impl())[i].m_aGlyphId == 0)
+        if (!bIsBase && (*m_GlyphItems.Impl())[i].glyphId() == 0)
             continue;
 
         if( i != j )
@@ -1185,12 +1184,12 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
     assert(nFirstValid >= 0);
 
     // get the next codepoint index that needs fallback
-    int nActiveCharPos = pGlyphs[nFirstValid]->m_nCharPos;
+    int nActiveCharPos = pGlyphs[nFirstValid]->charPos();
     int nActiveCharIndex = nActiveCharPos - mnMinCharPos;
     // get the end index of the active run
     int nLastRunEndChar = (nActiveCharIndex >= 0 && vRtl[nActiveCharIndex]) ?
         rArgs.mnEndCharPos : rArgs.mnMinCharPos - 1;
-    int nRunVisibleEndChar = pGlyphs[nFirstValid]->m_nCharPos;
+    int nRunVisibleEndChar = pGlyphs[nFirstValid]->charPos();
     // merge the fallback levels
     while( bValid[nFirstValid] && (nLevel > 0))
     {
@@ -1219,8 +1218,8 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
         {
             // drop the NotDef glyphs in the base layout run if a fallback run exists
             while (
-                    (maFallbackRuns[n-1].PosIsInRun(pGlyphs[nFirstValid]->m_nCharPos)) &&
-                    (!maFallbackRuns[n].PosIsInAnyRun(pGlyphs[nFirstValid]->m_nCharPos))
+                    (maFallbackRuns[n-1].PosIsInRun(pGlyphs[nFirstValid]->charPos())) &&
+                    (!maFallbackRuns[n].PosIsInAnyRun(pGlyphs[nFirstValid]->charPos()))
                   )
             {
                 mpLayouts[0]->DropGlyph( nStartOld[0] );
@@ -1241,7 +1240,7 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
 
             // proceed to next glyph
             nStartOld[n] = nStartNew[n];
-            int nOrigCharPos = pGlyphs[n]->m_nCharPos;
+            int nOrigCharPos = pGlyphs[n]->charPos();
             bValid[n] = mpLayouts[n]->GetNextGlyph(&pGlyphs[n], aPos, nStartNew[n]);
             // break after last glyph of active layout
             if( !bValid[n] )
@@ -1255,16 +1254,16 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
             //If the next character is one which belongs to the next level, then we
             //are finished here for now, and we'll pick up after the next level has
             //been processed
-            if ((n+1 < nLevel) && (pGlyphs[n]->m_nCharPos != nOrigCharPos))
+            if ((n+1 < nLevel) && (pGlyphs[n]->charPos() != nOrigCharPos))
             {
-                if (nOrigCharPos < pGlyphs[n]->m_nCharPos)
+                if (nOrigCharPos < pGlyphs[n]->charPos())
                 {
-                    if (pGlyphs[n+1]->m_nCharPos > nOrigCharPos && (pGlyphs[n+1]->m_nCharPos < pGlyphs[n]->m_nCharPos))
+                    if (pGlyphs[n+1]->charPos() > nOrigCharPos && (pGlyphs[n+1]->charPos() < pGlyphs[n]->charPos()))
                         break;
                 }
-                else if (nOrigCharPos > pGlyphs[n]->m_nCharPos)
+                else if (nOrigCharPos > pGlyphs[n]->charPos())
                 {
-                    if (pGlyphs[n+1]->m_nCharPos > pGlyphs[n]->m_nCharPos && (pGlyphs[n+1]->m_nCharPos < nOrigCharPos))
+                    if (pGlyphs[n+1]->charPos() > pGlyphs[n]->charPos() && (pGlyphs[n+1]->charPos() < nOrigCharPos))
                         break;
                 }
             }
@@ -1273,15 +1272,15 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
             if( n > 0 )
             {
                 // skip until end of fallback run
-                if (!maFallbackRuns[n-1].PosIsInRun(pGlyphs[n]->m_nCharPos))
+                if (!maFallbackRuns[n-1].PosIsInRun(pGlyphs[n]->charPos()))
                     break;
             }
             else
             {
                 // break when a fallback is needed and available
-                bool bNeedFallback = maFallbackRuns[0].PosIsInRun(pGlyphs[nFirstValid]->m_nCharPos);
+                bool bNeedFallback = maFallbackRuns[0].PosIsInRun(pGlyphs[nFirstValid]->charPos());
                 if( bNeedFallback )
-                    if (!maFallbackRuns[nLevel-1].PosIsInRun(pGlyphs[nFirstValid]->m_nCharPos))
+                    if (!maFallbackRuns[nLevel-1].PosIsInRun(pGlyphs[nFirstValid]->charPos()))
                         break;
                 // break when change from resolved to unresolved base layout run
                 if( bKeepNotDef && !bNeedFallback )
@@ -1292,21 +1291,21 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
             if (aMultiArgs.mpDXArray &&
                 nRunVisibleEndChar < mnEndCharPos &&
                 nRunVisibleEndChar >= mnMinCharPos &&
-                pGlyphs[n]->m_nCharPos < mnEndCharPos &&
-                pGlyphs[n]->m_nCharPos >= mnMinCharPos)
+                pGlyphs[n]->charPos() < mnEndCharPos &&
+                pGlyphs[n]->charPos() >= mnMinCharPos)
             {
                 if (vRtl[nActiveCharPos - mnMinCharPos])
                 {
                     if (aMultiArgs.mpDXArray[nRunVisibleEndChar-mnMinCharPos]
-                        >= aMultiArgs.mpDXArray[pGlyphs[n]->m_nCharPos - mnMinCharPos])
+                        >= aMultiArgs.mpDXArray[pGlyphs[n]->charPos() - mnMinCharPos])
                     {
-                        nRunVisibleEndChar = pGlyphs[n]->m_nCharPos;
+                        nRunVisibleEndChar = pGlyphs[n]->charPos();
                     }
                 }
                 else if (aMultiArgs.mpDXArray[nRunVisibleEndChar-mnMinCharPos]
-                         <= aMultiArgs.mpDXArray[pGlyphs[n]->m_nCharPos - mnMinCharPos])
+                         <= aMultiArgs.mpDXArray[pGlyphs[n]->charPos() - mnMinCharPos])
                 {
-                    nRunVisibleEndChar = pGlyphs[n]->m_nCharPos;
+                    nRunVisibleEndChar = pGlyphs[n]->charPos();
                 }
             }
         }
@@ -1334,7 +1333,7 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
                   nRunAdvance -= aMultiArgs.mpDXArray[nLastRunEndChar - mnMinCharPos];
             }
             nLastRunEndChar = nRunVisibleEndChar;
-            nRunVisibleEndChar = pGlyphs[nFirstValid]->m_nCharPos;
+            nRunVisibleEndChar = pGlyphs[nFirstValid]->charPos();
             // the requested width is still in pixel units
             // => convert it to base level font units
             nRunAdvance *= mnUnitsPerPixel;
@@ -1351,7 +1350,7 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
         nXPos += nRunAdvance;
 
         // prepare for next fallback run
-        nActiveCharPos = pGlyphs[nFirstValid]->m_nCharPos;
+        nActiveCharPos = pGlyphs[nFirstValid]->charPos();
         // it essential that the runs don't get ahead of themselves and in the
         // if( bKeepNotDef && !bNeedFallback ) statement above, the next run may
         // have already been reached on the base level
diff --git a/vcl/source/outdev/text.cxx b/vcl/source/outdev/text.cxx
index 5fe146448f23..a5ccdb1bd6d5 100644
--- a/vcl/source/outdev/text.cxx
+++ b/vcl/source/outdev/text.cxx
@@ -2295,7 +2295,7 @@ SystemTextLayoutData OutputDevice::GetSysTextLayoutData(const Point& rStartPt, c
     SystemGlyphData aSystemGlyph;
     while (pLayout->GetNextGlyph(&pGlyph, aPos, nStart, nullptr, &aSystemGlyph.fallbacklevel))
     {
-        aSystemGlyph.index = pGlyph->m_aGlyphId;
+        aSystemGlyph.index = pGlyph->glyphId();
         aSystemGlyph.x = aPos.X();
         aSystemGlyph.y = aPos.Y();
         aSysLayoutData.rGlyphData.push_back(aSystemGlyph);
diff --git a/vcl/unx/generic/gdi/cairotextrender.cxx b/vcl/unx/generic/gdi/cairotextrender.cxx
index d6355e65f173..f72664657673 100644
--- a/vcl/unx/generic/gdi/cairotextrender.cxx
+++ b/vcl/unx/generic/gdi/cairotextrender.cxx
@@ -184,7 +184,7 @@ void CairoTextRender::DrawTextLayout(const GenericSalLayout& rLayout, const SalG
     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
     {
         cairo_glyph_t aGlyph;
-        aGlyph.index = pGlyph->m_aGlyphId;
+        aGlyph.index = pGlyph->glyphId();
         aGlyph.x = aPos.X();
         aGlyph.y = aPos.Y();
         cairo_glyphs.push_back(aGlyph);
diff --git a/vcl/unx/generic/print/text_gfx.cxx b/vcl/unx/generic/print/text_gfx.cxx
index 156f801cb8c9..e7ced7a83c97 100644
--- a/vcl/unx/generic/print/text_gfx.cxx
+++ b/vcl/unx/generic/print/text_gfx.cxx
@@ -123,14 +123,14 @@ void PrinterGfx::DrawGlyph(const Point& rPoint,
             PSTranslate( aPoint );
         PSRotate (900);
         // draw the rotated glyph
-        drawGlyph(aRotPoint, rGlyph.m_aGlyphId);
+        drawGlyph(aRotPoint, rGlyph.glyphId());
 
         // restore previous state
         maVirtualStatus = aSaveStatus;
         PSGRestore();
     }
     else
-        drawGlyph(aPoint, rGlyph.m_aGlyphId);
+        drawGlyph(aPoint, rGlyph.glyphId());
 
     // restore the user coordinate system
     if (nCurrentTextAngle != 0)
diff --git a/vcl/win/gdi/DWriteTextRenderer.cxx b/vcl/win/gdi/DWriteTextRenderer.cxx
index 93f877d2aea9..734b68b0780a 100644
--- a/vcl/win/gdi/DWriteTextRenderer.cxx
+++ b/vcl/win/gdi/DWriteTextRenderer.cxx
@@ -260,7 +260,7 @@ bool D2DWriteTextOutRenderer::performRender(GenericSalLayout const & rLayout, Sa
         const GlyphItem* pGlyph;
         while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
         {
-            UINT16 glyphIndices[] = { pGlyph->m_aGlyphId };
+            UINT16 glyphIndices[] = { pGlyph->glyphId() };
             FLOAT glyphAdvances[] = { static_cast<FLOAT>(pGlyph->m_nNewWidth) / fHScale };
             DWRITE_GLYPH_OFFSET glyphOffsets[] = { { 0.0f, 0.0f }, };
             D2D1_POINT_2F baseline = { static_cast<FLOAT>(aPos.X() - bounds.Left()) / fHScale,
diff --git a/vcl/win/gdi/winlayout.cxx b/vcl/win/gdi/winlayout.cxx
index 1f0af819f6a1..25949dc0692e 100644
--- a/vcl/win/gdi/winlayout.cxx
+++ b/vcl/win/gdi/winlayout.cxx
@@ -260,7 +260,7 @@ bool ExTextOutRenderer::operator ()(GenericSalLayout const &rLayout,
     const GlyphItem* pGlyph;
     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
     {
-        WORD glyphWStr[] = { pGlyph->m_aGlyphId };
+        WORD glyphWStr[] = { pGlyph->glyphId() };
         if (hAltFont && pGlyph->IsVertical() == bUseAltFont)
         {
             bUseAltFont = !bUseAltFont;
@@ -414,9 +414,9 @@ bool WinSalGraphics::CacheGlyphs(const GenericSalLayout& rLayout)
     const GlyphItem* pGlyph;
     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
     {
-        if (!rFont.GetOpenGLGlyphCache().IsGlyphCached(pGlyph->m_aGlyphId))
+        if (!rFont.GetOpenGLGlyphCache().IsGlyphCached(pGlyph->glyphId()))
         {
-            if (!rFont.CacheGlyphToAtlas(hDC, hFONT, pGlyph->m_aGlyphId, *this, rLayout))
+            if (!rFont.CacheGlyphToAtlas(hDC, hFONT, pGlyph->glyphId(), *this, rLayout))
                 return false;
         }
     }
@@ -445,7 +445,7 @@ bool WinSalGraphics::DrawCachedGlyphs(const GenericSalLayout& rLayout)
     const GlyphItem* pGlyph;
     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
     {
-        OpenGLGlyphDrawElement& rElement(rFont.GetOpenGLGlyphCache().GetDrawElement(pGlyph->m_aGlyphId));
+        OpenGLGlyphDrawElement& rElement(rFont.GetOpenGLGlyphCache().GetDrawElement(pGlyph->glyphId()));
         OpenGLTexture& rTexture = rElement.maTexture;
 
         if (!rTexture)